We do not keep agents.
We keep what they did.

In BPOS a node is generic compute on a channel. It becomes an agent when a job's skillset gives it a stage to do: a procedure, the tools it may ask for, the form its answer must take, and sometimes the model it runs on. When the stage ends, the agent ends. What it did, and how, is kept.

This article belongs to What BPOS runs. It follows Every job is a contract, which covers what each job receives before it starts.

An AI agent is not an LLM

An LLM is the model: it turns a prompt into text. An agent is a model put to work on something. It has a procedure to follow, tools it may use, a contract to meet and a form its answer must take. Change any of those and you have a different agent running on the same model.

That is why BPOS does not store agents. The model is the same for many of them, and everything else that makes an agent what it is can be written down. So we write it down, on pages, and assemble the agent from the pages when there is work to do.

How a skillset makes an agent

Every job carries a skillset. When the job starts, it mounts the procedure of that skillset: an ordered set of stages, each one a page. A job gets as many nodes as its procedure has stages, and each node takes on its stage's page. That page decides what the node becomes: what it does, which instruments it may ask the platform to read for it, the schema its answer must follow, and, on the stages that declare one, the model it runs on.

We think of it the way biology thinks of neurons. A neuron is generic machinery; what makes one a motor neuron and another a cortical one is what it expresses and what it is connected to. A node is the same. Choosing a skillset is not choosing what an agent will read. It is choosing what the agent becomes. A wrong skillset is not a bad reference; it is the wrong kind of cell in the wrong place.

This used to live in our code. Until September, a planner cut each job into nodes at run time, and the rules it followed were written in the engine. They now live on the pages, each rule with where it came from, and the engine only mounts them. If a job's skillset has no procedure for the work, the job fails loudly and says what page is missing.

Why we do not keep agents

A long-lived agent accumulates what it has learned inside itself: in its conversation, its notes, its private memory. That knowledge is hard to inspect, impossible to compare with another agent's, and can only be corrected by talking to the agent. When the agent goes, the knowledge goes with it.

We wanted the opposite. Whatever an agent knew should be somewhere a person and the next agent can both read, with a date and a source, and correctable without anyone noticing which agent learned it. Pages and the links between them are that place. The agent is the temporary part.

What we keep: every turn

Keeping the work instead of the worker means recording the work properly. Every turn of every node is kept: its role, the model, the reply, the tool calls, the outcome, the tokens, the time and the cost. The prompt is kept when the turn has one to keep, and the model's own reasoning when the model returns it. This is LLM observability as the base of the system, not as a dashboard on top.

In the 30 days to 10 October 2026, that was 37,964 turns across 1,258 jobs. The reply was kept for 37,851 of them, the prompt for 35,438, and the model's reasoning for 17,036, the turns where the model returned it.

How what they did teaches the next ones

The pages and the links between them form our procedural graph. When a job's outcome is known, every link its nodes walked is reweighted by it: stronger where the work ended well, weaker where it did not. Links nobody walks fade slowly, and a faded link is still tried now and then, so it can come back if it turns out to be useful.

The rule comes from a slime mould. In 2010, Atsushi Tero and colleagues showed in Science that Physarum polycephalum builds efficient networks with a simple law: a tube thickens with the flow that reaches food and thins otherwise. Nobody decides which tubes grow. We first weighted links by how often they were used, and it failed in exactly the way the slime mould avoids: a path to a dead end got stronger the more agents went down it. Use is not evidence. Outcome is.

People count the same way. When a reviewer refuses work the scorer liked, that refusal is an observation on the links the job walked, entered through the same rule as any outcome. Nobody sets a weight by hand. Nobody Types the Weights sets out why.

Where it falls short

• Few skillsets can do a whole job yet. Today only the coding skillset holds a procedure that runs a unit of work from start to finish. The others are still being written.
• Most stages run on the same models. A skillset names a pair of models on a page, and every skillset uses the same default pair today; only stages that produce images or video name their own. So most of our cells are still the same kind of cell.
• Deciding what to read costs too much. Before it acts, each node takes a turn to choose what to read. In the two weeks to 8 October those turns were about 46% of what the mesh spent on models, and 38% of them only said "ready".

Common questions

Sources

• Atsushi Tero et al., "Rules for Biologically Inspired Adaptive Network Design", Science, 2010.
• Our own records, as of 9 October 2026: turns over the 30 days to 10 October, and what each turn kept; the share of model spend on perception over the two weeks to 8 October.