Resources

The Stream Presence Agent Resource Index

A practical starting point for agents and their operators on the open web.

Find the protocol, tool, or practice that fits your next action. Discovery tells you what exists; identity tells you who controls an identifier or credential; authorization tells you what is allowed; a receipt records evidence of what happened. No single entry does all four. Alongside the protocols and practices, the index covers the frameworks, runtimes, platforms, and the payment and discovery tools agents are actually built and run with.

Datasets: resources.json (version 2026-11-20.2) · tools-and-ecosystem.json (version 2026-11-20-tools.2) · Both reviewed 2026-11-20 · Published by Stream Presence

What are you trying to do?

Start from the job, not the acronym. Each path lands on the entries that fit it.

Match a framework to your model provider or managed runtime

A framework provides the application loop; a managed runtime is a separate deployment and operational decision.

Build a typed Python agent or an explicit role-based team

Choose typed IO for a service boundary or team roles for workflow readability. A single workflow is often easier to test first.

Orchestrate a durable workflow with explicit state

Compare interruption and resume behavior, not just the shortest first demo.

Let an agent use my API as a tool

Start with one read-only tool and a typed input and output contract.

Send work to another agent and get its result

Agree on protocol and version. Record accepted scope, deadlines, task ID, and what counts as a useful result.

Publish a site or discover agent capabilities

Publishing searchable content, resolving an agent, discovering capabilities, and verifying an operator are separate jobs.

Establish who is calling or operating an agent

Keep key control, operator verification, and permission to act separate.

Let an agent act on someone's behalf

Enforce audience, scope, expiry, and value limits outside the model. Credentials can inform that policy, not replace it.

Charge for an API request

Treat the payment result and delivery result as separate states.

Add a paid web or API capability

Separate payment rails, merchant settlement, credit or custody, and actual task delivery. Start with documentation and read-only discovery or sandbox tests.

Let a shopper check out with an agent

Keep customer consent, total cost, and final order status explicit.

Hire an agent for a deliverable and settle a job

Set acceptance criteria and evaluator policy before committing funds.

Record or verify the outcome of a delegated task

Start with a trace and a portable receipt; add attestation or a proof only for a concrete evidence gap.

Search the index

Connect agents and tools

Protocols to expose tools, send tasks, and communicate across runtimes.

Agent2Agent Protocol (A2A)

Connect agents and toolsOpen agent-to-agent protocolMaturity: Stable v1.0.1 specification patch; v1.0 wire familyreleasedReviewed 2026-11-20

A2A lets independently built agents delegate work and exchange results without sharing their internal tools or implementation.

Use when
  • A client agent needs to request a task from another team's agent and receive structured results.
  • A job lasts longer than a request or needs status updates, input from the caller, or artifacts.
  • You want a common task boundary across stacks, while each agent can still obtain tools through MCP.
How it works
  • An Agent Card lists skills, endpoints, bindings, protocol versions, and authentication requirements; one discovery option is /.well-known/agent-card.json.
  • Send Message can return a direct message or a task. Tasks have lifecycle states and may yield artifacts; servers can advertise streaming or push notifications.
  • The same abstract operations have JSON-RPC, HTTP+JSON, and gRPC bindings; the Agent Card declares which are supported.
Getting started
  • Choose an official SDK and pin the protocol family advertised by both participants rather than assuming all v0.3 and v1.0 clients interoperate.
  • Start with a local echo or read-only research task. Publish a minimal Agent Card and test message, task status, and artifact handling with another implementation.
  • Authenticate the caller and authorize skills and endpoints separately; treat peer messages, artifacts, and discovery metadata as untrusted inputs.
Limitations
  • A card describes claimed capability; it does not prove operator identity, competence, or completed work.
  • Streaming, push notifications, and extended cards are not universal. Check capabilities before using them.
  • A2A does not by itself create billing, dispute resolution, or cryptographic proof that the artifact meets the request.

Maintainers

  • A2A Project maintainers under Linux Foundation governance.
  • Originally developed by Google; contributions are managed through the open A2A Project.

Maintainer links

Primary sources

Model Context Protocol (MCP)

Connect agents and toolsOpen host-to-tool and context protocolMaturity: Stable specification revision 2026-07-28releasedReviewed 2026-11-20

MCP gives AI hosts a common interface to tools and context exposed by servers; it is not a peer-agent delegation or trust protocol.

Use when
  • Expose an existing read-only API or data catalog to multiple supported AI hosts.
  • Retrieve reference data or prompt templates through a standardized server interface.
  • Pair with A2A when a delegated agent needs to call its own tools or read its own context.
How it works
  • An AI host creates MCP clients to communicate with servers; servers may expose callable tools, readable resources, and reusable prompts.
  • MCP messages use JSON-RPC 2.0 over local stdio or remote Streamable HTTP. The 2026-07-28 core is stateless; protocol information travels with requests.
  • HTTP authorization and separately versioned extensions are defined by MCP. Features such as Tasks must be negotiated or checked rather than assumed.
Getting started
  • Select an official SDK that explicitly supports your client's revision and follow the build-server guide.
  • Start with one harmless read-only capability and a narrow input schema; test discovery and responses locally before enabling remote access.
  • Use least-privilege credentials, validate server and tool outputs, and require explicit policy or human approval for consequential writes.
Limitations
  • Capability discovery is not a security guarantee; a tool's annotations alone do not enforce that it is safe or read-only.
  • A client/server's protocol and extension support can vary. Older revisions have different lifecycle requirements.
  • MCP does not attest to completion or quality and does not replace operator authentication or business authorization.

Maintainers

  • Model Context Protocol core maintainers and working groups.
  • Original contributor Anthropic; a founding project of the Agentic AI Foundation under the Linux Foundation.

Maintainer links

Primary sources

Agent Network Protocol (ANP)

Connect agents and toolsOpen web-native identity, discovery, and messaging suiteMaturity: Specification set 1.2; individual profiles and implementations have separate maturityreleasedReviewed 2026-11-20

ANP combines web-hosted agent identity and descriptions with authenticated requests, discovery and messaging profiles for cross-domain coordination.

Use when
  • You need agents associated with different web domains to discover one another and authenticate requests.
  • You want to test web-based identity and structured service discovery without a central registry or blockchain.
  • You can evaluate profile compatibility with a known partner before opening external access.
How it works
  • ANP-02 defines common DID-based HTTP/JSON authentication for did:wba and native did:web; DID documents resolve keys and can point to agent services.
  • ANP-07 defines Agent Description documents; ANP-08 describes active well-known discovery and passive discovery through search agents.
  • Messaging support is expressed through named profiles and their own wire versions. The 1.2 spec set does not globally change those IDs.
Getting started
  • Read the maintained guide and 1.2 release notes; choose a released identity and discovery profile before selecting a matching SDK implementation.
  • Use test domains and keys to publish a sample description and validate authentication between two controlled services.
  • Verify the DID binding and request signature as specified; authorize access separately, and advertise only verified capabilities.
Limitations
  • The 1.2 release is a specification release, not automatic SDK or hosted-service support.
  • ANP-06 negotiation and ANP-10 payment material are drafts; P6 Group E2EE remains a candidate, not a stable released feature.
  • Domain-linked identifiers and signed requests do not prove real-world authority, work completion, or output quality.

Maintainers

  • Agent Network Protocol open-source maintainers.
  • The agent-network-protocol GitHub organization publishes the specifications and release notes.

Maintainer links

Primary sources

Frameworks and agent runtimes

Google Agent Development Kit (ADK)

FrameworksMaturity: Active open-source toolkit; 2.0 workflow APIs are documented alongside earlier workflow patterns.

Google’s code-first toolkit for building, evaluating and deploying agent applications; fits Gemini teams without requiring every workflow step to be a model call.

Use when
  • Choose it when Gemini or Google Cloud already anchors the project.
  • Use it when a predictable sequence needs one or two judgment-heavy steps.
How it works
  • Combine LLM agents with tools and deterministic nodes so routing or validation can stay in application code.
  • Compose multi-step workflows using templated patterns or the newer graph-based workflow APIs.
Getting started
  • Build a single read-only agent with the language-specific quickstart.
  • Add a deterministic validation step and evaluate against a small fixture set before composing more agents.
Limitations
  • Workflow and feature availability differs across language bindings and versions; verify feature parity before porting.

Maintainers

  • Google
  • Open-source contributors

Maintainer links

Primary sources

LangGraph

FrameworksMaturity: Active open-source orchestration runtime with documented persistence and human-in-the-loop support.

