The Agentic Cloud
The industry is making a category error.
We are attempting to force Autonomous Agents into the “Twelve-Factor App” paradigm. We treat them as stateless microservices, offloading their memory to databases and killing their processes after every HTTP response.
But Agents are not Apps.
| Apps | Stateless Logic |
| Databases | Stateful Storage |
| Agents | Stateful Logic |
An Agent is a Session. It is a continuous loop of perception, reasoning, and action that might last for minutes, days, or weeks. The current cloud stack (Kubernetes + Postgres + REST) separates compute and state too aggressively for entities that need to “remember” and “reason” continuously.
The State of the Ecosystem
We are currently in the “fragile prototype” phase of Agentic AI.
Developers today build agents by stitching together Python scripts, vector databases, and API keys. Frameworks like OpenAI Agents SDK and Pydantic AI provide the application logic, but they run on infrastructure built for stateless web servers.
This mismatch creates brittleness. When an agent pauses to wait for user input, the server often kills the process to save resources. When an agent needs to remember a fact from last week, it clumsily re-queries a vector store without context. We have built the applications, but we lack the Operating System.
The Primitives
We define the Agentic Cloud through five core categories, each containing the specific primitives required to build this new computer.
Agent Runtime
The Agentic Runtime manages the Lifecycle and Safety of an autonomous loop. It is not just a container orchestrator; it is a Durable Execution Engine.
The Checkpoint (State)
An agent’s thought process is valuable data. If a server crashes or waits for human input, the agent must not “die.”
| Definition | Automatic serialization of the stack trace and memory variables to disk, allowing “Durable Execution.” |
| Function | Enables the State/Hibernate Loop—agents can sleep for days without burning GPU, then wake up exactly where they left off. |
| Examples | Temporal, Restate, LangGraph Checkpointers |
The Sandbox (Compute)
Agents solve problems by writing and executing code on the fly. This code is generated at runtime and is inherently untrusted.
| Definition | An ephemeral, secure micro-VM that allows the agent to execute generated code (Python/JS) and use terminal commands without endangering the host. |
| Function | Provides the “hands” for the agent to manipulate data, generate charts, or test software. |
| Examples | E2B, Firecracker MicroVMs, Deno Deploy, gVisor |
The Trace (History)
Unlike traditional apps where logic is deterministic, agents are probabilistic. Debugging requires a perfect record of the reasoning chain.
| Definition | An immutable, structured log of every “Thought → Plan → Action → Observation” cycle. |
| Function | Enables “Time Travel” debugging. Developers can replay a failed session step-by-step to see exactly where the logic drifted. |
| Examples | LangSmith Traces, Arize Phoenix, OpenTelemetry for LLMs |
Agent Memory
Memory is not a single database query; it is a composite operating system that manages information hierarchy.
The Working Directory (Hot/Mutable)
Agents need a “scratchpad” that is more structured than a context window.
| Definition | A temporary, mutable filesystem where the agent can create files, write diffs, and store intermediate artifacts. |
| Function | Allows “Grounding.” The agent creates actual files (e.g., report.md) in its working directory rather than hallucinating content. |
| Examples | Claude Artifacts, OpenAI Code Interpreter Environment |
The Episodic Index (Warm/Log)
| Definition | A vector-indexed log of past sessions and decisions. |
| Function | Pattern matching against history. “How did I fix this error last time?” |
| Examples | Pinecone, Weaviate, MemGPT |
The Semantic Graph (Cold/Fact)
| Definition | A strict graph database defining relationships and facts. |
| Function | Governance and Truth. “User A is a Manager.” This data does not degrade or hallucinate. |
| Examples | Neo4j, FalkorDB |
Connectors
Agents need a standard interface to access the world, rather than distinct SDKs for every service.
The Tool Mount (Interface)
| Definition | A universal schema that transforms external APIs into local “function calls” or “read resources.” |
| Function | Decouples the agent from the API implementation. The agent sees tools.stripe_charge(), not a REST endpoint. |
| Examples | Model Context Protocol (MCP), OpenAPI Specs |
The Auth Proxy (Access)
| Definition | A middleware layer that holds the API keys (OAuth tokens) and manages refresh cycles. |
| Function | The agent never sees the raw API key. It requests action, and the Proxy injects the credentials if the agent is authorized. |
| Examples | Nango, Clerk, Tray.io |
The Control Plane
In an autonomous system, “Identity” is not just a login; it is the control mechanism that limits the blast radius of an agent. The Control Plane governs what agents can do.
The Identity (Auth & Wallets)
| Definition | A sovereign identity for the agent (e.g., AgentCore Identity) that is distinct from the user but authorized to act on their behalf. |
| Function | Enforces Intent-Based Access Control (IBAC). Instead of giving an agent a credit card, the user signs a cryptographic “Mandate” authorizing a specific intent (“Spend up to $50 on travel”). |
| Examples | AWS Bedrock AgentCore Identity, ERC-6551 (Token Bound Accounts), Google AP2 |
The Supervisor (Observability)
The Supervisor pattern is emerging as a critical governance layer for autonomous systems.
| Definition | A meta-process that monitors the agent’s reasoning logs for infinite loops, hallucinations, or policy violations. |
| Function | The “Circuit Breaker” for intelligence. It can interrupt a runaway agent, rollback to a safe checkpoint, or require human intervention before a high-stakes action. |
| Examples | LangSmith, Guardrails AI, Arize Phoenix, Microsoft Agent 365 |
Protocol
How do agents collaborate without tight coupling?
The Service Card (Discovery)
| Definition | A standard manifest file hosted by an agent that declares: “I am a Research Agent, I accept these inputs, and I cost $0.05 per run.” |
| Function | Allows agents to browse a directory and “hire” other agents dynamically. |
| Examples | Agent Protocol, agent.json standards |
The Signal Bus (Communication)
| Definition | A shared “Tuple Space” or semantic blackboard. |
| Function | Asynchronous coordination. Agent A posts: ("Task Failed", "Reason: No Internet"). Agent B (Network Fixer) subscribes to “Task Failed” events and wakes up. |
| Examples | Kafka (Semantic), Agent Communication Protocol (ACP) |
Conclusion
The transition to the Agentic Cloud is the shift from Stateless Request Handlers to Durable Stateful Actors.
We are building the Operating System for Intelligence. In this OS, the “process” is a thought loop, the “file system” is a memory hierarchy, and the “user” is a partner, not a driver.
Related Posts
Repowire: A Pull-Based Context Breakout
What if coding agents could ask each other questions directly? Introducing repowire, a mesh network that lets Claude Code sessions communicate in real-time.
The Vibe Bottleneck
Coding agents are great at understanding repositories. But when work spans multiple repos, you become the message transmitter, the slowdown, and the source of errors.
Agents Are Databases in Disguise
AI agents face the same challenges as databases and workflow engines. Here's why treating agent memory like a proper data system unlocks reliability.