Turn your backlog into reviewed PRs.
Your coding agents, running overnight on rails — for fewer tokens, independently reviewed, and never off the rails.
Free in preview · 33 issues shipped on our own backlog
System health
Accept rate
72%
18 green / 25 attempted
Escalation rate
12%
3 escalated to human / 25 attempted
Health line: accept rate > 50% is winning; below is losing
From agentrail init to a governed team.
Point it at your repo
One command builds a local index of your codebase — BM25 and a code graph. Repo-native; nothing leaves your machine to retrieve context.
agentrail initAgents run on compiled context
Instead of whole files, agents pull bounded line-range context packs with a cited reason per pick — the source of the measured token win.
agentrail runGate and review
Policy checkpoints stop agents between phases to show evidence. AFK mode runs unattended work that stays inside the gates.
review gatesSee it in the console
Every run, context pack, cost, failure, and audit event lands in one team workspace — searchable, replayable, and governed.
→ dashboardWe ran it on our own backlog.
AgentRail has been shipping its own issues, unattended — full runs from open issue to a reviewed PR. Here's the real tally, the ones it landed and the ones it didn't.
of its own issues taken from open to a reviewed PR — unattended.
One run, start to finish
#221 “Add API keys view” → PR #308
First attempt · one review round · no errors.
20 of 53 didn't land — they hit a gate or review and stopped to a human. We count the misses too; no cherry-picking.
Real autonomous runs on AgentRail's own backlog (Bensigo/agentrail) — full runs, not a synthetic or retrieval benchmark. One project; directional, and honest about it.
Built to run without you.
Hand it an issue and walk away — a reviewed PR comes back, your budget intact, with nothing merged on the agent's own say-so. Here's what makes that safe:
Clear the backlog, not your calendar
Point it at your GitHub or Linear issues and they're worked overnight in an isolated sandbox. You review PRs in the morning — you never sit and babysit a run.
Trust the work without watching it
Nothing counts as done until a second model and your own tests both agree. The agent never grades its own work, and nothing merges on its say-so.
Never get a surprise bill
Every issue runs under a hard budget — cheap models first, escalating only when it must, then stopping to a human. Your spend can't run away.
Pay for the lines that matter, not the whole repo.
Your agents read the exact lines they need — cited, and only those — instead of whole files. Far fewer tokens per run, same result.
So you always know what it cost — and whether to trust it.
Replay any run
See exactly what an agent did, start to finish — no guessing what happened overnight.
Know the real dollars
What each run actually cost, across every repo and your whole team — so spend never surprises you.
See why it failed
When a run doesn't land, the root cause is right there, linked to the run that caused it.
Promote a review to an issue
Reviews never block a merge — turn any finding into a tracked GitHub or Linear issue in a click.
The CLI runs your agents. The console runs your team.
The CLI is free, forever. The console is the team layer — one place to see, cost, and govern every run, across every repo.
Runs on your machine, in your terminal.
- Hybrid context retrieval — line ranges, not files
- Bounded, review-gated agent runs
- Durable project memory
- Repo-native, deterministic, offline
Your terminal shows your runs. The console shows your team's.
- Every developer's runs in one workspace
- Server-enforced review gates & policy
- Cost across repos, teams, workspaces
- Audit trail for every sensitive action
- Connectors for GitHub, Linear & chat
- Indexing health, API keys, members
One agent on your laptop is a tool. A team of agents you can see, cost, and govern is a control plane.
Questions, answered.
What does the console give me that the free CLI doesn't?
The CLI is one developer's terminal. The console is the team system: every developer's runs in one workspace, the issue queue and its budget leash, cost across repos and teams, a full audit trail, and member management — the things you can only do when agent work is centralized.
How do my team's agent runs get into the console?
Connect the CLI to your workspace with a key, and runs stream in automatically — each one's context packs, token and dollar cost, review-gate evidence, and outcome land in the dashboard with no extra steps.
Can I invite my team and control who sees what?
Yes. Invite teammates by email during setup or from the Members page; an invite is accepted automatically the next time they sign in. Roles — owner, admin, member — govern who can invite people, configure review gates, and manage repositories.
Does the console store my source code?
No. Indexing stays local on each developer's machine. The console stores run metadata, context-pack citations (line ranges, not file contents), costs, and audit events — not your source by default.
What can I actually govern from the console?
Server-enforced review gates and policy across every repo — require context-pack evidence before a run can merge, see and cap spend per repo and team, and get a source-linked audit trail for every sensitive action an agent takes.
Is the CLI still free, and how does the console price?
The CLI is free forever for every developer. The console is the team layer and is free while in preview — so you can connect a repo, invite your team, and see every agent's work in one place today.
Clear your backlog overnight.
Connect a repo, point it at an issue, and wake up to a reviewed PR — for a fraction of the tokens.
Free while in preview