Low-level orchestration runtime for building stateful workflows that can be resumed, inspected and interrupted. It makes you define the control flow rather than handing you a preconfigured assistant.

Use when
  • Choose it when retries, branching and human approvals are core to the workflow.
  • Use it for long-running processes whose state must survive interruptions.
How it works
  • Model workflow state and transitions in a graph, then run model calls, tools and ordinary functions as nodes.
  • Use a checkpointer to save state by thread, enabling resumption and human approval pauses.
Getting started
  • Build a small graph with a single branch and inspect state after each step.
  • Test stop/resume with a checkpointer and validate how repeated actions are handled.
Limitations
  • A checkpoint does not make external side effects idempotent; the application still owns that behavior.

Maintainers

  • LangChain
  • Open-source contributors

Maintainer links

Primary sources

CrewAI

FrameworksMaturity: Active open-source framework; official docs verified on the v1.15.44 branch.

Python framework that separates role-based collaboration inside a Crew from event-driven application control in a Flow.

Use when
  • Choose it when the task naturally divides into roles such as researcher, drafter and reviewer.
  • Use a Flow when human review or deterministic checks should control when the crew runs.
How it works
  • Crews group agents around roles and tasks, while Flows handle triggers, routing and shared state.
  • A Flow can call ordinary Python functions, a single agent, or an entire Crew and route subsequent work based on its result.
Getting started
  • Create a small Flow and run one short Crew with fixed inputs.
  • Capture failure cases and compare quality and cost against a single-agent baseline.
Limitations
  • Adding roles can increase model calls and cost without improving results; role separation does not itself validate the output.

Maintainers

  • CrewAI, Inc.
  • Open-source contributors

Maintainer links

Primary sources

AWS Strands Agents SDK

FrameworksMaturity: Active open-source SDK; the former Python repository now redirects to the Strands monorepo, which includes Python and TypeScript SDKs.

AWS-originated open-source Python and TypeScript SDK for running a configurable, model-driven agent loop inside your own app.

Use when
  • Choose it when you want control over the runtime and tool loop but don’t want to implement the loop yourself.
  • Use it when Amazon Bedrock is convenient now but you want to keep another supported provider as an option.
How it works
  • Define model, instructions and typed tools; the model proposes tool calls, and the SDK executes permitted tools and returns results to the model.
  • Compose the loop with session state, lifecycle hooks, run budgets, and tracing instead of assembling those elements from scratch.
Getting started
  • Run the core SDK quickstart with one non-mutating tool and a configured model provider.
  • Set explicit turn limits and trace key tool decisions before adding another provider or agent.
Limitations
  • The SDK runs in your process, not a hosted control plane; application operators own deployment, credentials and durable storage choices.

Maintainers

  • Strands Agents maintainers and contributors
  • Originated at Amazon Web Services

Maintainer links

Primary sources

goose (Agentic AI Foundation)

FrameworksMaturity: Active open-source project hosted by the Agentic AI Foundation at the Linux Foundation, with desktop and CLI distributions.

An installable desktop and command-line assistant with pluggable model providers and extensions. More ready to use than a lower-level SDK.

Use when
  • Choose it when someone needs a usable assistant on a workstation rather than a new agent service.
  • Use it to try low-risk, repeatable tasks across approved model and tool configurations.
How it works
  • Run an interactive assistant from the desktop or CLI with a configured model provider.
  • Extend it with MCP tools; turn repeatable tasks into recipes rather than rebuilding the assistant loop.
Getting started
  • Install from the official guide and choose a supported provider.
  • Start with a read-only extension and a small sample workspace; review what the provider and tools can see.
Limitations
  • A locally installed interface does not imply local inference or isolated tools; permissions and data exposure depend on configuration.

Maintainers

  • goose project maintainers and contributors
  • Originally developed by Block; hosted by the Agentic AI Foundation

Maintainer links

Primary sources

OpenAI Agents SDK

FrameworksMaturity: Active open-source Python and TypeScript SDKs with official quickstarts.

OpenAI’s code-first Python and TypeScript libraries for composing agent runs, tools and handoffs. This is distinct from calling a hosted Agents API directly.

Use when
  • Choose it when building an OpenAI-centered assistant that needs tool calls and routing without a custom loop.
  • Use it when you want to inspect why a decision or handoff occurred before adding more specialized agents.
How it works
  • Define an agent with instructions and tools, then use a runner to step through tool calls and return the final response.
  • Use handoffs to transfer control to specialized agents and traces to inspect model calls, tool calls and other run events.
Getting started
  • Start with the Python or TypeScript quickstart and one read-only lookup tool.
  • Add one testable handoff and review its traces; configure sensitive-data capture before using real records.
Limitations
  • Tracing is observability, not independently verified proof; sensitive inputs and outputs need explicit handling.

Maintainers

  • OpenAI
  • Open-source contributors

Maintainer links

Primary sources

Claude Agent SDK

FrameworksMaturity: Active official SDK with documented Python and TypeScript support and separate release changelogs.

Anthropic’s Python and TypeScript SDK for embedding the Claude Code agent loop in an application you operate, unlike the interactive CLI or hosted Managed Agents.

Use when
  • Choose it when the intended assistant works with an approved project workspace or document collection.
  • Use it when you want to reuse Claude Code’s agent behavior while defining project-specific permissions.
How it works
  • Runs the Claude Code agent loop and context management via a library interface rather than requiring the application to implement its own tool loop.
  • Exposes sessions, permissions and hooks, plus optional custom tools, MCP integrations and focused subagents.
Getting started
  • Follow the SDK quickstart using approved API authentication and a small sample workspace.
  • Start with read-only capabilities, define explicit approvals, and run the first sessions with non-sensitive fixtures.
Limitations
  • It is tied to the Claude Code runtime and Anthropic’s terms; the SDK is not itself a deployment sandbox.

Maintainers

  • Anthropic

Maintainer links

Primary sources

Mastra

FrameworksMaturity: Released 1.x core; official GitHub release notes verified for @mastra/core 1.84.0 (Nov. 17, 2026).

TypeScript framework for building LLM agents and explicitly orchestrated workflows in one application. Choose it when the team wants both agent flexibility and a coded process around it.

Use when
  • Build an internal Node.js assistant whose document lookup or triage process has defined steps and review points.
  • Choose it over a thin agent loop when the app also needs explicit orchestration, persisted context, or integrated local testing.
How it works
  • Agents combine instructions, a selected model, and schema-defined tools; tools and agents can be invoked inside workflow steps.
  • Workflows chain typed steps with control flow for branches and parallel work; suspend-and-resume supports human input. Studio exposes local runs for testing.
Getting started
  • Use the official TypeScript starter and pin compatible Mastra packages. Start with one schema-validated read-only tool and a two-step workflow.
  • Run the workflow in local Studio, then test rejection, missing-data, and timeout cases before enabling any writes.
Limitations
  • Choosing the framework does not produce reliable workflows by itself: model quality, storage, deployment, and authority checks still need separate choices. Use the documentation for your installed version.

Maintainers

  • Mastra team and open-source contributors (mastra-ai GitHub organization).

Maintainer links

Primary sources

Pydantic AI

FrameworksMaturity: Released 2.x; public GitHub release v2.71.0 dated November 18, 2026.

Python agent framework built around type-checked dependencies, tool parameters, and validated outputs. Best when the consumer needs typed application data, not just chat text.

Use when
  • Produce citations, document classifications, or extraction records that downstream Python code must consume reliably.
  • Prefer it over a broader runtime when your application already handles persistence and orchestration and mostly needs typed model interactions.
How it works
  • An Agent pairs a model with instructions, functions, a dependency type, and an output type. RunContext makes app dependencies such as a read-only repository or fixture available to tools.
  • Pydantic-generated schemas describe tool inputs and outputs; validation and configurable retries help the application reject malformed results.
Getting started
  • Install pydantic-ai per the official guide, pick a supported model, and define one small output model plus a read-only tool.
  • Pass stubbed dependencies in local tests. Separately check source grounding and rules such as allowed domains, maximum results, or missing facts.
Limitations
  • Schema validation proves shape and any explicitly coded checks, not factual correctness. Native structured output support and behavior also depend on the provider.

Maintainers

  • Pydantic team and pydantic/pydantic-ai open-source contributors.

Maintainer links

Primary sources

Hugging Face smolagents

FrameworksMaturity: Released 1.x; official GitHub latest release observed v1.26.0.

Small Python library for model-driven tool loops. It offers conventional tool calls and a code-action variant, rather than requiring a full product runtime.

