AI agents open and merge changes around the clock, and a green build doesn't mean it's safe to ship. ReleaseGate reviews the metrics for every release, writes its own analysis, and decides within the conditions and metrics your team defines. Clear-cut changes ship on their own; the gray areas go to a human, with the reasoning attached. Every call is recorded—what shipped, who or which agent wrote it, and why.
AI coding assistants and autonomous agents turned a steady stream of pull requests into a firehose—larger diffs, more changes, around the clock. Governance built for human-paced, human-authored code buckles under it.
Reviewers rubber-stamp because they can't keep pace. Manual approvals and review meetings were already the bottleneck—now they're underwater.
Industry surveys in 2026 put it bluntly: ~77% of teams trust their AI output, but only ~29% have an automated audit trail for it. That gap is the risk.
It's no longer just “how fast can we ship?” It's “what shipped, why did it change, and what—or who—influenced the decision?”
ReleaseGate answers that question for every release—including the ones an agent wrote—by making the decision itself a scored, explainable, auditable record.
Your pipeline tells you the code compiles and tests pass. It can't tell you whether you should ship this change, right now—or prove why you did.
No structure, no memory—try finding it in six months
Volume outran the reviewers; nobody really read it
Open incident, bad deploy window, risky path—the pipeline can't see it
Screenshots and spreadsheets assembled the week before the audit
You know it was approved; nobody remembers the reasoning
Signals, score, recommendation, sign-off, reasoning—structured and searchable
See what an agent wrote and whether a human reviewed it
AI decides the green-zone changes within your rules; the rest route for review
Yellow-zone changes go to the right person in chat, with the reasoning attached
Append-only and exportable—evidence is a side effect, not a project
Few releases are simply pass or fail. ReleaseGate reviews the metrics, writes its own analysis, and scores each release against the weights and thresholds your team defines—then decides within those guardrails. The score lands it in one of three zones; the zone decides who, if anyone, needs to act.
Lands in the yellow zone. Canary error rate is up 0.4%, and an agent-authored migration touches the billing path. Everything else is green—needs one human approval.
In-policy and low risk. ReleaseGate approves and ships it automatically, with a decision record written. Most releases land here.
A judgment call—risky path, rising errors, an agent-authored change. Routed to the right person in chat to approve or hold, reasoning attached.
Low score, or a critical violation—failed security scan, failing QA, open SEV1, blackout window. Hard-stopped and escalated; critical fails are rejected outright.
The score is always explainable: open any decision and see exactly which signals moved it, and by how much. Thresholds and weights are yours to tune as you learn.
Four steps, fully transparent. Hard rules are deterministic; the AI scores and explains; the zone decides who needs to act.
Pull from source control, CI, QA & test results, security scans, error tracking and incidents when a release is cut. Detect which changes were AI-authored.
Your weighted signals produce a readiness score, and an LLM writes a plain-English assessment with citations. You set the weights and thresholds.
Green: AI auto-approves. Yellow: routes to the right human in chat. Red: blocked and escalated—critical violations rejected outright.
Every decision is written to an append-only, hash-chained record: signals, score, rationale, who or what signed off. Queryable and exportable.
Policy is versioned code in your repo. Every team sets its own weights, thresholds and hard rules.
# Each team defines its own conditions, metrics and thresholds
version: 1
service: checkout-service
# Signals contribute to the 0–100 readiness score (you set the weights)
score_weights:
ci_build_passed: 20
qa_tests_passed: 20
security_scan_clean: 20
no_open_incidents: 15
small_change_size: 15
human_reviewed: 10
# Score thresholds define the zones — AI decides within these
zones:
green: { min: 80, action: ai_auto_approve }
yellow: { min: 50, action: require_human_approval, notify: ["#releases", "@on-call"] }
red: { max: 50, action: block_and_escalate }
# Critical violations force RED + outright rejection, regardless of score
critical_reject:
- security_scan_failed
- qa_tests_failed
- open_sev1_incident
- inside_blackout_window # e.g. Black Friday
# Treat AI-authored changes with extra care
ai_authored:
require_human_review: true
never_auto_approve: trueWhat we're building with our early customers. Honest about what's live versus on the roadmap.
The atomic unit: change, signals, score, recommendation, sign-off, and reasoning—captured automatically for every release.
A transparent, weighted score from your signals—CI, QA tests, security, incidents, change size, provenance. Green / yellow / red zones decide what happens.
Releases aren't black and white. ReleaseGate reviews the metrics, writes its own analysis, and makes the call within your guardrails—shipping the clear cases and escalating the gray areas. You stay in control of the conditions.
Detect and label agent-authored and co-authored changes from commit metadata. Know what the AI wrote—and whether a human reviewed it.
Deterministic gates and score weights in versioned config: required checks, deploy windows, blackout dates, separation of duties, critical-reject rules.
Append-only and hash-chained for tamper-evidence. Export to CSV/JSON—or map to common compliance controls as you grow.
Software teams shipping often, adopting AI coding tools fast, and feeling the first real pressure to govern it.
You adopted AI coding tools and your change volume jumped. You want governance that scales with it—not another meeting.
Release approvals live in a thread or a ticket today. You want structure and memory without a heavyweight platform.
A big customer or an upcoming audit means you need a trail—without running your delivery through a heavy enterprise suite.
Agents are starting to open and merge changes. You need a control point that makes even an agent-initiated release get scored, recorded, and policy-checked.
We start with a focused set of integrations our early customers actually use, and add more based on demand—not a logo wall.
ReleaseGate is pre-launch and built in the open with a small group of teams. Tell us you're interested and we'll be in touch.
Direct input into the roadmap, white-glove setup, and preferential pricing for life.
Real releases to learn from and the honest feedback that makes the product good.
Frequent deploys, AI coding tools in play, and approvals done by hand today.
Straight answers, including what we don't do yet.
Yes—within the guardrails you define. You set the metrics, weights and thresholds per team and service. ReleaseGate auto-approves the clear, in-policy releases (green zone), routes judgment calls to a human (yellow), and blocks critical violations outright (red). It never decides outside the rules you've set, and every decision is recorded and explainable.
From signals you weight yourself in policy-as-code—CI, QA tests, security scans, open incidents, change size, AI-authorship, error trends. It's fully transparent: open any decision and see exactly which signals moved the score and by how much. No model trained on someone else's data.
Yes—that's the point. Conditions, metrics, weights and thresholds are defined per team and per service in versioned config. A payments service can demand human review and high coverage; an internal tool can auto-ship more freely.
Your pipeline proves the code builds and tests pass. ReleaseGate decides whether you should ship this change right now—weighing incidents, error trends, change risk and provenance—then records why. It runs alongside your pipeline, not instead of it.
No. Monitoring watches health after the change is live and can roll back. ReleaseGate makes the call before you ship and keeps the durable record of the decision. They're complementary.
It reads commit metadata (trailers, bot identities, PR data) to label which parts of a release were written or co-written by an agent—and whether a human reviewed them. Policy can then score and treat agent-authored changes differently.
We work from metadata and signals (PR details, check results, diffs where you allow it). Data handling is something we'll define together with early customers, with a self-hosted option on the roadmap for sensitive environments.
Tell us you're interested below and we'll be in touch. We're onboarding a small number of teams so we can give each one real attention.
Tell us how your team approves releases today and which AI coding tools you use. If it's a fit, we'll reach out personally.