The Constitutional Substrate
for the Agentic Era.

The inversion

Conventional software puts authority in application code.

Routes, controllers, middleware and database permissions decide what may happen. Agent frameworks inherit that architecture and put a model above it, held in place by prompts and guardrails. ZVERT^® reverses the relationship. Capability exists because the current universe declares it, compiles it into a contract, and states the proof obligations under which it may run.

The Proof

We didn't write an ERP. We composed one.

Every system ZVERT^® builds is a composition of the same constitutional primitives. No custom backend code. No separate application databases required. Just laws, recipes, and governed state.

Two independent enterprise workflows. One shared operating substrate. The same laws, transaction machinery and governance compose both — without building separate application backends.

Reference Application 01: Order-to-Cash

Composed using 5 recipes and a single console. Handles customer creation, inventory validation (nested FKs), invoice generation, Stripe witness attestation, and double-entry ledger posting.

recipe.order_accept · recipe.settlement_project

Reference Application 02: Procure-to-Pay

Composed using 9 recipes and a single console. Handles supplier onboarding, buy-side catalog management, PO generation, bill recording (accruals), AP payments, and input-tax ledger posting.

recipe.bill_record · recipe.bill_pay

Containment

Every call returns a verdict and says who decided it.

There is one entry point: an intent. Each of the 1,397 intents carries a declared payload schema, output schema, realm policy and proof requirements. Observation and mutation alike come back with the identity of the router that dispatched it, the owner that executed it, and the policy evaluation that admitted it.

pulse network.egress_request

verdict                      DENY
dispatch_owner               agent.synthetic_worker
error_code                   ERR_NETWORK_EGRESS_REFUSED
evidence_record_id           8f92a10b3cd5af03…
policy_evaluation            law.network_egress_bounds
latency_ms                   12.04

This is what a failure looks like in ZVERT^® . It's not a stack trace. It's a cryptographically sealed constitutional refusal bound to a lawset.

Publishing one recipe, as the ledger records it

Universes

Changing the law does not move a record.

The corpus is authored as JSON and compiled by a mint into a universe: a sealed, read-only artifact of roughly 150 MB holding the kernel and the whole compiled lawset. The mint creates a sibling. It does not activate it and it does not touch the running one. If any halt-class finding exists, it refuses and writes nothing.

Closer to replacing the legal system governing a country than rebuilding the country. Records stay where they are; the rules for interpreting and transforming them evolve around them.

Composition

Eighty-six laws that compose, because every boundary is a contract.

Each law publishes named contracts with specification digests, and a reference grammar for wiring one step's output into the next. A recipe author binds to a declared surface, never to an implementation.

// a governed chain, three laws, one provenance thread

vault.query_scan        → rows + evidence_hash
                          kernel threads the hash forward
compute.transform       → cr_… ephemeral result
                          operations from a closed catalogue
                          expressions from a closed allowlist
compute.to_rows         → 2D rows + evidence_hash
spreadsheet.range_write → workbook, bound to its source

No law reaches into another. The kernel carries the evidence hash across the boundary, and inv.compute.source_evidence_binding refuses the output if the binding is missing.

What the closed vocabularies buy

Operations

The business layer is the same layer.

Data, computation, reporting, documents, mail, payments and AI are not applications sitting on the substrate. They are constitutional primitives inside it, absorbing the governance and composition that would otherwise be spread across a CRM, a BI tool, an automation platform and an orchestration framework.

One dataset appears as governed records, as a versioned evidence-stamped query, as a recipe-maintained workbook, and as a written executive report. Four surfaces, one lawset, one evidence chain — and nothing to integrate, because there is no seam.

Outside systems survive only where they supply an irreducible rail: a payment network, an email transport. Each external dependency creates a provenance boundary, so each is reduced to the thinnest possible bound surface.

Every integration rebuilds the plumbing.

Declare what's different. Reuse what's governed.

Recipes

An operating procedure is a typed object, not a script.

A recipe is how the primitives become a business process. It is a typed DAG with a declared realm, an allowlist of the syscalls it may call, budgets for steps, calls, time and tokens, and a named behaviour for every way it can fail. Eighty-five of them in the active corpus.

