Metaintelligence architectureMetaintelligence · Architecture · Agent environment

Metaintelligence: why the environment around the model sets a system’s ceiling

We are used to measuring progress by the size of the model. But a system that carries work for months consists of more than a model. It has relationships between participants, limited resources, a way of reaching agreement and a trail from which any decision can be taken apart. This series is about how such a layer is built and why it sets the ceiling of what is possible more firmly than the next generation of weights.

Metaintelligence architecture · part 1 of 6

Where the ceiling really is

Take any system that has to work for six months rather than ten minutes. The model in it is responsible for one step: to understand, to propose, to put into words. Everything else lies outside the model: who is connected to whom, who remembers what, who is allowed to act, what pays for the work, how a shared decision is made and what happens on failure.

This is exactly where projects hit the wall. If a model has no limits on its authority, its mistake can no longer be undone. Without limits on spending, it spends money nobody was counting. And when decisions are not recorded, nobody can explain why the system acted the way it did.

Three properties an environment cannot live without

Local decisions

A central planner is the simplest way to organise many participants, and also the most fragile. It becomes a throughput bottleneck, a single point of failure and the only one holding the context. A living environment works the other way round. Each participant decides for itself, from its own goal and what it can see, and the environment gives participants a way to meet and come to terms.

Provability

Any behaviour of the system has to be reconstructable from records: what a participant knew at the moment of decision, what it proposed, what it agreed to, what changed as a result. Without this you can neither improve the system nor answer for its actions. So it cannot be trusted with anything that matters.

Reversibility

The environment has to plan for mistakes in advance: a link can be dissolved, a merger of participants unwound, an action rolled back, autonomy revoked. If every decision is irreversible, the system cannot learn cheaply from its mistakes and pays the full price for each one.

Two primitives instead of a service architecture

A typical multi-agent system starts with roles: planner, executor, critic. Roles are convenient on a diagram and get in the way at work: they fix the structure before it is clear what structure the task needs.

We build differently, on two primitives. The first is the participant as a bounded local world. It has its own goal, state, capabilities, needs, budget and a boundary across which only the agreed part of its state goes out. The second is the link between participants as an independent, long-lived object with its own state, the rights of each party, a history of changes and a lifetime.

From these two primitives the topology forms by itself. Participants find each other, come to terms, work, strengthen useful links and let go of useless ones. The graph of links here is the working system itself, not a diagram in the documentation.

How this differs from a multi-agent setup

The difference lies in what counts as primary. In a typical multi-agent setup the scenario is primary: who passes the task to whom. In the environment the participant and the link are primary. The scenario follows from them and can change while the system runs.

What already works and what remains a hypothesis

Our environment layer is implemented and open. It is a runtime in which participants find each other, negotiate, synchronise boundaries, pay for resources, reach a shared decision and organise recursively into groups. You can download it, run it and check it; the link is at the end of the article.

The main question remains open: which laws of the environment lead to stable, useful behaviour of the population, and which lead to degeneration. Only experiments can answer it. The first comparison is in, and its result is negative: the graph of links gave no advantage (97.21% of tasks completed successfully against 97.24% without the graph, 16 agents, five seeds, with the sign of the difference changing from seed to seed). The tasks in that comparison were single-agent, so the hypothesis has not been tested either way. The summary is in the open repository.

One boundary needs stating separately. We have other research lines too: a numerical computation library and a neural core. Their code is open as well, but they are separate topics, and the series mentions them only at the level of purpose and observable properties.

What the series covers

  1. The participant as a bounded local world: what is inside it and why the boundary matters more than access.
  2. The link as a first-class object: negotiation, the rights of each party, revisions, fading.
  3. The living graph: topology as a consequence of the work.
  4. Agreement without a centre: how a group reaches a shared decision when nobody can be taken at their word.
  5. Economics: why autonomy needs a budget and what changes when thinking costs money.
  6. Fractal organisation: how a stable group becomes one participant and how it unfolds again.
  7. Provability: reproducible runs, evidence and why they matter more than a demo.

Each part rests on working code and on what we saw when we ran it. There are no reviews of other people’s work here. Where there is no data, the text says so.

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 does metaintelligence differ from a multi-agent system?

A multi-agent system is usually a scenario spread across several executors. Metaintelligence is our name for an environment in which participants and links are primary, and the structure of the work emerges and changes as the work goes on. A multi-agent setup can be a special case of such an environment, but not the other way round.

Is this research or a product?

The environment layer already works: it is an open runtime, and you can run it. The question of which laws of the environment produce stable, useful behaviour remains a research question, and we do not pass hypotheses off as results.

Why open code like this?

Trust in an architecture cannot be built with a story. An environment can be checked: run it, repeat a run, compare the events. Where code is closed, we say plainly where the boundary lies.

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