Pre-merge Compatibility Governance
Never ship a breaking API change again.
CodeRifts analyzes API contracts, database migrations, and agent workflows directly in your PRs. Predict blast radius, detect agent-breaking drift, and post signed BLOCK/WARN/ALLOW reports on every PR. Want a merge gate? Add branch protection — see Make the Check Block a Merge. The path that actually prevents a breaking contract call is the runtime guard below — PR reports alone do not. OpenAPI, PR-gate and action-verdict verdicts are cryptographically signed — verify it, don't just trust us.
Read-only GitHub access · Core Diff reads schemas only; opt-in gates read source references in memory, never persisted · Security details
All Pro and Team features free during beta · Full feature set · GitHub native · Zero config
Real PR comment from coderifts/demo#4
1,275,568 OpenAPI specs analyzed — public datasets document breaking changes at scale (APIstic)
Source: APIstic research dataset, USI Lugano (2024)
Most tools show what changed. CodeRifts shows how dangerous it is.
That's it. A list of diffs.
* Cost estimates are based on your team’s configured hourly rate and estimated engineering effort. Configure in .coderifts.yml.
The market shows you what changed.
We tell you how dangerous it is.
We tell you who it affects.
We tell you when deployment is blocked.
We tell you how much it will cost.
And we sign OpenAPI, PR-gate & action-verdict verdicts — so you can verify it, not just trust us.
@coderifts/agent-guard prevents the call
The runtime guard fails closed: when an agent attempts a breaking contract call, the call does not run. That is prevention — the strongest control we ship. The same limit travels with the claim: the runtime sees only calls through the tool table it returns (withCodeRifts / the guarded registry). Anything the host invokes directly is invisible to it.
MigraGuard: schema changes vs live code
A migration PR that drops a column passes code review and green tests - then production breaks because src/billing/sync.ts still reads it. MigraGuard cross-checks every schema migration against your actual code references and reports on the PR: DROP COLUMN with a live reference is a BLOCK with the exact file and line. Additive changes pass in seconds. Uncertain cases get a WARN, never a silent pass. Built into the same zero-config GitHub App — one install, two reports (API contracts and migrations).
What your team sees on every pull request
Risk Breakdown
Breaking Changes
| Endpoint | Change Type | Intent | Confidence | Severity |
|---|---|---|---|---|
DELETE /api/users/{id} |
Endpoint removed | 🏗️ Structural | 🟢 High | Critical |
GET /api/orders |
Response schema changed | ⚙️ Behavioral | 🟡 Medium | Warning |
POST /api/payments |
Auth scheme removed | 🔒 Security | 🟢 High | Critical |
Policy Violations
Recommendations
Signed & Verifiable
Don't trust the verdict. Verify it.
Ed25519-signed verdicts on the OpenAPI diff, PR gates and action-verdict flows — deterministic, with multi-protocol signing (GraphQL, gRPC, AsyncAPI) on the roadmap. The command below independently verifies that this exact verdict was issued and signed by CodeRifts and has not been altered; determinism itself is reproducible via the public diff API — same input, same fingerprint.
# Signed & Verifiable — coderifts/demo#4
verdict: deterministic BLOCK · 3 breaking changes
fp: sha256:70699341…cfec
ir_hash: sha256:f3de7721…a334
kid: 2026-07-k1
issued: 2026-07-21
alg: Ed25519Example from a real run — the live receipt is always fresher. Run the command below to fetch and verify it yourself.
Verify it yourself
# clone & verify the live demo receipt
git clone https://github.com/coderifts/receipt-verifier && cd receipt-verifier
node verify.js "$(curl -s https://api.github.com/repos/coderifts/demo/issues/4/comments \
| grep -oE 'eyJ2[A-Za-z0-9._-]+' | tail -1)" \
--keys https://app.coderifts.com/.well-known/coderifts-keys.jsonNode 20+, no npm install. Exit 0 = valid. Resolves the signing key by kid from our published key registry — retired keys remain listed after rotation.
Open-source verifier (Node and Python) · Live demo PR · Receipt format docs
Same input, same verdict, same fingerprint — byte-identical across runs. Each run gets a freshly timestamped Ed25519 receipt.
Four steps. Zero config.
Zero config is the report path. Turning a red check into a merge gate is optional — Make the Check Block a Merge.
Push
A pull request modifies an API schema.
Calculate
CodeRifts diffs base vs head and scores risk across 4 dimensions.
Evaluate
Governance rules checked: budgets, freezes, ownership, approvals.
Report
Full signed report as a PR comment and check run. Require the check to block merges.
A full governance feature set in a single PR comment
Zero config on GitHub. Works with GitLab, Bitbucket, and any CI/CD pipeline. Policy as code via .coderifts.yml.
4D Risk Scoring
Revenue, blast radius, app compatibility, and security — scored 0-100 on every PR, now powered by the formalized Ω_API engine with auditable components (S_contract, P_break, S_blast, S_agent).
Policy Engine
Governance rules as code, simulated against any spec pair before merge. Advanced rules — breaking budgets, freeze windows, approval matrix — available now.
Change Intent Classification
Every breaking change tagged: structural, behavioral, security, or performance.
AI-Generated Spec Safety
Detects when AI tools modify your API spec with 7 detection signals.
Auth Scheme Diff Severity
Granular security analysis: 5 severity levels with OAuth scope detection.
Deprecation Lifecycle
Enforce minimum deprecation periods, sunset dates, and replacement requirements.
Documentation Coverage
5-dimension docs quality score with PR delta tracking.
API Stability Badge
Embeddable SVG badges for your README: stability grade, breaking-free streak.
PR-Layer Enforcement
Block unsafe merges at the PR layer — not just detection, but enforcement with BLOCK/WARN/ALLOW decisions.
Agent Preflight Check
preflightCheck() before every tool invocation — verify API contracts haven't drifted before your agent calls them.
Policy as Code
Define governance rules in .coderifts.yml — version-controlled and simulated before merge. Advanced gates (breaking budgets, freeze windows, approvals) are available now.
Compliance Ledger
Permanent audit trail of every API change, risk decision, and policy evaluation — immutable and queryable.
SDK
npm install @coderifts/sdk or pip3 install coderifts-sdk — integrate governance checks directly into your agent pipelines. Available now.
Multi-Protocol Diff
Breaking-change detection across OpenAPI, GraphQL, gRPC, and AsyncAPI — one decision format for every protocol.
Agent-Readable Headers
Every decision ships as X-CodeRifts-Decision, Risk-Score, and Safe-For-Agent headers — agents read the verdict without parsing a body.
Explainable Decisions
Append ?debug=true for the full reasoning — cache lookup, score components, and a human-readable decision path.
AI Adoption Telemetry
See which AI crawlers and agents reach your API through the public preflight endpoint.
Owner Dashboard & Metrics
Per-repo decision distribution, cache efficiency, and request volume — for the teams that own the API.
Correlation ID & Audit Trail
Every request carries a correlation id — full traceability across logs, decisions, and PR comments.
Governance feature set in a single PR comment
Config required — install and it works
Policy as code via .coderifts.yml
Tests — production-grade reliability
10 Drift Patterns Live Today
Detected on static spec input. Deterministic, signed, reproducible by curl.
Agent-Specific Patterns — 6 patterns
TOOL_INPUT_SCHEMA_DRIFT
Tool input schemas change, breaking agent function calls
TOOL_RESULT_SHAPE_DRIFT
Tool response shapes change, breaking agent parsing
AGENT_PROTOCOL_DRIFT
Agent-to-agent communication protocol changes
AUTH_DELEGATION_DRIFT
Delegated auth flows change between agent hops
SHARED_STATE_SCHEMA_DRIFT
Shared state schemas diverge between cooperating agents
WORKFLOW_CHAIN_BREAK
Multi-step agent workflows break at chain boundaries
Semantic Drift Engine — 4 patterns
FIELD_SEMANTIC_CHANGE
Field meaning changes while name stays the same
ENDPOINT_SEMANTIC_CHANGE
Endpoint behavior changes while path stays the same
RESPONSE_CONTRACT_DRIFT
Response contracts shift in meaning or structure
DEFAULT_VALUE_SEMANTIC_CHANGE
Default values change, altering implicit behavior
19 Patterns on the Traffic-Capture Roadmap
These require live traffic data. CodeRifts is static and deterministic by design today; these ship with the traffic-capture layer.
AIDE Instability Engine — 13 patterns Roadmap
LATENCY_REGRESSION
Response times degrade beyond acceptable thresholds
PAYLOAD_FLAKINESS
Response payloads vary unpredictably between calls
ERROR_RATE_SPIKE
Sudden increase in error responses from endpoints
TOKEN_COST_DRIFT
API token consumption changes unexpectedly
SYSTEMIC_INSTABILITY
Multiple instability signals correlate across endpoints
SILENT_DATA_LOSS
Fields disappear from responses without error signals
ZOMBIE_ENDPOINT
Endpoints exist in spec but return errors or empty data
SESSION_INSTABILITY
Session state becomes unreliable across requests
CHANGE_INDUCED_FLAKINESS
Recent spec changes correlate with intermittent failures
BLOATED_RESPONSE
Response sizes grow beyond expected bounds
AUTH_DRIFT
Authentication requirements change without spec updates
INTERMITTENT_SLOWDOWN
Periodic latency spikes without consistent pattern
TRAFFIC_SHIFT
Request distribution changes across endpoint versions
Neural Drift Engine — 6 patterns Roadmap
LATENCY_DRIFT
Gradual latency degradation across neural pathways
SIGNAL_LOSS
Critical API signals attenuate below detection threshold
SYNAPTIC_NOISE_RISE
Noise-to-signal ratio increases in API responses
AUTH_CONDUCTION_DECAY
Authentication token propagation degrades over time
TOKEN_INFLATION
Token sizes or counts inflate beyond expected bounds
PAYLOAD_EROSION
Response payload quality degrades incrementally
Every pattern is backed by detection logic and verified test cases. The 10 live patterns run on static spec input today; the 19 roadmap patterns ship with the traffic-capture layer.
View Decision Spec v1.0 →Enforce release policies with version-aware, machine-checkable rules.
Governance as code
# .coderifts.yml — analyzer policy (can fail the check / stop a merge when required)
# Not the same file as .github/api-policy.yaml (comment-only DSL).
breaking_budget: 3
fail_on_breaking: true
policy:
no_delete:
- "/payments/*"
- "/auth/*"
freeze:
start: "2026-03-01"
end: "2026-03-15"
reason: "Q1 release freeze"Two policy files exist — only .coderifts.yml can stop a merge. See Two policy mechanisms.
Breaking budgets
Set max allowed breaking changes per PR
Freeze windows
Block breaking changes during release periods
Domain ownership
Route alerts to the right team by API path
Approval matrix
Require sign-off based on risk level
How it works
CodeRifts reads your OpenAPI specification files (JSON or YAML) directly from your repository on every Pull Request. It never accesses your source code, business logic, or runtime data.
What it analyzes
- OpenAPI 3.x and Swagger 2.x specifications
- Schema changes between base and head branch
- CI configuration for governance gap detection
What it does not access
- Your codebase (opt-in gates read only referenced files, in memory)
- Your database
- Runtime traffic or production data
- Any file outside the paths you configure
Core Diff reads your configured spec files; opt-in MigraGuard and ActionGuard also read configured migration files, source references and workflow YAML — processed in memory during the check run, never stored or logged.
Who is this for
Platform teams
Dozens of internal APIs, one breaking change away from a bad week. CodeRifts maps blast radius across declared consumers and affected endpoints, enforces breaking budgets and freeze windows, and blocks the merge before the pager goes off.
API-first companies
Your contract is your product. Semver-violation forensics, signed verdicts and auto-generated changelogs keep every release honest — and provable to your customers.
Agent builders
AI agents break silently when tool schemas drift. Preflight checks, agent-safe verdicts and MCP governance catch agent-breaking changes at the PR, before your agents hit them.
Start free. Scale when ready.
Ed25519-signed verdicts on the OpenAPI diff, PR gates and action-verdict flows — on every tier, even Free; multi-protocol signing is on the roadmap.
Free
Catch breaking changes locally
- Breaking change detection
- Auto-discovery of spec files
- Semver suggestion
- Lifecycle labels
- API surface stats
- Commit consistency check
- Breaking changes table
- REST in Peace
- Web UI, CLI & REST API
- Signed, verifiable verdict receipt
Pro
Risk intelligence on every PR
- Everything in Free, plus:
- GitHub App: zero-config PR comments
- Runtime guard prevents breaking contract calls
- Change intent classification
- Confidence scoring
- Catches auth regressions before merge
- Auth scheme diff severity
- AI-generated spec safety
- Generator-aware risk
- API design linter
- Auto-changelog
- Deprecation lifecycle tracker
- Documentation coverage score
- Heritage mode
- CODEOWNERS suggestion
- Versioning strategy advisor
Team
Governance enforcement for your team
- Everything in Pro, plus:
- Required check blocks merges when branch protection is set
- Freeze windows
- Breaking budget per team
- Approval matrix
- Domain ownership & notifications
- Exception lifecycle manager
- Migration assessment
- Governance health score (A-F)
- Overlap detection
- PR review insights
- Feature flag cleanup
- API stability badges
- Shadow API detection
- SDK surface coverage
- Generated spec drift control
Enterprise
Governance at scale with compliance
- Everything in Team, plus:
- Multi-repo compatibility guard
- Consumer-aware risk scoring
- Org-level API registry
- Compliance ledger & audit trail
- External API drift monitor
- Historical drift intelligence
- Slack & Teams notifications
- SSO & dedicated support
See How CodeRifts Compares
The only PR-native governance layer with deterministic, independently verifiable signed verdicts — at the pull request, not after deployment.
OSS diff engine vs full governance platform
API docs vs API contract enforcement
Single-spec linting vs PR-native breaking change detection
Design-time governance vs PR-native enforcement
iPaaS lifecycle vs PR-level contract protection
Gateway management vs shift-left governance
Runtime routing vs pre-merge contract enforcement
Get API governance insights in your inbox.
Join developers who care about API stability.
One email per week. No spam.
Featured Case Study
"A single field rename passed code review, passed all tests, and took down POS systems across 19 restaurants for a week."
Read the case study