Signatio is part of ontoref Gov.
Signatio
v0.1.0 · an optional capability of ontoref's gov domain

A signature grants a declared reach.

Signatio produces that grant and checks it.

An agent, usually an AI agent, works under a Work Order. A person signs the scope the agent may act within. Signatio is the mechanism behind that signature: how it is produced without the agent ever holding a key, how anyone verifies it with public material only, and how a verifier decides whether the signer's roles cover what the scope asks for.

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:

Attestation = subject_digest + scope + proof { scheme }
verify(Attestation) → { principal?, roles, ial, aal, isolation }
  • 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

  1. Token

    The client proves itself at /v1/token with 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/challenge signed with the client's key.

  2. Operation

    With the token, /v1/op carries the request: Whoami, Authorize, VerifySignature, Record, RegisterProject, RotationNotice, Holders, HatsOf, Log. A client reaches only its allowed actions.

  3. 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.

  4. 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

ontoref

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

capabilities

Declared, never imposed.

Custody, verification and authorization around the act of signing. A project chooses it.