Open agent runtime

Agent Native Universe

In active development

An open-source agent runtime (MIT) in which code enforces the rules of the world, not a request in a prompt. A run can be replayed from its log to the same final event hash, byte for byte.

The problem

Multi-agent runs are hard to trust: they are hard to repeat and hard for anyone outside to check.

Why the usual tools fall short

Closed agent environments do not let you repeat a run and check the result, and non-determinism turns a simulation into a one-off observation.

How it works

In ordinary orchestration, agents are calls in a fixed pipeline. Here an agent negotiates its own links with others, spends a budget in a shared economy and joins groups. For a fixed set of nodes there is a PBFT-style agreement protocol. The run is still deterministic: a replay from the log gives the same final event hash, so the result can be checked. The code is open under MIT.

Demo

Terminal: a run, an independent repeat and a replay from the log print the same final event hash dadf32e1…, and the attestation check gives status = verified.
Determinism: run A, an independent run B from the same random seed and a replay from the log give the same final event hash (8,456 events, 500 ticks). The attestation check, which compares the run against its recorded checksum, passed.

Technology

All our products and libraries →

Where it fits

Simulations you can check

A run replays from its log, and a matching final event hash shows that the result is the same.

Comparing agent architectures

The same tasks can be run through different team designs: self-organisation, a central dispatcher, fixed roles. A five-seed comparison of this kind is published in the repository.

What backs this up

Determinism: a replay gives the same final hash over 8,456 events (500 ticks)

Two independent runs on the same seed and a replay from the append-only log converged on one final event hash, and the attestation check against the run’s recorded checksum passed too. You can repeat this on your own machine from the open code.

Reproduce: Clone the open repository, run once and replay from the log, then compare the final event hashes

0ccae60 · 2026-08-24

Observer panel: run metrics and a log integrity check

The panel only reads the event log and changes nothing in it: metrics, a self-organisation chart, the structure of links and integrity hashes. Captured on a local run. The panel itself shows event contents in redacted form, and no service addresses appear in the frame.

0ccae60 · 2026-08-24

The “living network” example: three agents with no orchestrator reach agreement, with no errors

A real run of the example: three agents with no orchestrator publish advertisements, find partners, negotiate links and adapt the protocol. They end up as one cluster, with no errors.

Reproduce: Clone the repository (MIT) → npm run demo:living → check the log (0 errors)

0ccae60 · 2026-08-24

Fixed roles sag under a fourfold load: about 80% against 97%

A comparison of architectures over five seeds: 16 agents, synthetic tasks. With fixed roles, task success averages about 80%; the other architectures sit at about 97%. The cause is mechanical: once some agents leave, there are not enough solvers for the increased load. The comparison journal is published in the open repository.

The code is open, so everything above can be checked in the repository. Open the code ↗

Integration

An open repository under MIT: you can deploy the runtime yourself and repeat the runs.

Work it out on your own figures

The AVA calculator works out whether automating a process pays off, on your figures, with no form and no price from us. If it does not pay off, it says so.

Estimate the payback

Tell us about your problem

Describe it in your own words. If it cannot be solved or will not pay off, we will tell you before any work starts.

In the reply we will say what we understood, what we need to clarify and whether it is worth doing.

or email us directly: hello@xteam.pro

New write-ups on Telegram