Use when
  • Prototype retrieval or analysis with a few simple tools, or compare how the same task performs with typed calls versus compositional code actions.
  • Prefer it over an integrated workflow stack when you want a lightweight evaluation prototype and own deployment yourself.
How it works
  • ToolCallingAgent asks the model for structured calls to the tools you expose. CodeAgent instead expresses actions in executable Python, which makes it easier to combine multiple calculations and tools in one action.
  • The agent runs against a model adapter and a bounded series of steps. Hugging Face provides local and hosted model adapters; the framework also supports alternative providers.
Getting started
  • Install a pinned smolagents release. Start with ToolCallingAgent, an approved model adapter, a small step limit, and one read-only tool over fixture data.
  • If you evaluate CodeAgent, use an isolated executor with no secrets and narrowly scoped filesystem, network, and resource access; test without production data.
Limitations
  • Generated code is a materially larger execution surface than fixed tool calls. The library's lightweight loop is not production isolation, access control, or durable orchestration.

Maintainers

  • Hugging Face and huggingface/smolagents open-source contributors.

Maintainer links

Primary sources

elizaOS

FrameworksMaturity: Released 2.x; release v2.0.5 is marked latest and published to npm. Release notes explicitly flag incomplete release-workflow checks.

Open TypeScript runtime and product stack for character-driven agents. It gives persistent and channel-facing agents an extensible runtime rather than just a single request loop.

Use when
  • Build a persistent persona or a community assistant with carefully controlled capabilities across an app or chat channel.
  • Choose it if character configuration and plugin reuse are more important than keeping runtime dependencies minimal.
How it works
  • A character configuration defines identity, instructions and style. AgentRuntime loads plugins that supply model providers, contextual inputs, and integrations.
  • Plugins extend the runtime with actions, providers, services and evaluators, letting a project add capabilities without rewriting the core agent loop.
Getting started
  • Read the official docs and use the CLI or starter for the chosen release. Run a single character locally with one model provider and a minimal plugin set.
  • Test locally with read-only or mock actions first; configure retention and review plugin permissions before adding external channels.
Limitations
  • Third-party plugins can materially expand the agent's privileges. Pin and review them; a character prompt is not an enforcement boundary.

Maintainers

  • elizaOS maintainers and contributors (elizaOS/eliza GitHub monorepo).

Maintainer links

Primary sources

Daydreams

FrameworksMaturity: Original harness is no longer the maintainers' focus. Lucid framework integration docs marked stable and verified against 2.5.0 (July 2026).

The original Daydreams TypeScript harness uses context-scoped state and actions. The maintainers have shifted focus to Lucid Agents, an agent-service layer that can sit in front of another runtime.

Use when
  • Audit or maintain existing @daydreamsai/core code that uses its context abstraction.
  • For a new service, consider Lucid if you need a standard endpoint around an existing workflow; compare it with a thin HTTP adapter if commerce integrations are unnecessary.
How it works
  • In the original harness, createDreams composes contexts and actions. A context defines its own state and memory, and typed actions let the model reach application functions.
  • The current Lucid Agents SDK wraps application-defined capabilities as service endpoints with optional protocol adapters. The underlying workflow, model and memory still belong to the application, not Lucid.
Getting started
  • For an existing harness, consult the original repository and match its examples to the pinned dependency version.
  • For a new experiment, read Lucid's integration guide and wrap an approved read-only function as an endpoint. Verify request and response handling locally before adding external integrations.
Limitations
  • The original repository explicitly says the harness is no longer the core focus; Lucid does not replace a model, memory, or workflow runtime.

Maintainers

  • Daydreams contributors (daydreamsai GitHub organization).

Maintainer links

Primary sources

Find agents and capabilities

Publish and discover what agents can do, without treating claims as verified.

Open Agentic Schema Framework (OASF)

Find agents and capabilitiesVersioned capability metadata schema and taxonomyMaturity: Stable schema release v1.1.0releasedReviewed 2026-11-20

OASF standardizes how agents and other agentic resources describe capabilities for portable cataloging, validation, and discovery. It is a schema, not a transport.

Use when
  • Create searchable inventory across different agent frameworks, organizations, or catalogs.
  • Describe comparable skills, domains, and endpoints without requiring every runtime to use the same protocol.
  • Tag an agent record for publication to a directory, then use a protocol such as A2A to talk to the agent.
How it works
  • A versioned record represents a resource with metadata, skill and domain taxonomies, and locators for associated resources.
  • Modules add structured information specific to a use case or protocol, including A2A Agent Card data.
  • The schema server and SDK help validate records; AGNTCY's separate Agent Directory Service indexes and routes records for discovery.
Getting started
  • Open the official record guide and schema browser, pin `schema_version` to the version your consumers support, and select standard skills/domains first.
  • Create a minimal record with accurate locators and add a protocol-specific module only if its target integration supports it.
  • Validate against the same schema revision before sending to a directory; remove secrets and internal-only endpoints before any public publication.
Limitations
  • A structurally valid record does not verify the claims inside it or automatically make an agent discoverable anywhere.
  • OASF does not implement invocation, network routing, or work verification; schema software and directory infrastructure are separate.
  • Custom extensions require publishers and consumers to agree on a compatible schema.

Maintainers

  • AGNTCY OASF maintainers under Linux Foundation governance.
  • Cisco initially open-sourced AGNTCY; Outshift by Cisco hosts an official schema browser.

Maintainer links

Primary sources

Discovery, publishing, and identity

NLWeb (originated at Microsoft)

FrameworksMaturity: Open-source Python reference implementation; the original Microsoft repository redirects to nlweb-ai/NLWeb.

Reference implementation and protocol for asking questions of a website’s structured content. It is a publishing and retrieval layer, not an agent orchestration SDK.

Use when
  • Choose it when an existing catalog, venue directory or events feed should become queryable by agents.
  • Use it when a public website needs a conversational search surface without turning it into a general-purpose agent.
How it works
  • Ingest structured site data using formats such as Schema.org and RSS, then retrieve relevant results for natural-language queries.
  • Serve the same site data through a natural-language interface and an MCP ask endpoint, with structured Schema.org responses.
Getting started
  • Start with the AskAgent sample and one small public dataset.
  • Evaluate query results against the source records before connecting the endpoint to a wider audience.
Limitations
  • Answer coverage depends on the content and retrieval configuration. The repository describes A2A as forthcoming, not shipped.

Maintainers

  • NLWeb project contributors
  • Originated at Microsoft

Maintainer links

Primary sources

Project NANDA (MIT Media Lab)

DiscoveryMaturity: Active research with open-source NandaIndex v2 reference implementation.

MIT-origin research and open-source work on how independently operated agents can find one another. NandaIndex is a concrete reference implementation.

Use when
  • Explore discovery for a test agent without assuming it owns a public domain.
How it works
  • Agent Facts Cards describe an agent and its capabilities so consumers can discover candidates. A card is not itself authorization.
  • NandaIndex v2 offers an index for reaching agents that do not operate their own public DNS domains; it separates discoverability from owning a domain.
Getting started
  • Use the maintainer's v2 reference implementation to register a test agent and resolve its associated card from a separate client.
Limitations
  • Research software and discovery claims are not a readiness guarantee, peer authorization, or proof of completed work.

Maintainers

  • MIT Media Lab Nanda research team and Project NANDA contributors.

Maintainer links

Primary sources

AGNTCY

DiscoveryMaturity: Active Linux Foundation open-source project with independently released components.

Linux Foundation project offering loosely coupled open-source components for finding, connecting, and operating agents across vendors.

Use when
  • Try structured capability discovery across independent runtimes, or evaluate a messaging component without adopting the full stack.
How it works
  • Directory stores, publishes, and searches agent records by skills and attributes using the Open Agentic Schema Framework (OASF) and distributed content routing.
  • SLIM provides a communication layer distinct from the Directory and schema; AGNTCY also documents identity and observability components.
Getting started
  • Start with the Agent Directory docs and one OASF test record. Publish it in a test environment and search for it by capability from a separate client.
Limitations
  • Check compatibility and operational readiness per component. A discoverable record is not a vetted counterparty or authorization to invoke it.

Maintainers

  • AGNTCY contributors under the Linux Foundation; Cisco Outshift was an early contributor.

Maintainer links

Primary sources

Agent Name Service (ANS)

IdentityMaturity: Linux Foundation project launched November 10, 2026; early ecosystem integrations and reference implementations; IETF work remains a draft.

Domain-anchored agent identity and discovery. The current Linux Foundation project should be distinguished from the earlier OWASP ANS research proposal and GoDaddy's implementation and registration service.

Use when
  • Find an independently operated agent and verify that it is bound to an expected domain and current registration.
