APIs and MCP servers are both capabilities, services an agent can call to act in the world. CapIndex is the protocol that makes them discoverable. One file, on any domain. No registry. No gatekeepers.
Google made PageRank for the web. CapIndex is made for the agentic API world.
A capability is anything an agent can call to do work in the world. It might be a REST API. It might be an MCP server. The protocol is an implementation detail. CapIndex normalizes both, and whatever the ecosystem ships next, into a single, machine-readable Capability Card, published directly on the service's domain. REST API and MCP server are treated identically.
{ "id": "stripe-payments", "source_type": "openapi", "source_url": "https://stripe.com/openapi.yaml", "semantic_summary": "Process credit card charges, manage subscriptions, issue refunds, handle disputes, and manage customer billing across 135+ currencies.", "capability_tags": ["payments", "billing", "subscriptions", "refunds"], "use_cases": [ "Charge a customer's credit card", "Issue a refund for a transaction", "Create a recurring subscription" ], "auth_methods": ["api_key", "oauth2"], "human_signup_required": true, "sandbox_available": true, "pricing_model": "pay_per_transaction", "onboarding_url": "https://stripe.com/docs/api/authentication", "last_crawled": "2026-03-23", "quality_score": 0.94 }
pip install capcardpipx install capcarduv tool install capcardgit clone https://github.com/Capability-Index/capcardEvery new capability requires a human to find it, install it, configure it, and hard-code it in.
Today, agent developers hand-pick every tool their agent can use. They write the integration, wire in the credentials, deploy the update. The agent is not discovering capabilities, it is being given them, one at a time, by a human acting as its nervous system. That is not autonomy. That is a fast assistant with a fixed toolkit.
That is what CapIndex gives agents, not skills baked in at build time, but capabilities available the instant they are needed. Any REST API. Any MCP server. Discovered at runtime, on demand, without a human in the loop. The right tool, exactly when the job requires it.
One file. No SDK to install, no partnership to negotiate, and no developer portal to navigate. Any service that publishes a capability card is immediately reachable by the entire agent ecosystem, whether it is REST or MCP.
Agents do not browse documentation. They query indexes. CapIndex is the missing trust layer between any existing service and the agentic web, a ground truth agents can rely on without human translation. Publishing a capability card also helps your API show up where agents are looking, which creates organic agentic traffic for your product.
MIT licensed. No vendor lock-in. The schema is published, versioned, and open to contribution. No central authority controls who is discoverable. This is infrastructure, not a gated directory.
CapIndex ingests OpenAPI and MCP metadata, or a provider publishes /.well-known/capability-card.json. No manual registry is required.
The agent describes the job to be done. CapIndex ranks matching capabilities across REST APIs and MCP servers using one retrieval surface.
The app surface exposes trust tier, verification status, signup requirements, sandbox readiness, and policy filters before a team allows agent access.
The selected record gives the agent a concrete connection path: auth method, signup URL, rate limits, onboarding docs, and known gotchas for first call success.
An agent can reason, plan, and execute the skills it already knows. But the moment it needs to act in the world, charge a card, send a message, or parse a document, it either has that service pre-wired by a human, or it cannot. CapIndex changes that.
Process credit card payments, manage subscriptions, issue refunds, and handle customer billing with API-key and OAuth2 auth.
Every service in the index is normalized into a single Capability Card, regardless of whether it is a REST API or an MCP server. Agents do not see the difference. They just see capabilities.
Agents and operators search by job-to-be-done, not by vendor name. The system returns ranked Capability Cards with standardized fields.
Results are not just relevant. They are explainable: trust tier, verification status, ownership claim state, and connection friction are part of the product.
Twilio-style records can expose auth=api_key, human_signup_required=false, sandbox support, and onboarding paths up front so operators can approve messaging actions before an agent sends the first SMS.
# Agent needs to invoice a customer. No pre-wired tools. search_capabilities("send an invoice to a customer") # Returns ranked Capability Cards. REST APIs and MCP servers, unified. [ { "id": "stripe-payments", "source_type": "openapi", # REST API "semantic_summary": "Process credit card charges, create invoices, issue refunds, and manage subscriptions...", "auth_methods": ["api_key", "oauth2"], "human_signup_required": true, "quality_score": 0.94 }, { "id": "quickbooks-mcp", "source_type": "mcp", # MCP server, same schema "semantic_summary": "Create, send, and track invoices. Sync with accounting...", "auth_methods": ["oauth2"], "quality_score": 0.87 } ]
Early access pricing for teams deploying agents in production, plus a self-hosted enterprise path.
CapIndex is an open protocol and hosted search index that enables AI agents to discover REST APIs and MCP servers by describing what they need in plain language. Each service in the index has a Capability Card, a structured JSON object containing an LLM-generated semantic summary, use cases, auth methods, and an onboarding URL.
Agents query CapIndex at runtime to find the right capability for a task, without any pre-wired integrations or human configuration required.
MCP (Model Context Protocol) defines how an agent executes actions against a server. It is a runtime communication protocol. CapIndex solves the layer before execution, which is how an agent discovers which server to connect to in the first place.
They're complementary. An agent uses CapIndex to find the right MCP server, then uses MCP to interact with it. CapIndex also indexes REST APIs (OpenAPI), so agents can discover services that aren't yet MCP-enabled.
Composio provides pre-built, execution-coupled integrations for roughly 1,000 curated services. Agents use Composio to execute actions through Composio's servers. It is an integration platform with an execution layer.
CapIndex is an open index of 6,000+ services returning only metadata. It has no execution layer. Agents use CapIndex to discover services, then connect directly using the service's own API. CapIndex is infrastructure; Composio is a middleware product.
APIs.guru provides raw OpenAPI spec files with no semantic enrichment. It is a repository of machine-readable spec files. CapIndex takes those specs as input, runs them through an LLM enrichment pipeline to generate semantic summaries and use cases, and stores the enriched records in a vector database for natural language search.
APIs.guru is actually a primary data source for CapIndex, not a competitor.
A machine-readable JSON file published at a predictable URL on any domain, following the IETF RFC 8615 well-known URI standard. Any REST API or MCP server can publish one to declare their capabilities to AI agents and automated crawlers.
CapIndex crawls these files across the web automatically. Publishing a capability-card.json at this path makes a service passively discoverable by any agent or crawler that follows the standard, with no registration, partnership, or approval process required.
The tools are open source. The index is not. Specifically:
Open source (MIT): the Capability Card JSON schema, the capcard CLI tool that generates records from OpenAPI specs, and the capindex-mcp-server for searching a local set of records.
Proprietary: the hosted index (6,000+ crawled, validated, enriched records), the enrichment pipeline prompts, the ranking logic, and the crawler infrastructure. The moat is the index. Anyone can fork the tools, but 18+ months of crawled records cannot be reproduced without replicating the infrastructure.
Two ways. Directly via the REST API: GET /search?q=send an invoice to a customer, which returns ranked Capability Cards as JSON. Or via the MCP tool search_capabilities(), which wraps the same endpoint for use inside MCP-compatible agent frameworks.
Optional filters let agents match their own constraints without human configuration: ?auth=api_key, ?pricing=free, ?source=mcp.
Install the CLI: pip install capcard. Run capcard enrich <your-openapi-url>. It generates a Capability Card JSON from your existing spec. Publish that file at https://yourdomain.com/.well-known/capability-card.json.
CapIndex crawls the web and will find it. Manual submission via POST /submit accelerates initial indexing if you want it indexed faster.
CapIndex is the only index that combines LLM-enriched semantic summaries, cross-protocol coverage (REST + MCP), and an open search API, with no execution coupling.
| CapIndex | Composio | APIs.guru | MCP Registry | AWS AgentCore | |
|---|---|---|---|---|---|
| LLM-enriched semantic summaries | ✓ | N/A | N/A | N/A | N/A |
| REST + MCP unified | ✓ | ✓ | REST only | MCP only | ✓ |
| Open semantic search API | ✓ | N/A | N/A | N/A | N/A |
| No execution coupling | ✓ | N/A | ✓ | ✓ | N/A |
| Open standard / schema | ✓ | N/A | N/A | N/A | N/A |
| Self-hosted option | ✓ | N/A | N/A | N/A | N/A |
| No registration required | ✓ | N/A | ✓ | N/A | N/A |
| Index size | 6,000+ | ~1,000 | ~4,000 | Growing | Pre-registered |
| License | MIT / open standard | Proprietary | CC0 | Open | Proprietary |
pip install capcardpipx install capcarduv tool install capcardgit clone https://github.com/Capability-Index/capcardOpen standard and hosted index for agent-discoverable capabilities. Any REST API or MCP server can be discovered by AI agents using natural language, without pre-configuration, human mediation, or execution coupling.
CapIndex is the semantic discovery layer for the agentic web. Today, every capability an agent uses must be pre-wired by a human: found, evaluated, configured, credentialed, and hard-coded before the agent can use it. This creates a ceiling on agent autonomy, because agents can only act within the toolkit a human assembled in advance.
CapIndex breaks this ceiling. Any REST API or MCP server can publish a Capability Card at a predictable URL on their domain. CapIndex crawls these records, enriches them with LLM-generated semantic summaries, and makes them queryable by natural language. Agents discover capabilities at runtime, on demand, without a human in the loop.
The protocol is agnostic to execution. CapIndex returns metadata only. It does not proxy, route, or execute API calls. Index everything, execute nothing.
The atomic unit of the protocol. A JSON object published at /.well-known/capability-card.json on any domain. REST APIs and MCP servers use the same schema.
| Capability | CapIndex | Composio | APIs.guru | MCP Registry | AWS AgentCore | Nexus-AGI |
|---|---|---|---|---|---|---|
| LLM-enriched semantic summaries | ✓ | N/A | N/A | N/A | N/A | N/A |
| Cross-protocol (REST + MCP unified) | ✓ | ✓ | REST only | MCP only | ✓ | REST only |
| Open semantic search API | ✓ | N/A | N/A | N/A | N/A | N/A |
| No execution coupling | ✓ | N/A | ✓ | ✓ | N/A | ✓ |
| Open standard / schema | ✓ | N/A | N/A | N/A | N/A | N/A |
| Self-hosted option | ✓ | N/A | N/A | N/A | N/A | N/A |
| No registration required | ✓ | N/A | ✓ | N/A | N/A | N/A |
| Index size | 6,000+ | ~1,000 | ~4,000 | Growing | Pre-registered | ~133 |
| License | MIT / open | Proprietary | CC0 | Open | Proprietary | Unknown |
| Tier | Price | Queries / month | Notes |
|---|---|---|---|
| Pro | Early access | Unlimited | Priority ranking · Email support · Founding pricing for first 500 teams |
| Enterprise | Contact | Unlimited | Self-hosted · Custom data sources · SLA · Air-gapped deployment |
CapIndex Protocol, open standard, MIT licensed · capindex.dev · Schema · GitHub · Spec · llms.txt