Open Protocol · v1.0
The Unfragile Capability Protocol
DNS, ranking, and trust for the agent economy. Builders publish unfragile.yml. Agents resolve capability:// URIs. A trust passport backs every match. The graph learns from every interaction.
Manifest schema v1.0 · Trust Passport v1.0 · Open, permissively licensed
What it is
The Unfragile Capability Protocol is the open standard for describing what AI artifacts do, under what conditions they work, what they cost, what permissions they need, and how they fail. It has two stable contracts and one stable identifier:
- unfragile.yml — what a builder publishes alongside their artifact. Identity, capabilities, conditions, trust, pricing, permissions, failure modes, compliance, and execution.
- Trust passport — what Unfragile returns at
/api/v1/passport/[slug]. A machine-readable summary including observed outcomes from the match graph. - capability:// URI — a stable identifier for a capability (e.g.
capability://database.postgres.query.readonly). Agents resolve these to ranked artifacts with current trust signals.
The schemas are open. Unfragile's role is the intelligence layer on top — matching, ranking, learning. Neutrality is the moat: we never compete with what we distribute.
Why it matters
Every previous platform shift had a distribution layer that captured value through a two-sided graph: DNS + ranking + trust for the web (Google), App Store for mobile, OAuth for SaaS. The agent economy needs the same primitives at the capability layer.
Today, agents discover capabilities the way humans discovered websites in 1996 — by guessing. Search results aren't trust-aware. Permissions aren't machine-readable. Failure modes are tribal knowledge. The graph that resolves intent → capability → artifact with confidence and outcome history doesn't exist as a primitive.
The protocol fills three gaps:
- DNS for capabilities — stable, resolvable identifiers across artifact churn.
- Ranking with outcomes — every match leaves a trail; the graph compounds.
- Machine-readable trust — permissions, failure modes, observed success rate, side-by-side.
How to publish an unfragile.yml
Put a file named unfragile.yml at the root of your repo (or next to your service). Then submit your URL at /submit. Validate before publishing:
# Validate locally before submitting
curl -X POST https://unfragile.ai/api/v1/validate \
-H "Content-Type: application/json" \
-d "{\"yaml\": \"$(cat unfragile.yml | jq -Rs .)\"}"A minimal valid manifest:
unfragile_version: "1.0"
artifact:
name: "My Tool"
slug: "my-tool"
type: "mcp" # one of 19 artifact types
maintainer: "Your Name or Org"
repository: "https://github.com/you/my-tool"
license: "MIT"
capabilities:
- id: "my_tool.primary_capability"
name: "What it does in one phrase"
description: >
Architecturally deep — describe HOW it works, not just what it claims.
Minimum 100 characters. Mention transport, data model, scope, side effects.
intents_served:
- "the user intent this capability satisfies"
conditions:
bestFor: ["who gets the most value"]
limitations: ["honest failure modes"]
requires: ["prerequisites"]Five complete examples (MCP, framework, API, SaaS, platform) are shipped in the repo at app/src/lib/protocol/examples/. Copy one as a starting point.
How agents resolve capabilities
An agent that knows what it needs but not which artifact to pick can resolve a capability against the live graph. The resolver returns ranked artifacts with constraints, risk, and trust signals so the agent can choose the safest current one.
# Resolve a capability URI
curl "https://unfragile.ai/api/v1/resolve?capability=capability://database.postgres.query.readonly&risk=production&passport=true"
# Or a natural-language capability
curl "https://unfragile.ai/api/v1/resolve?capability=read-only+postgres+access&limit=3"For agents, the same surface is available natively as an MCP server. Install it inside Claude Code, Cursor, Windsurf, or any MCP-capable client:
claude mcp add unfragile -- npx -y @unfragile/mcp-serverTools exposed: search, find_mcps,get_artifact, resolve_capability,trust_passport, compare,find_stack, feedback,subscribe, plus the protocol-native unfragile_validate, unfragile_passport, and unfragile_resolve_capability tools.
Trust passport spec
Before an agent commits to a tool — and an enterprise lets an agent commit to a tool — it needs a single machine-readable summary of what the artifact does, what it requires, and how it has performed. The trust passport is that summary.
curl https://unfragile.ai/api/v1/passport/cursor{
"unfragile": {
"@version": "1.0",
"version": "2026-05",
"artifact": { "slug": "cursor", "type": "product", "verified": true, "...": "..." },
"capabilities": [
{
"uri": "capability://code.generation.editing.codebase.aware",
"intents": ["edit code", "refactor", "fix bugs"],
"requires": ["local filesystem access"],
"limitations": ["context window limits on very large monorepos"],
"confidence": 0.87, "matches": 1247, "success_rate": 0.82
}
],
"trust": {
"score": 87,
"verified": true,
"data_access_risk": "high",
"permissions": ["local filesystem (read/write)", "outbound HTTPS"],
"failure_modes": ["context window overflow on very large monorepos"],
"observed_outcomes": { "matches": 4200, "success_rate": 0.91 },
"rank_breakdown": { "adoption": 92, "quality": 88, "...": "..." }
}
}
}Full schema: /schema.json#trust_passport_v1
capability:// URI scheme
A URI scheme for naming capabilities independently of the artifacts that provide them. The graph maintains the mapping; the URI is stable across artifact churn.
capability://<category>.<name-with-dots>
Examples:
capability://database.postgres.query.readonly
capability://code.generation.editing.codebase.aware
capability://memory.retrieval.augmented.generation
capability://search.web.with.citationsLowercase. Dots separate components. Hyphens permitted inside components. The category should be one of the 10 standard capability categories (see /schema). URIs are returned by every passport and accepted by /api/v1/resolve.
Example manifests
Five complete, valid, copy-pasteable manifests covering the common artifact types. Each is shipped in the repo at app/src/lib/protocol/examples/:
- mcp-server-postgres.yml — MCP server providing read-only Postgres query + schema introspection.
- agent-framework-langchain.yml — Multi-capability framework with provider-swappable models.
- api-openai.yml — Hosted API with usage-based pricing, compliance, and rich execution detail.
- saas-cursor.yml — Commercial SaaS product with tier-based pricing.
- library-pinecone.yml — Vector platform demonstrating the platform artifact type.
FAQ
Is the protocol open?+
Yes. The schemas published at /schema.json (both unfragile_manifest_v1 and trust_passport_v1) are open and permissively licensed. Any platform may read, write, validate, or extend them.
Do I have to host my artifact on Unfragile?+
No. The protocol is the open standard for describing capabilities. Unfragile is one implementation that provides the match graph, the trust layer, and the distribution surface — but the manifest can live in your repo and be read by anything.
How is this different from Schema.org or OpenAPI?+
OpenAPI describes HTTP shapes. Schema.org describes web entities. The Unfragile manifest describes capabilities — what an artifact does, what conditions it works under, what permissions it needs, what can fail, and what it costs. The match graph layered on top learns from every interaction.
What is a capability:// URI?+
A stable identifier for a capability, derived from category and name. Agents pass capability:// URIs to /api/v1/resolve and receive ranked artifacts with current trust signals. Think of it as DNS for what AI can do.
Does Unfragile compete with the artifacts it indexes?+
No. Neutrality is the moat. Unfragile is the distribution and trust layer. The protocol explicitly forbids hosting builder execution surfaces or competing with what the graph distributes.
How does the graph learn?+
Every search, every resolve, every passport fetch, every click-through, every dwell signal, every explicit feedback call feeds the match graph. Capability matchConfidence is recomputed weekly and synced back to vector metadata so retrieval reflects observed outcomes.
Publish your artifact
Drop an unfragile.yml in your repo, validate it, and submit your URL. The graph indexes you, decomposes your capabilities, and starts recording match outcomes.