The Agent Compute Plane: Agents Shouldn't Care Where They Run

Every serious agent deployment eventually hits the same wall, and it is not the model. It is the agent compute plane — the layer that decides where a given agent run gets a machine, and what happens to that machine afterwards. Most teams find out they need one the first time a customer says the agent cannot run on a laptop.
That is roughly how it went for Factory at Blackstone, described in the talk as a trillion-dollar-in-assets institution. It could not run coding agents on developer laptops. It wanted its own compute, its own inference, its own identity, and single tenancy everywhere. As Nikhil Harithas, who leads forward deployed engineering at Factory, put it in an AI Engineer talk published on 3 November 2026: none of their defaults worked.
That engagement surfaced two questions that keep coming back. Who is the agent acting on behalf of, and where does it run? The first has a growing body of answers. The second one mostly doesn't, which is why every vendor ends up rebuilding it — and why the compute plane deserves a name of its own.
TL;DR — Agent products piggybacked on a human's laptop and a human's identity, and both are running out. The identity half is being solved with per-agent credentials. The where half needs a compute plane: a layer that hands an agent a machine, on whatever runtime the customer insists on, and manages that machine's whole life. Factory's answer is OpenCompute, announced 14 October 2026 and in private preview — drivers per backend, a required Core profile with optional Suspend, Snapshot and Fork, and an egress-only connection so no inbound port is ever opened. The consequence nobody states out loud: once a computer can be suspended, forked and rebuilt somewhere else, nothing durable can live on its disk. That is the argument for keeping an agent's knowledge in a networked markdown workspace like MDflow instead of in the sandbox.
What is the agent compute plane?
The agent compute plane is the layer that decides where a given agent run gets a machine, and manages what happens to that machine over its life. Create it, observe it, run commands on it, suspend it, snapshot it, fork it, destroy it.
Infrastructure has long split into two planes: a control plane that decides what should happen, and a data plane that carries the actual work. Harithas's framing is that agents force a third one out into the open. The compute an agent runs on is no longer an implementation detail of the control plane — it has different owners, different trust boundaries, and a lifecycle of its own.
Most agent products never needed this, because the machine was a given. It was your laptop, or a sandbox the vendor spun up in the vendor's cloud. Both assumptions break at the same place: an enterprise that will not put its code and context on someone else's infrastructure.
Why agents shouldn't care where they run
Because the answer to "where" changes for reasons that have nothing to do with the agent. In the Blackstone engagement, the plan to use one sandbox provider changed partway through when key constraints shifted, and the target became an EC2 machine instead. That pattern repeated across customers: one wants Kubernetes, one wants EC2, one wants their own cloud.
If the agent is coupled to one runtime, each of those is a rewrite. If the compute lifecycle sits behind a driver interface, each is a new driver and the agent is untouched.
The deeper argument in the talk is a deflationary one, and it is the most useful idea in it: agents are just slightly non-deterministic applications. We have decades of practice deploying applications into hostile, regulated environments. The job is not to invent a new discipline but to reposition the existing one — which also means an agent should no more hard-code its compute than a web service should.
For developers
- The abstraction is the deliverable, not the backend. Factory's stated goal in open-sourcing OpenCompute is to make the contracts, conformance tests and driver model useful to people building agent systems — the parts that are not Factory-specific.
- Scope it to computers, not sessions. OpenCompute deliberately manages computers rather than agent sessions. The moment a session concept leaks into the compute layer, the layer becomes product-specific and a customer can no longer reason about it independently.
- Durable intent beats a held-open request. Factory's design books the request as durable intent up front, instead of parking an open connection until the provider delivers. That single choice is what makes the dropped-acknowledgement case survivable: you asked AWS for a machine, it acknowledged and never delivered, and something has to own the bookkeeping of which sandbox belongs to which user and where the conversation got to.
- The spec can be the test. Harithas noted that handing the driver spec to their own coding agent produces a conforming driver, because satisfying the spec is the acceptance criterion — a neat, concrete instance of spec-driven development.
For AI agents
- Egress beats ingress, every time. The orchestrator sits inside the customer's network and dials out to Factory over a TLS WebSocket. Nothing listens on a public address, and the customer's firewall never has to let the vendor in. Security teams that will argue for weeks about ingress will approve egress in an afternoon. Anything your agent needs to reach should be reachable the same way.
- Placement is separate from inference. Factory's documentation is explicit that sandbox placement is independent of model inference and session storage, and bring-your-own-key or self-hosted inference keeps the model calls inside the customer's boundary too. This is the same optionality argument as model-agnostic architecture, one layer down.
- The identity half is a separate problem — and it is further along. Agents borrowing a human's credentials was always a stopgap; the durable answer is a per-agent identity with narrow, revocable authority. We covered that in agent authentication and scoped tokens, so this post stays on the where.
What a compute plane actually has to do
Three things in OpenCompute's design are worth copying even if you never use it.
1. Capability is not uniform, so say so in the contract. OpenCompute splits conformance into a required Core profile plus optional Suspend, Snapshot and Fork profiles, because those three abilities genuinely differ between backends: some can freeze a machine mid-run, copy its disk, or clone it wholesale, and some simply cannot. This is the detail most abstraction layers get wrong. A portable interface that silently pretends every backend is equally capable is worse than no abstraction, because your agent will depend on a capability that evaporates on the next deployment. Portability is a floor, not a guarantee — build on Core and treat anything above it as something to probe for.
2. Long runs outlive their machines. Factory's announcement lists AWS Lambda MicroVMs among its providers, and AWS documents those sessions as lasting up to eight hours. The talk describes agent runs — Factory calls them missions — that go on for multiple days. So the compute plane has to snapshot a machine that is about to hit its ceiling, rehydrate a new one, and swap it in as if nothing happened. Your agent's process is not the unit of durability. It never was.
3. Fork is the primitive that changes the shape of everything. As sub-agent fan-out becomes normal, the useful move is to snapshot a computer, fork it, and hand a subtask to a child agent that starts from the parent's exact state. It is fractal — sub-agents spawning sub-agents — and it is the opposite of a world where one agent owns one machine.
Which applications benefit most
- Regulated enterprises — finance, healthcare, government, defence. Where the code and context cannot leave the boundary, the compute plane is the adoption blocker.
- Coding agents and software factories — the case in the talk. Delegation from Slack or a Jira ticket to an agent that returns a pull request means a machine with real repository credentials, which is exactly what nobody wants on a laptop.
- Long-horizon agents — anything measured in days rather than turns runs straight into provider session ceilings. See long-horizon agent evals for what else breaks at that timescale.
- Sub-agent fan-out — swarms, parallel exploration, and any orchestration where forking a prepared state is cheaper than rebuilding it.
- Anyone mid-migration or multi-cloud — if you cannot name your runtime for the next three years with confidence, do not let your agent name it either.
The part a compute plane does not solve
This section is our argument, not the talk's. The talk is about managing computers; it does not discuss memory or knowledge at all. But follow its primitives one step and you land somewhere specific.
A compute plane's whole purpose is to make the machine disposable. Create it on demand, suspend it at a ceiling, snapshot it, fork it, destroy it, rebuild it on a different backend next quarter. That is the feature.
Now ask where the agent's accumulated knowledge lives while all that happens.
If it lives on the sandbox disk — a running plan, findings from a long investigation, conventions the agent worked out and wrote down — then fork copies it. Two children now hold the same notes and immediately start writing different versions of them. Nothing in the compute plane reconciles those, and nothing should: managing computers is deliberately not the same as knowing what the files mean. The same applies, less dramatically, to the snapshot-and-rehydrate swap at the eight-hour mark, and to the day the driver underneath changes.
So the compute plane's gift comes with a bill. If the machine is disposable, the knowledge cannot live on it. It has to sit somewhere reachable over the network, with its own identity and its own history, surviving every create and fork and destroy underneath it. This is the same conclusion portable AI memory reaches from the vendor-lock-in direction, and the same reason agent architectures have a half-life while the written layer does not.
How MDflow fits
MDflow is a markdown workspace built to be read and written by AI agents as well as people. Here is the honest mapping, boundaries first.
The boundary: MDflow is hosted, not self-hosted. It runs at mdflow.cz. It does not deploy into your VPC, so it is not an answer to the data-sovereignty requirement that drove OpenCompute's design. If your constraint is that nothing may leave your network, MDflow does not meet it. Documents can be client-side encrypted, which means the server stores ciphertext it cannot read — a different kind of answer, not the same one. Agent access via the API and MCP requires a Pro plan.
What does line up today:
- One outbound connection, same direction as the WebSocket. A sandbox on EC2, a Kubernetes pod, a MicroVM, a laptop or a phone reaches the same workspace over plain HTTPS. Nothing opens an inbound port into the sandbox, and nothing has to be installed on it — there is no vector database to ship into the image and no local index to rebuild after a fork.
- Two ways in, both token-shaped. A hosted remote MCP server and a REST API, authenticated with a Personal Access Token or OAuth. Tokens are per-client and revocable, which is the right granularity when the thing holding the token is an ephemeral machine.
- Retrieval that travels. Folder descriptions are the primary ranking signal for
mdflow_get_context, so an agent on a fresh machine asks a question and gets the relevant markdown back — no embeddings to carry. More on that in folder descriptions as agent context. - A record of who wrote what. Version history keeps line-by-line diffs, and the Log marks a write as automated and records the token's name alongside the version it produced. Agents writing under different token names leave separate Log entries, so you can tell which one touched a document — with a caveat spelled out below.
- Markdown all the way down. Every document has a raw
.mdtwin with YAML frontmatter, so what the agent reads is the file, not a rendering of it.
Connect Claude to MDflow: open the MDflow connector in Claude's Connectors Directory, click Connect to Claude, and sign in — no URL or token to paste. One connection covers claude.ai, the Claude desktop and mobile apps, and Claude Code.
Two limits, stated plainly, because they bite in exactly the scenario this post is about. First, writes through the API and MCP are last-write-wins: there is no compare-and-set on a document body, so if two forked agents write the same document the second simply overwrites the first, with no error. The editor does check — it compares against the revision you loaded — but agents do not. Second, version capture coalesces: at most one version is recorded per document per 60 seconds. That is deliberate and right for autosave bursts, but it means an overwrite landing inside that window leaves no diff behind either. So the honest advice for fan-out is not "check the history afterwards". It is keep forked agents on separate documents, and let a later pass merge them.
Where we are headed — direction, not a dated promise. The gap this post describes points at two things: richer retrieval over folder descriptions so a cold machine needs fewer round trips to get oriented, and version-pinned reads so an agent can state which revision it acted on. Both are about making a workspace behave predictably for a reader that has no memory of last time, because that is what every freshly forked sandbox is.
The bottom line
The question "where does this agent run?" has no good standard answer yet, so every serious deployment answers it privately and expensively. OpenCompute is the clearest public attempt so far: drivers per backend, honest conformance profiles instead of a pretend-uniform interface, and an egress-only connection that security teams will actually sign.
Take the idea seriously and it pushes further than compute. A machine you can suspend, snapshot, fork and rebuild elsewhere is a machine you have decided not to trust with anything that matters. Everything that matters then has to live somewhere the agent can reach from any of them.
Start free, connect an AI agent, or read the API docs.
Frequently asked questions
What is the agent compute plane?
The agent compute plane is the layer that decides where a given agent run gets a machine, and manages what happens to that machine over its life — create, suspend, resume, snapshot, fork, destroy. It is distinct from the control plane, which decides what should happen, and the data plane, which carries the work. Most agent products started without one because they ran on a developer's laptop or in a vendor-hosted sandbox, and the question of where never came up.
Why should an AI agent not care where it runs?
Because the answer changes, often mid-project, and for reasons that have nothing to do with the agent. A security review rules out a hosted sandbox provider, a team standardises on Kubernetes, a procurement term changes, a workload has to stay inside a VPC. If the agent is coupled to one runtime, each of those is a rewrite. If the compute lifecycle sits behind a driver interface, each of those is a different driver and the agent is untouched.
What is an egress-only agent architecture?
It is a design where the customer's environment opens an outbound connection to the vendor and the vendor never initiates an inbound one. Factory's OpenCompute works this way: the orchestrator sits inside the customer's network and dials out to Factory over a TLS WebSocket, so nothing listens on a public address and the firewall never has to let the vendor in. It matters because security teams are routinely far more willing to approve egress than ingress.
Can an AI agent store its notes on the sandbox disk?
It can, but the notes stop being reliable the moment the compute plane does its job. A sandbox that can be suspended, snapshotted and forked is a sandbox whose disk gets copied; two forks then write divergent versions of the same file and nothing reconciles them, because managing computers is not the same as knowing what the files mean. Anything that has to survive the machine belongs somewhere reachable over the network with its own identity.
Does MDflow run inside my VPC?
No. MDflow is a hosted service at mdflow.cz, so it is not an answer to the data-sovereignty requirement that drives self-hosted orchestrators like OpenCompute. What it answers is reachability: a sandbox anywhere — EC2, Kubernetes, a MicroVM, a laptop, a phone — reaches the same workspace over one outbound HTTPS connection via remote MCP or the HTTP API, so the knowledge does not live on compute that is designed to be thrown away. Documents can also be client-side encrypted, in which case the server stores ciphertext.
Further reading
- Your AI Agents Shouldn't Care Where They Run — Nikhil Harithas, Factory, AI Engineer, 3 November 2026. The talk this post is built on.
- Introducing OpenCompute — Factory's announcement, 14 October 2026, with the driver model and conformance profiles.
- OpenCompute overview — the product documentation, including the private-preview status.
- Lambda MicroVMs — AWS's documentation for the eight-hour session ceiling.
- Agent authentication and agent authorization — the other half of the pair of questions.
- Your agent architecture has a half-life of 6 months — why the written layer outlives the runtime.
- Portable AI memory — the same conclusion, approached from vendor lock-in.
- MDflow MCP docs and API docs — how an agent on any machine connects.