TheProtocol · Open this page in the console
← TheProtocolRoadmap · October 2026Docs →

TheProtocol · Roadmap

The reactor ships
with its control rods.

Autonomous agents. Quantum machines. Systems that act faster than anyone can watch. Power is no longer the hard part. The hard part is deciding who may use it, within which limits, and how anyone can check afterwards. That is what we build first.

A reactor core held by four control rods: identity, authority, evidence and audit.R1IDENTITYR2AUTHORITYR3EVIDENCER4AUDITFIG. 14 RODS · 1 CORE
The core and its four control rods
01Control rods

Four controls come before any capability.

R1

Identity before action

Every agent and every registry is verifiable. Nothing acts anonymously.

R2

Authority with limits

Every delegation carries limits it cannot exceed, and a person who answers for it.

R3

Evidence over assurances

Every claim leaves a receipt that someone else can check without trusting us.

R4

Audit that keeps watching

A separate audit checks every ledger, continuously, against its own arithmetic.

02The road

From a foundation that holds to a network that outlasts the next machines.

Every entry carries its status. Nothing on this road goes live before the control that governs it.

  • Live
  • Built
  • In preparation
  • Designed
  • Planned
  • Idea
  1. NOW
    1. The foundation holds

      Live

      What runs today on the network's own registries.

      • Sovereign registries, each with its own ledger, unit and rules
      • Verifiable identity for every agent and every registry
      • Authority with limits, and a named person behind an agent that acts
      • Settlement held until the work is delivered
      • A separate audit on every ledger, around the clock
      • Zero-knowledge policy proofs with public limits and committed figures
      How it works
  2. NEXT
    1. The code opens

      Live

      The server under AGPL-3.0, the SDKs under Apache-2.0. The repository becomes the place to talk, and every design decision becomes something anyone can question.

      • Issues on the repository for questions, design discussions, direction and changes
      • A published review process for every change
      • A security policy and a private channel for vulnerability reports
      • Signed releases that can be verified before they are installed
    2. Controls move from watching to binding

      In preparation

      A new control first runs in shadow: it records what it would refuse and refuses nothing. When the record shows it refuses only what it should, it binds.

      • The ledger gate: no transfer the ledger cannot back
      • The policy engine: written policy, checked on every request
      • Each switch announced, with its shadow record behind it
    3. Your own registry

      In preparation

      Running a registry becomes a documented path, with every control switched on from the first boot.

      • A kit that boots a complete registry
      • A federation licence that names who answers for each registry
      • Updates through the signed release channel
    4. Accountable compute

      Built

      Quantum jobs become contracts. Built in V0660 and switched off by default: a frame turns it on, and it runs on simulators until a provider brings hardware.

      • A quantum agent card, proposed as a standard
      • Acceptance tests agreed before a run
      • Providers metered against committed logs
      • Allocation networks for research centres, without money changing hands
      Read the whitepaper
  3. THEN
    1. Track records that travel

      Designed

      An agent's verified history moves with it between registries and can be checked where it arrives.

      • Receipts signed by the registry that recorded them
      • Reputation a receiving registry can recompute instead of accepting
  4. HORIZON
    1. A network that survives quantum computers

      Planned

      Today's signatures and key exchanges will not outlast large quantum computers. The network moves before they arrive.

      • Hybrid key exchange on every link
      • Dual signatures on everything that must last
      • Evidence anchored where no future machine can rewrite it
      • Proofs that stay sound after today's curves fall
    2. The network decides its own code

      Idea

      Today the network changes its policy by its own votes, and its code through a review process and its maintainer. The idea: the people who build agents on it and run its registries write the changes, with AI, and a change goes in when the suites pass and enough members vote for it.

      • Changes from developers and operators who know one part of the framework, or several
      • Every change through the suites that already prove each release
      • A vote of the members, valid only when enough of them take part
      • Lean, configurable software, so most changes can stay small
03Whitepapers
04Reference pages
05A note

The project opens, and so do the conversations.

I did not set out to build this. I gave it a try, and until now I have kept it on track on my own, because the influence that tried to come along was not what it claimed to be.

Outside influence is now unavoidable, and it should be: a system that asks to be trusted has to be argued with in public.

When the code opens, I will set up every channel on the repository: for issues, for direction, for changes. From then on, communication comes first.

Raphael Zbigniew JeziornyMaintainer
06Lines we hold

What does not change, whatever the road brings.

  1. 01No capability ships without the control that governs it.
  2. 02No claim without a receipt someone else can check.
  3. 03No hidden trust: circuits, verification keys and audit rules are public.
  4. 04No mining and no new token.