Agent Fleets Need a Session Platform, Not Another Editor
AI
Long-running agents need sessions that survive restarts, can be addressed, and stay within bounded resources. Why our team is designing a session platform around those contracts.
Published November 2026, dated to the month the work was done.
Most development environments assume one person, one window and one repository. Our work no longer looks like that. Our team runs many long-running agent sessions at once on the same compute tier: one planning a migration, one reviewing research, one supervising a set of other sessions and reporting back.
Tools built for one person fail quietly in that world. A restart wipes a session that had run for hours. An orchestrating session cannot reach another one except through someone clicking a tab. Memory runs out one heavy window at a time. So we began the research for the next version of our session platform, with the outcome stated first: sessions that survive restarts, can be addressed through an API, stay within bounded resources, and fail visibly. We specified a contract at every layer. The implementation language, Rust, is incidental.
Why not an existing editor
Existing editors are excellent at what they were built for. The problems start when the main user is not a person typing but many agents running in terminals for hours. Each problem became a contract:
- Sessions survive. If the window or the host process restarts, a long agent session comes back where it was. It does not start over.
- Sessions are addressable. An orchestrating session can read another session's output and send it input through an API, without a person in the loop.
- Resources are bounded. One heavy editor is fine. A fleet of them, each with its own browser engine, is not. Cost per session is a design input, not an afterthought.
- Visibility comes before editing. Operators spend most of their time seeing what is running and stepping in, not writing code by hand.
Research before code
We did not start by coding a shell. We split the platform into nine layers and gave each its own research track: the browser engine and compositor, text and pixel rendering, the terminal state engine, the session model, the viewers for HTML, PDF and markdown, the split between core and viewer processes, the host supervisor, support for other platforms, and rollout across machines.
Every track worked under the same written rules, which made the research itself a governed pipeline:
- Every claim has a source. A file and line in a cloned open-source project, or a URL. No source, no claim.
- Licenses are recorded and respected. Each source project's license was noted, and nothing was copied from copyleft code.
- Each track owns its own space. A track writes only inside its own folder, and one owner controls the shared source collection, so references never collide.
- Independent review gates each round. An independent review gate checked evidence, licensing and rule compliance before the next round could start.
Those rules set the quality bar for the research, not the tools that ran it. They are also contracts at every door: between a claim and its source, between a track and its neighbors, between one round and the next.
What we measure
A session platform for agents is judged by different numbers than an editor. Capacity testing runs the platform at several density levels on one host and measures memory per session, startup time, how long a session takes to come back after a restart, and whether the terminal keeps up when several agents print at once.
The rule is simple. If a design looks good on paper but cannot hold a dense fleet of sessions on one host, it is the wrong design.
The real decisions are process boundaries
The interesting decisions are not about the editor. They are about process boundaries: what runs in the core, what runs in a viewer, who supervises whom, and what happens when one piece dies. That is the same question you ask when designing any distributed system. A platform for a fleet of agents turns out to be a small distributed system that happens to have a screen.
Seen that way, the familiar patterns apply. The supervisor owns restarts. A viewer that crashes must not take the session with it. State that has to survive a restart lives outside the process that can die. Failure is reported, never hidden.
What the design guarantees
This is Governance-Driven Contract Design applied to a developer platform. The outcome comes first: a fleet of long-running agents the team can trust to keep working and to show its state. The guarantees follow from it:
- A session resumes after a restart without losing its state.
- Any session can be read and driven through an API.
- The cost of each session is measured and bounded.
- When a component fails, the operator sees it.
A session that dies silently, or that cannot be reached except by hand, is a quiet betrayal of the person relying on it. The editor chrome is the fashionable part of the work. The process contracts are what last. No design moves forward until it holds density and recovery on one host.
Every line holds.