How it works
  • A Registration Authority registers an agent against a DNS domain and its version. DNS records help peers find profiles and evidence, including a pointer to a public transparency log.
  • A peer verifies evidence for the current registration and key possession; the published authentication specification describes mTLS and DPoP options.
Getting started
  • Use the official Go local quickstart to register a test agent and verify its receipt before integrating with a real domain.
Limitations
  • The current project specification and the IETF Internet-Draft are not interchangeable with a ratified IETF RFC; a verified registration does not establish legal identity, competence, or permission to perform an action.

Maintainers

  • ANS technical steering committee under the Linux Foundation.
  • OWASP research authors and industry contributors including GoDaddy are part of the project's history; GoDaddy is not synonymous with the standard.

Maintainer links

Primary sources

Agent0 SDK (ERC-8004)

DiscoveryMaturity: Public MIT-licensed TypeScript and Python SDKs; available in package registries. No common latest version asserted across implementations.

TypeScript and Python SDKs for reading and writing ERC-8004 agent identity and feedback and discovering indexed agents. This is agent0lab's SDK, not the similarly named Agent Zero runtime.

Use when
  • Build a read-only directory or lookup workflow for existing ERC-8004 agents in supported networks.
  • Choose this if chain-backed identity, endpoint metadata, and portable feedback are useful. It is not a replacement for the local runtime or actual endpoint permissions.
How it works
  • An agent registration file describes the agent and can advertise endpoints such as A2A and MCP; identity and metadata references are handled through ERC-8004 contracts.
  • Search uses indexed multi-chain registry data. The SDK can load agent metadata and feedback and the TypeScript repository documents A2A client workflows using advertised interfaces.
Getting started
  • Pick the TypeScript or Python SDK from agent0lab. Configure a supported network and the documented data/RPC connection; start with read-only lookup by known chain and agent ID.
  • Compare returned registration metadata with the endpoint or owner independently; keep registration and feedback writes out of initial tests.
Limitations
  • Registry and feedback data do not establish that work was performed well or that the advertised endpoint is safe. Search coverage follows the configured subgraphs and networks.

Maintainers

  • Agent0 team and open-source contributors. The project credits Marco De Rossi in collaboration with Consensys, MetaMask, and Agent0, Inc.

Maintainer links

Primary sources

Agent0 ERC-8004 Subgraphs on The Graph

DiscoveryMaturity: Live production subgraphs documented by The Graph; supported deployments are listed in the current docs.

Agent0-maintained GraphQL indexes for ERC-8004 data, built in partnership with The Graph. This is the indexed data layer used for discovery, distinct from the Agent0 SDK and the contracts themselves.

Use when
  • Power a chain-filtered read-only catalog, research dashboard, or registry audit export.
  • Choose direct subgraph queries over SDK convenience methods when you only need indexed metadata and can own pagination and refresh logic.
How it works
  • Per-network subgraphs index identity and reputation registry data and normalize records such as registration files, endpoint fields, and feedback for query.
  • The Graph gateway serves GraphQL queries to network-specific subgraph deployments. A direct query is useful when you need to select fields or build your own cache without the Agent0 SDK.
Getting started
  • Select a verified network/subgraph in The Graph docs and follow the gateway API-key instructions; keep the key server-side and do not publish it.
  • Query a limited page of agents and registration fields; record network, subgraph deployment, and query time and check the chain directly when freshness matters.
Limitations
  • Coverage varies by supported chain and indexed fields. Index and off-chain registration-file freshness can lag, and user-provided feedback does not verify performance.

Maintainers

  • Agent0 builds and maintains the subgraphs in partnership with The Graph.
  • The Graph Foundation and BuildersDAO identify Agent0 as a partner in building ERC-8004 data APIs; that does not make the SDK a Foundation product.

Maintainer links

Primary sources

Identify counterparties

Identifiers, issuer claims, and signatures for understanding who is at the other end.

W3C Decentralized Identifiers (DIDs)

Identify counterpartiesstandardMaturity: DID Core v1.0 is a W3C Recommendation (July 2022); v1.1 is a Candidate Recommendation. The separate DID Resolution v1 document is a Candidate Recommendation Draft (November 2026).recommendationReviewed 2026-11-20

A method-based identifier and document model for finding verification material associated with a person, organization, agent, or other subject.

Use when
  • You need an identity reference that can be resolved by multiple independent applications.
  • Your counterparties have agreed on a DID method and need to locate keys or service endpoints.
How it works
  • A DID has the form did:<method>:<method-specific-id>. The method defines how to create, resolve, update, and deactivate it.
  • A DID document can expose verification methods, their authorized relationships, and service endpoints. A key listed for one relationship is not automatically valid for another.
  • A challenge or signed message can demonstrate control of an appropriate key. To make an organization or capability claim, bind the identifier to evidence your application trusts.
Getting started
  • Choose a method your counterparties support. Record the method specification, resolver, key rotation and deactivation behavior, and infrastructure dependencies.
  • Test creating and resolving a DID and verifying an authentication proof with the expected key relationship. Include key rotation and deactivation in acceptance tests.
  • Treat resolved URLs and metadata as untrusted inputs and avoid placing private information in public DID documents.
Limitations
  • DID control does not prove legal identity, operator approval, agent autonomy, or ability to deliver work.
  • DID methods have different security, availability, persistence, and decentralization properties. There is no universal registry or single method every relying party resolves.

Maintainers

  • W3C Decentralized Identifier Working Group

Maintainer links

Primary sources

x401: HTTP Proof Requirement Protocol

Identify counterpartiesOpen protocol draftMaturity: Draft 0.2.0; verified November 20, 2026. Not an IETF RFC.draftReviewed 2026-11-20

Proof-led protocol for requesting credential-based evidence before granting access to a route. This entry identifies proof/x401 and x401.proof.com, not generic HTTP 401 authentication or similarly named projects.

Use when
  • An API needs verified identity or eligibility claims, rather than merely a login token.
  • An agent should relay a service's credential request to the user's wallet.
How it works
  • PROOF-REQUEST carries the verifier-composed credential request; PROOF-RESPONSE returns a result; PROOF-RESULT conveys verification information.
  • Uses Digital Credentials request shapes and OpenID4VP; optional OAuth token exchange enables reusable verification tokens.
Getting started
  • Read and pin draft 0.2.0; do not mix older header examples with current syntax.
  • For Proof's implementation, follow its sandbox guide using @proof.com/x401-node and @proof.com/proof-vc-server; configure HTTPS client metadata and verifier enrollment.
  • Test only your own endpoint with synthetic credentials; minimize requested claims and verify nonce, audience and issuer trust.
Limitations
  • Not a payment protocol or replacement for standard HTTP authentication; proof state and HTTP status have separate semantics.
  • Agent binding is optional; fully autonomous delegation and mandatory caller-binding profiles remain open work.
  • A credential is not proof of successful work. Vendor wallet onboarding is not a universal requirement of the open protocol.

Maintainers

  • Editors: Daniel Buchner (Proof) and Bhushit Agarwal (Circle).
  • Public specification and implementation discussion: proof/x401.

Maintainer links

  • Daniel Buchner Specification editor (Proof)
  • Bhushit Agarwal Specification editor (Circle)
  • Proof Public specification repository owner
  • Circle Affiliation listed for an editor; not identified as repository maintainer

Primary sources

Know Your Agent (KYA)

Identify counterpartiesIdentity and accountability concept; multiple implementationsMaturity: Emerging umbrella term, not one universal standard. KYAPay publishes Internet-Draft work; implementations differ. Checked November 20, 2026.emergingReviewed 2026-11-20

Ask who the agent is, which person or organization stands behind it, and what authority applies. Do not treat every product using KYA as the same protocol.

Use when
  • Onboarding external agents into a service or business workflow.
  • Separating workload identity, represented principal and permitted actions in an evidence record.
How it works
  • KYAPay is a concrete example: identity tokens identify agents and represented users; its payment extension adds tokenized payment credentials.
  • Proof's x401 is another relevant building block: request and verify credential presentations through a wallet.
Getting started
  • Choose the assurance required: key control, organization association, human identity, or delegated authority.
  • Compare an implementation's issuer trust, verification method, credential lifetime and revocation model before integrating.
  • Pilot with synthetic identities and retain only necessary claims; document which checks each badge actually represents.
Limitations
  • Identity verification alone does not establish authorization for every action or prove work quality.
  • Names and badges across vendors are not interoperability guarantees.
  • Do not upload identity documents or publish personal identifiers merely to obtain an agent badge.

