Failure Modes That Emerge When Hundreds of Concurrent Agents Share a Kernel Instead of Owning One
Shared kernels expose agents to cross-boundary failures no isolation plan prevents.

Firecracker micro-VM isolation gives each AI agent its own guest kernel rather than placing agents behind container boundaries within one shared kernel. This separates guest-kernel failures, memory emergencies, and kernel-level compromises by agent, although physical host resources remain shared. For hundreds of concurrent agents, the architectural question is not just how much capacity is available, but which failures can cross workload boundaries.
Why shared-kernel concurrency is a different class of problem than scaling a single agent
“More agents” sounds like a linear scaling problem. If one agent needs a certain amount of CPU and memory, hundreds appear to need proportionally more. That model leaves out the kernel state through which those agents operate, including process identifiers, network resources, and scheduler queues. An agent’s behavior changes the conditions under which its neighbors run.
The distinction is between workload growth and failure coupling. A crash or runaway subprocess in an isolated workload can remain that workload’s problem, while shared-kernel concurrency gives pathological behavior paths into unrelated agents. Namespaces separate some resources, including process identifier spaces and network stacks, but scheduler queues are not namespaced. Resource contention, security exposure, correctness failures, and operational interference therefore need separate analysis, rather than treatment as variations of insufficient capacity.
How the kernel's process and thread scheduler becomes a contention bottleneck under concurrent agent load
The scheduler is where independent bursts meet shared capacity. Linux CFS distributes CPU time by weight through per-core run queues, with O(log N) tree operations in the scheduling path. Hundreds of agents making unpredictable demands create scheduling work as well as application work. As runnable processes and wake-ups accumulate, contention can inflate tail latency even when each agent’s individual workload appears reasonable.
Tool-use loops make that pressure uneven. Agents that make frequent short-lived syscalls and wake subprocesses can cause too much context switching, which affects both co-resident agents and the agent doing the work. A CPU-bound subprocess doing compilation, embedding generation, or browser rendering adds a different pattern of demand. Without the right cgroup hierarchy, that subprocess can put scheduling pressure on neighbors that have little work to do.
CPU allocation is only part of the dependency. An agent executing a filesystem or network path may hold a kernel lock when it is preempted, leaving other agents waiting for the same resource. This can lead to priority inversion, a risk that a simple CPU usage chart does not explain. Cgroup v2 cpu.weight gives agents proportional shares when they compete for CPU time, but it sets no cap on CPU usage or bound on every scheduling delay. A hard CPU bandwidth limit requires cpu.max, and missing or misconfigured controls leave paths for interference even when other agents are constrained.
Memory pressure, OOM kills, and how one agent's allocation pattern becomes every agent's emergency
A critical agent can die because another agent exhausts memory. Under host-wide memory pressure, the OOM killer can select an unrelated process to terminate, freeing memory while destroying work that did not cause the emergency. Its selection uses memory-related heuristics and oom_score_adj. The victim and the cause can be different agents.
Linux can allow committed virtual memory to exceed physical RAM on the assumption that not every committed page will be needed simultaneously. Concurrent agents with substantial working sets can invalidate that assumption when their active phases overlap. Once physical memory is exhausted, termination is not a graceful form of backpressure.
Long-running mixed workloads introduce problems before exhaustion, too. Hugepage allocation failures and slab fragmentation can degrade allocation latency even when total free memory looks adequate. Swap can also add delay because a paged-out agent may stall when it wakes, which can look to its caller like an application defect.
Per-agent memory cgroup limits narrow this blast radius, but a changed failure contract remains. An allocation that returns ENOMEM requires handling that many agent frameworks are not written to perform gracefully, creating risks of lost data or corrupted state. Containment therefore does not establish recoverability. Memory management is also part of the shared kernel’s attack surface, linking resource exhaustion caused by accident to the more serious risk of kernel-level compromise.
How shared kernel namespaces turn one agent's exploit into a host-wide security event
When agents compete for shared resources, they can harm one another by accident. A kernel exploit turns that shared dependency into a security boundary failure. Namespaces and cgroups provide visibility and resource controls, but they do not give each container a separate kernel. Code that crosses those controls through a kernel vulnerability reaches the kernel serving other agents.
An agent can run arbitrary tool-generated code, which makes its syscall exposure especially important. An agent may run unusual syscall sequences that ordinary application paths rarely use, reaching vulnerable kernel behavior through the same interface its legitimate tools use. Device files offer another way in when agents are allowed to use block devices, USB, or GPU devices. Those drivers run in kernel context, and each agent lacks its own kernel.
Information exposure also depends on namespace and permission configuration. Read access to /proc/net or /proc/sysvipc can reveal network or IPC resources visible to the process, while open file descriptors are exposed through /proc/[pid]/fd. System V semaphores and shared memory segments remain shared when agents use the same IPC namespace. These are distinct mechanisms.
Seccomp-bpf and AppArmor/SELinux profiles reduce exposure, but their protection depends on accurate, maintained policies for each workload type. Agent diversity increases that operational burden. In a single-tenant VM, compromising the guest kernel still leaves a hypervisor boundary between the attacker and other guests. When agents share a kernel, a kernel-level compromise exposes co-resident agents and any host credentials the attacker can reach. Yet even without an exploit, agents can fail because shared kernel-managed resources violate their assumptions about ownership.
Concurrency anomalies that emerge when agents share kernel-managed global state
Agents that choose the same temporary filename without per-agent prefixes can race between checking a path and using it. With hundreds of concurrent agents, it is harder to treat overlapping names and operations as rare cases. Code that works correctly under exclusive ownership can behave incorrectly when deployment silently removes that exclusivity.
Process identifiers create a related ownership problem. Tool-call orchestration that treats a PID as a durable external identifier can reference the wrong process after PID recycling in a shared namespace. Signal misdirection then becomes a correctness risk. The important distinction is between an identifier that was valid earlier and the process that owns it now.
Agents that share a network namespace also share routing tables, netfilter rules, and socket port space, so a port binding or rule change can affect tools doing other work. Fork-based spawning can propagate parent file descriptors into child processes when close-on-exec is not set, exposing data across agents and consuming more descriptors than an isolated capacity model predicts. These failures do not require resource exhaustion first.
Shared identity can also defeat application assumptions. Agents in one UTS namespace see the same hostname, which can break hostname-based telemetry, routing, or licensing logic. The underlying defect may lie in an isolation assumption in the deployment. When shared state degrades service without producing an obvious wrong result, the same ownership problem becomes an observability problem.
Noisy-neighbor interference patterns that are invisible to per-agent monitoring
Standard per-container CPU usage, memory RSS, and network-byte metrics describe workloads without necessarily exposing contention inside the kernel. Full per-agent APM coverage therefore does not establish visibility into lock contention, cache interference, or softirq saturation.
Large working sets can displace other agents’ cache and TLB entries. CPU performance counters may show that cache miss rates are rising even when the affected agents are doing the same work as before. Network activity can cause another shared bottleneck when the kernel’s softirq budget leaves too little time to keep up with receive processing. Resulting packet loss from interference on each agent’s own host can look to that agent like instability in a remote service.
Storage produces similarly misleading symptoms. Agents writing to the same ext4 or XFS filesystem compete for journal commits, while a large writeback storm can delay another agent’s fsync() calls. The affected agent may report a data-safety timeout even though it writes little data itself. Its own metrics describe only the victim’s workload.
Host-level eBPF tracing or perf-based profiling can expose these mechanisms, but those tools are not necessarily running continuously. Their deployment can also require kernel support and privileges that complicate multi-tenant security. Finding the cause therefore takes information that routine per-agent dashboards leave out. Without that information, teams cannot reliably assign the interference to an agent’s service-level objective or charge that agent for the resources responsible for its delay.
How these failure categories compound when agents are long-running and stateful
A stateless function can often be retried after termination, while a stateful agent may lose in-flight work, cached credentials, open browser sessions, and filesystem state that cannot simply be reconstructed. A corrupted write is also different from a failed RPC call. Retrying the operation does not necessarily repair the state it left behind.
Time changes the host as well as the agent. Fragmentation and sustained cache interference can make a mixed workload behave differently after prolonged operation than it did at startup. Meanwhile, agents accumulate tokens, session cookies, and API keys on disk, increasing the sensitive state exposed by a kernel-level attacker. A longer lifetime expands both the recovery obligation and the potential security loss.
The categories can then form a cascade. Noisy-neighbor interference may prolong active work until agents’ bursty phases overlap, increasing scheduler pressure while their working sets remain live together. If that overlap exhausts host memory, an OOM kill can destroy a third agent’s state even though that agent caused neither the original slowdown nor the allocation burst. The initiating symptom, resource emergency, and final loss belong to different workloads. This is why examining each category independently understates the risk of persistent agents sharing one kernel.

