Digital notarization
for the age of AI agents.
NotaryOS creates tamper-evident, cryptographically signed receipts for every AI agent action. When agents make decisions, send messages, or execute tasks, NotaryOS provides the proof that it actually happened—and that nobody altered the record afterward.
AI agents are making decisions.
But who's keeping the receipts?
As AI agents become more autonomous—managing finances, orchestrating workflows, making recommendations—a critical gap emerges: there's no standardized way to prove what happened.
Logs can be edited. Timestamps can be faked. Without cryptographic proof, "this agent did X" is just an assertion, not a fact.
NotaryOS closes that gap. Every action gets a signed, chained, verifiable receipt. Anyone can check it. Nobody can alter it.
No visibility
Agent actions disappear into logs that nobody audits
No accountability
When something goes wrong, there's no tamper-proof record
No trust between agents
Multi-agent systems can't verify each other's claims
NotaryOS solves all three
Cryptographic receipts that prove action, identity, sequence, and time
Four things no one else does.
NotaryOS isn't just logging with extra steps. It's a fundamentally different approach to agent accountability.
Per-Agent Hash Chains
Every agent maintains its own cryptographic chain. Each receipt links to the previous one. If anyone inserts, deletes, or reorders a receipt, the chain breaks — and you'll know.
Tamper detection built inCounterfactual Receipts
Prove an agent could have acted but chose not to. Three cryptographic proofs — capability, opportunity, and decision — create an irrefutable record of restraint. Essential for regulated industries.
Proof of non-actionProvenance DAG
Track trust across multi-agent workflows with a directed acyclic graph. If an upstream receipt is invalidated, everything downstream automatically becomes ungrounded — trust doesn't silently persist.
Cascading trust verificationThird-Party Verifiable
Receipts are self-contained JSON with embedded signatures. Anyone can verify them offline — no need to trust our servers, call our API, or even be online. The math speaks for itself.
Zero-trust by defaultNot another logging tool.
Here's how NotaryOS compares to what you're probably using today.
| Feature | NotaryOS | Traditional Logging |
|---|---|---|
| Cryptographic signatures | — | |
| Per-agent hash chains | — | |
| Tamper detection | Automatic | Manual audit |
| Third-party verification | Offline capable | Requires access |
| Proof of non-action | — | |
| Provenance tracking | DAG-based | Linear or none |
| Integration effort | 3 lines | Varies |
| Self-hostable | ||
| Agent-native design | — |
Seal. Verify. Trust.
Three concepts. One line of code. Complete accountability.
Seal — Create a cryptographic receipt
When an agent takes an action, seal() creates a receipt with a signed hash, timestamp, agent identity, and chain linkage. One function call. The receipt is immutable from the moment it's created.
Verify — Confirm it's authentic
Anyone with the receipt can verify the signature, check the chain position, and confirm the timestamp. No API key needed. No server required. The receipt carries its own proof.
Track — Follow the chain of custody
When multiple agents collaborate, provenance references link their receipts into a directed graph. If any upstream receipt is invalidated, downstream receipts are automatically flagged — trust cascades in both directions.
Decline — Prove you chose not to act
Counterfactual receipts cryptographically prove that an agent had the capability and opportunity to act, but deliberately chose not to. Three separate proofs. One irrefutable record.
from notaryos import NotaryClient
notary = NotaryClient(api_key="notary_test_...")
# Issue a receipt — one line
receipt = notary.issue(
action_type="task.completed",
payload={"message": "Task completed", "result": data}
)
# Verify anywhere — no API key needed
result = notary.verify(receipt.receipt_hash)
print(result.valid) # True
print(receipt.badge) # "seal:a1b2...c3d4"Built for teams that take agent trust seriously.
Agent Developers
- Add accountability to your agent in 3 lines
- Python, TypeScript, and Go SDKs
- Works with any agent framework
Platform Teams
- Audit trail for every agent interaction
- Provenance tracking across microservices
- Self-hostable for air-gapped environments
Compliance & Legal
- Counterfactual proofs for regulated industries
- Exportable verification history
- Cryptographic evidence for disputes
The cost of not having receipts
is always higher.
One disputed agent action. One compliance audit. One customer asking "did your AI actually do what it said?" That's when you wish you had cryptographic proof.
What you get
- Immutable proof for every agent action
- Instant tamper detection across chains
- Compliance-ready audit trails
- Customer-facing verification (shareable receipt links)
- Counterfactual proofs (regulated industries)
- Multi-agent provenance tracking
What it costs
Starter: 100 receipts/month. Perfect for development, testing, and small projects.
Explorer: 10,000 receipts/month. For production agents that need real accountability.
That's less than $0.006 per receipt on Explorer. A single disputed agent action costs more than a year of NotaryOS.
Built by AI agents. For AI agents.
NotaryOS was designed and implemented through a real-time collaboration between five AI agents, each contributing their specialized expertise.
This is the first cryptographic receipt system designed, debated, and built entirely through multi-agent collaboration. NotaryOS practices what it preaches.
Your agents deserve receipts.
Start with the free tier. Verify your first receipt in under a minute. Scale to production when you're ready.