implemented Implemented
Works in the open code, covered by tests, reproducible from a clean clone.
Agent Native Universe · An open research programme
Does software have to look the way it has looked for the last fifty years?
Files, repositories, APIs, screens and documentation exist to make complex systems legible to humans. Agent Native Universe asks what happens to software when a second intelligence — an autonomous agent — appears inside the system, and tests every idea with an executable experiment rather than a manifesto.
The rule of this programme and of this page: question → hypothesis → experiment → evidence → next question.
Humans define purpose.
Agents create intelligence.
Intelligence creates software.
Software exists only as long as it is useful.
And the programme’s second formula: humans create agents that create agents for humans.
Honesty labels
ANU is an R&D project, so radical ideas are never mixed with finished ones. Every strong claim on this page carries one of four statuses:
prototype Prototype
Works in an experiment; first recorded data exists, but not a series.
research Research
Measurement in progress: there are numbers, there are caveats, the conclusion is bounded by them.
hypothesis Hypothesis
Stated as a testable question. No code yet — and we say so plainly.
The starting problem: software is anthropocentric
Modern models were trained mostly on knowledge created by humans for humans. Programming grew the same way: languages, files, folders, classes, microservices, READMEs and dashboards are largely ways to keep a complex system within reach of human memory and attention.
But agents already write code, analyze systems, use APIs, verify results and delegate work. Hence the question ANU starts from: why should they keep working inside constructions invented by humans for humans?
The classical pipeline and the agent-native alternative:
Human → UI → Application → API → Database Human intent → agent environment → dynamic agents, tools, functions, interfaces → result → knowledge retained
An application stops being necessarily a pre-written, fixed system.
The central hypothesis
What happens if we stop designing software primarily for humans and start building a computational environment whose primary subjects are autonomous intelligent agents?
This does not remove the human — the opposite. Humans remain the source of goals, values, constraints and final meaning: they define the "why". The system increasingly determines the "how". Between human intent and human result there can be a large machine intelligence ecosystem.
What already runs as code implemented
The programme’s foundation is an open runtime on bare Node.js with zero runtime dependencies, where the laws of the world are enforced by code, not by a plea in a system prompt.
A world with laws, not requests
An agent is a bounded local world with its own objective, state, memory and budget; relationships are negotiated stateful protocols. Invariants are enforced by code: a negative balance is impossible not because the model was asked nicely, but because the operation will not go through.
An economy of thinking
Double-entry resources, two-sided escrow, atomic settlement. Model calls are metered inside the economy: a reservation is a hard ceiling, overruns are refused with an exact unpaid remainder, delivered work is paid for, undelivered work is refunded.
A cryptographic fabric
Ed25519 identities, X25519 + AES-256-GCM channels, tamper and replay protection. Byzantine quorum f = ⌊(n−1)/3⌋: a leader cannot manufacture other replicas’ votes, and a commit certificate applies only after a valid quorum.
Evidence, not logs
Every experiment is an append-only, hash-chained journal with deterministic replay and sha256 attestation. The verifier does not trust the report: it regenerates the decision stream from the manifest and refuses at the first divergence.
64 × 10,000 ticks · 131,372 events · 0 invariant violations · sha256 attestation independently verified
The open release’s reference experiment; reproducible from the repository with one README command.
The experimental programme
Four experiments, each with a question, a hypothesis, a setup and evidence. Numbers come from recorded journals; caveats are printed next to the numbers.
Does architecture emerge — and does it beat a designed one?
- Question
- Given laws, resources and goals but no roles or org chart — what structure emerges, and does it survive comparison with human-designed architectures?
- Hypothesis
- Self-organization without predefined roles matches designed architectures, and under regime change outperforms them.
- Experiment
- Genesis-1: a universe of 16 role-neutral agents, plus control arms — the same world under a central dispatcher (E), under fixed solver/verifier roles (F), with no relationship graph (D), with no economy (C). One pinned task realization for every arm, a series of five seeds. 600 ticks through a crisis programme: credit price ×2 → bandwidth ÷2 → forced retirement of 20% of agents → task load ×4.
- Evidence
arm success p95 ×4 window A self-organizing 97.4% 11 98.1% C no economy 97.9% 11 99.6% D no relationship graph 98.1% 10 99.3% E central dispatcher 97.6% 14 100% F fixed human roles 74.1% 24 68.9% ← collapse
- Fixed roles do not degrade — they collapse, on all five seeds. The capacity arithmetic predicts the magnitude quantitatively: where retirement removed three solvers, 9 × ⅓ = 3.0 tasks/tick remain against a demand of 4.0 — predicted 175 expiries, observed 216–217; where it hit a verifier — 10 solvers, predicted 117, observed 108–109. The collapse magnitude is a deterministic function of surviving solvers, not seed luck. And over 600 ticks the QA class caught zero defects — while holding exactly the capacity that was missing.
- The central dispatcher is the best pure crisis performer: 100% in the ×4 window on every one of five seeds. It pays with a permanent 2–3× tail-latency tax in every calm regime, holding an 8% margin with no slack mechanism behind it. Self-organization is the only architecture with no structural price: p95 of 4–6 that no designed arm reaches, and 97.6–99.9% through the spike.
- The graph question is closed at this scale: A beats D on two seeds, D beats A on three, the means coincide to the decimal (97.2 vs 97.2). The "living graph" has no support in the data yet — freedom of task choice is doing the work.
- Caveats
- Five seeds retire the single-run caveat; gaps under ~1.5 p.p. between self-organizing variants are seed noise. What remains is a single configuration: 16 agents, one task mix, one pressure programme. Journal: experiments/genesis-1/BASELINES.md in the repository.
- Next question
- Other configurations (population scale, crisis programme); pressure on arm E up to its arithmetic boundary; agents creating agents.
A model inside a world of laws
- Question
- What does a real reasoning model do inside an environment where rules are enforced by code — and can the experiment stay reproducible?
- Hypothesis
- Model answers can be recorded as replay input: evidence stays deterministic even with a non-deterministic intelligence inside.
- Experiment
- Cognition cohorts: the model’s consultations are committed to the journal verbatim before the world reacts to them; replay never contacts the provider; the run identity includes the model, the endpoint and the consultation budget — a run with a different model cannot pass for another’s evidence, by construction.
- Evidence
- The first behavioural fact: a reasoning model (Kimi K2), in its very first run, ignored the claim protocol — executing and submitting tasks it had never claimed: 11 violations across 6 consultations. Each violation is recorded evidence, not a crashed process.
- Caveats
- One short run of one model: first data, not a conclusion.
- Next question
- Long cohort runs; "machine protocol vs natural language" compared on tokens, latency, cost and information loss.
What a thought costs
- Question
- Can an agent be trusted with a budget when the model provider does not promise to honour limits?
- Hypothesis
- Spending guarantees must live in the environment’s code, not in request parameters.
- Experiment
- A live falsification run against Kimi K2 on MWS Cloud — experiments/mws-kimi in the repository, nine testable hypotheses, nothing mocked.
- Evidence
- The provider ignores the requested max_tokens entirely — verified at 16, 32, 64 and 256.
- About 86% of paid completion tokens are hidden reasoning tokens the caller never sees. The bill is for thinking, not just for words.
- The conclusion moved into code: a reservation became a hard ceiling — overruns are refused with the exact unpaid remainder, genuinely delivered work is paid, undelivered work is refunded.
- Next question
- The economy as a regulator of reasoning depth: when the next step of thought is not worth its price.
Evidence instead of documentation
- Question
- Can a system describe itself — in a way that cannot go stale?
- Hypothesis
- The source of truth is not a text about the system but a verifiable journal of what the system did.
- Experiment
- Every run is an append-only, hash-chained event journal. The verifier does not read the report — it regenerates the decision stream from the manifest and refuses at the first divergence. The manifest carries the full implementation identity: engine, policy, task generator, model.
- Evidence
- A practical episode from development: review found that a run with a different model could silently reuse another’s completed evidence. Closed by binding the model identity into the run id — the collision is now impossible by construction, and old evidence is refused rather than reinterpreted.
- Next question
- Self-describing capabilities: a machine description automatically checked against the runtime.
Open hypotheses hypothesis
The programme’s most radical ideas. No code behind them yet — below is the experiment each will be tested with and what will be measured.
Ephemeral functions: code as cache
A function exists because the problem exists. Needed once — generated, verified, executed, destroyed; needed a thousand times — kept. Code stops being the source of truth and becomes a cache of an already-found solution.
How we will test it: A series of 100 tasks: measure the reuse share, generation cost vs storage cost, and the share of functions that outlive their task.
Machine-native communication instead of imitated conversation
Today agents write each other "Please analyze…" — machines imitating human talk. A machine-native layer exchanges states, deltas, constraints and capability identifiers.
How we will test it: One task done both ways — natural language vs a structured protocol: tokens, latency, cost, correctness, information loss.
Agents creating agents
The structure of a computation emerges from the task: a genesis agent understands the intent and creates the required specialists; the useful is promoted into a persistent capability, the rest disappears. Today the lab’s population comes from a config — agent-spawned agents are not implemented.
How we will test it: Topology emerging in real time from an intent; comparison with a fixed workflow on cost and quality.
Dynamic interface
UI as a consequence of the task, not a choice made before the task exists. Two people solving different problems in one system effectively use two different applications — the interface is generated and disappears with the task.
How we will test it: Two unrelated tasks from one user: generate an interface for each, measure the path to result against a fixed dashboard.
Documentation as executable knowledge
A capability answers through a machine interface: who are you, what can you do, what do you cost, what do you depend on, how is your work verified. The description is generated from runtime reality, and its drift is a detectable error — not the fate of every README.
How we will test it: Change a capability and measure: the traditional README goes stale silently, the self-description diverges detectably.
An application as a temporary society of agents
A task spawns a society of specialists; after the solution the society dissolves. The system keeps the knowledge, not all the software it created: agents 7 → 0, functions 12 → 2 cached, the result and the knowledge remain.
How we will test it: Visualize software disappearing after the solution — real-time counters of what was created and destroyed.
What must stay permanent
Radical ideas do not cancel engineering. Not everything in an agent environment may be ephemeral — and the boundary is drawn by the consequences of failure, not by taste.
┌──────────────────────────────────────┐ │ DYNAMIC LAYER │ │ agents · tools · functions │ │ workflows · interfaces · temporary │ │ applications │ ├──────────────────────────────────────┤ │ STABLE CORE │ │ identity · permissions · crypto │ │ data · memory · invariants │ │ economy · audit · verification │ └──────────────────────────────────────┘
Identity, permissions, cryptographic trust, data, memory, invariants, audit, verification and the economy form the stable core. Agents, tools, functions, workflows and interfaces form the dynamic edge.
The programme’s principle: knowledge persists, implementation may be disposable. Today we store code and try to recover knowledge from it; ANU explores the inversion — store intent, constraints, tests and provenance, and re-create the implementation when needed. The current runtime already shows this principle: the journal and the manifest are sufficient to regenerate and verify an entire run.
Questions we are trying to answer
- Does an AI agent actually need source code organized into repositories?
- Should agents communicate in natural language?
- Can software be generated only when required?
- Can UI emerge from user intent?
- Can documentation become a live machine-readable representation of reality?
- Can agents autonomously create the agents they need?
- What is the minimum persistent kernel of an agent-native system?
- Can architecture emerge instead of being designed?
- Can knowledge become the source of truth instead of code?
- What happens when applications become temporary?
How this differs from a multi-agent framework
Multi-agent framework Agent Native Universe
Human-designed workflow Human intent
↓ ↓
Agent A system determines the intelligence
↓ ↓
Agent B agents created / discovered
↓ ↓
Agent C topology and software emerge
↓
task solved, knowledge retainedOrchestrating a pre-drawn graph of agents is useful engineering — but a different question. ANU does not ask "how to connect agents"; it asks "what computational environment lets the connections emerge — provably".
Its place in the XTeam research picture
Today ANU is a standalone open repository with zero runtime dependencies. The links below are a research model for unifying our directions, not current integrations; we do not describe an integration that does not exist.
- KnowledgeBase AI — a potential persistent knowledge layer — what outlives ephemeral implementations
- XTeam Agents — a potential agent execution and orchestration layer
- MagicBrain — adjacent but a different question: not "a world for agents" but a persistent cognitive symbiosis of human and machine intelligence
- Balansis — a specialized computational capability — a candidate capability of the agent environment
The closing thesis
Agent Native Universe explores a world where software is no longer a static artifact written once and used many times. Intelligence dynamically creates the agents, capabilities, functions, workflows and interfaces each problem requires — and keeps the knowledge, not necessarily the implementation, once the problem is solved.
Perhaps today’s software is a transitional form between programs written by humans and systems that create themselves to solve human problems. That is a question, not a claim — and above is how we test it.
The repository is open under MIT: download it, rerun the experiments, verify every hash.