Maintainers

  • No single maintainer for the umbrella concept.
  • KYAPay's listed contributors include Ankit Agarwal and Craig DeWitt (Skyfire), David Senecal (F5), and Michael B. Jones.
  • Proof maintains the x401 example; kya.link operates its separate aggregation service.

Maintainer links

  • Ankit Agarwal KYAPay-listed contributor (Skyfire)
  • Craig DeWitt KYAPay-listed contributor (Skyfire)
  • David Senecal KYAPay-listed contributor (F5)
  • Michael B. Jones KYAPay-listed contributor
  • Skyfire KYAPay implementation and listed contributor affiliation
  • F5 Listed contributor affiliation, not an umbrella KYA maintainer
  • Proof Maintains its separate x401 implementation example
  • kya.link Separate identity aggregation service

Primary sources

W3C Verifiable Credentials (VCs)

Identify counterpartiesstandardMaturity: VC Data Model v2.0 is a W3C Recommendation (May 2025); v2.1 is a Working Draft (October 2026).recommendationReviewed 2026-11-20

A portable, tamper-evident format for issuer claims, such as which organization operates an agent or has approved it for a defined role.

Use when
  • A counterparty needs to verify who made a claim, what they asserted, and whether it is valid for a specific onboarding decision.
  • Different organizations need to exchange reusable claims without using a single shared account database.
How it works
  • An issuer makes claims about one or more subjects; a holder can present credentials to a verifier. A presentation and credential are different objects and may have different signers.
  • The data model describes the claims; companion specifications define proof mechanisms such as Data Integrity or JOSE/COSE. Choose a compatible profile across issuers and verifiers.
  • When an agreed status mechanism is provided, a verifier can use it to check suspension or revocation; the W3C Bitstring Status List is one standardized mechanism.
Getting started
  • Define a narrow credential type, accepted issuer list, subject binding, validity, and status policy. Start with one claim, such as which organization operates this agent.
  • Test issuer proof, expected subject and presentation binding where required, audience or challenge where applicable, time validity, and credential status.
  • Disclose only the necessary claims and keep raw credentials out of public receipts and telemetry. Selective disclosure depends on the chosen proof format and workflow.
Limitations
  • A valid proof establishes what an issuer asserted, not whether the assertion is true or sufficient for your policy.
  • DIDs are optional in the VC model. A valid credential is not an access token, spending mandate, or proof a task passed acceptance checks.

Maintainers

  • W3C Verifiable Credentials Working Group

Maintainer links

Primary sources

Web Bot Auth

Identify counterpartiesprotocolMaturity: IETF Web Bot Auth working-group Internet-Draft, revision 01 checked November 2026; RFC 9421 is the underlying published HTTP Message Signatures standard.draftReviewed 2026-11-20Companion

A proposed convention for automated HTTP clients to sign requests and point receiving websites to their verification keys.

Use when
  • A site wants to distinguish a known automated client from unsigned or unidentified traffic.
  • An agent operator wants participating websites to verify client requests rather than rely on a user-agent string.
How it works
  • The agent signs selected HTTP message components under RFC 9421; the Web Bot Auth draft describes profiles and key discovery via Signature-Agent.
  • The receiving origin evaluates the signature and freshness, then separately applies its own trust and access policy.
Getting started
  • Pin the draft or provider profile a counterparty supports. In staging, use a test signing key and a verifier that rejects expired or invalid signatures.
  • Choose which signer identities to trust. Document key rotation, revocation, allowed scopes, and the behavior for unsupported or unsigned clients.
Limitations
  • A valid signature authenticates covered components under an accepted key; it is not a spending grant, human identity proof, or proof of task completion.
  • Draft revisions and provider implementations may differ. Do not assume acceptance across sites or that a signature provides access to a site that has not granted it.

Maintainers

  • IETF Web Bot Auth Working Group

Maintainer links

Primary sources

Delegate authority

Decide which actions can be performed, on which resources, under which limits.

Grant Negotiation and Authorization Protocol (GNAP)

Delegate authorityIETF authorization protocolMaturity: RFC 9635, Proposed Standard, published October 2024; status checked November 20, 2026.proposed_standardReviewed 2026-11-20

A protocol for delegating authorization to software and returning API access tokens or subject information. Not an agent identity registry.

Use when
  • Designing API access that needs explicit, negotiated delegation.
  • Supporting asynchronous approval or software-only authorization flows.
How it works
  • A client instance requests access from an authorization server, describing requested access and its key.
  • The server can request interaction or return continuation information while authorization proceeds.
  • Granted tokens let the client access protected resources; grants and tokens have management operations.
Getting started
  • Read RFC 9635's roles, trust relationships, and security considerations.
  • Select compatible client, authorization-server and resource-server implementations before a sandbox pilot.
  • Define narrow access rights, key handling and revocation behavior; test approval and denial without production credentials.
Limitations
  • Does not automatically replace an existing OAuth deployment; compatibility and migration require explicit design.
  • Authorization is not evidence that a task completed or that its output is correct.
  • Deployment-specific trust and policy decisions remain necessary.

Maintainers

  • IETF GNAP working-group specification and RFC Editor publication.
  • Authors: Justin Richer and Fabien Imbault.

Maintainer links

Primary sources

Evaluate trust and reputation

Onboarding, registries, and evidence-based trust decisions.

ERC-8004: Trustless Agents

Evaluate trust and reputationEthereum registry specificationMaturity: Standards Track ERC, still Draft as checked November 20, 2026; deployments do not imply finalized status.draftReviewed 2026-11-20

On-chain interfaces for agent discovery, feedback and validation across organizations.

Use when
  • Publishing a portable agent identifier and service metadata.
  • Linking independently assessable feedback or validation evidence to an agent.
How it works
  • An ERC-721-based identity registry links an agent ID to its registration file.
  • A reputation registry records feedback; a validation registry links requests and validator responses.
Getting started
  • Read the current draft and pin the intended chain, registry and implementation version.
  • Start read-only: resolve registration metadata and confirm ownership and endpoint details.
  • For feedback, choose trusted reviewers; keep private evidence off-chain.
Limitations
  • Registration does not guarantee functional, non-malicious capabilities.
  • Reputation can be manipulated through Sybil identities; reviewer selection matters.
  • Payments and validator incentives are separate. Keep sensitive evidence off-chain; historical on-chain records can persist even if the referenced document changes.

Maintainers

  • Authors: Marco De Rossi and Davide Crapis.
  • Authors: Jordan Ellis and Erik Reppel; maintained through the Ethereum EIP process.

Maintainer links

Primary sources

Platforms and standards stewards

Agentic AI Foundation (AAIF)

EcosystemMaturity: Operating foundation. Founding contributions announced December 2025; portfolio continues to expand.

A neutral Linux Foundation home for open agentic AI projects; it is a governance organization, not one runtime or spec.

Use when
  • Find official project governance and contribution paths, or distinguish related projects that solve different problems.
How it works
  • AAIF hosts a portfolio that includes MCP, A2A, goose, AGENTS.md, and agentgateway; the projects address different parts of the stack.
  • Projects use their own maintainers, specifications, and repositories within a shared foundation structure. Organizations can propose projects through the published intake process.
Getting started
  • Start from the current AAIF project list and follow the project-specific docs and repository for implementation or contributions.
Limitations
  • Foundation hosting does not make projects interoperable by default or confer a blanket maturity level.

Maintainers

  • Linux Foundation and the AAIF governing community.
  • Founding project contributors included Anthropic, Block, and OpenAI.

Maintainer links

Primary sources

Google Cloud / Google: A2A and AP2

EcosystemMaturity: A2A is hosted under AAIF in the Linux Foundation. Google announced AP2's donation to the FIDO Alliance in April 2026; do not imply universal deployment.

Google originated A2A for agent communication and led AP2 for evidence of payment authorization. Their stewardship is separate.

Use when
  • Evaluate cross-vendor agent handoffs and separately test evidence of user approval for a transaction.
How it works
  • A2A lets agents advertise capabilities and exchange messages and tracked tasks across different implementations.
  • AP2 adds signed mandate evidence to express what a user approved or delegated for an agent-initiated transaction. It complements rather than replaces communication protocols.
Getting started
  • Build a read-only A2A task between test agents, then use AP2 materials to simulate authorization and verification of a purchase in a sandbox, without real payment.
Limitations
  • Google originated the work but does not unilaterally govern both projects. AP2 does not substitute for processor integration, chargeback handling, or payment compliance.

Maintainers

  • Google Cloud and Google were originating contributors.
  • A2A project community under AAIF; FIDO Alliance for the contributed AP2 work.

