Why Multi-Tenant Agent Platforms Allocate a Dedicated VM per Tenant Instead of Sharing Serverless Pools
Dedicated VMs give agents a hard boundary that shared pools lack.

Persistent AI agent infrastructure must preserve a running environment as well as handle requests. Agents hold credentials, write files, run generated code, and pause between steps. A dedicated VM per tenant gives that work an enforceable execution boundary, while shared serverless pools leave tenant separation dependent on application checks that agent-generated code can bypass.
Why long-running agents cannot be treated as stateless web requests
A request arrives, a function executes, and the invocation ends without owning persistent state. A multi-step agent does the opposite. It maintains a session, accumulates files, and may stop halfway through a task while waiting for a person or an external event.
That difference changes what the infrastructure must preserve. Restarting a function is not the same as resuming an agent with its working memory, files, and tool access intact. An application can explicitly save and rebuild state, but that puts the work of reconstructing the session on its developers. The execution environment itself offers no continuity.
Credentials make that continuity more than a storage problem. An agent that reads files and calls external APIs holds live secrets the whole time it works, even between tool calls. EnterOS’s workspace-placement RFC, core #1819, calls the threat model “unpredictable code with credentials”. Those credentials exist inside the execution boundary, so the strength of that boundary determines what the agent can reach.
Why logical isolation breaks down when the tenant is an autonomous agent
Application-layer tenant separation relies on every path to customer data having the right access check. Human developers can build those checks into the code paths they know. An agent can create new paths at runtime. It can generate code, read files, and call endpoints that were not part of a fixed application workflow.
EnterOS describes how tenant scope can disappear after login as work moves through tools, queues, caches, artifacts, credentials, and logs. A tenant_id in a prompt expresses intent without enforcing an access restriction. The same is true when a model supplies it as a tool argument.
Archil identifies retrieval as a concrete source of leakage. A similarity query against a shared embeddings index can return another tenant’s vectors if it omits the tenant filter. A shared knowledge graph can merge unrelated customer records, while names such as production or main can resolve to the wrong tenant’s resource. No attacker is needed for these mistakes.
Background work extends the same risk beyond the visible session. Summarization, reindexing, and graph enrichment jobs can read shared records with elevated credentials and write results without reapplying the tenant restriction. EnterOS therefore places each tenant on its own machine. If another tenant’s data is on a different host with no route to it, a missing query filter cannot retrieve it.
Why shared-kernel containers cannot enforce the boundary agents require
Containers separate processes, but they share the host kernel. Docker namespaces do not give each tenant a separate kernel to attack. If generated code exploits a vulnerability in that shared kernel, the escape can expose the host and neighboring tenants. Stronger application checks do not remove this structural dependency.
The boundary has four parts to examine. Compute isolation controls where code runs, storage isolation controls which data it can read, credential scope controls whose authority it holds, and network restrictions control where it can connect. A container boundary addresses only part of that problem. An over-scoped API token keeps its broad access even when process separation works as it should.
Prompt injection makes the other parts especially important. Agents process external content that can redirect their behavior, and redirected actions use whatever privileges the execution environment permits. A sandbox does not distinguish a legitimate instruction from a malicious instruction the agent has accepted.
In practice, excessive credentials or open egress paths are more common failures in the notes than kernel escapes. An agent can exfiltrate data while remaining inside a correctly configured process sandbox. The shared kernel sets a limit on containment, but credentials and network access determine how much damage can occur without crossing it.
What production container escapes and prompt injection disclosures revealed about the threat model
Named vulnerabilities need to be read for what they actually demonstrate. CVE-2025-59528 is a code-injection and remote-code-execution flaw in FlowiseAI Flowise. It supports concern about executable application inputs, but it does not establish a shared-kernel failure. Confusing those mechanisms produces the wrong defense.
Microsoft’s May 7, 2026 research post, “When prompts become shells”, accompanied the fix for CVE-2026-25592 following its original disclosure. The OWASP Top 10 for LLM Applications identifies prompt injection as the leading LLM vulnerability. The practical danger is the agent’s tool access. Adversarial input becomes consequential when the agent can act on it with real privileges.
EnterOS supplies a less dramatic but equally useful example. A GITHUB_TOKEN automatically seeded to new tenants had broader access than any single tenant should hold. The change cp #204 removed it. No external attacker was required to create the exposure, because the credential delivery itself crossed the intended boundary.
These failures are grounds for treating generated code as hostile by default, though a sandbox cannot prevent prompt injection. Its job is to contain the consequences. Firecracker raises the escape barrier because code must break through both the guest kernel and the hypervisor layer, rather than exploiting the single shared kernel of a standard container.
How Firecracker microVMs satisfy the isolation requirements containers cannot meet
Firecracker gives each workload a dedicated guest kernel behind hardware virtualization. Agent code does not call the host kernel directly through its system-call interface. A guest-kernel vulnerability therefore does not, by itself, expose the host or neighboring tenants. The additional boundary is the crucial change.
MicroVM startup is fast enough for allocation per session or task, while snapshot-restore avoids repeating a full boot for each allocation. Firecracker captures memory, CPU registers, and device state from a running VM. Restoration memory-maps the snapshot file and loads the captured CPU state so execution can resume where it stopped. This preserves an execution environment rather than reconstructing one from application records.
Firecracker’s diff snapshots are still a developer preview in the supplied sources, so hibernation writes all guest memory each time. That affects snapshot storage costs as the number of suspended agents grows. Suspension removes active compute charges under the described billing model while retaining the cost of keeping state.
Archil identifies Firecracker and Kata Containers as approaches that place a dedicated guest kernel behind hardware virtualization. The mechanism makes tenant-specific execution practical without claiming that every VM must run continuously. Production implementations then combine that compute boundary with tenant-scoped identity, storage, and network access.
How production platforms have implemented the microVM-per-tenant model
Axonius’s AgentCore case study, published in August 2026, describes hundreds of isolated customer environments, each with a dedicated VPC. The company extended that silo model to agents. It needed to work with each tenant’s identity system, track costs, and limit API access to each customer’s workload. Isolation had to survive the move into agent execution.
The trade-off was explicit in that choice. A silo provides dedicated compute and avoids shared process state, while a pool supports rapid onboarding but makes separation depend on application code. Axonius chose continuity with its existing customer boundary.
EnterOS implements the same principle at the host layer. Its control plane is the only multi-tenant component, and no agent code runs there. Each organization receives a tenant EC2 instance whose instance role is scoped to that tenant’s resources. Workspace containers run within that host, where they share a trust domain and deliberately provide a softer boundary.
With that setup, tenants share no filesystem, process environment, or secret store. EnterOS also moved workspace configuration out of EC2 user-data and into AWS Secrets Manager, fetched at boot using the tenant’s instance role. The change removed a shared delivery path that could truncate or cross-contaminate configuration. Once execution and secrets are separated this way, the next requirement is preserving the tenant’s environment between sessions.
What persistent state across sessions requires from the underlying infrastructure
An agent task may span hours or days, with long gaps between useful actions. The task can stay available while compute is idle during those gaps. It does require preserving enough state to resume meaningfully. Killing a process and starting another loses the in-memory state unless the application has explicitly saved it.
VM-level snapshots move that responsibility below the application. Firecracker preserves RAM, CPU registers including instruction and stack pointers, and device state such as virtio queues and serial port state. The agent code need not know it was suspended. Application-level checkpointing, by contrast, requires developers to decide what to serialize and how to rebuild it.
Persistent environments also support a concrete human intervention. A VM with display capability lets an operator connect to the agent’s desktop session when it is stuck or needs approval. Preserving that desktop session for takeover requires an execution capability beyond what a stateless function provides.
Snapshots provide parallelism as well as continuity. A single snapshot identifier can create multiple sandboxes from the same captured filesystem and memory state for evaluation pipelines and RL rollouts. In regulated workloads, that controlled starting point sits beside a separate requirement for complete audit trails.
Why regulated industries face additional constraints that make shared pools legally untenable
Healthcare, lending, and insurance require agents to handle sensitive data and work with legacy software. Agents operating EHR systems, Citrix environments, Document Management Systems, or Loan Origination Systems may need a full graphical desktop for each tenant session. A headless serverless function cannot provide that environment. Some legacy thick clients also require Windows VM support beyond what Linux microVMs provide.
The compliance architecture described here has on-premises or VPC-isolated infrastructure, complete audit trails, and Business Associate Agreement–ready governance that covers HIPAA and HITECH. Each tenant’s environment must be independently auditable and isolatable. Those technical controls must be in place even with a BAA. PHI in an agent’s memory or filesystem still needs a boundary that generated code cannot bypass through application-level access paths.
Storage must follow the same separation model. Archil recommends database-per-tenant designs and separate credentials when regulatory requirements, customer-managed encryption, independent restore needs, or unusually large tenants call for them. Infrastructure must accommodate these requirements according to the workload.
Signed URLs remain a separate access decision. A service must check object ownership before signing, because signing any object key supplied by an agent can bypass otherwise sound controls. That authorization error remains even in a dedicated VM. Regulated deployments therefore require both isolated execution and correctly scoped data access, which also shape their cost and operating model.
How to choose the right isolation boundary for a given agent workload
The decision should start with state lifetime, code trust, and data sensitivity. A stateless, single-step tool call can use a pool when its trust and data requirements allow it. An agent that resumes across idle periods needs persistent execution infrastructure. Most production agents cross at least one threshold that ordinary shared-container isolation does not address.
To turn that assessment into an architecture, examine compute, storage, credentials, and network access separately. Compute must contain the code the agent can execute. Qovery itself is not a microVM sandbox runtime and must be paired with one for those workloads.
Checks on storage and credentials must then match which tenant owns the data. Access restrictions must be enforced on shared records, and stricter requirements mean each tenant needs its own databases and credentials. Network isolation is an independent decision. Agents that work with PHI, financial records, or customer-scoped enterprise data need the per-tenant VPC or account boundary described here as well as isolated session compute.
Teams can assemble these controls themselves or use a managed service that supplies the VM, network boundary, and credential scoping while the customer supplies the model and keys. Both paths are legitimate. The final economic test is how idle environments are metered. Per-second billing for active compute, with suspended VMs charged for storage rather than running compute, makes dedicated persistent agents commercially viable without paying for every hour they spend waiting.


