Standardize the Runtime Before You Scale the Agents

aiarchitecturesecurity

Introduction

Something structural happened in the last two weeks of September 2026. Several major vendors shipped agent runtimes within days of each other:

  • Docker shipped Cloud Sandboxes. Every agent gets a microVM with its own kernel, the same runtime locally or in Docker’s cloud, per-second billing, and secrets and policy gateways built in. Docker’s own framing was blunt: containers were not designed for the level of isolation AI agents demand.
  • NVIDIA launched the Open Agent Safety Platform. OpenShell, open-sourced under Apache 2.0, traces every agent action and enforces policy at runtime. NVIDIA’s Sentry runs as an out-of-band watchdog on BlueField DPUs, quarantining a misbehaving agent in milliseconds from a trust domain the agent cannot reach.
  • OpenAI’s Codex Cloud gave every task its own VM with a persistent, reusable dev environment.
  • The Kits specification started producing OCI-compliant images, headed for the CNCF.

Read these together and the direction is unmistakable. The agent runtime is becoming standardized infrastructure. Not a config choice per team. Not a snowflake per deployment. A contract: the same execution boundary, the same policy enforcement, the same observability, whether the agent runs on a laptop or in someone else’s cloud.

Most enterprises are about to scale their agent fleets by two orders of magnitude on runtimes that were never designed for it. The order of operations matters enormously: define the runtime contract first, then scale. The alternative is retrofitting governance onto ten thousand running agents, which is the most expensive migration path available and the one most organizations are currently walking.

Key Concepts

The Runtime Is Becoming a Contract

For most of the current agent wave, the “runtime” was whatever the developer happened to have: a laptop, a container with broad permissions, a cloud VM configured by hand. Sandboxing was a checkbox. Policy was a document. Observability was whatever the harness logged.

The September releases converge on a different model:

  • The execution boundary is a microVM with its own kernel, not a container sharing one.
  • The same boundary applies identically in local development and in the cloud, which means a policy written once is enforced everywhere.
  • Secrets, network egress, and tool permissions are declared at the boundary, not discovered in the code.
  • Billing is per-second against vCPUs, which means the runtime is metered like infrastructure, not approximated like headcount.

The sandbox stops being configuration and becomes a contract: a standardized, portable execution boundary with policy attached. That is the precondition for everything else. You cannot govern what you cannot define, and you cannot define what changes shape between environments.

This is a familiar maturation. Virtual machines standardized the server. Containers standardized the deployment artifact. Each time, the industry went through a phase of bespoke setups, then converged on a contract, and only then scaled. Agents are entering the convergence phase now.

Scale Multiplies Mess, Not Discipline

Ten agents with bespoke runtimes is manageable. A platform engineer can know each one, audit each one, reason about each one. Ten thousand agents with bespoke runtimes is not ten thousand manageable things. It is an unknowable system.

Every unstandardized dimension becomes an incident class at scale:

Unstandardized dimension Incident class at scale
Secrets handling that varies by team Credential-sprawl breach
Network egress that depends on who configured the VM Data-exfiltration path
Tool permissions granted ad hoc Privilege-escalation surface
Identity models inherited from human service accounts Attribution nightmare

None of these are hypothetical. They are the standard failure modes of every infrastructure wave, replayed because the runtime was never contracted.

The mess you tolerate in a pilot becomes the breach surface at scale. This is the arithmetic most agent strategies get wrong. They model the cost of the pilot and multiply by the seat count, but the risk does not scale linearly. It scales with the number of unstandardized decisions, and unstandardized decisions compound.

Discipline, meanwhile, does not multiply on its own. It has to be encoded in the contract, because no human team can hand-enforce policy across ten thousand agents. The contract is how discipline scales.

The Contract Has Four Clauses

A runtime contract worth the name covers four things. Miss one and the other three do not save you.

Identity. Agents are a distinct class of actors and cannot inherit human identity models. The contract issues scoped, short-lived credentials for every task, so every action carries an auditable authorization. No standing credentials, no shared service accounts, no ambiguity about who did what. When an agent touches production, the credential it holds should permit exactly that task and expire when the task ends.

Isolation. The execution boundary is the same everywhere: a microVM with its own kernel, declared resources, declared network egress, declared tool permissions. An agent that cannot reach beyond its boundary in development cannot reach beyond it in production, because there is no “beyond” that differs between the two. Isolation is a property of the contract, not of the deployment.

Observability. Every agent action is traced in a common schema, auditable by something outside the agent. This is the clause most often faked: logs that only the agent’s own harness can read, telemetry that lives in a vendor dashboard, traces that cannot be correlated across environments. The contract requires traces that an independent observer can audit, because verification must never depend on the subject’s own testimony.

Policy. The same authorization decisions, enforced the same way, in every environment. What an agent may do is declared at the boundary and enforced at runtime, not described in a wiki and hoped for. When the policy changes, it changes once, in the contract, and propagates to every runtime.

These four clauses are not new ideas. They are the standard infrastructure contract, applied to a new workload. That is precisely the point: agents do not need a novel governance philosophy. They need the boring, proven contract, extended to cover them. It is also the same set of controls that The Attacker’s Agent Stack Is Your Agent Stack argued must live below the session layer. The runtime contract is where they get built.

Standardize Before You Scale, Not After

The sequencing argument is economic:

  • Defining the runtime contract on a pilot fleet of fifty agents is a platform project: weeks of work, a small team, direct feedback.
  • Retrofitting the contract onto ten thousand agents already running production workloads is a migration: quarters of work, coordination across every team, and a long tail of exceptions that never quite close.

Every enterprise currently planning to “figure out governance after the rollout” is choosing the expensive path. The rollout is when the unstandardized decisions get baked in. The credentials get scattered. The bespoke VMs get built. The exceptions get granted. By the time governance arrives, it is negotiating with ten thousand incumbents.

The right sequence is narrow and deliberate. Stand up the runtime contract on a single high-value domain. Prove that identity, isolation, observability, and policy hold under real workloads. Then scale the contract, not just the agents. Each new agent inherits the boundary, the credentials model, the trace schema, and the policy. Scale becomes multiplication of something known-good rather than replication of something unknown.

What This Looks Like on the Ground

A platform team defines the agent runtime contract for its first production use case: contract renewals. Every renewal agent:

  • Runs in the standard microVM
  • Holds a scoped credential that expires with the task
  • Emits traces in the common schema
  • Is subject to the same policy in staging and production

Six months later the company expands to ten thousand agents across a dozen domains. Nothing about the governance model changes, because the governance was never per-agent. It was in the contract, and the contract scaled.

Conclusion

The September standardization wave is the industry telling you what comes next. The runtime is becoming a contract: same boundary local and cloud, policy attached, metered like infrastructure, auditable from outside. Docker, NVIDIA, and OpenAI all landed in the same place within days of each other, which is what convergence looks like.

The strategic question is sequencing. Standardize the runtime before you scale the agents. Define the four clauses (identity, isolation, observability, policy) on a pilot fleet. Prove the contract under real workloads. Then scale the contract.

Scale multiplies whatever you feed it. Feed it a mess and you get ten thousand incident classes. Feed it a contract and you get ten thousand agents running inside a boundary you defined, with credentials you issued, emitting traces you can audit, under policy you wrote once. That is the only version of “agents at enterprise scale” that survives contact with reality.