The contract
Consumed by its shape, not its implementation
Signatio is an optional requirement a project chooses by installing the pack and declaring the provider (ADR-001). A project depends on the shape of what it produces:
- subject_digest is the digest of the Work Order being granted.
- scope is the paths and aspects the grant covers.
- proof is a signature, or any other proof, tagged with the scheme that produced it. Verification dispatches on the tag and fails closed on a scheme it cannot evaluate.
- principal is optional: a verifier receives the attributes its decision reads, not necessarily who the signer is.
Three mechanisms
One responsibility each
custody
Answers who holds the key, and whether a person was present when it signed. It knows nothing about what is signed, or why.
verify
Answers whether a proof is valid for its subject and scope, using public material only. It knows nothing about private keys or roles.
authorize
Answers whether the signer's roles cover what is asked: each project's Cedar policies, evaluated over the principals and the hats they hold. It knows nothing about how the proof was produced.
verify and authorize touch public material only, so they may run anywhere: a daemon, a plugin, a CI job, the agent's own session. sign is packaged apart; where it may be installed is declared, never assumed.
Principles
What holds, by mechanism
Only a person signs
An agent never signs: not with a person's key, not with its own.
Keys out of the agent's reach
By mechanism, not by instruction. The agent reads public keys only.
Nothing grants itself
No actor widens its own authorization under any pretext.
A trace, not a signature
The agent leaves a trace. The trace authorizes nothing.
A signature authorizes a declared scope
Changing the scope is signing again.
Outside the scope, stop and ask
Ask the role that governs that surface: a matter of roles, not hierarchy.
Declared, never imposed
No mechanism is required. The floor is a software ed25519 key anyone can generate; hardware authenticators raise the assurance level. The attestation states what was used, and the consumer's policy decides whether it is enough.
Exposure is declared per audience
What a signed artefact carries travels with it through every channel and cannot be withdrawn; which field reaches which audience is decided at issuance.
Three binaries
Only one holds the key, and it never faces the network
signatio-signer
The custodian. The only process that loads the private key. It listens on a local Unix socket only and answers the one peer uid it allows. It gives its public key and signs raw Ed25519 bytes; it knows nothing of projects, clients or policy.
signatiod
The authority service projects see: TLS and three routes, /v1/challenge, /v1/token, /v1/op. It holds the store and no key: it links no library able to sign, and every answer is signed by asking the signer.
signatio
The administrator's CLI, a client of signatiod over TLS like any other, holding no key. Three commands need no administrator's token: bootstrap writes the first administrator into a stopped daemon's store, key-id gives a key's id offline, and verify-connection checks a consumer's declaration.
signatio-boot is not a fourth service: it is the launcher every installed use goes through.
Workflow
How the binaries work together
Projects and the administrator talk to signatiod over TLS. signatiod holds no key: it asks the custodian, through a local socket and nothing else, to sign every answer. The numbers are the steps of the request below.
A request, end to end
Every answer is signed, a refusal included
Token
The client proves itself at
/v1/tokenwith its id, project and proof: a client secret, of which the store keeps only the sha256, or a signed challenge, a single-use nonce from/v1/challengesigned with the client's key.Operation
With the token,
/v1/opcarries the request: Whoami, Authorize, VerifySignature, Record, RegisterProject, RotationNotice, Holders, HatsOf, Log. A client reaches only its allowed actions.Signature
The daemon builds the answer and has the signer sign it. Every answer carries
signature { key_id, scheme, value }, a refusal included. What is recorded is written to the project's chain.Verification
The project checks every answer with the authority key it pinned before asking anything, received out of band. TLS protects the transport; the signature proves the authority answered.
Rotation. A second custodian holds the next key. A rotation notice is signed by both custodians; from its effective time the daemon signs through the new one, and at every start it checks its custodians against the stored notices.
Run it
Three ways it runs
Development
From code/: just dev-init generates keys, certificate and configs, just dev-seed the first administrator, and just dev starts the signer and the daemon.
Installed
just install puts the binaries and the pack in place; the operator brings the keys, since nothing generates one. signatio-boot layout, signatio bootstrap and signatio-boot service install set up the custodian before the service.
End to end
just e2e-* runs the same cycle in a temporary directory; just e2e-pack installs the pack and runs it with the example consumer against it.
A project associates by receiving the handover: the endpoint, the certificate that vouches for it, the authority key to pin and the administrator's client. The administrator then registers it with its profile, whose digest the project pins.
Boundaries
What Signatio is not
Not a secrets store
sops, age and a vault's key-value engine decide who reads values; Signatio decides who granted what.
Not identity or sessions
That is stratum-ui's auth; Signatio complements it with authorization and attestation.
Not needed to check what it attested
An attestation verifies offline with the authority's pinned public key, forever after; only new governance acts need the service.
ontoref Gov
One domain in three layers: how a project governed by ontoref governs itself.
What it is
Gov is ontoref's own domain. It holds the arrangement — what a project's boundary declares, its members, which artefacts a consumer inherits — and the exercise — what work is committed and how an act is delivered. Its name is the root of governance, governability and government, and elects none of them.
Why
A decision, a boundary or a delivery that lives only in someone's memory binds no one. In Gov each one is a declaration a project can be held to, and what holds it is a mechanism, not a good intention.
What for
A project reaches Gov by bond, never by imposition, and takes only the parts it needs. In signature governance each project carries one: the contract, the operations of work, the signature, the dossier, the agreement and the signing on an agent's behalf. Beside them, the capabilities any state of governance uses: the host boundary, deployment, the observed session and the opening by name.
How governance is layered
Protocol · base
ontoref's base: bonds and planes, content bound by digest, the unsigned work order, the check form, and mandatum's types. Every project is written in it; a project can bond without adopting any governance.
Management and governability · gov
The gov domain, in ontoref: how the constellation is organised, its management modes, and decisions held by validators.
Signature governance · foedus
The foedus domain, provided by the foedus project and operated by warden: the agreement, each party's annex and the tests that prove it. A project is here because it is a party to the agreement.
Isolation, provisioning, wuwei and openbyname are capabilities any state of governance uses — the agent's boundary, deployment, sessions, and running tasks locally — not governance: governance needs them, they do not need governance.
Each project chooses its governance mode
Governability (coherence) · ontoref alone
Coherence only: ontoref checks that the declarations hold together. No signature.
Auditable governance · signature
The person signs. It detects a departure; it does not prevent it.
Applied governance · signature + isolation
Signature and isolation together. It prevents.
Part of the same system
signature governance
Custody
A safeguarded project is held to a contract, one axis at a time. Custody states it; implementations hold it.
custody.ontoref.dev →
foedus
Many parties, one agreement: each holds its own part, and every condition is proved by a test that fails when it should.
foedus.ontoref.dev →
iter
An owner and an agent work in one store. gov decides what each class of change requires; iter carries it out.
iter.ontoref.dev →
SpecDossier
SpecDossier keeps the terms of a Statement of Work, not its execution, and brings them to landing.
specdossier.dev →
warden
No agent holds a key: warden signs for it, only inside a core the owner signed.
warden.ontoref.dev →
capabilities
Isolation
Owner and agent share the same trees. What the agent may not do, the host refuses.
isolation.ontoref.dev →
openbyname
openbyname lets a link on a web page open a file on your own machine, by name and safely: the link carries only names, and your machine's declarations decide what it may do.
openbyname.dev →
wuwei-observer
Agent sessions, observed without forced intervention.
wuwei.observer →
Declared, never imposed.
Custody, verification and authorization around the act of signing. A project chooses it.