Designing AI Agents

From Shared Agent Pool to Per-User Agent Identity at Production Scale

Per-user agents need isolated microVMs and scoped credentials, not just authentication.

· 9 min read
Cover illustration for “From Shared Agent Pool to Per-User Agent Identity at Production Scale”
Per-User Agent Patterns · November 12, 2026 · 9 min read · 1,928 words

Per-user persistent AI agent deployment at scale is an infrastructure problem as well as an authentication problem. Each user’s agent needs an isolated, persistent computer that holds state, limits access, and supports an attributable audit trail. Moving from a shared pool changes the machine boundary, the path credentials take, and the audit records, while keeping the application logic that already works.

Why shared agent pools fail when user count grows

An agent that cannot say whose authority it is acting under cannot be trusted in production. Yet the common starting point is a single service account connecting every user’s agent session to backend systems. Everyone borrows the same identity and permission set. The backend attributes actions to the shared account, so its audit records cannot distinguish one user’s actions from another’s.

That ambiguity compounds when credentials and session state are shared. A narrow task can get access meant for broader work, and context one user leaves behind can reach another session. Better prompts do not fix either problem. Tightening OAuth scopes also leaves shared memory and disk untouched.

Avatier’s 2026 identity reference identifies two early mistakes, treating the agent as a service account and passing it the user’s actual token. The first loses user attribution. The second makes agent actions indistinguishable from human actions. In production, an agent needs its own identity, clear authority from the user, and an isolated place to act on that authority.

What per-user identity actually requires, beyond authentication

Authentication answers who the agent is and on whose behalf it acts. It does not remove another user’s files from the runtime or keep credentials in shared memory safe. Identity alone leaves that boundary unfinished. Avatier describes a pattern in which the agent holds its own standing identity while per-invocation delegation tokens supply the user’s authority separately.

The same reference distinguishes user-delegated, autonomous, hybrid orchestrated, and scoped impersonation architectures. Each preserves authority differently, so mixing them without explicit policy creates ambiguity about who can authorize what. A user-delegated task and an autonomous task cannot simply inherit the same assumptions because both use an agent.

Even with the right identity pattern, broad provisioning scopes, token theft, and prompt injection are still risks when agents run. A valid token can still allow an action the user never meant to take. Runtime authorization therefore has to accompany authentication, and the audit record has to separate authorization from execution. At the machine layer, that means each user’s agent needs its own memory, disk, and credential environment.

Why isolated compute — not containers — is the right boundary for per-user agents

With shared-kernel containers, users all rely on the same kernel boundary. Their processes share underlying host memory surfaces and page cache, and a compromised container can escalate to the host. Generated code deserves no special trust here. When an agent can execute model-generated code, container separation is not the hardware boundary that per-user state calls for.

A Firecracker microVM gives each user’s environment its own kernel, memory, and disk. That boundary is designed to contain a compromise within the VM rather than expose neighboring agent environments through a shared kernel. It also supplies the basis for persistence. Full snapshots capture the microVM’s state and memory, while diff snapshots capture memory written since the previous snapshot.

To avoid repeated cold boots, a pristine, credential-free sandbox can be snapshotted at boot and cloned copy-on-write for each user. But cloning has a security catch. Firecracker’s documentation warns that resumed clones can share pseudo-random generator state, identifiers, cached random values, and cryptographic tokens. It recommends reseeding on resume, with Linux 5.18+ providing automatic support through VMGenID and older kernels or userspace state needing explicit handling.

The economic advantage comes from suspension. A sleeping microVM consumes storage while active RAM and compute use are suspended.

How IBM's deterministic layer approach reduces what the agent has to guess

IBM TechXchange 2026 describes four deterministic layers around the model, namely facts, functions, permissions, and records. Facts come from live data lookups. Functions come from a pre-approved tool catalog, permissions from runtime authorization, and records from rules about what gets logged. The model reasons within those boundaries.

Whether a tool is allowed is an authorization decision. Likewise, the model should not decide which facts are up to date or which actions must go in an audit record. Deterministic components answer those questions with inputs and rules that have been set.

That separation also makes growth less dependent on model complexity. Lookups, catalogs, rules, and logs do the same kinds of work as the number of agents grows. Inside a per-user machine, they govern that user’s facts, available tools, permissions, and records. Compute isolation separates the environments, while these layers govern the work performed within each one.

How does each user’s agent remember context between sessions?

A database record of the conversation is not the same thing as a paused computer. Rehydrating context on every invocation can recover application data but misses files, runtime memory, and open application sessions. The agent then has to reconstruct its working environment. Persistence at the machine layer instead makes continuity a checkpoint-and-resume problem.

The pristine warm snapshot and the user’s working checkpoint serve different purposes. The first supplies a clean starting environment without a cold boot. The second preserves the user’s work between sessions. Filesystem snapshots preserve disk state, while resuming in-memory state requires the memory snapshot described earlier, so those mechanisms are not interchangeable.

With that distinction in place, the machine can sleep between tasks and resume. The described sleep-and-wake pattern resumes in well under a second, typically tens to hundreds of milliseconds.