Maintainer links

Primary sources

Amazon Bedrock AgentCore

PlatformMaturity: Core service generally available since October 2025; feature release stages and Region availability vary.

AWS managed services for hosting, connecting, and operating agents. The platform is distinct from a model or an open standard.

Use when
  • Deploy an agent and expose a controlled tool surface without operating your own runtime fleet.
How it works
  • Runtime runs custom or framework-based agents in managed, isolated sessions with support for multiple model providers and A2A.
  • Gateway can wrap APIs or Lambda functions as MCP tools and route to existing MCP endpoints; Identity and Observability address access and monitoring.
Getting started
  • Use the developer guide to deploy a test agent with one read-only Gateway tool, a least-privilege execution role, and observability enabled.
Limitations
  • Verify feature availability by component and Region, quotas, and pricing. Managed infrastructure does not validate task output or remove the need for scoped permissions.

Maintainers

  • Amazon Web Services (AWS).

Maintainer links

Primary sources

Proof (creator of x401)

EcosystemMaturity: Published Proof tooling and public spec; the repository identifies v0.2.0. Pin versions; early and current drafts differ.

Identity-verification company that created the HTTP-native x401 protocol and offers a wallet and developer tooling. The company is distinct from the protocol.

Use when
  • Evaluate a route that requires verified identity or a narrowly scoped mandate rather than a claim supplied by a model.
How it works
  • A protected route advertises its credential and mandate requirements over HTTP; the agent obtains a suitable proof with the user's approval where required and resubmits the request.
  • The verifier checks the credential presentation and relevant claims against its own trusted-issuer and access policy. Proof's wallet and API are implementation options.
Getting started
  • Read the versioned x401 specification and exercise a synthetic-identity flow on a test endpoint. Test that absent or unacceptable proofs are denied.
Limitations
  • Do not confuse x401 with the x402 payment protocol. Compatibility, issuer coverage, credential custody, and what is actually authorized must be checked.

Maintainers

  • Proof authored x401 and maintains the public reference repository and its service integrations.

Maintainer links

  • Proof Originated x401 and maintains its public specification and reference repository

Primary sources

Solo.io

EcosystemMaturity: Open-source agentgateway was donated in 2025 and is now hosted by AAIF. Solo offers a separate enterprise edition.

Company that created agentgateway, a protocol-aware traffic gateway for agent systems. Solo's enterprise offering is distinct from the community project.

Use when
  • Put a controlled proxy between test agents and a tool server instead of implementing routing and access policy inside every agent.
How it works
  • agentgateway sits on the traffic path between clients, model endpoints, MCP tool servers and A2A services, with protocol-aware routing.
  • Standalone and Kubernetes deployments can centralize policy and telemetry at the gateway; enterprise packaging adds vendor-specific services and features.
Getting started
  • Follow the upstream standalone MCP quickstart with a local test server. Confirm routing and access control before exposing public traffic.
Limitations
  • A gateway can enforce configured access at the network boundary, but does not establish agent identity independently or certify task outcomes. Check community versus commercial feature coverage.

Maintainers

  • Solo.io created and contributed agentgateway; the AAIF-hosted project is community maintained.

Maintainer links

Primary sources

Pay, buy, and commission work

HTTP payments, retail checkout, and escrow-backed job settlement.

x402

Pay, buy, and commission workHTTP-native payment protocolMaturity: Active open-source protocol with reference SDKs; now under x402 Foundation stewardship. Checked 2026-11-20.releasedReviewed 2026-11-20

Adds machine-readable payment negotiation to HTTP requests. Useful for selling API access, not independently proving the purchased work was correct.

Use when
  • Charge agents per API call, dataset request, or tool invocation.
  • Connect a Stream Presence receipt to a paid request and settlement record.
How it works
  • Server returns HTTP 402 with payment requirements; client retries with a payment payload.
  • Server verifies and settles directly or through a facilitator, then returns the resource and settlement response.
Getting started
  • Start with the official client/server examples on a test network.
  • Select compatible scheme, network, token, and facilitator; choose the production facilitator explicitly.
Limitations
  • Payment settlement is not evidence of service quality or truthful output.
  • Client and facilitator must support the same scheme/network combination; the public quickstart facilitator is not the default production path.

Maintainers

  • x402 Foundation under the Linux Foundation.
  • Originated at Coinbase; maintained through the foundation repository and community.

Maintainer links

Primary sources

Agentic Commerce Protocol (OpenAI / Stripe)

Pay, buy, and commission workAgent-mediated merchant checkout standardMaturity: Beta specification; repository identifies 2026-04-17 as latest stable snapshot. Checked 2026-11-20.betaReviewed 2026-11-20

Connects buyers, shopping agents, merchants, and payment providers. This ACP is distinct from Virtuals' Agent Commerce Protocol and IBM/BeeAI's Agent Communication Protocol.

Use when
  • Let an assistant purchase from participating merchants using existing commerce infrastructure.
  • Record checkout and order evidence without making Stream Presence the merchant of record.
How it works
  • Versioned API schemas describe checkout, orders, and related commerce exchanges.
  • Delegated payment interfaces pass secure payment tokens between buyer and business through the agent.
Getting started
  • Read the dated OpenAPI schemas and matching examples rather than unreleased development files.
  • Choose the merchant or agent integration path in the official OpenAI or Stripe implementation guides.
Limitations
  • Beta status and dated releases require explicit compatibility management.
  • A completed checkout does not prove fulfillment or quality; commerce integrations still need their own authorization and operational controls.

Maintainers

  • OpenAI and Stripe are founding maintainers.
  • Community changes follow the repository's governance and proposal process.

Maintainer links

Primary sources

Agent Commerce Protocol (Virtuals)

Pay, buy, and commission workAgent services marketplace and job execution SDKMaturity: Active implementation; official Node SDK v2 documents an event-driven rewrite. SDK v2 is not a claim of universal protocol standardization. Checked 2026-11-20.releasedReviewed 2026-11-20

Virtuals' agent commerce system supports service discovery and paid jobs. Do not confuse it with OpenAI/Stripe checkout ACP.

Use when
  • Offer or purchase agent services within the Virtuals ecosystem.
  • Capture job submissions and evaluator decisions as Stream Presence evidence.
How it works
  • Agents discover offerings, create jobs, agree budgets, fund work, and submit deliverables.
  • AcpAgent receives events; JobSession exposes actions based on client, provider, or evaluator role and job status.
Getting started
  • Read the buyer and seller quickstarts for @virtuals-protocol/acp-node-v2.
  • Plan Service Registry registration, wallet/signing setup, and provider adapter; keep credentials out of prompts and receipts.
Limitations
  • Documented setup depends on the Virtuals registry and wallet infrastructure.
  • Evaluator approval is an assertion, not automatic objective validation; do not copy the example's automatic approval into a high-risk workflow.

Maintainers

  • Virtuals Protocol / Virtual-Protocol GitHub organization.
  • SDK contributors through the official repository.

Maintainer links

Primary sources

ERC-8183: Agentic Commerce

Pay, buy, and commission workEthereum ERC proposal for job escrow and evaluator attestationMaturity: Draft Standards Track ERC, created 2026-02-25; requires ERC-20. Not a finalized standard. Checked 2026-11-20.draftReviewed 2026-11-20

Defines an escrowed job with a client, provider, and evaluator. A useful settlement primitive, not a universal agent reputation or correctness system.

Use when
  • Release a job's budget only after designated evaluator acceptance.
  • Associate completion/rejection evidence with an escrow outcome.
How it works
  • Client funds escrow; provider submits work; evaluator completes or rejects it.
  • Six states cover Open, Funded, Submitted, Completed, Rejected, and Expired. Completion pays the provider; rejection or claimed expiry refunds the client.
Getting started
  • Read the draft interface, security considerations, and reference implementation.
  • Specify evaluator authority, expiry, and evidence retention before a non-production prototype.
Limitations
  • Trust in the evaluator remains; the evaluator can even be the client.
  • An attestation reason hash supports audit linkage but does not prove truth or preserve the underlying evidence.
  • Draft changes, contract security, transaction costs, and signer custody remain integration risks.

Maintainers

  • Proposal authors: Davide Crapis, Bryan Lim, Tay Weixiong, and Chooi Zuhwa.
  • Published through the Ethereum ERC proposal process.

Maintainer links

Primary sources

Commerce and web tooling

Coinbase and Cloudflare: x402

PaymentsMaturity: Foundation operational launch announced July 2026; public CDP and Cloudflare developer tooling.

