For teams that build with Claude Code

Your agents' pull requests, held to your team's checks.

Every ticket you hand to Runfast passes coverage on the lines it changed and a review by a second agent. Larger changes also get an audit against your spec. You see the pull request after it passes, and a question only when an agent is stuck on a decision.

Request access Log in

Invite only while we onboard our first teams.

A real run 6afa3101 · skillflow-lite
  1. planfrom the invite-only spec
  2. tickets1 ticket, about 400 lines
  3. implement T1in its own worktree
  4. coveragesent back once, then every changed line
  5. spec audit23 criteria, 0 findings
  6. pull requestopened, waiting for review
84 min · 9 attempts · 0 interventions How it works
How it works

Follow one spec to a merged pull request.

A flow is a YAML file in your repository. Each step names a skill: one of ours, or one you already use.

  1. 01

    Plan from your spec

    An agent reads the spec and your code, then writes a plan with acceptance criteria.

  2. 02

    Split into tickets

    The plan becomes tickets. Each ticket gets its own git worktree, so agents never share a branch.

  3. 03

    Pass every checkpoint

    Every ticket passes coverage and an independent review. Larger changes also face the spec audit. A failure goes back to the agent with the reason.

  4. 04

    Ask a person only when it matters

    The pull request arrives with its checks passed. Merge it, or send it back with a note.

One run, from spec to pull request spec plan tickets T1 T2 T3 each ticket in its own worktree checks checks checks sent back: 2 review findings pull request
example run · reading the spec 00:00
Checks

The checks a strong team runs, as skills you can read.

Most agents check their own work. Here a second agent reviews it, a script measures it, and a failing check sends the ticket back before any pull request opens. Each check is a skill in your repository: read it, or drop in your own copy with the same name.

  • Coverage on changed lines

    Measures only the lines the ticket changed, so a well-tested old file can't hide an untested new branch.

    Default: 80% lines · 70% branches
    TypeScript and JavaScript with Vitest today

  • Independent review

    A different agent reviews the diff, on a second model where one is available. Findings go back to the author, with the file where it can.

    Default: every ticket

  • Audit against the spec

    Checks each acceptance criterion against the diff and the tests, and cites the section it came from.

    Default: larger changes

  • Spec protection

    Fails any edit to the spec that the ticket didn't ask for, so an agent can't move the goalposts.

    Default: larger changes

  • Delivery policy

    Reviewed by default: a person merges on GitHub. Switch a repository to an approval card, or to merge when checks pass.

    Default: per repository

  • Run budget

    Caps attempts, minutes and tokens, so a stuck loop stops at the cap and lands in your inbox.

    Default: 60 attempts · 8 h
Inbox

One inbox for every decision your agents can't make.

  • Reviews arrive with the evidence.Coverage, review findings and the spec audit sit on the card, so a decision takes a minute.
  • Anyone with access can answer.Approve, send back with a note, or answer the agent's question. The run picks up where it stopped.
  • Runs wait for the world.Steps wait on CI, reviewers or a person, then resume hours or days later, when your daemon is online.
Example inbox

Organization invites and pending list

review
ticket T1 · 3 checks passed
  • coverage 94.1%
  • review clear
  • 12/12 criteria
ApproveSend back with a note

Which Postgres version does staging run?

question
plan step · asked 3 min ago

Promote script: deploy order and rollback

review
ticket T1 · waiting since 09:42
Where it runs

Your machine runs the agents. Runfast keeps the record.

A small daemon on your laptop or build box uses the Claude Code subscription you already pay for, and Codex if you have it. Your repository and full transcripts stay on that machine.

Your machine

The daemon

  • Runs Claude Code, and Codex if you use it, with your logins
  • Builds each ticket in its own git worktree, and runs the checks there
  • Pushes as you, or as a GitHub App you install. Branch rules still apply
runfast.io

The control plane

  • Schedules steps and holds the proofs
  • Records every attempt, verdict and approval
  • Teams, roles, invites and the inbox
Before you ask

What it needs, and what leaves your machine.

What you need

Machine
macOS or Linux, with Node 22.12+ and Git 2.38+
Agents
Claude Code, logged in. Codex is optional
Code host
A GitHub repository, with gh logged in
Coverage
Measured for TypeScript and JavaScript with Vitest today
Permissions
Agents run as your user, so give the daemon its own clone

What leaves your machine

Stays local
Your repository, full agent transcripts and your logins
Stored by Runfast
Run inputs including the spec, each step’s result and verdict, JSON artifacts up to 256 KB, and the last 500 log lines of each attempt, which include commands and diffs of edited files
Fetched on demand
Other run files, such as a plan or a patch, only when you open them and only while your daemon is online
Request access

Get your first checked pull request.

We're onboarding a small number of teams. Leave your GitHub username. We'll add that account and email you when it can sign in.

The daemon is free. The hosted service is a paid plan; we share pricing with your invite.

Already invited? Log in with GitHub.

Access is tied to this GitHub account.