substrate

Product Introduction

1. Definition: Agent Substrate is an open-source, Kubernetes-native control plane and runtime environment specifically designed for the high-density, stateful orchestration of AI agents and similar long-lived, interactive applications. It functions as a specialized scheduler and lifecycle manager that sits atop Kubernetes.
2. Core Value Proposition: It solves the critical infrastructure problem of fragmented and inefficient AI agent deployment by providing a unified, scalable foundation for running stateful agents. Its primary value is enabling heavy multiplexing of a large number of intermittently active "actors" onto a smaller pool of physical compute resources, dramatically reducing infrastructure costs and latency for large-scale multi-agent AI applications.

Main Features

1. Sub-Second Actor Lifecycle Management: Agent Substrate provides full lifecycle control for agent sandboxes, specializing in fast suspend (hibernate) and resume (activate) operations. It achieves this by taking full-state snapshots of an actor's volatile memory (RAM) and filesystem, storing them in object storage (like Google Cloud Storage), and restoring them onto any available worker pod in under a second, enabling instant agent teleportation.
2. Sandbox-Agnostic Runtime with gVisor & MicroVM Support: The system is designed to be low-level and flexible. It supports multiple secure sandboxing technologies, primarily gVisor (a container sandbox) and cloud-hypervisor for micro-VMs. This allows developers to choose the isolation boundary appropriate for their agent's security needs while maintaining consistent lifecycle management APIs across all sandbox types.
3. Kubernetes-Native Architecture & Declarative Configuration: Agent Substrate extends Kubernetes, leveraging its Pods, autoscaling, and networking primitives. Users manage resources through familiar Kubernetes patterns using Custom Resource Definitions (CRDs) like WorkerPool, ActorTemplate, and Atespace. This provides a consistent operational model and allows holistic infrastructure management alongside other Kubernetes workloads like inference servers.
4. Intelligent Traffic Routing with Request Parking: The integrated atenet networking controller handles DNS and HTTP/gRPC routing, dynamically directing requests to the specific worker pod where an actor is currently active. A key feature is request parking, where during periods of oversubscription, incoming requests are held in a queue until a worker becomes available, instead of failing with a 503 error, improving reliability under load.
5. Framework and Harness Agnosticism: Unlike many AI agent platforms, Agent Substrate does not impose an SDK or specific programming model. It runs standard OCI containers, making it compatible with agents built using any stack, including LangChain, Claude Code, Agent Development Kit (ADK), or custom frameworks. It provides the "plumbing," not the agent logic.

Problems Solved

1. Pain Point: Inefficient Resource Utilization for Idle Agents. Traditional container orchestration treats each always-running agent as a separate pod, leading to massive resource waste as agents spend most of their time idle, waiting for user input or LLM responses. This makes large-scale agent deployment prohibitively expensive.
2. Target Audience: Platform Engineers and SREs building production AI agent systems, Developers of multi-agent applications requiring coordination, and Teams needing secure, sandboxed tool execution (e.g., for Model Context Protocol/MCP servers). It is for those who need to go beyond prototyping to deploy hundreds or thousands of persistent, stateful agents.
3. Use Cases: Hyper-scalable Customer Support Agent Swarms where thousands of personalized agent instances can be multiplexed onto dozens of machines. Durable Coding Environments like Claude Code, preserving terminal state across sessions. Secure Sandboxed Tool Servers for LLMs that require persistent filesystem state. Large-scale simulation environments with many intermittent participants.

Unique Advantages

1. Differentiation: Compared to simply using Kubernetes Deployments or even KEDA, Agent Substrate operates at a lower level, managing the full kernel-level state of sandboxed containers/VMs for true sub-second resumption. Unlike serverless platforms (e.g., Cloud Run), it preserves in-memory state between invocations. Compared to other agent frameworks, it focuses exclusively on the infrastructure layer, not the agent SDK.
2. Key Innovation: The core innovation is the "actor-worker" multiplexing model combined with full-state snapshotting at the sandbox (gVisor/VM) level. This allows Agent Substrate to treat physical worker pods as a generic compute pool, dynamically mapping a much larger set of logical, stateful actors onto it based on real-time demand, achieving 30x or higher oversubscription ratios without sacrificing user-perceived latency.

Frequently Asked Questions (FAQ)

1. What is the difference between Agent Substrate and Kubernetes? Agent Substrate is not a replacement for Kubernetes; it is a specialized add-on that runs on top of it. While Kubernetes manages the lifecycle of worker pods, Agent Substrate manages the lifecycle of actors (agents) inside those pods, providing agent-specific scheduling, state snapshotting, and fast resumption that vanilla Kubernetes does not offer.
2. Can I use Agent Substrate with my existing LangChain or AutoGen agents? Yes. Agent Substrate is framework-agnostic. If your agent can run in a Docker container, it can run as an Actor on Substrate. You would containerize your existing agent application and define it via an ActorTemplate. The substrate handles the runtime environment and persistence, not the agent logic.
3. Is Agent Substrate ready for production use? No. The project is explicitly in early development. The APIs are unstable and subject to change, and it is not yet intended for production-critical workloads. It is currently a technology demonstration and a foundation for ongoing development.
4. How does Agent Substrate handle persistent storage for agents? It provides state persistence through two primary mechanisms: volatile working memory preserved via RAM snapshots, and filesystem state preserved via filesystem snapshots. Both are captured during suspend and restored during resume, giving the agent the illusion of having run continuously. For long-term storage, actors can mount standard Kubernetes PersistentVolumes.
5. What are the main components of the Agent Substrate architecture? The key components are: the ate-apiserver (control plane API), the atelet (node agent managing workers), the atenet (networking/router layer), and the ateom (in-pod helper for snapshot operations). These work together with Kubernetes CRDs to manage the entire lifecycle.