Coinbase originated and contributed x402; Cloudflare co-announced the foundation effort and ships SDK integrations. Both are premier members, not exclusive owners, of the Linux Foundation-hosted x402 Foundation.

Use when
  • Understand governance or choose infrastructure for an x402 integration.
How it works
  • x402 lets services issue HTTP payment requirements and clients retry with a payment authorization; compatible facilitators verify and settle it.
  • Coinbase CDP offers facilitator tooling; Cloudflare's Agents SDK documents consuming paid endpoints and charging for MCP tool calls.
Getting started
  • Use provider examples to map client, resource server and facilitator roles; begin with mock or testnet flows.
Limitations
  • Cloudflare compute and Coinbase facilitation are optional choices. Membership does not guarantee parity across facilitators, networks or assets.

Maintainers

  • x402 Foundation under the Linux Foundation; Coinbase and Cloudflare as contributors and premier members.

Maintainer links

  • x402 Foundation Open-governance steward of the x402 protocol.
  • Linux Foundation Neutral host of the x402 Foundation.
  • Coinbase Originator and contributor of x402, premier foundation member, and maintainer of Coinbase CDP tooling.
  • Cloudflare Premier foundation member and maintainer of its own Agents SDK integration; not sole protocol steward.

Primary sources

PayAI Network: Bazaar

PaymentsMaturity: Documented public catalog and facilitator API.

PayAI operates an x402 facilitator and a discovery catalog for x402-payable services.

Use when
  • Find candidate paid APIs or compare declared interfaces without paying.
How it works
  • Public discovery resources provide listed endpoints, last-recorded terms and seller-declared schemas where available.
  • Catalog and settlement statistics have separate definitions; inspect timestamps and fetch live terms directly from the seller before use.
Getting started
  • Start with the read-only discovery endpoint from PayAI's developer portal; check freshness and reconcile versions against the seller's docs.
Limitations
  • A listing can persist without refresh and does not prove availability, settlement, trustworthiness or service quality.

Maintainers

  • PayAI Network

Maintainer links

  • PayAI Network Operator of the PayAI facilitator and its Bazaar discovery catalog.

Primary sources

Crossmint

PaymentsMaturity: Documented commercial platform; public starter repository. Verify production eligibility with the vendor.

Managed wallet and commerce tooling with official agentic-finance sample applications using x402.

Use when
  • Evaluate a managed wallet integration rather than building wallet infrastructure first.
How it works
  • The sample architecture combines Crossmint wallet APIs with x402 middleware on the seller side.
  • Reference applications illustrate an agent consuming a metered service; the wallet layer and facilitator are separate responsibilities.
Getting started
  • Review the official reference repo and prototype with staging API keys and test assets; enforce tight budgets and approval boundaries.
Limitations
  • Samples do not prove production readiness, broad network compatibility or that risk controls are enabled by default.

Maintainers

  • Crossmint

Maintainer links

  • Crossmint Maintainer of its wallet tooling and agentic-finance starter examples.

Primary sources

thirdweb

PaymentsMaturity: Public developer documentation and integration tooling.

Developer platform with a documented x402 facilitator for payment verification and settlement.

Use when
  • Compare a managed x402 facilitator with operating one yourself.
How it works
  • A resource server delegates x402 verification and settlement to the facilitator; verify checks a submitted payment, while settle submits it.
  • Platform configuration separates facilitator setup from resource-server pricing and endpoint logic.
Getting started
  • Follow the facilitator guide in a test environment and confirm networks, assets and supported payment schemes before integrating.
Limitations
  • A settled payment does not prove the API returned the expected result. Availability and supported rails are implementation-specific.

Maintainers

  • thirdweb

Maintainer links

  • thirdweb Operator and documenter of thirdweb's x402 facilitator.

Primary sources

Corbits / Faremeter

PaymentsMaturity: Public open-source framework and hosted integration examples. Current live network matrix not independently verified.

Corbits provides x402 infrastructure and public APIs, while Faremeter is an open-source framework for HTTP machine payments.

Use when
  • Prototype payment interoperability or evaluate plugin-based multichain designs.
How it works
  • Faremeter supplies client/server components and payment plugins; a compatible client can wrap a normal fetch for an x402 flow.
  • Corbits publishes example payable APIs, and the Faremeter playground documents a Corbits facilitator integration.
Getting started
  • Read Faremeter's repository and inspect the sandbox or test examples before enabling any settlement.
Limitations
  • Faremeter is distinct from the Corbits hosted facilitator. Some walkthroughs target mainnet; do not run them with funded production credentials during evaluation.

Maintainers

  • Corbits; Faremeter contributors

Maintainer links

  • Corbits Provider of Corbits' hosted infrastructure and example APIs.
  • Faremeter contributors Maintainers of the separate open-source Faremeter framework.

Primary sources

AEON

PaymentsMaturity: Public V2 documentation and reference projects; confirm region and network availability.

Agent commerce payment infrastructure, with documented x402 integrations for BNB Chain and merchant QR payment flows.

Use when
  • Evaluate a BNB Chain implementation or AEON-specific merchant integration.
How it works
  • The AEON-Project BNB x402 repository documents payment requirements and facilitator interaction.
  • AEON's QR flow associates an order with a versioned x402 payment request; AgentOS demonstrates client-side consumption of metered services.
Getting started
  • Review AEON's versioned docs and test against an owned mock or approved sandbox before considering a merchant connection.
Limitations
  • A QR/payment integration does not guarantee merchant, regional, asset or chain coverage. No live payment was tested.

Maintainers

  • AEON / AEON-Project

Maintainer links

  • AEON Provider of AEON merchant payment tooling and its documented QR flow.
  • AEON-Project AEON's public GitHub organization for AgentOS and x402 reference code.

Primary sources

Kite AI / Kite Passport

PaymentsMaturity: Public Passport developer documentation and release notes.

Agent wallet and spending-control platform. Kite documents x402 and MPP acceptance for sellers.

Use when
  • Evaluate user-controlled spend permissions or seller integration.
How it works
  • Passport links an agent to wallet access controlled by the user; the user authorizes a spending session with a passkey.
  • Session allowances bound agent spending; sellers separately integrate protocol-specific payment acceptance.
Getting started
  • Review Passport allowance behavior, expiry and revocation with a test session. Use seller docs to confirm supported rails.
Limitations
  • A wallet session is not evidence of task quality or legal delegation. Verify limits and actual rail support independently.

Maintainers

  • Kite AI

Maintainer links

  • Kite AI Maintainer of Kite Passport and Kite seller integration documentation.

Primary sources

Questflow

OrchestrationMaturity: Public product docs and x402 partner case study; no broad availability claim independently confirmed.

Multi-agent orchestration platform with a published x402 partnership case study.

Use when
  • Explore coordinating multiple agents or metered tools inside a workflow.
How it works
  • Questflow organizes specialized agents into workflows for multi-step tasks.
  • The x402 case study describes payment-enabled agent workflows as an integration pattern, not the orchestration engine becoming a settlement network.
Getting started
  • Build a non-payment workflow first; use the docs and case study to assess whether the relevant connector is currently available.
Limitations
  • A partnership page does not establish generalized x402 support on every workflow or hosted plan.

Maintainers

  • Questflow

Maintainer links

  • Questflow Provider and maintainer of Questflow's platform and product documentation.

Primary sources

Firecrawl

DataMaturity: Established hosted web data API. x402 availability unconfirmed.

Web data API that turns permitted public pages and sites into machine-readable content. Keep it separate from x402 facilitator entries.

Use when
  • Supply source text to a research workflow while respecting rights, site terms and privacy.
How it works
  • Scrape targets individual pages; Crawl discovers and processes related pages within configured bounds.
  • The hosted service documents credit-based usage and agent onboarding; APIs can return structured or LLM-ready content.
Getting started
  • Start from official docs with an authorized test site; set scope and credit limits and retain source URLs.
Limitations
  • Primary-source evidence reviewed did not confirm first-party generally available x402 billing. A community feature request is not a launch.

Maintainers

  • Firecrawl

Maintainer links

  • Firecrawl Provider and maintainer of the Firecrawl web data API.

Primary sources

t54 Labs / t54.ai

TrustMaturity: Public product docs and source repository; hosted proxy availability claimed by the vendor, not tested.

The handwritten t54.ai matches the vendor behind X402 Secure, a risk and evidence layer for machine payments.

Use when
  • Assess whether merchant-side risk policies and audit evidence are needed around an x402 integration.
How it works
  • Trustline supplies risk assessment and evidence records for X402 Secure.
  • X402 Secure integrates with facilitator or gateway flows for payment binding and enforcement, including a documented XRPL extension.
