Chancery
Open source · Apache-2.0 · Self-hosted

The identity provider for AI agents.

Your agents share one API key, can't be stopped mid-task, and write their own logs. Chancery gives them what every other privileged identity already has: their own identity, authority that can only narrow, revocation that lands on the next call, and an audit trail they can't write to.

Star on GitHub 5-min quickstart
1
Go binary
19
Locked RFCs
109
Tests
0
Cloud deps
deploy-bot — governed session
chancery writ grant --to deploy-bot --cap "call:github/get_*" --ttl 8h
writ w_01K3MZQ4T8 · block b_01K3MZQ4TB · expires in 8h

chancery mcp wrap --agent deploy-bot --writ w_01K3MZQ4T8 -- npx @acme/github-mcp
listening · tools/list filtered to the writ

agent → github/get_pull_request
ALLOW forwarded · attributed · recorded
agent → github/delete_repo
DENY never reached the server

chancery writ revoke w_01K3MZQ4T8
revoked — the delegation tree dies on the next call

agent → github/get_pull_request
DENY authority revoked · mid-session, no restart
Real command output. Nothing here is mocked.
The problem

We give agents more standing power than we'd give a new engineer.

Three failures show up in almost every agent deployment — and none of them are the model's fault.

01

Shared credentials

Agents run on one API key. You can't revoke a single agent without breaking every other one, and you can't attribute an action to a specific agent after the fact.

02

Injection becomes escalation

Once an agent is wired to a tool, every capability that tool exposes is reachable. A successful injection doesn't just change output — it drives anything the agent can touch.

03

Logs from the compromised party

"Revoking" usually means waiting for a token to expire. And the record of what happened is written by the agent — the exact component you stopped trusting.

How it works

A gate the agent cannot talk its way around.

Chancery runs as an out-of-process proxy in the tool-call path. The agent holds no credentials and no server command — only a request that has to survive the gate.

Untrusted
The agent

Holds an identity document. No API keys, no server command, no way to skip the next step.

In-path · fail closed
Chancery

Decides every call against live state, then records it.

agent alive writ valid not revoked allow-list audited
Pinned · confined
The tool server

Its code identity is verified before every spawn. Secrets are injected here — never into the agent.

Because state is read per call, revocation takes effect on the next action — no propagation delay, no CRL, no cache to expire.

What you get

Identity, authority, and evidence — enforced outside the agent.

Real identities

Agent → immutable content-addressed version → revocable running instance, each separately killable and owned by a named human. Change the prompt and it's a new version — "did this change since review?" is a hash comparison.

Authority that only narrows

A writ is a signed chain where every delegation can only add restrictions. Widening isn't forbidden, it's unrepresentable: the block format has no field for it. Revoke any block and its whole subtree dies.

Revocation that lands

writ revoke takes effect on the agent's very next tool call — mid-session, no restart, no waiting out a token's lifetime.

Agents never hold secrets

Credentials are AEAD-sealed and injected into the tool server's environment at spawn. Prompt injection cannot exfiltrate what was never in the context.

The tools get verified too

Pin an MCP server by image digest, whole install tree, or binary hash — drift refuses to start. --confine adds an egress allow-list and a read-only filesystem, enforced by the OS.

Evidence, not logs

Hash-chained and metadata-only by schema: prompts, payloads, and arguments have nowhere to be stored. Written by the gate, so a compromised agent can't skip or forge an entry.

In practice

Four commands you'll actually use.

# authority under a named human, scoped and expiring
chancery writ grant --for user:you@acme.com --to deploy-bot \
    --cap "call:github/get_*" --ttl 8h --task "review PR #123"

# hand a sub-agent LESS — never more; widening has no syntax
chancery writ delegate <writ-id> --to test-runner \
    --caveat "call:github/get_pull_request"

chancery writ check <writ-id> --resource github/get_pull_request
ALLOW  lineage: user:you@acme.com → deploy-bot → test-runner
See what happened

A timeline written by the gate, not the agent.

Chancery ships a read-only dashboard: the live audit timeline with a permanent integrity badge, the agent roster with spawn provenance, and the delegation tree rendered as a tree. Writes stay in the CLI — a dashboard that can grant authority is a dashboard worth attacking.

Chancery dashboard showing the audit timeline in plain English with allow and deny decisions and a live integrity badge.
Every decision, attributed — with a hash-chain badge that breaks on any tampering.
Chancery dashboard showing writs of authority as a delegation tree.
The delegation tree. Each block can only narrow what its parent held.
Honesty as a feature

Every known gap is published.

Chancery is a security product, so its own posture is documented rather than implied: a full threat model — STRIDE, OWASP LLM and Agentic Top 10 mappings, abuse cases walked — and a table of every known gap, each with an owner and a phase.

Two promises. What ships open source stays Apache-2.0 — no license flip, ever. And security is never paywalled: every gap in that table closes in the open-source core.

The design itself is public too — 19 locked RFCs, each stating the problem, the alternatives considered, the decision, the trade-offs accepted, and the failure modes. If you want to know why something works the way it does, the argument is in the repo.

Enterprise

Running agents somewhere that has auditors?

Everything that makes a single trust domain secure and operable is open source, forever. What exists only at organizational scale is where the commercial edition starts:

  • SSO & SCIM — bind agent ownership to your existing identity provider
  • Multi-tenancy & scoped operator roles — beyond a single admin token
  • SIEM export & external anchoring — audit chains you can prove to a third party
  • Compliance packs & HA orchestration — EU AI Act, SOC 2 evidence, Postgres backends
  • Design-partner support — a direct line to the engineers who built it
Get in touch →

Not enterprise, just running agents and something broke? Bug reports are the most valuable thing you can send — open an issue or use the address above.