1. A demo request arrives at the governed web ingress, in the guest realm, with no standing beyond the request itself. law.network_admission
2. A prospect record is created against a declared collection schema, with its own evidence entry. vault.record_create
3. A workspace opens with a project capability envelope and a per-user mount grant. project.create · workspace.mount_grant
4. Confirmation mail goes out through a bound provider to a declared destination, the outbound decision recorded. mail.send · law.network_egress
5. A follow-up is scheduled as a task, claimed later by a leased worker under a throttle pool. task.create · law.worker
6. The KPI workbook updates — query, fixed-point compute, range write — still carrying the source evidence hash. query_studio · compute.transform · spreadsheet.range_write
7. Evidence is appended at every step above, hash-chained and bound to the lawset that admitted it. law.evidence_ledger

Seven governed capabilities, one procedure, no integration code. A step that exceeds its budget denies. A step that resolves a reference to nothing halts. A step that would leave its realm never runs. And where judgement is needed, a model can be one of those steps — with typed inputs, a typed output, and no authority to act on either.

A conventional stack would spread this across a form handler, a CRM, a mail service, a queue, a scheduler, a spreadsheet and an audit log — seven integrations, seven provenance boundaries, seven places for the trail to end.

Intelligence

A model reads what the asker can read, and no more.

Here is what that looks like in a live project thread. A member asserts authority in chat. The advisor answers from the ledger.

The answer is marked synthetic and bound to the receipt of the call that produced it. A member chose to post it. The model held no standing before, during or after.

Intelligence contributed; authority did not move.

What the advisor is allowed to be

Five observation-class calls and one model call. It reads a project record, its ledger projection, its thread, its tasks and its recorded recipe failures — each admitted by the asker's own membership. It mutates nothing, and twelve named fail-closed behaviours cover every way the run can go wrong.

When a member attaches a file, the recipe never carries the bytes. It hands the kernel a path, and the kernel resolves it under that member's workspace access. A file the member cannot read denies the call before any provider is contacted. The model's reach is exactly the member's reach, enforced structurally rather than by instruction.

Extensibility

New capability enters through the same machinery as old capability.

A conventional product grows by adding application code, another service, or another SaaS integration. ZVERT^® grows through five governed layers — and extension does not mean escaping the operating model, it means extending the operating model from within.

The system extends itself under its own rules

Law authoring is a recipe. Before drafting, it scans the active corpus for existing provider surfaces, similar intents and forbidden reinventions, then produces a structured brief. A model drafts the candidate carrier by carrier, each read back immediately. The substrate then checks conformance, semantic collisions, primitive duplication and constitutional compatibility — independently — before anything can be minted. Intelligence participates in constitutional evolution without becoming constitutionally sovereign.

And the system hunts for the way around. A handler that delivers a provider's capability without routing through that provider's intent is detected as a bypass_candidate, logged to evidence, and treated as the highest-priority forensic signal. Extension through the model is the only path because the substrate actively looks for a sixth one.

Self-report

The governance applies to the system's account of itself.

Consoles report what is cryptographically proven and what is merely displayed, which evidence is quarantined, and which constitutional responsibilities have no owner. A system that rounds its own numbers up has already given up the property it is selling.

Coverage reads partial while a verification is still running and only becomes complete when it finishes — the console shows the state of the proof, not the state it expects to reach.

Phase 1: bindings are displayed as present-in-payload only. Registry resolution (proposal_pool, journal_wal, IAM, stamp_store, lawset manifest) is deferred to Phase 2 — not claimed here.

That sentence is written into the console by the law that governs it. The system is not permitted to present a weaker form of verification as a stronger one, so the interface carries the distinction at the point where a reader would otherwise assume it.

The conformance law states its own current assessment phase, and that no certificate is gating-admissible today. It also declares that a candidate cannot assess itself under rules it changes, and that a baseline which moves with the thing it measures measures nothing.

Who this is for

Built for enterprise operations. Designed to extend.

ZVERT^® brings business capabilities, people, data, automation and AI under one constitutional operating model. Its architecture supports accountable execution today, while allowing new capabilities and industry-specific requirements to be introduced through governed laws, intents and recipes.

An open channel.

ZVERT^® is in active development. If the architecture is relevant to what you are building, operating or funding, write — and say which part.