Systems that prove before they act.
VAIXLNS is a sovereign operating fabric: a deterministic, governed runtime where every action is proven, ledgered, and replayable. AI agents run inside the law, not above it.
Proof before effect
No command touches state until the constitution returns ALLOW. Missing proof is a rejection, not a warning.
Every effect is ledgered
Append-only, hash-chained, tamper-evident. Rejections are recorded too, without changing canonical state.
Replay to the same root
Same genesis, same events, same rules, same SHA-256 state root. Every time, on any machine.
Powers are separated
The engine proposes. Governance approves. The runtime executes. No actor holds all three.
Agents run inside the law
The Intelligence Fabric composes capabilities as a DAG and executes them under the governed runtime.
Watch a governed runtime think.
Commands arrive. The constitution decides. The ledger records. Replay proves. Every hash below is a real SHA-256 computed in your browser.
The constitution answers first.
A command is a request, not an action. The runtime asks the constitution, and only an ALLOW reaches the transition function. A DENY still gets written to the ledger, so the attempt is auditable and the state root is unchanged.
- Pure transition: Sn+1 = T(Sn, En), no clocks, no randomness, no I/O.
- Each event carries the constitution hash and VIK hash it was proven under.
- Sequence and previous-hash are checked before any handler runs.
Same history, same root. Anywhere.
The replay engine validates the whole event sequence first: monotonic sequence numbers, an unbroken hash chain, one constitution, one VIK. Then it folds genesis through every event and emits a state root you can compare byte-for-byte.
- A broken chain fails closed before any transition runs.
- Every transition is logged from-root → to-root for lineage audits.
- Causation and correlation ids link effects back to the command that caused them.
Agents as a DAG, not a pipeline.
The fabric scores every registered capability against the task, keeps the relevant ones, and resolves them into parallel layers by dependency. Each layer runs, is evaluated, and feeds a knowledge base that improves the next composition.
- Six roles: analyzer, planner, executor, validator, optimizer, learner.
- Topological sort rejects cycles; layers run in parallel where dependencies allow.
- Designed to host LLM-backed capabilities under the same proof-before-effect rules.
Thirteen kernels. One root of trust.
VAIXLNS is specified as a family of small, single-purpose kernels. VX owns the lifecycle and nothing else. Nothing below it may depend on anything above it. Highlighted kernels have code in the repository today; the rest are ratified specifications.
A genesis engine for systems of systems.
The long-run thesis: a system should not only ask “how do I change myself?” but compute “which systems should exist at all?”. ΩΣ moves from reality to ontology to law to a space of candidate systems, composes them, and lets only proven compositions become generators. The root of trust never moves.
Genesis closure
Ten invariants sit above mechanical closure: every generated system has an identity, a specification, laws, a cause, and a provenance back to its origin; failures never alter canonical state; a generated system can never modify TB₀; and every generation can be rebuilt from its record. The evolution policy itself may evolve, but only when TB₀ proves the new policy safe.
What is real today.
We publish the state of the code honestly. The kernel primitives are written and tested; the higher kernels are ratified specifications with a 32-week build plan.
Build on VAIXLNS.
Clone the repository, run the replay tests, and read the specification. Then tell us what you would govern with it.
Free and open source · built by Team Pro Workload