Product1 publisher3 min readPublished
Red Hat clocks sandbox isolation at under 5 percent of an agent request's latency
Part one of a three-part benchmark series says isolating code execution is close to free and the GPU still has room at 10 concurrent agents. The same runs disabled tool calling and held every request to a single turn.
The Product Desk · Product desk

What happened
- Red Hat published the first of three posts profiling a secured agentic pipeline on OpenShift AI, with multiturn tool calling and scaling past 10 agents held over for the next two installments.
- The post reports that sandbox security adds minimal resource consumption and under 5 percent of end-to-end latency, which Red Hat presents as grounds for leaving isolation on by default.
- The design was full-factorial: three stack configurations across three concurrency levels of 1, 5 and 10 agents against the same vLLM backend, for nine runs in total.
Compiled by The Product DeskSomething wrong?How this is made
Why it matters
- decision A team that has been treating code-execution isolation as a performance tax now has a published figure to argue against, and it has to decide whether a number measured with an idle sandbox transfers to its own workload.
- constraint Capacity planning off this baseline understates real agent traffic, because the conditions of the run exclude the cost that grows with each additional turn of context.
- capability Span-level tracing gives a platform team a repeatable way to charge latency to a named stage of its own harness instead of arguing about the pipeline as a whole.
- contradiction The methodology says two progressively more complex configurations were benchmarked and then describes three stack configurations, so anyone reproducing the setup has to work out whether the third is the plain vLLM baseline.
Sizing a cluster for agents usually starts with a number taken from the wrong test. Red Hat's post says most inference benchmarks send a raw request to vLLM and count the tokens coming back [1], while a production request first goes through a harness that assembles context, manages sessions, injects tool schemas and, if you want isolation, provisions a sandbox before any token is generated [2].
The sub-5 percent figure is for bringing that sandbox up. Red Hat lists sandbox startup as one of its three analysis areas and defines it as the cost of provisioning isolated execution environments [13]. Tool calling was off in every run and every request was a single turn, a choice Red Hat made to separate framework overhead from the variable latency of tool invocations and accumulating history [6]. So the sandbox was provisioned with nothing to execute, and the figure does not cover what isolation costs while a container is actually running model-generated code.
C=10 here means ten drivers taking turns. Each agent is an independent OpenClaw instance driven by a dedicated GuideLLM worker sending 500 prompts per dataset to the streaming /v1/responses endpoint [9], and each prompt goes only after the previous response completes [10], so the backend sees at most ten requests in flight. Ten agents at 500 prompts is 5,000 requests per dataset in that run [14]. Between runs Red Hat restarted the vLLM serving runtime to clear the prefix cache [11].
Red Hat reports significant GPU spare capacity at that concurrency and concludes that the optimization opportunity is in the harness pipeline, not necessarily in faster hardware [5]. If sandbox provisioning is under 5 percent of end-to-end latency, everything else accounts for more than 95 percent, and token generation sits inside that remainder [15]. Splitting harness time from generation time is the job of Figure 1 and the tables; the text names context assembly, sandbox initialization and response processing among the five OpenTelemetry spans [12], and lists prompt expansion and SSE forwarding as framework overhead elsewhere [6].
For a team applying this to its own deployment, the split worth making is two per stage in the trace: whether the cost recurs once per session or once per turn, and whether it lands on the GPU or on CPU and I/O. Sandbox startup is once per session and off the GPU. Context assembly is per turn, on CPU, and grows as history accumulates. Generation is per turn and on the GPU. A run with tool calling disabled measures the once-per-session column cleanly and holds the per-turn column at one [6].
Red Hat says it published its methodology, tooling and results so engineering teams can benchmark and size their own OpenShift AI deployments the same way [18].
What to watch
- Whether the under-5% sandbox share holds in Part 2, once the sandbox executes tool code and conversation history accumulates across turns.
- Where GPU saturation lands in Part 3, when the shared cluster carries more than 10 agents.
- Whether the GuideLLM and OpenClaw configuration ships in a form another team can rerun against its own harness.