one task. one card. fresh evidence.

Make “done”
show its work.

Stop trusting an agent's own "I'm done." Read task.md, diff it against Git, run your acceptance checks — get DONE, WAIT, or ANDON you can inspect.

Thanks — you're on the list. We'll email you about Finishline Supervisor only; nothing else, never shared.

Download the free CLI ↓Read the limits

Python 3.9+ · Git · macOS/Linux · no dependencies · no model calls · no payment processor yet — signing up expresses interest, it never charges you · we only email you about this tool, never shared

WAIT 1

The checklist is incomplete, or fresh checks have not been run.

ANDON 2

Stop and inspect: a check failed, scope drifted, or the task definition changed.

DONE 0

Checklist complete. Scope fits. Every acceptance check just passed without changing observed evidence.

pricing

Free forever. Paid tiers are early-access, not a checkout.

Local

Any dev comfortable writing their own checks

Full CLI, example task card, runnable demo
Local evidence, no account, no telemetry

source: codex + claude

Setup Pilot

$99 one-time, founding price

Small teams wanting a reliable agent handoff on one repo

One task-contract template
Up to 3 acceptance checks
One setup review

source: codex

Team Early Access

$9/seat/mo, planned

Teams running agents across multiple repos

Hosted card-history dashboard
GitHub PR status check gating merge on DONE
Slack alert on ANDON

source: claude

Join above and pick a plan — this is a waitlist, not billing. Full launch plan and synthesis →

why this exists

The task survives the handoff.

A new agent session can read the same finishline.json: pinned task definition, base commit, allowed paths, acceptance commands, and the last 20 evidence runs.

Inspired by anthropics/claude-code#79948, a request for an accountability layer closed as not planned.

This implements a small repo-local slice of that request. It cannot provide the native, unbypassable enforcement boundary the issue asks for.

a real three-run task

Build. Check. Finish.

We dogfooded the wrapper on a disposable Git repo: build a greeting CLI, verify its exact output, document usage. The first output was almost; the required output was finish line.

Inspect the full recorded evidence →
Read the recorded terminal output →

recorded CLI output · runnable demo included in source

run 1: WAIT (exit 1)
  task checklist is incomplete
  checks not executed; pass --run-checks after reviewing argv
  evidence: task.md#L1, task.md#L2, task.md#L3
run 2: ANDON (exit 2)
  task checklist is incomplete
  acceptance check failed
  acceptance exit: 1
  evidence: task.md#L1, task.md#L2, task.md#L3
run 3: DONE (exit 0)
  acceptance exit: 0
  evidence: task.md#L1, task.md#L2, task.md#L3

Run 1 built the CLI. Run 2 added documentation and exposed the wrong output. Run 3 repaired the output and completed verification. Signals came from three separate CLI invocations, not an agent's narrative.

start small

Your task, your definition of done.

Keep the downloaded script in a trusted location. In a Git repository with at least one commit, create task.md:

- [ ] Build a greeting CLI
- [ ] Verify its exact output
- [ ] Document usage

Pin the task before work starts. The check below actually runs app.py and verifies its output. Review the argv in the generated card before opting into execution.

python3 /path/to/finishline.py init \
  --allow task.md --allow app.py --allow README.md \
  --check '["python3","-c","import subprocess; assert subprocess.check_output([\"python3\",\"app.py\"], text=True).strip() == \"finish line\""]'

# Observe without running commands:
python3 /path/to/finishline.py check

# After reviewing the commands:
python3 /path/to/finishline.py check --run-checks

Mark checklist items [x] as you finish them. Run again at each handoff. A prior passing run never counts as a fresh check. ANDON exits 2, WAIT exits 1, DONE exits 0.

honest limits

Evidence, with a trust boundary you supply.

Anyone who can edit the card, script, or checks can bypass this wrapper. It is not a sandbox or native agent enforcement.
Checks execute local programs with your permissions and environment. They can have side effects; there is no rollback. No automatic merge, deploy, or agent orchestration.
Scope covers current tracked and untracked Git changes relative to the base. Ignored files, external state, reverted changes, and the card itself are excluded.
DONE is only as strong as your acceptance checks. A deployment needs its own check. Command output is discarded; evidence contains exit codes and paths. Keep secrets out of task text, filenames, and argv.

Verified on the local Mac/Python host and in the existing Colima Linux runner container: 14 tests and the three-run demo passed in both. The CLI has not been tested on Fly or Boring.