CodeRifts exposes exactly three tools via the Model Context Protocol — preflight_change_set, verify_receipt, and get_decision_details. Any MCP-compatible client — Claude Desktop, Cursor, Windsurf, or your own agent — can preflight a contract change set, verify a receipt, and look up a past decision. Additional governance operations are available over the separate REST API.
MCP is an open standard that lets AI agents discover and call tools from external services. Instead of hardcoding API calls, agents read a manifest file (mcp.json) that describes available tools, their input schemas, and endpoints. The agent then calls whichever tools it needs to complete a task.
Agent reads mcp.json to learn what tools are available and what inputs they accept.
Agent constructs a JSON request matching the tool's input_schema and sends it to the endpoint.
Agent receives structured results and uses them to make decisions — block a deploy, warn a developer, or approve a merge.
Every tool is callable via any MCP-compatible client. Pass your API key as an Authorization: Bearer header.
| Tool | Input | Output |
|---|---|---|
| preflight_change_set | artifacts, context, previous_receipt, idempotency_key |
decision, risk_score, breaking_changes, artifacts (per-artifact findings), bundle_fingerprint |
| verify_receipt | token |
valid, reason, payload (present only when valid) |
| get_decision_details | decision_id or fingerprint |
stored decision_result (verdict + receipt) + meta (source, created_at) |
Only the three tools above are exposed through MCP. The endpoints below are REST integrations for callers without an MCP client — the agent-relevant surface, not the full product API.
Direct HTTP without an MCP client. This is the agent-relevant surface — not the full product API. Auth: Authorization: Bearer unless a route is documented as keyless.
| Endpoint | Description |
|---|---|
POST /api/v1/diff |
Analyze an API contract change. |
POST /api/v1/preflight |
Evaluate a multi-artifact change set and return a signed decision. |
POST /api/v1/verify-receipt |
Verify a CodeRifts receipt. |
POST /api/v1/decisions/lookup · GET /api/v1/decisions/:id |
Retrieve a previously issued decision. |
POST /api/v1/agent-readiness-score |
Score an API or manifest for agent readiness. |
POST /api/v1/registry-validate |
Validate a set of specs together. |
POST /api/v1/agent/preflight |
Evaluate changed agent tool schemas. |
POST /api/v1/mcp-diff |
Compare two MCP manifests. |
Paste your mcp.json URL or content below and get an instant agent readiness score.
Start building with the free tier. Upgrade when you need higher limits or advanced tools.
| Tier | Requests / month | Requests / minute | Price |
|---|---|---|---|
| Free | 1,000 | 100 | $0 |
| Pro | Unlimited | 100 | $49 / mo |
| Team | Unlimited | 100 | $79 / mo |
| Enterprise | Unlimited | Custom | Custom |
Free tier is permanent. No credit card required. Pro includes up to 5 repositories, Team up to 20. Rate limit is 100 requests per minute per key on every tier.
Add CodeRifts to your MCP client in under 60 seconds. Choose your client below.
Open Settings → Developer → Edit Config and add the CodeRifts server to your claude_desktop_config.json:
{
"mcpServers": {
"coderifts": {
"command": "npx",
"args": ["-y", "mcp-remote", "https://app.coderifts.com/mcp", "--header", "Authorization: Bearer ${CODERIFTS_API_KEY}"],
"env": { "CODERIFTS_API_KEY": "YOUR_API_KEY" }
}
}
}Restart Claude Desktop. You will see CodeRifts tools in the tool picker.
Open Settings → MCP and add a new server:
{
"mcpServers": {
"coderifts": {
"command": "npx",
"args": ["-y", "mcp-remote", "https://app.coderifts.com/mcp", "--header", "Authorization: Bearer ${CODERIFTS_API_KEY}"],
"env": { "CODERIFTS_API_KEY": "YOUR_API_KEY" }
}
}
}Cursor will auto-discover all three MCP tools. Use them in chat with @coderifts.
Open Settings → Cascade → MCP and add:
{
"mcpServers": {
"coderifts": {
"command": "npx",
"args": ["-y", "mcp-remote", "https://app.coderifts.com/mcp", "--header", "Authorization: Bearer ${CODERIFTS_API_KEY}"],
"env": { "CODERIFTS_API_KEY": "YOUR_API_KEY" }
}
}
}Restart Windsurf. CodeRifts tools will appear in Cascade's tool list.
Fetch the manifest, then call any tool endpoint directly:
curl -s https://coderifts.com/mcp.json | jq '.tools[].name'curl -X POST https://app.coderifts.com/api/v1/agent/preflight \
-H "Content-Type: application/json" \
-H "Authorization: Bearer YOUR_API_KEY" \
-d '{
"tools_before": [{"name": "get_order", "inputSchema": {"type": "object", "properties": {"id": {"type": "string"}}}}],
"tools_after": [{"name": "get_order", "inputSchema": {"type": "object", "properties": {"id": {"type": "integer"}}}}]
}'CodeRifts works with any client that supports the Model Context Protocol.
Anthropic's desktop client with native MCP support
SupportedAI-first code editor with MCP tool integration
SupportedCodeium's IDE with Cascade MCP support
SupportedAny agent that reads mcp.json and calls HTTP endpoints
SupportedThe MCP integration adds a discovery layer on top of the existing CodeRifts API. No new infrastructure required.
The agent fetches https://coderifts.com/mcp.json and reads the three MCP tools with their input schemas and endpoint URLs.
The agent constructs a JSON payload matching the tool's input_schema and sends a POST request to the endpoint with your API key.
The full analysis pipeline runs: dual-engine diff, behavioral drift detection, agent pattern scoring, and the V3 scoring engine with 11 components and reflex rules.
The agent gets a JSON response with the decision (BLOCK / REQUIRE_APPROVAL / WARN / ALLOW), risk score, breaking changes, detected patterns, and mitigation templates. It can then act: block a deploy, request approval, or approve the merge.
A typed JavaScript/TypeScript SDK for programmatic access to every CodeRifts tool. Run preflight checks, explain decisions, and get unblock guidance — all from your agent code.
import { CodeRifts } from '@coderifts/sdk'
const cr = new CodeRifts({ apiKey: 'cr_live_...' })
// Diff two OpenAPI specs before merge
const diff = await cr.diff({
old_spec: oldOpenApiYaml,
new_spec: newOpenApiYaml
})
if (diff.breaking_changes_count > 0) {
// diff.risk_level drives the gate: block, require approval, or warn
}
// Score an MCP manifest for agent readiness
const score = await cr.agentReadinessScore({
spec: mcpManifest,
spec_type: 'mcp'
})
// score.score, score.band e.g. 100 STRONGInstall now
npm install @coderifts/sdk
pip3 install coderifts-sdk
Python and TypeScript SDKs are published and versioned. See the agent frameworks guide for full examples.
Install the CodeRifts GitHub App to get started. All three MCP tools are available on every plan; paid plans add more repositories and higher monthly request limits.
Already have an API key? Jump to the quickstart above.