Metaintelligence architectureMetaintelligence · Agents · Boundaries

The agent as a bounded local world

In most systems an agent is built as a function with a prompt. Such an agent cannot refuse work, come to an end or run out of resources. Yet it is being bounded that makes a participant fit for an environment where nobody controls everyone.

Metaintelligence architecture · part 2 of 6

What is wrong with “the agent as a function”

A function-agent takes input and returns output. In place of a goal of its own it has someone else’s task, in place of state it has the context passed in, and its limits rest on the hope that the caller will not ask for too much. While there is one agent, this works. When there are dozens of them and they have to coexist for months, the lack of internal structure produces every problem at once.

A useful comparison: a function-agent relates to a participant in an environment roughly as a procedure relates to a process in an operating system. A procedure runs and disappears. A process has memory, permissions, quotas and a lifecycle, and it can be stopped from outside.

What a participant is made of

In our runtime a participant is built as a bounded local world. Each part of it is there because some specific scenario breaks without it. Nothing was added just to make the model complete:

A boundary instead of access

Most often a multi-agent system is built on one shared context for everyone. That is convenient until the first incident. A shared context means any participant can read other participants’ data, any failure spreads at once, and the cost of a call grows with the total volume.

The alternative is an explicit boundary. A participant declares what it accepts, what it produces and what it needs. Everything else stays inside, and exchange goes through the agreed part of the state. In practice, the failure of one participant does not corrupt the others, and data does not spread across the system just because that was easier.

Local decisions

A participant judges for itself whom it is useful to connect with. It compares its needs with others’ capabilities and weighs reciprocity, closeness of goals, the cost of communication and free capacity. The environment can show it candidates but cannot assign a link: both sides have to accept the proposal.

Compared with a planner that simply hands out tasks, this looks more complicated. In return there is no node whose failure stops everything, and no single place that has to hold an understanding of the whole system.

Lifecycle: birth, sleep, departure

A participant can clone itself, split into several, merge with another, fall asleep when there is no work, be quarantined when it violates its invariants, and retire. For the environment these are all ordinary operations; none of them counts as an emergency.

What being bounded gives you

A bounded participant behaves predictably in unpleasant situations, and that is exactly what people pay for in production:

  1. It can refuse, because it has a goal of its own and commitments already made.
  2. Its budget is checked by the environment, not by the model’s conscience. With a hard ceiling it will not spend more than it was allocated. Why a soft limit is dangerous is covered in the part on economics.
  3. It will not make off with other participants’ data: that data is not inside its boundary.
  4. It can be stopped, put to sleep or isolated without stopping the others.
  5. Its lineage and links let you reconstruct the history: where the behaviour came from and with whom it was agreed.

What it costs

This model has a price: it is more expensive to design. You have to decide what exactly is exposed, which invariants are mandatory, how the budget is counted and what happens when it runs out. On a small task this is unnecessary; one agent with tools is enough there.

It starts to make sense where there are many participants, they live long and they have to survive each other’s mistakes. Then being bounded stops being overhead and becomes a way to keep the system manageable.

Code and artefacts

The “Metaintelligence architecture” series

  1. Metaintelligence: why the environment around the model sets a system’s ceiling
  2. The agent as a bounded local world
  3. A link as a first-class object: a relationship with state and history
  4. Living graph: topology shaped by work
  5. Consensus without a centre: deciding together without taking anyone’s word for it
  6. Agent economics: autonomy needs a budget

Frequently asked questions

How is such a participant different from a microservice?

A microservice executes an interface, and its behaviour is set from outside. A participant in the environment has a goal of its own and can turn down a proposal if it does not serve that goal or breaks its commitments. The rest (boundaries, quotas, failure isolation) really is similar. Both designs solve the same problem: how many parts can coexist.

Why does a participant need its own budget?

So that the limit on activity is physical and not declarative. While “do not do too much” lives in an instruction, it gets broken. When a resource is debited for every action and runs out, the environment itself limits behaviour.

Would it not be simpler to give everyone a shared context?

Simpler at the start and more expensive later. A shared context means leaks between tasks, failures that spread, and the cost of every call growing with the volume. An explicit boundary takes effort once and pays off at every exchange after that.

How we help with this

Read next

Follow the series

If you’re building a similar environment or want to discuss the research with us, write through the form on the homepage.

Email hello@xteam.pro