Library
The vocabulary, the failure modes, and the open problems of a discipline that does not yet have a settled name.
19 of 19 entries
R-19
Oct 22, 2026
80 min · Paper
Every time institutions scaled to coordination among strangers, the new scale became stable only after infrastructure existed that let strangers rely on the same rules without trusting one another. Autonomous agents are the next such scale. Computable Authority defines an authorized action by one equation, V = Eval_A(a, F, t), with no term for the agent, yet in deployment the agent carries the authority, the action and the facts, and can choose versions, facts and omissions without forging anything. This paper formalizes "the agent is not an input" as carrier indifference and characterizes it: four conditions are jointly sufficient, and the six obligations they refine into are each necessary, with every necessity construction executed against a reference verifier. Withholding facts is a known attack on attribute-based access control; when the adversary carries every fact, it is always available. Kleene's third value with one gate makes every prioritized defeasible rule set safe as written, and safety must preserve which approvers apply, not only whether the act is permitted. The result is proved in Lean 4, and proving it exposed a soundness gap in the published specification, now fixed in NOMOS-SPEC-008 0.5.0.
R-18
Oct 13, 2026
22 min · Position Paper
As machines take over execution, the question of what humans are for is usually answered in one of two ways: as supervisors kept in the loop, or as competitors racing the machine. Both lose. This paper gives a third answer from first principles. Any relation of authority needs someone to grant it, someone to decide the cases it reserves, and someone to answer for it. None of the three can be computed into existence, because each confers authority rather than exercising it. Computable Authority names them the Issuer, the Escalation Target and the Sovereign, maps each onto the equation V = Eval_A(a, F, t), and specifies the primitive that keeps each one human at machine speed. None of the roles requires humans to be more intelligent than the machine. Each requires that humans hold the authority.
R-16
Oct 7, 2026 · rev. Oct 8, 2026
35 min · Technical Paper
Proposals for an agent standard usually start from identification: agents should declare themselves so services can treat them differently from people. Identification tells a service who is calling. It does not tell the service whether to do what the agent asks, which depends on whom the agent acts for, under which rules, on which facts and with whose approval. This paper treats that decision as the problem to standardize. It describes NOMOS-SPEC-007 (chain-of-trust key certificates) and NOMOS-SPEC-008 (Act Binding): an agent presents an Act, a self-verifying package that binds one exact change to sealed institutional rules, signed facts from witnesses certified for those facts, and consents from approvers certified for the required role, and the system that would make the change verifies it locally and commits exactly that change or nothing. We give the threat model, the security properties and their arguments, including a proof that withholding facts cannot produce an authorization. We compare the design with trust management, proof-carrying authorization, XACML and capability tokens, and report an evaluation across two implementations: 29 conformance vectors, 729 derived mutants on which the implementations agree exactly, seven defects found by building a second implementation or by testing the stated properties against the reference, all now fixed, and verification latency of about 1 ms per Act.
R-17
Oct 8, 2026
8 min · Definition
V = Eval_A(a, F, t). An action is authorized when an institution's sealed authority, applied to proven facts about that exact action at that moment, says so, and the system the action would change computes the answer itself. The agent that asks is not an input. Computing an authority decision from several inputs is established practice; the contribution of Computable Authority is what those inputs must be for the result to be trusted by someone who did not write it.
R-15
Sep 17, 2026
8 min · Engineering Case Study
R-08 decomposed the authority handshake into exactly one missing link: a system that has never encountered a given issuer before, recognizing that issuer's authority on its own terms, without a hand-configured allowlist. This entry reports what was actually built in response — NOMOS-SPEC-007's offline chain-of-trust verification — checked item by item against R-08's own decomposition and its nine named open questions, not just described in the abstract.
R-14
Sep 16, 2026
5 min · Note
As AI systems move from producing answers to producing decisions software can act on, two questions have to be separated: what should happen, and who is authorized to make it happen. TypeSafe AI's launch this week is a clean example of the first. A calibrated model answering what should happen is not the same claim as an authority artifact proving what was permitted, and only one of them is what can() was ever built to answer.
R-12
Sep 13, 2026 · rev. Sep 15, 2026
12 min · Design Note
Every authority artifact today expresses static constraints — an amount, a role, a date range. Some real authority is not static: 'up to $20,000 cumulatively during this window' is a claim about a running total, not a threshold checked once per call. This note names that gap precisely, explains why it cannot be closed by simply adding a mutable counter without breaking the deterministic-execution and offline-verification guarantees the rest of the model depends on, and converges on an architectural direction: authority stays immutable, an external state layer (reserve/settle/release) holds what changes, and can() stays pure — evaluating authority against an explicit state fact rather than owning the state itself. A vertical slice of this direction has since been built and tested — see R-13.
R-13
Sep 15, 2026
6 min · Engineering Case Study
R-12 converged on an architectural direction for conserved-state constraints — authority stays immutable, an external state layer (reserve/settle/release) holds what changes, can() stays pure — but stopped short of a claim that the design was tested. This entry reports what happened when that vertical slice was actually built: a real database, real concurrent transactions, a real HTTP surface and SDK, checked item by item against the proof list R-12 itself set out. Six of seven items are verified. One further question R-12 left open — does settlement re-check the authority — is resolved. What remains open is named plainly, not folded into the result.
R-10
Aug 28, 2026
12 min
Organizations are not rule-executing systems. They are emergent decision systems whose true structure is not documented, but inferred from behavior under constraint.
R-11
Aug 28, 2026
14 min · Engineering Case Study
Why chunked LLM extraction fails on legal documents longer than roughly thirty pages, and the architecture that fixes it: separate indexing from extraction.
R-08
Aug 26, 2026
13 min · Position Paper
Existing guardrail architectures treat authority as a filter applied after an autonomous system has already decided what to do. This paper proposes bounded contextual authority — a portable, machine-verifiable representation of the mandate an autonomous system acts under — and decomposes precisely which part of the resulting handshake problem is already solved and which is not.
R-09
Aug 26, 2026
18 min · Design Note
NOMOS's trust primitives — sealing, third-party attestation, revocation, and chain-of-trust key certificates (now published as NOMOS-SPEC-007, Draft) — all assume a relying system already has reason to trust the root key an authority chain is checked against. This note proposes a candidate governance model for that root, then deliberately red-teams it against web PKI, DNSSEC, RPKI, Certificate Transparency, accreditation, professional licensing, treaty recognition, and federated trust — and reports plainly what survives and what does not.
R-07
Aug 21, 2026
18 min · Position Paper
The emergence of autonomous AI agents changes the problem that Law as Code needs to solve — and requires more than machine-readable law. It requires machine-computable authority.
R-01
Jul 31, 2026
6 min
Authority is the right to decide. Computable authority is that same right, expressed so a machine can exercise it inside defined limits — and prove it did.
R-02
Jul 31, 2026
7 min
Capable models with no authority layer are not governed systems. They are fast improvisation with an institution's name attached.
R-03
Jul 31, 2026
5 min
A decision is only defensible against the rule that was in force when it was made. Almost no institution can produce that rule on demand.
R-04
Jul 31, 2026
6 min
Most policy disputes are not about rules. They are about what a word meant, to whom, and when.
R-05
Jul 31, 2026
8 min
The compilation pipeline: how a published instrument becomes an artifact a runtime can evaluate — without losing its provenance.
R-06
Jul 31, 2026
10 min
Institutions will exchange authority the way systems now exchange data — and that requires shared infrastructure, not shared documents. Three prior efforts got partway there; none closed the gap.