How it works
Build governance once.
Let every application inherit it.
Every consequential action passes through one authority path that starts closed. Policy is evaluated, the checks are trusted for a measured reason, the right person approves, and only then is a single-use permit issued for the exact output.
Six questions
Every governed decision must answer them.
An agent can draft a clinical explanation or a financial research brief. That's capability. But capability is not authority.
Three runtimes
Each wraps the next. The dependency runs one way.
- Factory runtimethe core: runs any application declared as data, and knows nothing about what any of them are for
- Execution runtimedoes the work: the agent loop, a replaceable model harness, credentials, cost, and a tamper-evident ledger of what the agent did
- Governance runtimedecides whether a consequential action is allowed at all, and records which rule allowed it, which checks were trusted and who approved
Governance knows about the platform; the platform never knows about governance. An ordinary application runs exactly as before, and a regulated one inherits governance without the core changing.
Who checks the checker?
The decision graph answers whether a particular action was allowed: assertion, verification, approval, permit, evidence. The qualification graph answers why a checker should be trusted at all: its signed, expiring qualification, the dataset behind it and its measured performance. Every decision cites that qualification.
Every human approval is bound to a fresh identity and licence check at the moment of approval, not to an authenticated click.
One truth, many views
Every decision produces one signed, hash-chained evidence record, kept where it cannot be overwritten. The regulator's report, the auditor's view, the human summary and the machine attestation are views of that same record, never competing versions of the truth.
The demonstration
Same application. Three governing decisions.
Qualified checks pass, policy allows, the credentialed approver signs, a single-use permit is issued for the exact bytes, and the signed record is anchored to write-once storage.
The content-addressed policy in force now requires approval — or denies. The action stops before emission; the reason code and the refusal are recorded as evidence.
Load a different domain pack — different verifiers, approvers and emission rules — and the authority path runs unmodified. The application did not change. The authority did.
The application did not change. The authority did.
Seven principles
What we hold to
Govern once, deploy everywhere
Governance belongs in the shared platform, rather than being rebuilt inside every application.
Policy over code
Rules and boundaries are expressed as declarative, versioned configuration.
Prevention before audit
Governance is a prerequisite for the action. When a required check fails, the gate blocks or escalates.
Evidence by design
Evidence is generated during normal operation, not reconstructed afterwards.
Separate execution and governance
The system doing the work stays distinct from the system deciding whether it may.
One platform, many domains
Specialise through domain packs while the foundation stays constant.
Humans remain accountable
Automation amplifies judgment; it does not remove responsibility.