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.
MCP server middleware for atrib's verifiable action layer. Signs and chains successful tool calls with one-line integration.
2026-11-11
Sao
—
Công cụ
—
Thời gian hoạt động
—
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.
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.
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.
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.
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.
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.
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
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
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
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/trace and /v1/chain for
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.
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.
What atrib certifies, what it does not
atrib certifies five verifiable axes of agent activity: who acted (identity),
what they did (event_type), when (timestamp), what came before what in the
chronology plane, and what the signer claimed informed, anchored, annotated, or
revised the action in the declared-relationship plane.
atrib does NOT certify that the agent's reasoning is truthful, that prior records actually influenced subsequent decisions, or that tool responses were real absent tool-side attestation. A signature proves who committed to a claim, never that the claim is true. The first two limits are intrinsic to signed claims. The third narrows when another party signs its own evidence: the tool signs its response, a counterparty co-signs a transaction, an evaluator signs a diagnostic, or a witness attests the outcome. Those signatures corroborate the action, not the agent's reasoning. The substrate is content-preserving (commitments, not content) and disclosure-configurable: harnesses pick how much each record reveals via the privacy postures in spec §8.
This positioning keeps the claim honest. See spec §3 "What atrib chains, what it does not" for the detailed enumeration and spec §7.6 for the outcome-verification patterns that close the tool-response gap.
Framework support
This table covers framework tool-call middleware, not full host runtime
integration. Host runtime work has its own boundary in
Architecture and in
the OpenClaw/Hermes map.
packages/integration/examples/mcp-interceptor-audit/ runs the Interceptors WG draft methods through a real MCP client and server. It emits a signed hash-only receipt for exactly paired request and response phases and emits no receipt when the operation identity is missing.
packages/integration/examples/a2a-handoff/ signs an A2A v1 AgentCard, carries an atrib evidence packet in a data-valued A2A Part, verifies the packet, and signs the receiver follow-up through informed_by.
packages/integration/examples/google-stack-chain/ links AP2 / VI receipt verification, A2A signed handoff evidence, a Google ADK Python allow decision, and the ADK Python tool outcome through verifier-resolved informed_by records, with a deterministic snapshot, BigQuery Agent Analytics-shaped local fixture, Cloud Run-backed runtime path, and a visual workbench.
atrib detects transaction events from six payment-related completion cases. It
does not implement payment methods, move money, or enforce transactions. The
per-surface hooks are defined by the atrib Payments Profile,
which versions independently of the core spec (D147);
core keeps the transaction event type, the cross-attestation rule, and the
evidence envelope. The public packages provide runtime observation and
verification of supplied evidence, not a payment client or protocol-wide
market measurement system.
x401 is intentionally not in this table. It is a 401 proof-requirement
protocol for credential-gated HTTP routes, so
@atrib/verify treats x401 artifacts as
authorization evidence rather than transaction signals. The current Proof
issue and PR map lives in docs/proof-x401-open-threads.md.
Packages
Current packages come first. The deprecated legacy packages follow: all are re-export shims whose tool names stay mounted as permanent aliases per D164. Private workspace packages that never publish close the list.
Consolidated client SDK: attest()/recall() cognitive verbs plus action() for paired request/outcome evidence around an application-owned execution boundary. Daemon-first with in-process fallback, and the full §1 record layer re-exported. Byte-identical Python sibling at python/.
The write verb: one attest tool signs observations, annotations (ref.kind: "annotates"), and revisions (ref.kind: "revises"), with the legacy emit / atrib-annotate / atrib-revise tool names mounted as permanent aliases over the same handler.
The read verb: one recall tool dispatches every read shape (history, walks with direction, content search, session chain, annotations, revisions, policy-bound current state, orphans, by-signer) plus a verification parameter, with the legacy recall_* / trace / trace_forward / atrib-verify names mounted as permanent aliases.
Stateless-native local daemon (binary atribd): serves the seventeen-tool alias-window union (fifteen legacy names plus the attest and recall verbs) over stateless Streamable HTTP, direct stdio, or a stdio-to-HTTP proxy shim, with per-context write serialization. The recommended local topology per D148.
Host-owned action gate. Signs policy decisions and outcomes before selected high-impact actions run, with a protected MCP executor that rejects missing, mismatched, expired, and replayed permits before the upstream side effect.
OpenTelemetry SpanProcessor consuming OpenInference-shaped spans and emitting signed atrib records plus recall-readable local sidecar content. Reference impl of spec §9 Pattern #4; one adapter transitively covers every framework with OpenInference instrumentation.
Cognitive-primitive MCP server: reads N records and synthesizes a narrative via an OpenAI-compatible LLM. No successor shape in the read verb; stays mounted through the alias window.
Deprecated legacy packages
All five are deprecated on npm and remain installable. Their tool names stay mounted as permanent aliases, so existing configurations keep working and signed records are byte-identical either way.
Local MCP runtime: exposes the seventeen-tool alias-window union through one stdio or Streamable HTTP MCP server for dogfood harnesses that would otherwise spawn one process per primitive. Superseded as the recommended topology by @atrib/daemon.
Open-source reference client for named, bounded workspace views, body-aware search, live decisions and outcomes, handoffs, explicit conflicts, and signed application resolutions.
The twenty designed-public packages split fifteen current and five deprecated;
the public-package tables above are the canonical list. Private application and
test packages do not change that count. The python/
directory ships the atrib Python SDK (published on PyPI), the first
non-TypeScript implementation of the
§1 record layer, held
byte-identical to the TypeScript implementation by the shared conformance
corpora and a cross-implementation determinism harness.
Open-source operating graph
apps/operating-graph/ is a complete inspectable
application over the protocol. It verifies local mirror records and presents
named, bounded workspace, task, team, and agent views with body-aware search,
live decisions and outcomes, incoming handoffs that expose prior task state,
and explicit state conflicts. The reader verifies each private application body
against the signed record's args_hash before projection.
The application never chooses a conflict winner from time or signer preference.
A resolution is accepted only when its signed record cites every active head
through informed_by and its private body names the selected head. Local,
container, fresh-machine, and application-conformance instructions ship with
the client.
Its revision stream carries exact event IDs and reports missed local projection
revisions as gaps that require a bounded-view reload. Full signed-body and
opening disclosure is disabled by default. Operators can enable a separate
bearer-protected route that re-verifies local or archived record bodies and
tests available content, tool-name, argument, and result openings against the
signed commitments.
The application also exposes signed runtime observations in a separate,
bounded feed. The source-neutral D183 path verifies a portable batch and
commits its complete artifact, signed observation, and authoritative cursor in
one caller-owned journal update. The observation does not create accepted state
or other semantic events. A later application event must cite the
atrib-signature-verified observation and match its named scope before it enters
an operating view.
The runnable open composition uses the Codex rollout profile, a separate host
mapping, a bounded view receipt, paired SDK action records, signed
D168
membership, and an independent selected-effect verdict. It is a deterministic
local fixture, not evidence of a live external session or deployed product.
Buzz runtime-window observations use the same non-semantic application lane.
Their later reader verifies the atrib signature and body commitment; it cannot
replay absent Buzz frames or manifests.
This is an application profile, not a new protocol surface. It demonstrates
usable shared state while keeping names, values, and resolution policy outside
the public record format.
The record layer, transparency log, graph, key directory, payments profile, and
verifier evidence checks are implemented, deployed, and pinned by conformance
corpora. services/witness-node/ is an
external-operator-ready witness reference that verifies pinned log checkpoints,
detects historical rewrites, and publishes C2SP cosignatures. The deployment
kit includes an image publication workflow, Compose and Fly templates, offline
backup verification, scheduled monitoring, signed retirement, and an
endpoint-aware verifier that binds fetched cosignatures to caller-pinned
witness keys and endpoints. Its software path has been exercised locally
against log.atrib.dev; no independently operated witness is deployed yet. The
independent operator guide supplies the
deployment and acceptance contract. Multi-log replication also remains
undeployed. The full enumeration, with spec and decision references, is in
STATUS.md.
§9: Runtime integration patterns (informative; seven peer patterns per D069 and D102)
Design principles
Provenance travels with the artifact. Embedded at creation, not inferred later.
Accountability without content exposure. The log stores hashes, not content.
Settlement is separate from attribution. The protocol records what happened. It does not move money.
No central arbiter of value. Trust from math and open spec, not from trusting atrib.
The protocol is open. Deployments are independent. The spec, signing libraries, calculation algorithm, service software, explorer, and reference clients are open. Anyone can run the public services or build an independent deployment. No hosted analytics or SaaS application is part of the protocol requirement.
Product design
DESIGN.md is the source of truth for atrib's public product surfaces: website, explorer, docs, package README patterns, share images, and user-facing reliability states. It records the current state, target direction, tokens, components, writing rules, and remaining design backlog.
atrib-log-pp-cli: a Printing-Press-generated Go CLI for the public log API (signed checkpoint, recent entries, lookups by hash / context / creator, Merkle tiles, local SQLite mirror). Complementary to the attest/recall MCP verbs: agents use the verbs, humans and scripts use the CLI.
Chưa có danh sách công cụ. Máy chủ từ xa sẽ có danh sách sau lần kiểm tra tình trạng đầu tiên.
Câu hỏi thường gặp
Câu hỏi
Làm thế nào để cài đặt @atrib/mcp?
Sao chép cấu hình stdio cho Cursor, Claude Desktop, Claude Code hoặc VS Code trên trang này. Cấu hình dùng bản cài đặt của nhà phát hành, không phải proxy của PlugMCP.
@atrib/mcp có cần khóa API không?
Bản ghi này không liệt kê biến môi trường bắt buộc nào.
@atrib/mcp dùng giao thức truyền tải nào?
@atrib/mcp chạy cục bộ qua stdio.
@atrib/mcp được kiểm tra lần cuối khi nào?
Kiểm tra lần cuối: 2026-11-11. MCP server middleware for atrib's verifiable action layer. Signs and chains successful tool calls with one-line integration.