Every specification, standard, and protocol that atrib builds on, extends, or hooks into. Organized by layer. Five relationship tags:
- core: atrib directly builds on this
- extends: atrib adds a layer on top of this
- hooks: atrib attaches to this at transaction time
- direct prior art: close action-provenance or proof-log alternative
- context: Relevant prior art or adjacent space
Draft 0.1, April 2026
How attribution context travels across service and agent boundaries.
| Name | Maintainer | Status | Relationship | Description | URL |
|---|---|---|---|---|---|
| W3C Trace Context Level 2 | W3C | Recommendation | core | Defines traceparent and tracestate headers. tracestate: atrib=<token> is atrib's primary HTTP propagation channel; the trace-id from traceparent is atrib's context_id. |
https://www.w3.org/TR/trace-context-2/ |
| W3C Baggage | W3C | Candidate Recommendation | core | Defines the baggage header for propagating arbitrary key-value pairs across service boundaries. atrib uses baggage as a fallback carrier for session_token when tracestate is stripped by intermediaries. |
https://www.w3.org/TR/baggage/ |
| OTel MCP Semantic Conventions | OpenTelemetry | Development | core | Defines how trace context propagates inside MCP params._meta. atrib's MCP propagation follows this exactly: params._meta.traceparent, params._meta.tracestate, params._meta.baggage. |
https://opentelemetry.io/docs/specs/semconv/gen-ai/mcp/ |
| OTel GenAI Semantic Conventions | OpenTelemetry | Development | extends | Defines span structure for GenAI operations including invoke_agent, tools/call, gen_ai.tool.name, gen_ai.tool.call.id. atrib attribution records extend these spans with atrib.* custom attributes. |
https://opentelemetry.io/docs/specs/semconv/gen-ai/ |
| OTel Agent Span Conventions | OpenTelemetry | Development | extends | Defines invoke_agent and create_agent span kinds. Establishes the span hierarchy that atrib's structural edge detection relies on for graph construction. |
https://opentelemetry.io/docs/specs/semconv/gen-ai/gen-ai-agent-spans/ |
MCP _meta Propagation Proposal |
MCP / GitHub | Draft PR #414 | core | Formalizes params._meta as the canonical carrier for OTel context in MCP messages. atrib's propagation depends on this being adopted. Currently in community review. |
modelcontextprotocol/modelcontextprotocol#414 |
The layer where attribution events originate.
| Name | Maintainer | Status | Relationship | Description | URL |
|---|---|---|---|---|---|
| Model Context Protocol Specification | Anthropic / Linux Foundation | Stable | core | The primary protocol atrib instruments. Every tools/call is an attribution event. Defines JSON-RPC message format, params._meta, session lifecycle, and mcp.session.id. Spec version 2025-11-25. |
https://modelcontextprotocol.io/specification/2025-11-25/ |
| MCP Authorization | MCP / Linux Foundation | Draft | extends | OAuth-based authorization profile for HTTP MCP transports. Defines MCP servers as OAuth resource servers, protected-resource metadata discovery, authorization-server discovery, scope challenges, resource binding, and token validation requirements. @atrib/verify consumes caller-supplied MCP/OAuth evidence as tiered evidence[] blocks on signed tool-call records. |
https://modelcontextprotocol.io/specification/draft/basic/authorization |
| MCP TypeScript Schema | modelcontextprotocol/modelcontextprotocol | Source of truth | core | Canonical source for all MCP message structures including tools/call, result shapes, isError flag, and _meta. JSON Schema is generated from this TypeScript source. |
https://github.com/modelcontextprotocol/modelcontextprotocol |
| MCP TypeScript SDK | modelcontextprotocol | Stable v1.x | core | The SDK @atrib/mcp wraps as middleware. Ships McpServer, McpClient, Streamable HTTP + stdio transports, auth helpers. Note: GenAI semantic convention attributes are in @opentelemetry/semantic-conventions/incubating; copy relevant constants locally rather than importing from incubating at runtime. |
https://github.com/modelcontextprotocol/typescript-sdk |
| MCP Conformance Test Suite | modelcontextprotocol/conformance | Active | core | Official conformance tests for MCP implementations. @atrib/mcp should run against this suite to verify correct params._meta propagation, tools/call response handling, and session lifecycle behavior. |
https://github.com/modelcontextprotocol/conformance |
| A2A (Agent-to-Agent Protocol) | a2aproject (Google origin) | Stable v1.0 | extends | Agent coordination and delegation protocol using JSON-RPC 2.0 over HTTP(S), with AgentCards at /.well-known/agent.json, the discovery pattern atrib's /.well-known/atrib-policy.json mirrors. atrib maintains attribution chain continuity across A2A delegation boundaries. |
https://github.com/a2aproject/A2A |
| MCP OTel Tracing Proposal | MCP / GitHub | Discussion #269 | context | Proposal to add OTel trace span emission as MCP notifications. Relevant to atrib's server-side span collection strategy. Currently open discussion. | modelcontextprotocol/modelcontextprotocol#269 |
Where transaction events fire. These are atrib's settlement hooks. The per-rail detection rules live in the atrib Payments Profile §2 (D147); the core spec keeps the transaction event type and the cross-attestation rule.
| Name | Maintainer | Status | Relationship | Description | URL |
|---|---|---|---|---|---|
| ACP (Agentic Commerce Protocol) | OpenAI + Stripe | Beta | hooks | Defines checkout session lifecycle and order.created webhook. atrib hooks into order.created to close the attribution loop. Checkout session metadata carries atrib_context_id. Spec version 2026-01-30. |
https://agenticcommerce.dev |
| UCP (Universal Commerce Protocol) | Google + Shopify | Stable v1.0 | hooks | Full shopping lifecycle protocol. Exposes /.well-known/ucp profile and webhook-based order events. atrib embeds atrib_context_id in UCP checkout session extensions. Apache 2.0. |
https://ucp.dev/ |
| x402 (HTTP Payment Protocol) | Linux Foundation / x402 Foundation | Stable v2 | hooks | HTTP 402-based pay-per-request protocol. Formally launched April 2026 as a neutral open standard with Coinbase, AWS, American Express, Circle, Cloudflare, Fiserv, and Stripe as founding members. atrib's hook fires on the PAYMENT-RESPONSE header in the 200 response. |
https://x402.org |
| MPP (Machine Payments Protocol) | Tempo + Stripe | IETF I-D (Standards Track) | hooks | HTTP 402-based protocol using WWW-Authenticate: Payment / Authorization: Payment / Payment-Receipt pattern. Submitted to IETF as draft-ryan-httpauth-payment-01 (March 2026). A separate IETF draft (draft-payment-transport-mcp-00) defines the MCP transport binding; atrib's hook fires on Payment-Receipt within the MCP session. Backward-compatible with x402. |
https://mpp.dev |
| AP2 (Agentic Payment Protocol) | Google / google-agentic-commerce | v0.2 | hooks | Open protocol for agent commerce. Current AP2 uses SD-JWT Checkout and Payment Mandates for authorization, then signed Checkout and Payment Receipts for verifier outcomes. atrib's current hook fires on successful AP2 receipts, while @atrib/verify checks disclosed mandate constraints. The public AP2 SDK and samples feed atrib's opt-in interop artifact harness. The older v0.1 ap2.mandates.PaymentMandate DataPart remains a compatibility fallback. |
https://ap2-protocol.org/ |
| a2a-x402 (A2A Payment Extension) | Google / google-agentic-commerce | v0.1 Spec | hooks | Brings x402 cryptocurrency payments to A2A agent-to-agent interactions. Three-message flow: payment-required → payment-submitted → payment-completed with service delivery. The payment-completed message is atrib's transaction hook when agents pay agents via A2A. |
https://github.com/google-agentic-commerce/a2a-x402 |
| RFC 9457 (Problem Details for HTTP APIs) | IETF | Internet Standard 2023 | core | Defines application/problem+json, the standard format for structured HTTP error responses. atrib's log API, graph query API, and settlement recommendation API use RFC 9457 for all error responses. |
https://www.rfc-editor.org/rfc/rfc9457 |
Signing, verification, and key management.
| Name | Maintainer | Status | Relationship | Description | URL |
|---|---|---|---|---|---|
| RFC 8032, Edwards-Curve Digital Signature (Ed25519) | IETF | Internet Standard | core | Defines Ed25519, the signing algorithm atrib uses for all attribution records. 32-byte public keys, 64-byte signatures. No PKI required. Implementation: @noble/ed25519. |
https://www.rfc-editor.org/rfc/rfc8032 |
| RFC 8785, JSON Canonicalization Scheme (JCS) | IETF | Informational | core | Defines byte-for-byte deterministic JSON serialization used before signing. atrib uses JCS to ensure identical canonical form across all implementations. Key ordering is lexicographic. Implementation: canonicalize npm package. |
https://www.rfc-editor.org/rfc/rfc8785 |
| W3C Data Integrity EdDSA Cryptosuites v1.0 | W3C | Recommendation (May 2025) | core | Formal W3C standard for Ed25519 signing of structured data. atrib's attribution record signing follows eddsa-jcs-2022 (JCS canonicalization, no JSON-LD dependency). |
https://www.w3.org/TR/vc-di-eddsa/ |
| JOSE / JWT / JWK (RFC 7515, 7517, 7519) | IETF | Internet Standards | core | Compact JWT and JWK/JWKS formats used by AP2 signed receipt JWTs and VI SD-JWT credentials. @atrib/verify uses jose for AP2 receipt JWT verification against caller-supplied trusted JWKS roots, then pins atrib's AP2 header, JWKS, metadata, and clock-edge policy in spec/conformance/ap2-vi-crypto/. |
https://www.rfc-editor.org/rfc/rfc7515 |
| OAuth 2.0 JWT Access Token Profile (RFC 9068) | IETF OAuth WG | Proposed Standard | context | JWT claim profile for OAuth access tokens. The MCP/OAuth evidence adapter accepts compact access-token JWTs and checks issuer, subject, audience, scopes, client id, and confirmation claims against caller-supplied constraints. | https://www.rfc-editor.org/rfc/rfc9068 |
| OAuth 2.0 DPoP (RFC 9449) | IETF OAuth WG | Proposed Standard | context | Proof-of-possession access-token binding through cnf.jkt and per-request DPoP proofs. The MCP/OAuth evidence adapter checks DPoP proof signatures, htm, htu, ath, jti, iat, nonce when supplied, and cnf.jkt binding. Replay-cache state remains caller-owned. |
https://www.rfc-editor.org/rfc/rfc9449 |
| SD-JWT / SD-JWT VC | IETF OAuth WG / OpenWallet | Draft / implementation | context | Selective-disclosure JWT and SD-JWT VC formats used by AP2 / Verifiable Intent mandate chains. @atrib/verify uses OpenWallet sd-jwt-js for async VI credential conformance, then applies AP2-specific disclosure, delegation, and receipt-binding checks. |
https://github.com/openwallet-foundation/sd-jwt-js |
| Wycheproof | C2SP / Community | Active | core | JSON test vectors for validating cryptography implementations against known attacks, spec edge cases, and 80+ attack patterns including biased nonces and invalid curve attacks. Covers EdDSA, ECDSA, AES-GCM, X25519, and more. atrib's Ed25519 signing implementation must be validated against Wycheproof's EdDSA vectors before production release. Referenced by the W3C Data Integrity EdDSA spec. | https://github.com/C2SP/wycheproof |
| C2SP (Community Crypto Specification Project) | C2SP | Active | core | The specification repo that publishes cryptographic specs at c2sp.org, including the signed-note format (atrib log checkpoint format) and tlog-tiles (atrib log read API). | https://c2sp.org |
| Verifiable Intent | FIDO Alliance / AP2 ecosystem | Draft | context | SD-JWT delegation-chain model for agent authorization. AP2 v0.2 uses the same evidence shape around L1 issuer credentials, L2 user mandates, optional L3 agent mandates, sd_hash, disclosures, and cnf.jwk delegation keys. atrib verifies this evidence in @atrib/verify after AP2 receipt detection. |
https://verifiableintent.dev/spec/ |
| OTel JavaScript SDK | open-telemetry/opentelemetry-js | Stable | core | The JS/TypeScript OTel SDK that @atrib/mcp integrates with as a span processor. Key packages: @opentelemetry/sdk-node, @opentelemetry/api, @opentelemetry/semantic-conventions. GenAI + MCP attributes are in the /incubating entry point; copy constants locally, do not import from incubating at runtime. |
https://github.com/open-telemetry/opentelemetry-js |
| W3C Verifiable Credentials Data Model v2.0 | W3C | Recommendation (May 2025) | context | Defines the VC data model including proof structures. atrib attribution records are structurally compatible with VC proof format; future versions may produce valid VCs for DIF/W3C ecosystem integration. | https://www.w3.org/TR/vc-data-model-2.0/ |
The global verifiable record, where commitments are published.
| Name | Maintainer | Status | Relationship | Description | URL |
|---|---|---|---|---|---|
| RFC 9162, Certificate Transparency v2.0 | IETF | Proposed Standard | core | Defines the Merkle tree log architecture, inclusion proofs, and consistency proofs that atrib's log is modeled on. The canonical reference for append-only, tamper-evident logs. atrib's log API follows CT's proof API design. | https://www.rfc-editor.org/rfc/rfc9162 |
| C2SP Signed Note Spec | C2SP / Community | Stable | core | Defines the checkpoint and signed note format used by CT-compatible logs including Rekor v2. atrib's log checkpoints follow this format for interoperability with CT ecosystem monitoring tools. | https://c2sp.org/signed-note |
| C2SP tlog-tiles Spec | C2SP / Community | Stable | core | Defines the tile-based read API for transparency logs. atrib's log read API (/v1/tile/...) follows the tlog-tiles spec for high read scalability and compatibility with CT ecosystem tooling. |
https://c2sp.org/tlog-tiles |
| Tessera (Tile-based Transparency Log Library) | transparency-dev | Production | core | Current recommended Go library for building tile-based transparency logs. Logical successor to Trillian v1. Bakes in a decade of CT production lessons. Supports GCP, AWS, POSIX backends. services/log/ (the future production Go service) should be built on Tessera. |
https://github.com/transparency-dev/tessera |
| Sigstore Rekor v2 | Sigstore / OpenSSF | GA | context | Production transparency log using Trillian-Tessera backend. Accepts arbitrary signed payloads. hashedrekord and dsse entry types. Relevant as a secondary log target or tile-based API reference. |
https://github.com/sigstore/rekor |
| transparency-dev/distributor | transparency-dev | Active | context | Libraries and binaries for running checkpoint distributors for verifiable logs. Relevant to atrib's v2 federation roadmap: when multiple independent log operators need to cross-verify checkpoints without central coordination. | https://github.com/transparency-dev/distributor |
| AKD (Auditable Key Directory) | facebook (Meta) | Production | core | Rust library implementing the Auditable Key Directory primitive. Supports both unblinded labels (atrib's directory mode per §6 / D034) and VRF-blinded labels (an alternative configuration for downstream consumers requiring privacy-preserving lookup). Provides per-label append-only version chains, authenticated lookup, and non-membership proofs that a plain Merkle log does not. Used by Meta in production for WhatsApp key transparency. atrib's directory is built on AKD via a WASM or NAPI bridge. | https://github.com/facebook/akd |
| WhatsApp Key Transparency (SEEMless / Parakeet) | Meta | Production | context | The deployed Key Transparency system in WhatsApp. AKD is the open-source extraction. The whitepaper details the threat model and operational properties that informed atrib §6 (D034) and inform any VRF-blinded directory deployment. | https://research.facebook.com/publications/whatsapp-key-transparency/ |
| Sigstore Fulcio | Sigstore / OpenSSF | GA | context | Code-signing certificate authority that ties OIDC identities to ephemeral signing keys, anchored in Sigstore's transparency log. Relevant as a comparison point for atrib's identity-claim format: Fulcio binds identity-via-OIDC; atrib §6 binds identity-via-self-attestation-or-domain-verification, with no centralized CA. The architectures share the witness-anchored append-only directory pattern but differ on the identity-verification primitive. | https://github.com/sigstore/fulcio |
Community context and v2 integration targets.
| Name | Maintainer | Status | Relationship | Description | URL |
|---|---|---|---|---|---|
| OTel Specification (Core) | OpenTelemetry / CNCF | Stable | core | The full OTel API/SDK specification. atrib's middleware is an OTel span processor; it hooks into the OTel span lifecycle. Developers with OTel already configured need minimal additional setup. | https://opentelemetry.io/docs/specs/otel/ |
| OTel Semantic Conventions (repo) | open-telemetry/semantic-conventions | Active | core | Source repo for all OTel semantic conventions. Relevant to atrib in two ways: (1) where to file issues or PRs to propose official atrib.* span attribute namespacing; (2) where MCP and GenAI convention PRs (including PR #414) are actively developed. Monitor for breaking changes to incubating GenAI/MCP attributes that @atrib/mcp depends on. |
https://github.com/open-telemetry/semantic-conventions |
| C2PA (Content Credentials) | C2PA / Linux Foundation | Stable + ISO Track | context | Content provenance for media assets. Solves attestation-at-creation for images/video/audio. Does not close the value loop. atrib is philosophically downstream of C2PA; if content carries C2PA credentials, atrib can read creator identity from them. | https://c2pa.org/specifications/ |
| W3C Decentralized Identifiers v1.0 | W3C | Recommendation 2022 | context | DIDs as persistent creator identifiers. V2 atrib creator keys may be DID-anchored for key rotation and cross-ecosystem interoperability with DIF/ToIP work. did:key is the simplest entry point. |
https://www.w3.org/TR/did-core/ |
| DIF Trusted AI Agents Working Group | Decentralized Identity Foundation | Active WG | context | Working on identity, delegation, and accountability for AI agents. Creator Assertions WG overlaps with atrib's provenance work. Strategic community for spec adoption and positioning at AIW/IIW. | https://identity.foundation/working-groups/trusted-agents |
| W3C AI Agent Protocol Community Group | W3C | Active CG | context | Working toward official W3C web standards for agent communication, identity models, and inter-agent protocols. Specs expected 2026-2027. atrib should engage for formal standardization path. | https://www.w3.org/groups/cg/agentprotocol/ |
| OAuth 2.0 Protected Resource Metadata (RFC 9728) | IETF OAuth WG | Proposed Standard | context | Metadata document for OAuth-protected resources, including authorization server discovery. MCP Authorization requires protected-resource metadata; atrib's MCP/OAuth evidence checker accepts the caller-supplied metadata as verifier evidence. | https://www.rfc-editor.org/rfc/rfc9728 |
| OAuth 2.0 Rich Authorization Requests (RFC 9396) | IETF OAuth WG | Proposed Standard | context | Defines authorization_details for fine-grained authorization data beyond plain scopes. atrib's MCP/OAuth evidence checker can require authorization-detail entries by type, action, and location. |
https://www.rfc-editor.org/rfc/rfc9396 |
| OAuth 2.0 Token Introspection (RFC 7662) | IETF OAuth WG | Proposed Standard | context | Defines the response shape for introspecting opaque OAuth tokens. atrib keeps introspection host-owned: @atrib/verify can help a host call its chosen endpoint and convert the result into supplied MCP/OAuth evidence, while verifyRecord() still performs no hidden network fetches. |
https://www.rfc-editor.org/rfc/rfc7662 |
| x401 Proof Requirement Protocol | Proof | Draft v0.2.0 | context | HTTP 401 proof-requirement protocol for credential-gated routes. Current x401 uses PROOF-REQUEST, PROOF-RESPONSE, and PROOF-RESULT headers carrying Digital Credentials and optional verification-token material. atrib treats x401 as verifier-side authorization evidence under evidence[], not as a transaction hook. Optional x401 payment hints still require a real payment protocol such as AP2, x402, or MPP. |
https://x401.proof.com/spec/latest/ |
| AAuth Protocol | Dick Hardt / AAuth | IETF I-D -02 | context | Agent authorization protocol with per-instance agent identifiers, HTTP Message Signature proof of possession, agent/resource/auth JWTs, AAuth-Access, missions, sub-agents, and Person Server / Authorization Server governance. atrib treats AAuth tokens and verification results as external authorization evidence under evidence[] rather than a new signed action type or graph edge. |
https://datatracker.ietf.org/doc/draft-hardt-oauth-aauth-protocol/ |
| ZCAP-LD Authorization Capabilities | W3C CCG | Work item | context | Linked Data object-capability model for delegation and attenuation. It remains a strong semantic reference for future capability-chain adapters, but atrib keeps the action-log substrate separate from authorization credential issuance. | https://w3c-ccg.github.io/zcap-spec/ |
| Vouch Protocol | Vouch Protocol | CCG report draft | context | VC/Data Integrity profile for autonomous-agent identity, intent attestation, resource-bound delegation, sidecar key isolation, and heartbeat renewal. Strategic overlap is real, but atrib treats Vouch-style credentials as external authorization evidence rather than a replacement for signed action records and public Merkle-log commitments. | https://github.com/vouch-protocol/vouch |
| JIS (JTel Identity Standard) | Humotica / Jasper van de Meent | IETF Internet-Draft | context | Companion identity and intent-negotiation layer for the Humotica stack. It separates human identity keys from device signing keys, uses FIR/A handshakes for trust establishment, and records intent-validation evidence into TIBET. atrib should treat JIS as optional external identity evidence or directory claim material, not as a mandatory identity universe. | https://www.ietf.org/archive/id/draft-vandemeent-jis-identity-01.txt |
| AINS (AInternet Name Service) | Humotica / Jasper van de Meent | IETF Internet-Draft | context | Agent discovery and metadata registry with endpoint, capability, trust-score, identity, and provenance-chain references. AINS capability metadata can feed atrib resolvedFacts, identity claims, or optional evidence blocks, while AINS trust scores remain registry opinions rather than atrib facts. |
https://www.ietf.org/archive/id/draft-vandemeent-ains-discovery-01.txt |
| UNCITRAL MLETR | UNCITRAL | Model law (2017) | context | Legal model for electronic transferable records. MLETR frames the reliability problem around identity, integrity, and control of transferable documents or instruments. atrib does not implement negotiable-instrument law, but ETR workflows are a natural high-impact agent-action class. Verifier policy should treat legal title, control recognition, and attestor authority as external evidence, not as base record-validity facts. | https://uncitral.un.org/en/texts/ecommerce/modellaw/electronic_transferable_records |
| OpenETR | Tom Bouma / OpenETR | Draft implementation | context | Nostr-backed open scheme for electronic transferable record control events. It maps an object to a digest, publishes origin and control-transfer events on relays (31415 origin, 31416 control family), and separates event publication from legal or operational recognition by attestors or title-transfer authorities. For atrib, OpenETR is an evidence-provider and proof-target candidate: wrap agent issue, transfer, accept, and terminate calls; archive event ids or event JSON; keep OpenETR attestations as verifier evidence unless the counterparty signs atrib's own record bytes. |
https://github.com/trbouma/openetr |
| MCP Registry | modelcontextprotocol/registry | Active | context | Community-driven registry of MCP servers. Referenced in the MPP payment discovery IETF draft as a canonical index for MCP service discovery. The registry's well-known discovery pattern informs atrib's /.well-known/atrib-policy.json convention. |
https://github.com/modelcontextprotocol/registry |
| a2a-directory | sing1ee / Community | Active | context | Community index of A2A resources: AgentCards, servers, clients, official and community samples. Covers A2A implementations across LangGraph, CrewAI, AutoGen, Semantic Kernel, Azure AI Foundry, and more. Reference for real-world A2A deployment patterns atrib middleware must be compatible with. | https://github.com/sing1ee/a2a-directory |
| KERI (Key Event Receipt Infrastructure) | ToIP TSWG / WebOfTrust | Working Draft + IETF | context | Self-sovereign identifier framework. AIDs are self-addressing digests of inception events; KELs (Key Event Logs) chain rotation, delegation, and interaction events; pre-rotation commitment scheme makes key-compromise recoverable. Production via GLEIF vLEI. atrib's creator_key model shares the "signer-key-is-the-identity" philosophy; a future extension could allow creator_key to bind to a KERI AID's current signing key. Complementary: KERI handles identity-key lifecycle, atrib handles action attestation. |
https://trustoverip.github.io/tswg-keri-specification/ |
| ACDC (Authentic Chained Data Containers) | ToIP TSWG / WebOfTrust | Working Draft + IETF | context | KERI's authenticated-data-container layer. Verifiable credentials backed by KERI AIDs, composable via SAID-linked edges with authority-delegation semantics (I2I / NI2I / DI2I). Production via GLEIF vLEI. Philosophically differs from atrib §3 graph: ACDC edges are declared authority claims; atrib edges are derived structural facts per §3.6 fact/policy separation. Complementary rather than competitive; the two address different layers. | https://trustoverip.github.io/tswg-acdc-specification/ |
| CESR (Composable Event Streaming Representation) | ToIP TSWG / WebOfTrust | Working Draft + IETF | context | Domain-coded self-describing encoding, substrate for KERI's crypto-agility, binary/text composable, supports selective disclosure. atrib chose JCS (RFC 8785, §1.3) for Web/JOSE ecosystem alignment; CESR is the CBOR/COSE-side equivalent. Two envelope traditions; atrib does not need CESR but should be aware when interoperating with KERI/ACDC systems. | https://trustoverip.github.io/tswg-cesr-specification/ |
| GLEIF vLEI (Verifiable Legal Entity Identifier) | GLEIF | Production (v3.0 EGF Apr 2026) | context | Real production deployment of KERI + ACDC. Legal-entity identity credentials with cryptographic verifiability. Proves the KERI/ACDC stack ships in enterprise settings. Reference point for atrib's future organizational-identity interoperability. | https://www.gleif.org/en/vlei/introducing-the-vlei |
The semantic-recall layer that runs inside an agent's conversation loop. atrib does not implement this layer; it runs underneath it. Listed here because the framing of "agent memory" overlaps semantically with atrib's "agents that reason from a past they can prove," and reviewers should see the distinction made explicit.
These systems operate on the conversational/semantic layer (what should the LLM read next turn?). atrib operates on the action layer (what action was emitted, by whom, in what causal context, and can a third party prove it?). Composition is clean: an agent can run any of these systems for recall while running atrib middleware for signed action history. Most of this layer has no cryptographic record signing. Walrus Memory / MemWal is the important exception to track: it verifies decentralized storage and access-control state, not action provenance or recall use.
| Name | Maintainer | Status | Relationship | Description | URL |
|---|---|---|---|---|---|
| Letta (formerly MemGPT) | Letta Inc. (Berkeley Sky Computing Lab spinout) | Production | context | Three-tier memory architecture (core / recall / archival) inspired by computer-architecture analogy, with the agent itself editing memory via tool calls (core_memory_append, core_memory_replace, archival_memory_insert). All tiers fully mutable; no signing or append-only invariant. Operates on conversational state. atrib composes with Letta at the MCP tool-call boundary: Letta shapes recall, atrib signs the externally-observable action. Originated from the MemGPT paper (Packer et al., 2023). |
https://github.com/letta-ai/letta |
| Zep / Graphiti | Zep AI | Production | context | Temporal knowledge graph (Neo4j-backed) with bi-temporal validity (valid_at / invalid_at) per edge. Edges are append-only-by-convention at the data-model level, when a fact is contradicted, the old edge gets invalid_at set rather than deletion, but the storage layer is freely mutable, no cryptographic enforcement, no signing. Optimizes for relationship-aware retrieval at sub-200ms P95. atrib composes by signing the action records that feed Zep; Zep keeps its retrieval graph, atrib keeps its proof graph. |
https://github.com/getzep/zep |
| Mem0 | Mem0 Inc. | Production | context | Vector-DB-backed memory layer with LLM-mediated extraction and consolidation. Earlier algorithms used UPDATE / DELETE / ADD / NOOP per-fact decisions; the April 2026 algorithm shifted to single-pass ADD-only extraction at the LLM layer (storage layer still supports update() and delete()). Multi-signal retrieval (semantic + BM25 + entity matching). No signing, no append-only cryptographic invariant. atrib composes at the action-emission boundary; Mem0 stays in the user-fact-consolidation layer. |
https://github.com/mem0ai/mem0 |
| Walrus Memory / MemWal | Mysten Labs / Walrus | Beta | context | Portable decentralized memory substrate. Encrypted memory blobs live on Walrus, account and delegate authority live in a Sui Move contract, Seal gates access, and Postgres / pgvector stores the rebuildable search index. Verifiability covers blob integrity/availability, authorized access, and Ed25519-signed relayer requests. It does not prove extraction fidelity, recall completeness, or that an agent used a memory before a later action. atrib composes by signing MemWal remember / recall / analyze / ask / restore calls and downstream actions. |
https://github.com/MystenLabs/MemWal |
| Graphiti (standalone) | Zep AI / Open Source | Active | context | The open-source temporal-knowledge-graph engine underneath Zep, available for direct use. Same bi-temporal model and same lack of cryptographic verifiability as the hosted Zep platform. | https://github.com/getzep/graphiti |
| TraceBase | 64envy64 / Open Source | Active | context | Coding-agent memory runtime with a project-scoped SQLite pattern store, recall/gist/loop/guard/fold arms, local event log, deletion and rollback, and holdout-based impact measurement. It pressures atrib on proactive useful memory: agents should surface the right past work before another run repeats it. It is still a semantic memory and optimization layer, not a signed public evidence layer. atrib should compose with this shape rather than copy it wholesale. | https://github.com/64envy64/tracebase |
Agent observability platforms record what an agent does for operational debugging, cost tracking, evaluation, and root-cause analysis. atrib records the same activity for verifiability: every action becomes a signed Merkle-log entry any third party can audit without trusting the platform operator. The two layers compose rather than compete. atrib's primary observability integration is an AtribSpanProcessor that consumes OpenInference-shaped spans on the same OTel pipeline, emits signed records, and preserves rich span fields as local sidecar content for recall, trace, and summarize.
| Name | Maintainer | Status | Relationship | Description | URL |
|---|---|---|---|---|---|
| OpenTelemetry JS trace-base | OpenTelemetry / CNCF | Stable | core | Foundation package for JS tracing SDKs. It provides BasicTracerProvider, samplers, and span processor hooks for manual span creation in browser or Node.js, but it does not ship automated instrumentation, context management, or propagation by itself. This is the low-level OTel surface that makes atrib's span-processor shape fit normal JS observability stacks. |
https://github.com/open-telemetry/opentelemetry-js/tree/main/packages/opentelemetry-sdk-trace-base |
| OpenInference | Arize AI | Production (Apache-2.0) | context | OpenTelemetry semantic conventions for LLM and agent telemetry. Defines a schema (openinference.span.kind, tool.*, llm.*, session.*) implemented across a multi-language package set for Python, JavaScript, Java, and Go, including OpenAI Agents SDK, Claude Agent SDK, LangChain, Vercel AI, CrewAI, LlamaIndex, DSPy, and MCP itself. The reference integration shape is an OpenTelemetry SpanProcessor; the JS package @arizeai/openinference-vercel ships OpenInferenceSimpleSpanProcessor and isOpenInferenceSpan as canonical entry points. atrib's primary observability integration consumes these spans. |
https://github.com/Arize-ai/openinference |
| Arize Phoenix | Arize AI | Production | context | Self-hostable viewer for OpenInference traces. Single Docker container, fully featured at zero cost. Composes with atrib via shared OpenInference span format. | https://github.com/Arize-ai/phoenix |
| Langfuse | Langfuse GmbH | Production | context | Adoption leader for LLM observability. Its product shape centers on traces, nested observations, sessions, model metadata, usage, costs, scores, prompt versions, and evals. It operates an OTLP HTTP receiver at /api/public/otel and maps OpenInference attributes natively, so atrib can share the same span stream without platform-specific code. Difference: Langfuse consumes the span tree for operations; atrib consumes it as intake for signed records plus local cognitive sidecar content. |
https://github.com/langfuse/langfuse |
| AgentOps | AgentOps Inc. | Production (MIT) | context | SDK-shaped capture via Python decorators. Coexists with atrib on different layers but does not expose a span-processor-equivalent hook. | https://github.com/AgentOps-AI/agentops |
| Helicone | Helicone Inc. | Production (Apache-2.0) | context | HTTP-proxy-shaped capture for LLM API calls. Captures the LLM call boundary, not the agent's tool dispatch. Coexists with atrib on different layers. | https://github.com/Helicone/helicone |
| AgentTrace causal graph tracing | Zhaohui Geoffrey Wang | Preprint / ICLR 2026 AIWILD workshop | context | Post-hoc root-cause localization for deployed multi-agent workflows. It reconstructs causal graphs from execution logs, walks backward from an error manifestation, and ranks candidate causes using structural and positional signals without LLM inference at debug time. This pressures atrib's D087 diagnostic loop: signed records should feed AgentTrace-style ranking, and diagnostic outcomes should become signed replayable evidence. Difference: AgentTrace assumes the trace/log input exists and is trustworthy; atrib makes the input and the repair conclusion independently checkable. | https://arxiv.org/abs/2603.14688 |
| AgentRx | Microsoft Research | Open-source framework and benchmark | context | Systematic agent debugging framework that synthesizes executable constraints from tool schemas and domain policies, then records evidence-backed violations to find the first unrecoverable step. Useful prior art for failure taxonomies and critical-step annotation. atrib should use this as eval and diagnostic-shape pressure, not as a replacement for signed action records. | https://www.microsoft.com/en-us/research/blog/systematic-debugging-for-ai-agents-introducing-the-agentrx-framework/ |
| Tracebase local trace capture | ssreeni1 / Open Source | Active | context | Secure local-first trace capture and inspection for Codex and Claude agent sessions. It imports local transcripts, encrypts raw events locally, builds searchable redacted metadata, serves a localhost dashboard, supports read-only MCP trace search/listing, and exports safe incident packets. It is local workstation observability over existing agent logs, not a signed public evidence layer. atrib should compose with the local-inspection shape while keeping signed records, body commitments, and inclusion proofs as the verifier boundary. | https://github.com/ssreeni1/tracebase |
| agenttrace | luoyuctl / Open Source | Active | context | Local-first terminal TUI and report generator over coding-agent logs from Claude Code, Codex CLI, Gemini CLI, Cursor exports, and related tools. It ranks expensive or slow runs and surfaces long gaps, retry loops, tool failures, context pressure, and reportable incident timelines without a hosted backend. It is operational observability over local logs; atrib is verifiable action evidence over signed records. | https://github.com/luoyuctl/agenttrace |
| AgentTrace | TensorStax / Open Source | Active | context | Lightweight tracing and evaluation library for AI agents and language models with local SQLite trace storage, decorators, custom eval functions, and a web dashboard. It is useful as an agent observability and eval substrate. It does not sign trace records, chain them, or publish inclusion proofs. | https://github.com/tensorstax/agenttrace |
The generic observability platforms in this section do not sign records, chain-link them, or commit them to a transparency log. Some field overlap is intentional: trace ids, span ids, prompts, outputs, usage, costs, scores, and model metadata may exist in both the observability backend and the local atrib mirror. The verifier boundary is different. In atrib, those fields stay local sidecar content unless committed through args_hash / result_hash, an archive body, or a future promoted protocol field. The next section tracks closer proof-log alternatives separately.
Some newer tools do sign local agent activity. They are closer alternatives than generic observability tools because they share atrib's claim that agent actions need tamper-evident receipts.
| Name | Maintainer | Status | Relationship | Description | URL |
|---|---|---|---|---|---|
| TIBET (Transaction/Interaction/Bilateral Evidence Trail) | Humotica / Jasper van de Meent | IETF Internet-Draft + Python/Rust implementations | direct prior art | Direct action-provenance prior art. TIBET tokens sign erin, eraan, eromheen, and erachter fields, link through parent_id plus optional parent_hash, and make stated intent first-class. The difference is the verifier boundary and graph model: TIBET centers on signed token integrity and parent chains; atrib commits signed records to a public Merkle log, derives a multi-edge graph, supports cross-session anchors, annotations, revisions, transaction convergence, and verifier evidence blocks. |
https://www.ietf.org/archive/id/draft-vandemeent-tibet-provenance-01.txt |
| UPIP (Universal Process Integrity Protocol) | Humotica / Jasper van de Meent | IETF Internet-Draft | direct prior art | Process-integrity companion to TIBET. UPIP fork tokens freeze STATE, DEPS, PROCESS, RESULT, and VERIFY material for multi-actor continuation, including capability requirements and handoff metadata. This overlaps atrib continuation packets and handoff evidence, but at a wider process-reproduction layer. atrib can carry UPIP fork tokens as external evidence without replacing informed_by, Pattern 3 handoff verification, or public log inclusion. |
https://www.ietf.org/archive/id/draft-vandemeent-upip-process-integrity-01.txt |
| ZeroProof AI | Zero-Proof-AI / Montauk Capital | Public POC, SDK forks, packages, releases | direct prior art | MCP and agent-commerce proof stack centered on tools/call proof collection, zkTLS/Reclaim web proofs, SP1/Groth16 intent proofs, attestation-service proof IDs, proof badges, and on-chain verifier contracts. This overlaps atrib at its busiest intake boundary: selected tool calls and payment or intent facts become verifiable artifacts. Public surfaces do not yet show atrib-equivalent public Merkle action logs, derived session graphs, cross-agent replay, cognitive read/write primitives, or verifier-side composition over many evidence types. Treat as the closest direct competitor and a strong evidence-provider candidate. |
https://github.com/Zero-Proof-AI |
| AgentProofs | AdelElo13 / Open Source | Active | direct prior art | MCP-native local-first proof log for AI agent tool executions and audit events. Uses Ed25519 signatures and a hash chain to make local logs tamper-evident. This is genuine overlap: signed action receipts are part of atrib's surface too. The difference is the verifier boundary. AgentProofs keeps proof local to the agent or app; atrib commits records to a public Merkle log, returns inclusion proofs, derives cross-agent causal graphs, commits local bodies through args_hash, and exposes verifier APIs so third parties can check evidence without trusting the local store. |
https://github.com/AdelElo13/agentproofs |
The gaps that atrib fills. Close alternatives provide useful pieces, but none of the above provide this full set as one verifier surface:
| Gap | Why it matters |
|---|---|
| Public commitment-backed action records | Signed local token integrity is not enough for third-party verification. atrib records are committed to a public Merkle log with inclusion proofs, while private bodies stay in local mirrors or archives. |
| Value provenance graph | A queryable graph connecting tool call events to transaction events via shared context, with typed edges for chain order, sessions, parallelism, convergence, cross-session anchors, informed_by, annotations, and revisions. |
| Attribution policy format | A machine-readable, negotiable document expressing how value should distribute across graph contributors. No existing spec defines weighting models for agent-mediated commerce. |
| Settlement recommendation format | A verifiable output produced by applying a policy to a graph query ("Creator A gets 45%, Creator B gets 35%"), signed and auditable. Entirely novel. |
atrib_context_id in commerce metadata |
The convention for embedding an attribution context identifier in ACP/UCP checkout session metadata. Currently undefined in any commerce spec. |
| Cross-session recommendation token | A mechanism for attributing conversions that happen outside agent sessions (e.g., browser purchase after agent recommendation). Partially novel problem space. |