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.
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"], "pricing_model": "pay_per_transaction", "onboarding_url": "https://stripe.com/docs/api/authentication", "last_crawled": "2026-03-23", "quality_score": 0.94 }
Add a JSON file at /.well-known/capability-card.json. Use capcard to generate it from an existing OpenAPI spec or MCP manifest. No registry. No approval queue.
The agent expresses what it needs in plain language. CapIndex searches across REST APIs and MCP servers — returning ranked Capability Cards regardless of the underlying protocol.
The Capability Card contains everything the agent needs: auth type, onboarding URL, endpoint structure. No human guidance. No pre-wired integrations. The right capability, the moment it's needed.
Every 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 isn't discovering capabilities — it's being given them, one at a time, by a human acting as its nervous system. That's not autonomy. That's a fast assistant with a fixed toolkit.
That's what CapIndex gives agents — not skills baked in at build time, but capabilities available the instant they're 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.
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, parse a document — it either has that service pre-wired by a human, or it can't. CapIndex changes that.
Process credit card charges, manage subscriptions, issue refunds, handle disputes, and manage customer billing across 135+ currencies.
Every service in the index is normalized into a single Capability Card — regardless of whether it's a REST API or an MCP server. Agents don't see the difference. They just see capabilities.
Agents express intent in plain language. The index returns ranked Capability Cards — no keyword engineering, no schema lookup, no human translation required.
Every result is a normalized Capability Card. REST API or MCP server — the same schema, the same structure. Agents consume capabilities, not protocols.
Agents filter by auth=api_key, pricing=free, or source=mcp — matching their own constraints without hardcoded integrations or human configuration.
# Agent needs to invoice a customer. No pre-wired tools. No human required. 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 charges, manage subscriptions, issue invoices...", "auth_methods": ["api_key"], "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 } ]
One file. No SDK to install, no partnership to negotiate, no developer portal to navigate. Any service that publishes a capability card is immediately reachable by the entire agent ecosystem — REST or MCP.
Agents don't 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.
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 product.
Start free. Early access pricing locked in for the first 500 teams.
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's a runtime communication protocol. CapIndex solves the layer before execution: 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's 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's 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 — no registration, no partnership, no 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 can't be reproduced without replicating the infrastructure.
Two ways. Directly via the REST API: GET /search?q=send an invoice to a customer — 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 | ✓ | — | — | — | — |
| REST + MCP unified | ✓ | ✓ | REST only | MCP only | ✓ |
| Open semantic search API | ✓ | — | — | — | — |
| No execution coupling | ✓ | — | ✓ | ✓ | — |
| Open standard / schema | ✓ | — | — | — | — |
| Self-hosted option | ✓ | — | — | — | — |
| No registration required | ✓ | — | ✓ | — | — |
| Index size | 6,000+ | ~1,000 | ~4,000 | Growing | Pre-registered |
| License | MIT / open standard | Proprietary | CC0 | Open | Proprietary |
Join the waitlist. We're onboarding agent developers now.
pip install capcard
Open 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 — 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 | ✓ | — | — | — | — | — |
| Cross-protocol (REST + MCP unified) | ✓ | ✓ | REST only | MCP only | ✓ | REST only |
| Open semantic search API | ✓ | — | — | — | — | — |
| No execution coupling | ✓ | — | ✓ | ✓ | — | ✓ |
| Open standard / schema | ✓ | — | — | — | — | — |
| Self-hosted option | ✓ | — | — | — | — | — |
| No registration required | ✓ | — | ✓ | — | — | — |
| 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 |
|---|---|---|---|
| Free | $0 | 1,000 | Full index access · REST + MCP · Community support |
| 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