From Single Bots to Agentic Infrastructure
AI agent orchestration is the emerging class of runtimes, control planes, and sandboxes that coordinate many persistent, stateful AI agents as they share memory, exchange tasks, and execute untrusted code in parallel, with isolation and scheduling tuned for millions of long-lived, mostly idle sessions rather than a handful of short-lived requests. This is no longer about one assistant and a prompt; it is about building infrastructure where agents behave more like operating system processes than web services. The headline story is that three new runtimes—Google’s Agent Substrate and Agent Sandbox, Raft’s team mode, and Perplexity’s SPACE—are quietly redefining what “scaling AI” means for serious automation. Together, they mark a decisive break from container-era thinking and push enterprises to treat agents as a new compute tier, not an add-on to yesterday’s platforms.
Google’s Agent Substrate: Kubernetes Steps Aside
Google’s move to make GKE Agent Sandbox generally available and introduce Agent Substrate is an admission that Kubernetes is the wrong control plane for AI agents. The container winner was built for a modest number of long-running Pods, not for millions of bursty, stateful sessions that sleep for hours and wake on events. Agents resemble OS processes: they need persistent memory, stable identity, and the ability to hibernate without losing context. For orchestration, that breaks Kubernetes’ assumptions about infrequent, durable placement decisions and a central API server that holds every object. Agent Substrate routes around this, pairing Agent Sandbox’s secure execution with a lean scheduler that sits alongside the cluster and keeps most agents out of the standard control plane. In effect, Kubernetes becomes infrastructure plumbing; agent-specific scheduling becomes a distinct layer, optimized for fine-grained events instead of coarse-grained services.
This is not a small tweak. It turns AI agents into a fourth compute option next to virtual machines, containers, and serverless. Agent Sandbox handles isolation by running model-generated, untrusted code inside hardened environments built on gVisor or Kata Containers, with default-deny networking and snapshotting that can lift idle sessions out of compute. According to Google, "the API can allocate 300 sandboxes per second per cluster, with 90 percent of allocations finishing in 200 milliseconds," a performance claim that signals real production intent rather than an experiment. The opinionated takeaway: if you are still trying to cram agents into Deployments and StatefulSets, you are fighting the platform. Agent-specific runtimes like Substrate will become the standard way to coordinate persistent memory agents at scale.
Raft’s Team Mode: Multi-Agent Platforms Meet Human Workflows
Where Google is reshaping the lower layers, Raft 1.0 attacks the daily reality of multi-agent work. Launched by RC as a full multi-agent collaboration platform built around "team mode," it replaces the mess of terminals, sessions, and separate agent windows with one shared workspace of channels, threads, tasks, and mentions where humans and agents work side by side. Each agent is a persistent process with its own identity, memory, and expertise, running on whichever runtime fits—Claude, Codex, Hermes, and more. Agents claim tasks, run in parallel, hand work to each other, and review each other’s output in shared threads, so the output of one becomes the starting point for the next. That is true multi-agent orchestration at the collaboration layer: not a single chatbot, but a team whose internal workflows resemble a small organization.
Raft’s design also answers a practical concern enterprises have ignored: control over compute and data. Execution happens on the user’s own hardware via a lightweight daemon, keeping code and data under local control rather than shipping everything to a remote black box. Over 20,000 agent-native builders and teams used the beta, averaging four agents per human—and power users running more than sixty. That usage pattern is a strong signal that serious builders do not want one super-agent; they want many specialized agents that cooperate. Raft is now available at raft.build with a free tier that includes channels, tasks, agents on local machines, and 30 days of message history, while an enterprise tier with private deployment and SSO is listed as coming soon. The message is clear: multi-agent platforms are moving out of hobbyist Discords into structured, enterprise-ready workspaces.
SPACE: Sandboxed Runtime for Persistent Memory Agents
Perplexity’s SPACE runtime takes the sandbox idea and pushes it into long-lived, persistent memory agents. SPACE—short for Sandboxed Platform for Agentic Code Execution—is a runtime for long-running agents that execute code, edit files, and complete multi-step tasks over hours, days, or even months. It separates the agent session from the sandbox that runs it: each task gets a disposable Firecracker microVM destroyed when the work ends, while rolling snapshots preserve memory and files so sessions can pause, resume, or branch across sandboxes. Each sandbox runs inside its own guest kernel, isolating untrusted workloads from the host and other tenants, with an in-guest daemon controlling filesystem and processes and a gateway regulating outbound network traffic. Credentials stay outside the sandbox, and enterprises can inject them at the network layer or encrypt external data with their own keys. This is a sandboxed runtime built for autonomy, not short transactions.
Crucially for AI agent orchestration, SPACE is engineered for performance and resilience. It supports persistent sessions with pausing, resuming, suspension, restoration, rollback, forking, and crash recovery, using regular disk snapshots for filesystem changes and full snapshots for the paused VM. Suspended sessions upload to object storage so another node can restore the agent with its prior state. Perplexity built the storage layer on btrfs, using copy-on-write cloning and atomic snapshots to cut startup times and storage use. In production, median sandbox creation time fell from 185ms to 60ms, and P90 latency from 447ms to 89ms—making SPACE between 3.1 and 5 times faster than the previous sandbox system. The platform already powers 100% of Perplexity Computer sessions, handling millions of sandbox creations and tens of millions of reconnections, and is set to expand across more products, Linux microVMs, Windows guests, and even users’ local machines.
The New Control Plane for Enterprise Automation
Viewed together, these three platforms show that the era of single-agent tools is ending. Google’s Agent Substrate turns sessions into first-class workloads and builds a dedicated scheduler that lives beside Kubernetes instead of inside it. Raft treats agents as teammates with persistent memory, parallel execution, and shared workspaces that bind tasks to conversations. Perplexity’s SPACE builds a sandboxed runtime where persistent sessions can survive naps, crashes, and migrations while keeping untrusted code and credentials apart. All three accept that agents are long-running, stateful sessions that wake on events, need to hibernate without losing RAM or filesystem, and must run in hardened boxes because the code they execute is model-generated and cannot be trusted by default.
The practical impact for ordinary users is already visible: Raft users move from juggling terminals to a single workspace where agents and humans work side by side, while Perplexity users get agents that can stay attached to long tasks without sacrificing isolation. But the deeper consequence is architectural. The "session-aware, isolated runtime for agents" is becoming a fourth compute offering next to virtual machines, containers, and serverless. The next thing worth watching is whether this agent control plane consolidates around one open project, like container orchestration did, or fragments into hyperscaler-specific stacks that recreate today’s silos one layer up. My view: enterprises that want durable, multi-agent automation must treat these runtimes as core infrastructure choices, not optional developer toys. The winners will be those who standardize early on agent-native orchestration and sandboxed runtime patterns—before the control plane solidifies around them.
