Signs agent actions as Ed25519 records with Merkle proofs so later agents and reviewers can verify what happened.
Also known as creatornader/atrib, @atrib/mcp, @atrib/summarize, @atrib/verify
- Stars
- 8
- Tools
- 1
- Downloads, 30 days
- 5,455
- Latest version
- —
- Last commit
- Nov 11, 2026
- License
- Apache-2.0
What is atrib MCP?
atrib signs agent actions as Ed25519 records with Merkle proofs so later agents and reviewers can verify what happened. It exposes 1 tool, such as summarize.
Summary generated from the project's README
About atrib MCP server
Signing an agent action so that a later reviewer can check it actually happened is the job atrib takes on. It turns tool calls, browser clicks, desktop actions, policy decisions, handoffs, transactions and agent notes into Ed25519-signed records with Merkle inclusion proofs, and it links records across sessions, agents, teams and organisations. Product teams place it in the execution path of a harness such as Claude Code, Cursor or an in-house runtime, where an allow, block, escalate or approval decision can be signed before a high-impact step such as a deployment, admin change or payment.
The text presents two client-side packages for capture, @atrib/mcp and @atrib/mcp-wrap, an @atrib/action-gate for action control, and @atrib/verify with a recall verification parameter for checking incoming records. Verification covers signer trust, context policy, freshness, body commitments and inclusion proofs before follow-up work is signed through informed_by. A protected MCP adapter needs a one-time server-side permit plus a non-revoked credential when the host supplies a live revocation view.
What sets it apart is the split between public and private material. The public log holds commitments rather than tool arguments, results, memory text or runtime logs, while a caller-supplied signer and context policy project verified revision lineages into current heads, and forks remain visible as unresolved conflicts. The text is explicit that commitments alone do not give a continuation agent enough to proceed, so it needs canonical bodies, redacted evidence references, skill pack hashes, the latest chain tail and dispatch anchors. The protocol leaves harness design to the integrator.
What you can do with it
- 1Gate a high-impact browser clickHave a browser agent sign an allow, block or escalate decision before it clicks a destructive button in an admin console, so the outcome cites that decision.
- 2Verify a record before continuingAsk a receiving agent to check an incoming record hash, signer trust and inclusion proof before it signs its own follow-up work.
- 3Trace a repair back to its actionHave an incident agent sign a diagnostic outcome linked to the original action, then walk that link back with recall to see what the fix supersedes.
- 4Review a support investigation pathHave a support agent sign ticket intake, scoped log reads, hypotheses and human handoffs so a reviewer can verify the path without trusting the runtime.
- 5Recompute a settlement for auditFeed a set of signed records into an agreed policy so any merchant or auditor can recompute the payments profile result independently.
Written from the project's README. Every use case is checked against a quote from it.
How to install atrib MCP
Formats verified 10 Nov 2026Add to CursorAdd to GooseInstall atrib MCP in Claude Code
$ claude mcp add atrib -- npx -y @atrib/mcpInstall atrib MCP in Cursor
~/.cursor/mcp.json
{
"mcpServers": {
"atrib": {
"command": "npx",
"args": [
"-y",
"@atrib/mcp"
]
}
}
}Install atrib MCP in VS Code
.vscode/mcp.json
{
"servers": {
"atrib": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"@atrib/mcp"
]
}
}
}Install atrib MCP in VS Code CLI
$ code --add-mcp '{"name":"atrib","type":"stdio","command":"npx","args":["-y","@atrib/mcp"]}'Install atrib MCP in Claude Desktop
claude_desktop_config.json
{
"mcpServers": {
"atrib": {
"command": "npx",
"args": [
"-y",
"@atrib/mcp"
]
}
}
}Install atrib MCP in Codex
$ codex mcp add atrib -- npx -y @atrib/mcpInstall atrib MCP in Codex config.toml
~/.codex/config.toml
[mcp_servers.atrib] command = "npx" args = ["-y", "@atrib/mcp"]
Install atrib MCP in Gemini CLI
$ gemini mcp add -s user atrib npx -- -y @atrib/mcpInstall atrib MCP in Gemini settings.json
~/.gemini/settings.json
{
"mcpServers": {
"atrib": {
"command": "npx",
"args": [
"-y",
"@atrib/mcp"
]
}
}
}Started by HostedMCP on 16 Nov 2026
We ran this command for @atrib/summarize 0.6.1 in an isolated container with no network and no keys. It answered and listed 1 tool.
atrib MCP tools 1
Read from the server with tools/listsummarizeRead a set of records (by context_id and/or record_hashes) and ask an LLM to synthesize a coherent narrative across them. Reads the local signed-record mirror (~/.atrib/records/*.jsonl) including the optional _local sidecar for semantic content. Records without a sidecar are flagged so the LLM can be honest about impoverished input.
Configuration
ATRIB_PRIVATE_KEY
Automated checks
Ran Nov 16, 2026Full report →Passed our automated checks. That is not a security audit: read the code and give the server the narrowest access it needs. How checks work
- Source repository linked and reachablecreatornader/atrib is public and reachablegithub.com/creatornader/atrib ↗Pass
- Package names this repository as its source@atrib/mcp, @atrib/summarize name creatornader/atrib as sourcenpmjs.com/package/@atrib/mcp ↗Pass
- Build provenance (Sigstore attestation)Sigstore attestation for @atrib/mcp, @atrib/summarizenpmjs.com/package/@atrib/mcp/v/0.27.0#provenance ↗Pass
- 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-11github.com/creatornader/atrib ↗Pass
- OpenSSF ScorecardNot checked
- Package name not close to a popular packageNo popular package one edit away from @atrib/mcp, @atrib/summarize, @atrib/verifyPass
- No critical advisory in the package or its dependenciesNot checked
- No hidden instructions to the model1 tool description and the README read; no override phrases, credential paths or hidden charactersPass
- Destructive tools are labelledNo tool named like delete, drop or execPass
- Remote endpoint answers the MCP handshakeNot checked
README
View on GitHubatrib
Verifiable agent actions. Every action becomes signed context for the next.
atrib signs agent actions as records that later agents, teams, and verifiers can check. A record can describe a tool call, browser click, desktop action, policy decision, handoff, transaction, or intentional note from the agent.
Agent work already crosses tools, memory, identity, authorization, observability, evals, handoffs, and payment rails. atrib does not replace those systems. It gives them a common record that carries the action, selected evidence, and graph links across sessions, agents, teams, organizations, and protocols.
Product teams can put atrib in the execution path. A harness can sign an allow, block, or escalate decision before a high-impact browser click, desktop action, support reply, admin change, deployment, or payment-impacting step. The outcome then becomes signed context for later recall, review, handoff, or verification.
Browser and computer-use agents make the product concrete. Follow-up work can cite the decision and outcome without exposing raw browser state, desktop state, private tool payloads, or full runtime logs in public records.
Shared memory and context systems still decide what an agent should remember. Observability tools still inspect live runs. Authorization systems still issue policy and credentials. atrib signs the action trail so those systems can carry forward the same verifiable facts without trusting the runtime that stored them.
What this enables
Everything below depends on one substrate property: an action is signed when it happens and remains verifiable later.
| Surface | What atrib gives you | What it composes with |
|---|---|---|
| Action control | A host can sign an allow, block, escalate, or approval decision before a selected action runs. The outcome cites the decision, and the protected MCP adapter requires a one-time server-side permit plus a non-revoked credential before the upstream side effect when the host supplies a live revocation view. | @atrib/action-gate, policy engines, approvals |
| Cross-session continuity | Signed action hashes can travel with follow-up work. Later sessions and agents can cite accepted records instead of relying on a transcript, replay link, or runtime-local memory. | Memory systems, shared context layers, recall tools, agent runtimes |
| Shared current state | The recall state view projects verified revision lineages into current heads under a caller-supplied signer and context policy. Forks stay visible as unresolved conflicts instead of collapsing to an arbitrary winner. The open explorer shows the corresponding public revision commitments while keeping its weaker browser verification basis explicit. |
Multi-agent workspaces, incident rooms, support teams, fleet control surfaces |
| Browser and desktop review | Clicks, form fills, desktop actions, support replies, admin changes, and payment-impacting steps become decision/outcome pairs that can be recalled or verified later. | Browserbase, browser-use, OpenAI Computer Use, support teams, admin teams |
| Verified handoffs | A receiving agent can verify incoming record hashes, body commitments, signer trust, context policy, freshness, and inclusion proofs before signing follow-up work through informed_by. |
@atrib/verify, the recall verification parameter (@atrib/recall), continuation packets |
| Investigations and audit | Support, incident, billing, and RCA agents can sign ticket intake, scoped log reads, code-path checks, hypotheses, diagnostics, revisions, and human handoffs. A reviewer can verify the path without trusting the original runtime. | Observability tools, logs, traces, support systems, SOC 2 evidence |
| Evals and repair loops | A harness can link task setup, tool calls, verifier checks, diagnostic outcomes, and scorer output through informed_by, then publish evidence another team can replay. |
Eval harnesses, benchmark reports, inspection tools |
| Commerce settlement | The same signed record set can feed a deterministic settlement document under an agreed policy. Any merchant or auditor can recompute the payments profile §8 result. | AP2, Verifiable Intent, x402, ACP, merchant policies |
| Private evidence by default | The public log stores commitments, not private work product. Verifiers can check signatures, hashes, inclusion proofs, and selected evidence without dumping tool arguments, tool results, memory text, authorization material, or workflow context into the public payload. | Local mirrors, sidecars, opt-in archive evidence, private evidence stores |
Substrate vs harness
atrib is the substrate underneath the action layer. Consuming it well (surfacing an agent's history at session start, exposing recall tools the agent can call, persisting signed records locally for replay, and putting policy gates around high-impact actions) is the job of an agent harness or runtime. atrib does not prescribe a harness. The substrate is independently useful to any harness (Claude Code, Cursor, custom agent products, in-house agent runtimes) that wants to give agents and teams contextual awareness, coordination, control, and proof over work the agent performs.
Hard boundary: the public Merkle log proves a commitment, but it is not enough context for a future agent to continue the work. A continuation agent needs Tier 2 and Tier 3 material: canonical record bodies or archive references, redacted evidence references, skill pack identities and hashes, the latest chain tail, parent dispatch anchors for subagent work, and provenance anchors. Without those, it can prove a record existed but still has to guess what happened.
One canonical harness pattern is signed diagnostic outcome + trace replay: sign the action, sign the diagnostic outcome that evaluates it with informed_by back to the action, then let the next repair step walk informed_by back from the diagnostic record with recall. This keeps "what happened" and "what it supersedes" in one verifiable path without requiring a whole-session transcript dump.
Derived evidence products sit above the protocol. A harness can build a prior-work packet, suspect report, or eval summary from signed records, body commitments, verifier checks, and inclusion proofs. Those products can decide which records are useful for a task, which stale records to avoid, and which risks remain open. They do not change the record format, the graph derivation rules, or the attest/recall verb surface.
Logs and traces
Logs and traces are primary integration inputs for atrib, but the word "trace" can point at several different objects. The boundary matters.
| What you already have | Use | What atrib adds |
|---|---|---|
| Tool calls through MCP or an SDK callback | @atrib/mcp, @atrib/mcp-wrap, or @atrib/agent |
Signed action records with chain continuity and optional local sidecars. |
| Pre-action policy gates, approval hooks, or host lifecycle hooks | @atrib/action-gate, @atrib/mcp-wrap preCallTransform, host-specific adapters, and signer proxies |
Verifiable control points around high-impact actions. The host records the decision, execution result, outcome hash, and selected evidence. |
| OpenTelemetry or OpenInference spans | @atrib/openinference |
Signed records and recall-readable sidecars from the span stream, while Langfuse, Phoenix, LangSmith, Braintrust, or another backend keeps the operations view. |
| A host-owned run log, event stream, session history, checkpoint log, fork log, or compaction log | @atrib/runtime-log, including buzz and live observation adapters |
A bounded manifest or cursor-bound observation batch without publishing raw log bodies by default. Observation stays separate from execution and accepted state. |
| A runtime API that exports session events after the fact | A future per-runtime adapter under Pattern 5 | Consumer-side attestation over what the vendor reported, not a claim that the vendor's private runtime state is itself true. |
| Application or service code with no MCP wrapper in the path | @atrib/sdk (TypeScript) or the atrib Python SDK |
One-import cognitive writes and reads. TypeScript also provides action() for a paired signed request and outcome around an application-owned execution boundary. |
| A handoff, support investigation, or continuation packet | @atrib/verify, the recall verification parameter (@atrib/recall), and continuation packets |
Verifier-accepted record hashes that the receiving agent can cite through informed_by. |
The short rule: observability tools inspect and debug live traces; runtime systems own logs that reconstruct or resume a run; atrib signs actions and verifies claims over selected windows. Those layers compose, but they should not collapse into one product.
Frameworks and host runtimes
The "any agent framework" claim is about tool-call middleware, not every host
runtime feature. It covers SDK and MCP surfaces where application code owns the
agent loop: raw MCP SDK, Claude Agent SDK, Cloudflare Agents, Vercel AI SDK,
LangChain JS, and similar SDKs. Those integrations live in
@atrib/agent,
@atrib/mcp, and
@atrib/mcp-wrap.
Host runtime adapters cover a different shell: Claude Code, Codex, OpenClaw,
Hermes, Cursor, Goose, hosted runtimes, or another harness that owns sessions,
lifecycle hooks, approvals, subagents, checkpoints, telemetry, and run logs.
Those adapters use @atrib/mcp-wrap for MCP
tool calls, host-specific signing code for native tool hooks,
@atrib/openinference for
OpenInference-shaped span intake,
@atrib/runtime-log for bounded run windows,
@atrib/action-gate for pre-action policy
gates, @atrib/verify for accepted handoff claims,
and atrib-attest-cli (or the forwarded atrib-emit-cli) or the local substrate for hook-class observations.
The implementation rule: one host event has one signing owner. If an MCP wrapper
already signs a tool call, the host adapter should correlate ids and skip a
second tool_call record. The private integration package pins this rule in
packages/integration/src/host-runtime-proof.ts
so future OpenClaw, Hermes, and other host proofs share the same vocabulary.
Stateless MCP attribution
Add verifiable records to a tool call without adopting a new agent runtime or
maintaining an atrib transport session. A native server can advertise
dev.atrib/attribution; an existing server can sit behind @atrib/mcp-wrap;
and the TypeScript and Python SDKs carry the complete request envelope
automatically. The tool result can include a signed receipt that a verifier
checks without trusting any single log operator.
The stateless MCP attribution guide shows the request, result, receipt, integration choices, runnable proofs, retry rules, and the boundary between proof of a signed claim and proof that the claim is true.
How it works
- Each record is signed by the actor's Ed25519 key and JCS-canonicalized
- A Merkle log stores commitments (hashes, not content) with RFC 6962 inclusion proofs and C2SP-canonical signed-note checkpoints
- Nine deterministic edge types connect actions into one graph with two reading
planes: chronology edges (
CHAIN_PRECEDES,SESSION_PRECEDES,SESSION_PARALLEL,CROSS_SESSION,CONVERGES_ON) and declared-relationship edges (INFORMED_BY,PROVENANCE_OF,ANNOTATES,REVISES) - The explorer's primary trace path composes
/v1/traceand/v1/chainfor readability without adding a new graph edge, validity rule, or settlement input (D118) - A pure-function calculation maps graph + policy to value distribution when commerce closes
- A public-key directory (§6) resolves opaque keys to identity claims; rotation and revocation are normative (§1.9); identity claims may declare capability envelopes (§6.7) that verifiers check records against
- Transaction records require cross-attestation: at least 2 distinct verified signer keys (agent + counterparty) per §1.7.6
- Cross-log replication (§2.11) lets consumers submit records to multiple independent logs and detect equivocation
- Privacy is configurable per record (§8 privacy postures): tool_name forms (verbatim, opaque, hashed), commitment schemes (plain, salted-sha256, hmac-sha256), timestamp granularity (ms through day)
- Adversarial threat model (§8.7) enumerates the 10-layer trust assessment stack the substrate provides
No custom cryptography. No content exposure unless the harness opts in. No trust required.
Try the demo
One command, no setup beyond cloning. Generates a fresh key, spins up an in-process Merkle log, fake merchant, and fake agent, runs two tool calls plus one transaction, and prints what landed in the log.
ATRIB_PRIVATE_KEY=$(node -e 'console.log(Buffer.from(crypto.randomBytes(32)).toString("base64url"))') \
pnpm --filter @atrib/integration demo
Expected output:
[demo] starting dev log...
[demo] dev log running at http://127.0.0.1:58958
[demo] starting merchant tool server (fake search API)...
[demo] starting agent client...
[demo] agent connected to merchant
[demo] step 1: agent calls 'search' for the first time (genesis)
[log] +tool_call ctx=7f71199d… chain=sha256:064692c27… idx=0
[demo] step 2: agent calls 'search' again (chained from step 1)
[log] +tool_call ctx=7f71199d… chain=sha256:381c22ac6… idx=1
[demo] step 3: agent observes a fake x402 payment receipt
[log] +transaction ctx=7f71199d… chain=sha256:96ac3e962… idx=2
[demo] final state
[demo] 3 records in the log
[demo] 2 tool_call records
[demo] 1 transaction record
[demo] chain length: 3
[demo] done.
The signatures, chain hashes, and transaction detection are production code. Only the surrounding environment (merchant, agent, network) is stubbed.
Quick start
Node.js consumers need Node 22 or newer. See the canonicalization compatibility notes when upgrading from canonicalize 4.
Now that you've seen the demo, pick the install path that matches what you're doing:
- Sign tool calls your MCP server handles:
@atrib/mcp(below) - Sign tool calls your agent makes:
@atrib/agent(below) - Gate high-impact actions before they run:
@atrib/action-gate - Attach signed records to an existing OpenInference span stream:
@atrib/openinference - Prove a bounded run window from a host-owned runtime log:
@atrib/runtime-log - Verify records someone else produced:
@atrib/verify(below)
Sign tool calls (your MCP server)
import { atrib } from '@atrib/mcp'
import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
const server = atrib(new McpServer({ name: 'my-tool', version: '1.0.0' }), {
creatorKey: process.env.ATRIB_PRIVATE_KEY,
serverUrl: 'https://my-tool.example.com',
})
One line. Every successful tool call emits a signed attribution record, propagates W3C trace context, and submits to the log asynchronously.
Sign tool calls (your agent)
@atrib/agent exports one interceptor plus a helper
per framework; side-by-side quick-starts live in its README. Every runnable
example and proof, one per framework or runtime surface, is cataloged in
Examples and proofs below.
Verify records (any third party)
import { AtribVerifier } from '@atrib/verify'
const verifier = new AtribVerifier({
merchantKey: process.env.ATRIB_MERCHANT_KEY,
})
const result = await verifier.verify(recommendationDoc)
// { valid: true, signatureOk: true, calcMatch: true, distribution: {...} }
Verification re-runs the payments profile §8 calculation locally and compares the result. No trust in any intermediary.
atrib MCP questions
How do I add atrib MCP to Claude Code?
Run claude mcp add atrib -- npx -y @atrib/mcp in your terminal. Add --scope user to make it available in every project.
How do I add atrib MCP to Cursor?
Open ~/.cursor/mcp.json and add the server under mcpServers, using the Cursor config shown in the install section above.
What tools does atrib MCP provide?
It exposes 1 tool, including summarize.
How does atrib make agent actions verifiable?
Each action is signed as a record when it happens, and a public Merkle log proves a commitment to it, so anyone can check signatures and inclusion proofs later.
Does atrib expose my private tool data in the public log?
No. The public log stores commitments and selected evidence rather than raw tool arguments, results, or memory text.
Can a receiving agent verify work handed off from another agent?
Yes. It can check record hashes, body commitments, signer trust, context policy, freshness, and inclusion proofs before signing follow-up work.
Does atrib work with MCP tool calls?
Yes, MCP tool calls are a primary integration point alongside SDK callbacks and harness adapters.
Can atrib gate high-impact actions before they run?
A host can sign an allow, block, escalate, or approval decision before a selected action executes, and the outcome cites that decision.