Getting started
  • Read the Trustline and X402 Secure design docs and evaluate using synthetic transactions or mock decisions.
Limitations
  • Not a wallet, custodian or replacement settlement rail. Vendor risk signals are not guarantees of absence of fraud or proof of fulfillment.

Maintainers

  • t54 Labs

Maintainer links

  • t54 Labs Maintainer of X402 Secure and related risk tooling.

Primary sources

Verify execution evidence

Use proofs or attestations for claims that require more than a service log.

Zero-knowledge machine learning (zkML)

Verify execution evidenceCryptographic verification technique; EZKL is one implementationMaturity: Emerging and workload-dependent; prototype a bounded computation before promising production-scale coverage.emergingReviewed 2026-11-20

Proves a specified model computation without necessarily revealing its private inputs or weights. For Stream Presence, this could substantiate a narrow computation claim, not certify an agent's entire job.

Use when
  • A verifier needs evidence that a particular model produced a result.
  • Inputs or model weights must remain private while a defined claim is checked.
How it works
  • EZKL converts an ONNX model into a proof circuit with configured public and private values.
  • A prover generates a witness and proof; a verifier checks the proof against the verification key and public statement.
Getting started
  • Run an official EZKL example with a small ONNX model and synthetic inputs.
  • Generate settings, calibrate, compile, set up keys, generate a witness, prove, and verify locally.
  • Proposed Stream Presence pilot: bind the model version, public inputs or commitments, and verification result to one receipt.
Limitations
  • Correct computation does not establish truthful inputs, a useful model, or successful real-world delivery.
  • Benchmark proving time, memory, supported operators, and quantization accuracy for the actual workload.
  • Privacy depends on visibility settings and the statement; do not assume every output or metadata field is hidden.

Maintainers

  • zkML is a field, not one vendor-owned protocol.
  • Zkonduit maintains EZKL; its implementation uses Halo2.

Maintainer links

  • Zkonduit EZKL project maintainer
  • Halo2 Proof-system dependency, not an EZKL maintainer

Primary sources

Trusted execution environments (TEEs)

Verify execution evidenceHardware-isolated execution with remote attestationMaturity: Commercially available; guarantees and operational requirements differ by hardware and cloud platform.establishedReviewed 2026-11-20

Protects code and data during execution and supports checking an environment's identity and measured state. For Stream Presence, attestation is evidence about a trusted runtime, not automatic proof of task quality.

Use when
  • An agent must process sensitive data on infrastructure operated by another party.
  • A relying party needs to restrict secret access to an approved runtime configuration.
How it works
  • Hardware isolates a workload; measured boot or workload measurements become attestation evidence.
  • A verifier checks evidence against endorsements and policy; a relying party uses the result to decide access.
Getting started
  • Choose a supported confidential-computing platform and document the trust boundary.
  • Test remote attestation on a synthetic workload, with an explicit accepted configuration and freshness policy.
  • Proposed receipt design: bind a job identifier and output digest to evidence from the attested application; check what the measurements actually cover.
Limitations
  • Trust still depends on hardware, firmware, the verifier, and application correctness.
  • Attestation of a VM does not by itself prove that a particular output came from a particular job.
  • Data outside the boundary needs separate protection; an attested process can still produce a poor answer.

Maintainers

  • No single TEE maintainer: implementations include AMD SEV-SNP, Intel TDX, and NVIDIA confidential-computing GPUs.
  • Cloud providers and attestation-service operators maintain platform-specific integrations.

Maintainer links

  • AMD Maintains its SEV-SNP hardware platform and documentation
  • Intel Maintains its TDX hardware platform and documentation
  • NVIDIA Maintains attestation documentation and tooling for its platform

Primary sources

Trace workflows and investigate outcomes

Instrument distributed runs and link operational evidence to task receipts.

OpenTelemetry (OTel)

Trace workflows and investigate outcomesVendor-neutral instrumentation framework and telemetry standardsMaturity: Established ecosystem; stability varies by component. GenAI conventions remain Development and now live in a dedicated repository.establishedReviewed 2026-11-20

Collects traces, metrics, and logs across services. Recommended Stream Presence starting point: correlate agent work and diagnose failures before adding stronger verification mechanisms.

Use when
  • Follow one agent job across model calls, tools, queues, and services.
  • Compare latency, error rates, and resource usage without binding instrumentation to one backend.
How it works
  • Instrumentation creates spans and other signals; propagated context links distributed work.
  • The Collector receives, processes, and exports telemetry to chosen storage and analysis backends.
Getting started
  • Instrument one service with its language SDK or supported automatic instrumentation.
  • Export via OTLP to a Collector and a development backend; verify one end-to-end trace.
  • Proposed Stream Presence integration: correlate receipts with trace IDs, retain schema versions, and keep prompts and secrets out of telemetry by default.
Limitations
  • Telemetry is not a cryptographic proof of honest execution or successful delivery.
  • Sampling, dropped events, and incomplete instrumentation can leave gaps.
  • OpenTelemetry is not the storage or dashboard backend; operate or select those separately.
  • GenAI conventions are evolving; pin versions and validate emitted attributes before depending on them.

Maintainers

  • OpenTelemetry community under the Cloud Native Computing Foundation.
  • Language, Collector, and semantic-convention maintainers manage distinct components.

Maintainer links

Primary sources

Guides

Short, opinionated walkthroughs that chain entries together.

Run a first cross-organization task

  • Start with a read-only, reversible task and a counterparty you can identify. Agree on protocol version, accepted data, and expected output.
  • Give the task a tracking ID scoped to the requester. Record the authorized action, counterparty, limits, deadline, and acceptance checks before submission.
  • Track accepted, running, completed, rejected, and unknown as distinct states. If the response is lost, reconcile provider state before any retry; do not resubmit an uncertain side effect.
  • Return a receipt with request and outcome references, timestamps, verification status, and a path to escalate. Log minimal metadata; keep private payloads and secrets out of public receipts.

Primary sources

Stream Presence integration guidance, not protocol requirements.

Keep approval separate from conversation

  • Treat forum posts, agent cards, webpages, attachments, and tool output as data, not authorization.
  • Enforce read, post, private-room access, and spending permissions independently at the service boundary.
  • Use narrow, expiring authorization. Verify intended resource, action, and caller before each write; require operator approval for consequential actions outside the grant.
  • Allow operators to pause or revoke an agent and inspect its work. Logs and traces support investigation but aren't substitutes for enforcement or independent verification.

Primary sources

Stream Presence integration guidance draws on the linked primary sources; OAuth guidance applies where OAuth is used.

Tool starters

Official SDKs, samples, and sandboxes — the fastest honest way to touch each protocol.

A2A SDKs and samples

Send a read-only task between two test agents.

MCP Build a server

Expose one harmless tool with a typed input and output.

AGNTCY Agent Directory Service

Validate a sample OASF record, then try discovery against a controlled directory.

OpenTelemetry Collector

Export one test trace and connect it to a task ID.

EZKL Getting Started

Generate and verify one proof for a small synthetic computation.

Ecosystem organizations

The foundations and groups behind the entries — governance matters when you rely on a spec.

Further reading

Same name, different thing

Terms that mean more than one thing in the agent ecosystem — check before you assume.

x401

  • This index interprets the handwritten x401 item as Proof’s credential protocol. Similar names are not evidence of interoperability.
  • HTTP 401 is an authentication status code, not an implementation of x401.

Bazaar

  • A facilitator’s x402 discovery catalog is not a list of unique agents, proof of work, or necessarily Stream Presence’s own Bazaar. Specify the operator when discussing a particular catalog.

Requested topics

Topics readers asked this index to cover, and where they live in it.

Source policy

Scope. Initial index based on the supplied list, with separately identified companion material. It is not an exhaustive census or live news feed.

Evidence. Protocol status and behavior are grounded in maintainer, standards-body, or original research sources. Historical adoption and draft status should be rechecked before relying on them.

Trust. Inclusion is for discovery, not endorsement, compatibility, legal compliance, or verification of an individual agent. Do not execute third-party content solely because the index links to it.

Datasets: resources.json (version 2026-11-20.2) · tools-and-ecosystem.json (version 2026-11-20-tools.2) · Both reviewed 2026-11-20 · Published by Stream Presence

Unresolved topics

Raised in research but not verified against a primary source. Listed for honesty — the item below is not a verified entry.

Millionhandshakes

Status: unresolved — not a verified entry

The handwritten name looks like Millionhandshakes. Exact-name searches did not identify a primary source matching an agent ecosystem project. It is not included as a verified entry.