CodeRifts exposes 10 tools via the Model Context Protocol. Any MCP-compatible client — Claude Desktop, Cursor, Windsurf, or your own agent — can run preflight checks, diff schemas, and assess agent readiness before deploying API changes.
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_check Free | before, after, branch_name |
decision (ALLOW/WARN/REQUIRE_APPROVAL/BLOCK), risk_score, breaking_changes, safe_for_agent |
| agent_tool_check Pro | before, after |
decision, detected_patterns (name, severity, consequence) |
| agent_readiness_score Pro | spec, spec_type |
score (0-100), band (STRONG/GOOD/NEEDS_WORK/POOR/CRITICAL), signals (signal, severity, deduction) |
| registry_validate Pro | specs |
valid, issues, stats (specs_count, endpoints_count, schemas_count) |
| agent_preflight Pro | tools_before, tools_after, workflow_type |
decision, safe_for_agent, breaking_changes, extended.blast_radius.affected_consumers |
| mcp_diff Pro | before, after |
decision, risk_score, risk_level, mcp_tool_impact (tool, change, severity) |
| governance_health Pro | before, after |
decision, risk_score, breaking_changes, patterns, policy_violations, security_findings, evidence_quality |
| verify_receipt Free | token |
valid, reason, payload (present only when valid) |
| preflight_change_set Pro | artifacts, context, previous_receipt, idempotency_key |
decision, risk_score, breaking_changes, artifacts (per-artifact findings), bundle_fingerprint |
| get_decision_details Pro | decision_id or fingerprint |
stored decision_result (verdict + receipt) + meta (source, created_at) |
For direct API calls without an MCP client. Pass your key as an Authorization: Bearer header.
| Tool(s) | REST Endpoint |
|---|---|
preflight_check / agent_tool_check / governance_health |
POST /api/v1/diff |
agent_readiness_score |
POST /api/v1/agent-readiness-score |
registry_validate |
POST /api/v1/registry-validate |
agent_preflight |
POST /api/v1/agent/preflight |
mcp_diff |
POST /api/v1/mcp-diff |
verify_receipt |
POST /api/v1/verify-receipt |
preflight_change_set |
POST /api/v1/preflight |
get_decision_details |
POST /api/v1/decisions/lookup · GET /api/v1/decisions/:id |
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 10 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 list of 10 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. Free tier includes preflight_check and verify_receipt; Pro unlocks all 10 MCP tools at full limits, agent-aware analysis, and the V3 scoring engine.
Already have an API key? Jump to the quickstart above.