Product

One runbook, every agent,
your whole team.

Visual flow canvas, MCP server that plugs into any agent, human checkpoints, kanban + reports. Works with whatever stack your team picks — the canvas palette reshapes around your tools.

Canvas Designer

Design your engineering workflow visually

Build Run Books on a drag-and-drop canvas with 7 configurable swim lanes. Each lane represents a phase -- from Ingestion to Shipping. Add nodes from a palette of 20+ integrations.

  • Drag-and-drop node reorder within phases
  • Checkpoint nodes pause for human review after AI steps
  • Duplicate node prevention -- same integration once per phase
  • Add, remove, or rename phases per template
  • Templates are versioned -- running Run Tasks lock to creation version
canvas-editor.html
Scope
Jira Import Framework Detect
Planning
Agent (plan) Checkpoint Figma Sync
Design
Figma → your framework Checkpoint
Implement
Agent (build) Git Branch Apply Patch
Review
Build verify Agent (review) Checkpoint Create PR
Testing
Unit tests Integration Lint
Distrib.
GitHub Actions Deploy target Slack Notify
runs.html -- Kanban View
Scope
FU-041
Auth refactor
scope
Plan
FU-039
Settings page
planning
Design
Impl
FU-037
Push notifs
implementing
FU-036
Profile API
implementing
Review
FU-034
Onboarding
reviewing
CI
CD
FU-031
Login fix
distribution
Done
FU-028
Dark mode
done
Kanban Board

See every Run Task at a glance

Nine columns track the full lifecycle -- 7 phases plus Done and Failed. Each card shows the Run Task ID, title, assignee, and current status. Switch between kanban and list views.

  • Filter by assignee, template, status, or date range
  • Phases progress automatically -- no drag-and-drop needed
  • Click any card to open the 360-degree detail view
  • Timeline, comments, permissions, node summaries, and audit events
AI Pipeline

Three AI agents. One verified result.

Your agent decomposes the ticket, writes the diff, and self-reviews via its native LLM. RailRun supplies the scope manifest, gates phase transitions with checkpoints, and records the outcome. No LLM code runs on our servers.

  • Your agent's own LLM, via Claude Code or Cursor -- RailRun never sees the model or the key
  • BYOK (Bring Your Own Key) -- LLM calls go direct to your provider, never our servers
  • PII scanner runs on every request before any LLM call
  • Per-node dry run -- preview output without committing
  • Checkpoint nodes pause for human approval after AI steps
AI Pipeline Execution
14:23:01 [Agent (plan)] Decomposing ticket PROJ-417...
14:23:04 [Agent (plan)] Generated 6-step workflow plan
14:23:04 [Checkpoint] Waiting for approval...
14:24:12 [Approved] kanesh@railrun.dev
14:24:13 [Agent (build)] Generating unified diff...
14:24:38 [Agent (build)] +147 -23 across 4 files
14:24:39 [Git] Branch feat/PROJ-417 created
14:24:40 [Git] Patch applied successfully
14:24:41 [Agent (review)] Reviewing changes...
14:24:55 [Agent (review)] PASS -- no issues found
14:24:56 [Build] Build verification started
14:25:22 [Build] BUILD SUCCESSFUL
reports-velocity.html
Team Velocity -- April 2026
Kanesh P.
34 FU
Jamie R.
25 FU
Alex T.
19 FU
Sarah M.
14 FU
Total: 92 FUAvg: 23 FU/engineer+18% vs last month
Reports

Visibility for leads.
Accountability for teams.

Three report dashboards give PMs, leads, and principals the metrics they need to understand delivery velocity, individual performance, and LLM cost efficiency.

  • Velocity report -- Run Tasks completed per engineer per sprint
  • Engineer performance -- completion rate, average cycle time, review pass rate
  • LLM cost breakdown -- spend per provider, per model, per engineer
  • PM role sees velocity only. Engineers see their own data. Leads see the team.
Team Roles

Five roles. Granular module masking.

Every screen in the admin portal enforces role-based visibility. Sidebar navigation, page content, and API endpoints all respect the same permission model. No role can see more than they should.

  • PM -- read-only kanban, velocity reports, commenting
  • Engineer -- create Run Tasks for assigned tickets, own reports
  • Senior Engineer -- create templates, approve checkpoints, team reports
  • Tech Lead -- full team management, all templates, all reports
  • Principal -- org-wide access, all teams, full admin
Role Permission Matrix
CapabilityPMEngSr EngLeadPrincipal
View kanbanYYYYY
Create Run Tasks--YYYY
Create templates----YYY
Approve checkpoints----YYY
Team reports----YYY
Velocity reportsY--YYY
Team management------YY
Org-wide access--------Y
Pipeline

Every phase in detail

Each phase has its own set of configurable nodes. CI and CD are separate phases with distinct toolchains.

01
Scope
Import a ticket from any connected source — Jira, Linear, GitHub Issues, Sentry, Crashlytics, or manual entry. Detect your stack + tools automatically and build a scope manifest the agent respects.
Jira ImportLinear ImportFramework Detect
02
Planning
Agent (plan) decomposes the ticket into a step-by-step workflow plan. Extract Figma design tokens if a design link is attached.
Agent (plan)Figma SyncCheckpoint
03
Designing
Pull design tokens and component references from Figma. The agent writes UI code in whatever format your stack uses (React, Vue, Svelte, Tailwind, Compose, SwiftUI, plain CSS). Optional phase — skip if no design work is needed.
Figma tokensComponent refsCheckpoint
04
Implementing
Your agent writes the diff locally via its filesystem MCP. RailRun supplies the scope manifest (editable + read-only paths based on the stack your agent detected — Gradle, pnpm, cargo, poetry, whatever it finds) and records diff stats via record_generated_diff.
Agent (build)Git BranchApply Patch
05
Reviewing
Local build verification runs first — whatever command your stack uses. Agent (review) reviews the changes and triggers fix loops. When clean, a pull request is created automatically.
Build verifyAgent (review)Create PRCheckpoint
06
Testing (CI)
Run whatever test and static-analysis commands your runbook defines — unit, integration, E2E, lint, type-check, coverage. Agent runs them locally, reports pass/fail counts. CD stays separate — tests must be green before distribution.
Unit · Integration · E2ELint + type-checkCoverage gate
07
Distribution (CD)
Trigger CI (GitHub Actions, CircleCI, Bitrise, GitLab CI). Build artifacts. Upload to whatever your team ships to — web targets (Vercel, Netlify, Cloudflare Pages), container registries (ECR, GHCR), package registries (npm, crates.io, PyPI), app stores (TestFlight, Play, Firebase AD), or custom HTTP. Notify via Slack / Teams / Discord / email.
GitHub ActionsVercelDockerSlack

See it in action

Free forever up to 3 engineers. No credit card. Paste one RailRun key into your agent's mcp.json and run your first template in minutes.

Start free View pricing