obsigna MCP server
Commit Nov 14, 2026Provides cryptographically signed, tamper-evident audit trails for AI agent actions through an MCP proxy and multi-language SDKs.
Also known as agent-receipts/obsigna
- Stars
- 22
- Tools
- —
- Downloads, 30 days
- —
- Latest version
- —
- Last commit
- Nov 14, 2026
- License
- Apache-2.0
What is obsigna MCP?
obsigna provides cryptographically signed, tamper-evident audit trails for AI agent actions through an MCP proxy and multi-language SDKs.
Summary generated from the project's README
About obsigna MCP server
Creating cryptographically signed, tamper-evident audit trails for AI agent actions is the primary function of obsigna. This toolset implements the Agent Receipts protocol to provide verifiable records of every tool call an agent makes. It is designed for developers building AI agents who need to ensure that action histories cannot be modified, reordered, or deleted without detection.
Users can deploy this via an MCP stdio proxy that signs tool calls and adds policy hooks, or by using a PostToolUse hook for runtimes like Claude Code. For higher security, the obsigna-daemon acts as an out-of-process signing service that maintains key custody and owns the audit chain. The system includes multi-language SDKs for Go, TypeScript, and Python, allowing developers to embed receipt creation directly into their own applications. A local CLI and dashboard are available to browse, verify, and inspect the resulting receipt databases.
What you can do with it
- 1Automate Claude Code auditingConfigure a PostToolUse hook so that every tool call made within Claude Code automatically receives a signed receipt.
- 2Embed receipts in custom codeIntegrate receipt generation into your own software using the provided Go, TypeScript, or Python SDKs.
Written from the project's README. Every use case is checked against a quote from it.
Automated checks
Ran Nov 14, 2026Full report →Not verified yet. A server needs a score of 80, no serious finding, and enough data for us to check. How checks work · What to fix for more points
- Source repository linked and reachableagent-receipts/obsigna is public and reachablegithub.com/agent-receipts/obsigna ↗Pass
- Package names this repository as its sourceNot checked
- Build provenance (Sigstore attestation)Not checked
- Open source license (OSI)Apache-2.0spdx.org/licenses/Apache-2.0.html ↗Pass
- Commit or release in the last yearLast commit or release 2026-11-07github.com/agent-receipts/obsigna ↗Pass
- OpenSSF ScorecardNot checked
- Package name not close to a popular packageNot checked
- No critical advisory in the package or its dependenciesNot checked
- No hidden instructions to the model0 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPass
- Destructive tools are labelledNot checked
- Remote endpoint answers the MCP handshakeNot checked
README
View on GitHubAgent Receipts
Cryptographically signed audit trails for AI agent actions
| Protocol site & spec | agentreceipts.ai |
| Conformance | Cross-language interop suite |
| Tooling docs | obsigna.dev |
| Daemon setup & migration guide | obsigna.dev/getting-started/daemon-setup/ |
| API reference | Go · TypeScript · Python |
| Examples | obsigna-examples |
| Blog | Your AI Agent Just Sent an Email · Every MCP Tool Call My AI Makes Now Gets a Signed Receipt |
| Go | sdk/go · mcp-proxy · dashboard |
| npm | @obsigna/sdk-ts |
| PyPI | obsigna |
What is this?
Agent Receipts is an open protocol for producing cryptographically signed, tamper-evident records of AI agent actions. It defines the receipt format, signing scheme, chain structure, and taxonomy of action types. Anyone can implement it — in any language, in any runtime.
Obsigna is the reference toolset that implements the protocol:
| Tool | What it does |
|---|---|
obsigna-mcp |
MCP stdio proxy — signs every tool call, adds policy hooks |
obsigna-daemon |
Out-of-process signing daemon — holds the key, owns the audit chain |
obsigna-hook |
PostToolUse hook for Claude Code and other runtimes |
obsigna |
CLI for browsing and verifying receipt databases |
sdk/go, @obsigna/sdk-ts, obsigna (Python) |
SDKs for embedding receipt creation in your own code |
Conformance
Anyone can implement the protocol — so interoperability is the property that matters. The three SDKs (Go, Python, TypeScript) are separate, no-shared-code implementations that verify one another's receipts: every conformance vector is signed once with a shared Ed25519 keypair, and each SDK re-verifies the signatures, canonical JSON, and hashes the other two produced — across a positive corpus, a MUST-reject corpus, and four pinned spec versions. This cross-language verification is enforced in CI (it catches serialisation drift between the languages, not spec-interpretation ambiguity — the SDKs share one author).
The Conformance page is the citeable summary: the interop claim, a results matrix with per-set vector counts, permanent links to every frozen vector set, and how to reproduce the checks. The shared corpus lives in cross-sdk-tests/.
Formal verification
Where conformance shows the implementations agree, formal verification shows the protocol logic itself is sound. The receipt chain's tamper-evidence property (spec §7) is machine-checked with a bounded Alloy model in formal/chain-invariants/: over all instances up to the checked scopes, any receipt sequence that passes §7.3 verification is a genuine chain the issuer signed, in issuer order — so no modification, insertion, interior deletion, reorder, or cross-chain splice by a party without the issuer's key can produce a different sequence that still verifies. The one residual, tail truncation of an open chain, is the documented floor of §7.3.1, reproduced as an explicit fact rather than hidden.
This is bounded model checking relative to the cryptographic assumptions (collision-resistant hashing, unforgeable signatures) — it does not prove the primitives, and the Byzantine key-holder case is named as the boundary, not covered. Run it yourself with formal/chain-invariants/run.sh; the decision, threat model, scope, and honest statement of guarantee are in ADR-0039.
Start here
Both paths below require the daemon — it holds the signing key and owns the audit chain. Install it first:
brew install agent-receipts/tap/obsigna
obsigna daemon start
Fastest path — PostToolUse hook (Claude Code): one config snippet and every tool call gets a signed receipt automatically:
{
"hooks": {
"PostToolUse": [{ "matcher": "", "hooks": [{ "type": "command", "command": "obsigna-hook" }] }]
}
}
Add that to ~/.claude/settings.json, then inspect the audit trail:
obsigna list
obsigna show <seq>
obsigna verify
More control — MCP proxy: wraps any MCP server and adds policy hooks and risk scoring on top of signed receipts:
Project layout
| Project | Description |
|---|---|
spec/ |
Protocol specification, JSON schemas, governance |
sdk/go/ |
Go SDK |
sdk/ts/ |
TypeScript SDK |
sdk/py/ |
Python SDK |
daemon/ |
Signing daemon — out-of-process key custody, shared audit chain |
mcp-proxy/ |
MCP proxy with receipt signing, policy engine, intent tracking |
hook/ |
PostToolUse hook binary for Claude Code and other runtimes |
cross-sdk-tests/ |
Cross-language verification tests |
formal/ |
Formal models (Alloy) machine-checking protocol properties |
docs/adr/ |
Architecture Decision Records |
| dashboard | Local web UI for browsing and verifying receipt databases |
| openclaw | Agent Receipts plugin for OpenClaw |
| obsigna-examples | Worked examples and integration demos |
SDK quick start
Choose your trust model. The snippets below keep the signing key inside the agent process — a deliberate deployment model where the agent host is trusted and tamper-evidence is aimed at downstream parties. In this model, anyone with code execution in the agent can forge receipts. To defend against a compromised agent, use the daemon-mediated path, where a separate daemon owns the key and your app only sends events over a socket. See the Trust Model page for the full spectrum (in-process → daemon-isolated → HSM/KMS).
Go
go get obsigna.dev/sdk/go
import "obsigna.dev/sdk/go/receipt"
keys, _ := receipt.GenerateKeyPair()
unsigned := receipt.Create(receipt.CreateInput{
Issuer: receipt.Issuer{ID: "did:agent:my-agent"},
Principal: receipt.Principal{ID: "did:user:alice"},
Action: receipt.Action{Type: "filesystem.file.read", RiskLevel: receipt.RiskLow},
Outcome: receipt.Outcome{Status: receipt.StatusSuccess},
Chain: receipt.Chain{Sequence: 1, ChainID: "chain_1"},
})
signed, _ := receipt.Sign(unsigned, keys.PrivateKey, "did:agent:my-agent#key-1")
TypeScript
npm install @obsigna/sdk-ts
import {
createReceipt,
generateKeyPair,
signReceipt,
} from "@obsigna/sdk-ts";
const keys = generateKeyPair();
const unsigned = createReceipt({
issuer: { id: "did:agent:my-agent" },
principal: { id: "did:user:alice" },
action: { type: "filesystem.file.read", risk_level: "low" },
outcome: { status: "success" },
chain: { sequence: 1, previous_receipt_hash: null, chain_id: "chain_1" },
});
const signed = signReceipt(unsigned, keys.privateKey, "did:agent:my-agent#key-1");
Python
pip install obsigna
from obsigna import (
create_receipt, generate_key_pair, sign_receipt,
CreateReceiptInput, Issuer, Principal, Outcome, Chain,
)
from obsigna.receipt.create import ActionInput
keys = generate_key_pair()
unsigned = create_receipt(CreateReceiptInput(
issuer=Issuer(id="did:agent:my-agent"),
principal=Principal(id="did:user:alice"),
action=ActionInput(type="filesystem.file.read", risk_level="low"),
outcome=Outcome(status="success"),
chain=Chain(sequence=1, previous_receipt_hash=None, chain_id="chain_1"),
))
signed = sign_receipt(unsigned, keys.private_key, "did:agent:my-agent#key-1")
See the Python SDK README for the full quick start and daemon delivery.
Contributing
See CONTRIBUTING.md for development setup and PR guidelines.
Security
See SECURITY.md to report vulnerabilities. The threat model documents trust boundaries, in-scope and out-of-scope threats, and the mitigation roadmap.
License
Apache License 2.0 -- see LICENSE.
The protocol specification in spec/ is licensed under MIT.
obsigna MCP questions
What is obsigna?
Obsigna is a reference toolset that implements the Agent Receipts protocol, providing signed, tamper-evident records of AI agent actions.
How can I use it with Claude Code?
You can use the obsigna-hook as a PostToolUse hook in your Claude Code settings to automatically sign every tool call.