For a long-running workflow, continuity includes the signed-in application session as well as the files. An agent can sign into a service, navigate several steps, and return to its checkpoint later. Preserving that session preserves the working environment, subject to the service’s expiry rules.

What per-user identity requires from the credential and protocol layer

The isolated machine still needs narrowly bounded authority. Its credentials must be short-lived, task-scoped, and tied to a delegation chain leading back to the invoking user. Otherwise, isolation merely gives an overpowered credential its own room. The machine boundary and the token boundary have to agree about whose task is running.

For a user-delegated agent, OAuth 2.1 with PKCE handles initial user consent and access-token issuance. A JWT bearer assertion can then be exchanged for an access token when invoking a downstream API. MCP supports user-delegated authorization through OAuth 2.1, but it does not propagate the original delegation context into third-party tool calls. The MCP server issues its own access token tied to the third-party session, and the MCP specification does not cover downstream authorization.

AppScale’s 2026 NHI guide identifies five capability-token claims. These are the agent workload identity in sub, the represented user in act, the policy-derived task scope in scope, a short expiry in exp, and the downstream service audience in aud. Together, those fields describe the actor, authority, permitted work, time limit, and destination.

Workload identity mechanisms including SPIFFE/SPIRE, WIF, and IRSA replace static API keys with attested workload identity. Credentials can then be issued per task. The audit record retains both identities. It can distinguish the agent that executed an action from the user who authorized it.

Automating legacy desktop applications in regulated industries without APIs

Some regulated workflows offer no API path at all. They run through legacy Windows applications, proprietary EHR systems, claims platforms, government portals, mainframe terminal emulators, or Citrix desktops. For those workflows, an agent needs a desktop it can use as well as tools for calling services. Prior authorization and loan origination are practical tests of whether the architecture supports real work.

Vision-based computer-use agents read what is on screens. That gives them a way to adapt when a payer portal changes its interface, whereas a selector-based script can require re-recording. If every interface change needs another recording, the script is still just as fragile even with an AI label.

A per-user desktop adds continuity to that visual interaction. Its checkpoint can retain the authenticated EHR environment, avoiding repeated setup where the session remains valid. In the Citrix pattern, the agent’s microVM runs a Citrix client connected to the hospital’s virtualized desktop. The agent operates within that session without changes to the EHR vendor’s infrastructure.

Where a platform runs can rule it out even if it meets the other needs. Where PHI cannot leave the customer’s perimeter, the environment must run on-premise or inside the customer’s own cloud VMs. Operating-system coverage is another constraint. Workflows that span Linux, Windows, and Android need support for those machines because every task cannot be assumed to fit a browser.

HIPAA, audit trails, and the security argument for per-user compute in healthcare

If two patients’ prior-authorization workflows pass through one process, application controls must prevent the first patient’s data from reaching the second session. Shared memory makes that separation harder to inspect. Separate microVM memory and disk make the boundary part of the infrastructure.

A machine assigned to a user does not, by itself, define which patient records that user may access. Minimum-necessary access still depends on scoped permissions and runtime enforcement. Isolation keeps neighboring environments from sharing state, while authorization limits what the current environment can get.

Auditability requires the same combination of structure and enforcement. A standing agent identity plus separate user delegation makes file reads, form submissions, and API calls attributable to both executor and authorizer. Those identities give the recording layer the information needed for a clean audit trail and incident investigation.

HHS treats encryption as an addressable specification under the Security Rule and does not mandate role-based access by name. That distinction prevents architecture from being mistaken for a compliance certificate. An infrastructure provider processing PHI is a business associate and needs the appropriate Business Associate Agreement, but isolation does not erase application responsibilities. The same structural argument applies to lending, insurance, and property management, where shared credentials and state also obscure access and accountability.

Designing the transition from shared pool to per-user machines without rebuilding everything

Diagram: Four-Stage Migration: Shared Pool to Per-User Machines. Visualizes: Show the four sequential stages of transitioning from a shared agent pool to per-user isolated machines, as described in the article.

The move can keep the same application logic, model integrations, tool definitions, and business rules. What changes is the infrastructure around them. Provisioning moves from one pool to one machine per user, credential issuance moves from a shared account to delegated authority, and audit records gain both agent and user identity.

A practical decision framework begins with attribution. In the first stage, the team instruments the existing pool with per-request audit context so it has a baseline before splitting compute. That makes regressions easier to detect. The second stage moves high-sensitivity or high-privilege workflows onto per-user machines while less sensitive work remains pooled.

The third stage replaces shared credentials with per-agent workload identity and short-lived delegation tokens. Teams can combine this with the compute move or handle the credential path independently. The fourth stage extends the established machine, credential, and audit pattern to the remaining workflows. The sequence is a framework, not a requirement to maintain four separate projects.

With per-second active-compute billing and sleeping machines, idle users consume storage while running capacity is suspended. That removes the assumption that a dedicated environment must cost more than pooling. Snapshot-and-resume also provides a migration path for work already underway, allowing a machine to be checkpointed, moved, and resumed.

An operator can view and control the same environment when an agent needs help, rather than infer its position from a headless shared process. The per-user machine is the agent’s computer, with persistent work, an isolated boundary, a resumable session, and an observable desktop that a human can take over.

More in Per-User Agent Patterns