Build Autonomous Agent Fleets
The unit of work is the fleet, not the agent. Lightspeed makes every sub-agent a durable workflow with its own profile, its own machine and a limit it cannot exceed.
One agent with a long task list is a bottleneck with a context window. Real work is parallel: a planner that splits, workers that build and test, reviewers that disagree, a coordinator that merges. The unit that matters is the fleet, and fleets are where most agent frameworks break, because a fleet of processes is a fleet of machines, and a fleet of machines is expensive to keep and impossible to keep alive.
In Lightspeed a fleet is agents starting agents, and every one of them is a durable workflow.
Agents that start agents
A session starts a child with one of two calls. agent_run is joined: the result returns inline, and several calls in one turn fan out and join together, so a planner can ask three specialists at once and continue when all three answer. agent_spawn is detached: the child runs on its own, and the parent is woken when it finishes. Either way the child is a full session with its own log, its own tools and its own machine, supervised by an execution workflow, and it carries typed lineage back to its root.
Children come from profiles. A profile fixes the model, the prompt, the tools and grants an agent starts with, and either activates an existing environment or provisions a fresh one per session. A planner does not describe a builder; it names the builder profile the organisation approved, and the child starts with exactly that and nothing more.
A machine per agent, for exactly as long as it needs one
Each sub-agent can borrow a clean machine from a versioned image: clone the repository, run the suite, release the machine when it closes. Nothing is shared between children unless a profile says so; nothing is left running when a child finishes. A fleet of thirty builders is thirty machines while thirty builds run, and zero machines an hour later.
Limits the fleet cannot exceed
The root of a fleet carries limits: how deep delegation may go, how many descendants may exist in total, how many may run at once, and a deadline for the whole tree. Every descendant inherits them and a spawn that would break them is refused at admission. Cancelling the root closes everything beneath it, aborting in-flight model and tool calls without a farewell turn. A fleet is a tree with a budget, not a swarm.
Survives everything
Every session in the fleet is a workflow, so the fleet survives a worker restart, a redeploy, and a week of waiting for a human. The planner’s state is its event log; when the worker comes back, it replays and continues at the next step. A fleet can keep working for days and pick up where it left off, and when it waits it costs nothing: an idle session is a row in an event store, not a machine.
Two branches from one state
A fork copies a running agent’s complete state straight from the event log. A planner that cannot decide between two approaches forks, runs both as branches on their own machines, compares, and keeps one. The shared prefix is paid for once.
The software factory
The canonical fleet: a planner reads a feature request and spawns builders, testers and reviewers. Builders provision their own machines, clone, implement, and run the suite. Reviewers read the builders’ diffs with fresh context and critique. The planner merges what passed and reassigns what did not. The tree runs for days, survives a restart on the second day, forks on the third to try two designs for the storage layer, and hands back a reviewed, tested change on the fifth. Every decision in the tree is in a log a human can read.
Seeing the fleet
A fleet is visible as a tree. The session list groups children under their parent; a session shows its lineage, pinned profile, depth and live children. Ask “what is running under this planner right now” and the console answers.
Arithmetic
A fleet of a thousand agents, of which fifty are working at any moment. Under one-OS-per-agent: a thousand machines. A modest 2-vCPU cloud instance is about $30 a month, so $30,000 a month before a token is spent, and 950 of those machines are waiting. Under Lightspeed: fifty borrowed machines, and 950 rows in a database. The fleet is the same size; the bill is for the work.
Rests on: sub-agents, agent profiles, per-session environments, idle power policy, session fork and clone, long-running sessions. See also Deploy Resident Agents for fleets that never end, and Accelerate and Automate Migrations for the factory applied to a legacy estate.