How should agent infrastructure give each agent its own isolated kernel?
The architectural response is per-agent VM isolation, with Firecracker micro-VMs providing a way to assign each agent its own guest kernel. The choice is about the boundary being established. Namespaces and cgroups partition visibility and resource use within a kernel, while a micro-VM separates the kernel state itself. For untrusted agent code, Firecracker’s minimal device model and reduced VMM attack surface further constrain the path beyond a compromised guest.
That boundary changes several failure contracts at once. Each guest has its own scheduler and kernel-managed process, network, file descriptor, and IPC state, removing cross-agent races on those guest resources by construction. With dedicated vCPU allocation, guest scheduling no longer uses a common guest run queue, though host scheduling still matters. Hypervisor-enforced memory allocation also keeps one guest’s OOM decisions from choosing another guest’s processes to kill. It does not make termination harmless to the affected stateful agent.
Physical contention still needs its own account. Separate kernels do not eliminate shared cache, storage, network, or host CPU pressure, and per-VM metrics do not automatically identify which neighbor caused a delay. CPU steal time, memory pressure, and I/O wait can make interference visible within a VM, while accurate attribution can still require host-level instrumentation.
Stateful durability adds a further requirement beyond isolation. VM-level snapshot-and-restore preserves guest-kernel memory, including open file descriptors, in-memory structures, and socket state, without CRIU-style reconstruction of each resource. That lets infrastructure preserve state across sleep cycles, so the agent framework no longer has to do all of that work itself. The resulting design separates three obligations that shared-kernel deployments often blur, namely containing failures, observing physical interference, and preserving agent state. Each needs an explicit boundary rather than an assumption that another layer has already provided one.
Sources
- Position: Multi-Agent Systems Should Prioritize Concurrency Control
- Verified Detection and Prevention of Concurrency Anomalies in Multi-Agent Large Language Model Systems
- Always-OnAgents:A Survey of Persistent Memory, State, and Governance in LLMAgents
- Governed Shared Memory for Multi-Agent LLM Systems
- One kernel feature, 93% system throughput gone: A Red Hat Enterprise Linux 10.2 kernel regression and how to mitigate it
- AgentCgroup: Understanding and Controlling OS Resources of AI Agents
- SWAM: Revisiting Swap and OOMK for Improving Application Responsiveness on Mobile Devices
- CPU-Limits kill Performance: Time to rethink Resource Control


