It asks instead of guessing
When a stage needs a decision, tad pauses and asks on the issue. Answer in Linear and it carries on from where it stopped.
Free For teams on Linear, GitHub and Claude Code
Delegate the issue.
Delegate the issue.
Review the pull request.
Assign a Linear issue to tad and go do something else. An architect plans it, a developer builds it, QA tests it and a reviewer reviews it, on your machine, with your Claude Code. You get a pull request. You decide what merges.
$ curl -fsSL https://relay.tad.46.225.154.205.sslip.io/get | sh
macOS and Linux · Windows through WSL2 · no account tiers, no card
PLAT-142
Export invoices as CSV
Finance needs every invoice in a date range as a CSV, from the invoices page. Some months have 40k rows.
- Status
- Backlog
- Delegated to
- ttad
- Owner
- MRMaya R.
- Labels
- repo/apiqa-passed
Plan
- Stream the CSV from GET /invoices/export.csv, no buffering
- Validate the range; cap it at one year
- Export button on the invoices page
- Tests: empty range, 40k rows, commas in names
Agent sessionlive
How it works
The four steps a good team already takes.
Every issue goes through the same stages, each run by an agent whose instructions live in your repo. tad moves the issue across your Linear board as it goes, and after every stage it checks that the board says what the agent claims.
01
Architect
Reads the issue and the code, writes the plan into the issue, and splits big work into PR-sized slices in the order they have to land.
Backlog → Todo
02
Developer
Creates the branch in its own worktree, with its own database and ports, and writes the code and the tests.
Todo → In Progress
03
QA
Runs the tests, calls the API, starts the app. Passes it, or sends it back with findings. Says plainly what it couldn't click through.
In Progress → In Review
04
Reviewer
Reads the diff against the plan and your conventions. Sends it back, or opens the pull request.
In Review → In PR
05
you
Read the pull request and merge it. That part is yours: tad never merges, and never pushes to main.
In PR → Done
The agents are Markdown files in .claude/agents/. Change how tad plans, codes, tests or reviews the way you change anything else: in a pull request.
Guardrails
Unattended, not unsupervised.
tad is built to work while nobody's watching, so it's strict about what it does on its own.
It never merges
Merging, force-pushing, pushing to main and hard resets are denied to every run, whatever an agent's instructions say.
The board tells the truth
After each stage, tad re-reads the issue and checks that its state and labels match what the agent reported. If they don't, it stops.
It knows when it's going in circles
QA and review can send work back, up to a limit. The same findings twice and tad stops and hands the issue to you.
A clean room per issue
Each issue gets its own git worktree and whatever your .tad/setup provides: a database, ports, seed data, test logins. Parallel runs never collide.
Merge conflicts, handled
When main moves under an open pull request and they conflict, tad runs the pipeline again to combine the changes, and tells you it did.
Where it runs
Your code stays where it already is.
The agents run on each developer's own machine, with their Claude Code login, git and GitHub access. A small relay takes Linear and GitHub webhooks and routes each issue to the right machine. It never runs code and never sees a repository.
- Your Claude Code subscription. No API keys to hand over, no new bill.
- Linear through the relay. Machines never hold your workspace's app token.
- Access through Clerk. Remove someone from your organisation and their machines stop at once.
Linearissues, agent sessions
GitHubpull requests, merges
tad relaywebhooks · routing · leases
your machine tad start
claudethe four agents
git · ghbranch, push, PR
worktreesone per issue
Teams
Made for a team, not a demo.
Whoever delegates, builds
Each issue runs on the machine of the person who handed it to tad. Leases make sure it's never built twice.
PLAT-142 → maya-mbp:apileased
PLAT-151 → jon-linux:webleased
PLAT-142 → jon-linux:apirefused
Many repos, many teams
An API and a web app, one team or five. Each issue is built in the repo it belongs to, and projects are split into slices across repos.
Checkout v2 → 4 slices
PLAT-160 · repo/api1st
PLAT-161 · repo/webafter 160
PLAT-162 · repo/apiafter 160
See all of it
Live steps in every issue's agent session, and a dashboard of your organisation: who's online, what's running, what's blocked, what's waiting on you.
● maya-mbp:apideveloper · PLAT-142
● jon-linux:webqa · PLAT-151
● PLAT-161blocked by 160
Get started
From install to your first pull request.
-
Install the CLI
One static binary. Run
curl -fsSL https://relay.tad.46.225.154.205.sslip.io/get | sh, or download it. -
Connect your organisation, once
An admin of your organisation opens
https://relay.tad.46.225.154.205.sslip.io/installand approves tad for your Linear workspace. Everyone else skips this step. -
Set up your repo
Run
tad initin your repo. It asks a few questions, signs you in, and writes the agents,PROJECT.mdand an environment hook. Commit what it writes: your team shares it. -
Leave it running
Run
tad startin a terminal tab or tmux. It waits for work. -
Delegate an issue
In Linear, delegate an issue to tad. Follow it in the issue, or with
tad status.
You'll need git, the GitHub CLI and Claude Code, each signed in, on macOS or Linux. On Windows, run tad inside WSL2. The default environment hook uses Docker for a database per issue.
$ curl -fsSL https://relay.tad.46.225.154.205.sslip.io/get | sh Installed tad to ~/.local/bin/tad $ tad init ✓ signed in as maya@acme.dev (Acme) ✓ acme/api builds for PLAT ✓ wrote .claude/agents, PROJECT.md, .tad/ $ tad start [relay] building acme/api for PLAT [scheduler] started, max 1 in parallel [scheduler] PLAT-142 delegated by maya · architect
Download
Get tad.
A single static binary. No runtime, nothing else to install. tad 1554a72
yours
Windows
Runs inside WSL2, next to your repo and your Claude Code.
Downloaded in the browser? Make it runnable:
SHA-256 checksums
chmod +x tad-* && mv tad-* /usr/local/bin/tad. On macOS, also xattr -d com.apple.quarantine /usr/local/bin/tad, since the binary isn't notarised yet.Free. That's the whole pricing page.
There's no plan to pick and nothing to upgrade to. tad runs on your own machine with your own Claude Code subscription, so the only usage involved is Claude usage you already have.
FAQ
Fair questions.
Does my code go to tad's servers?
No. The agents run on your machine through Claude Code, which talks to Anthropic exactly as it does when you use it yourself, and branches are pushed to your GitHub. The relay sees issue identifiers, statuses and short notes. It never sees a repository and never runs code.
Will it merge something I haven't reviewed?
No. Merging, force-pushing, pushing to main and hard resets are denied to every run. tad's job ends at an open pull request.
What happens when it gets stuck?
It asks. A stage that needs a decision posts its questions on the issue and waits for your answer. If work keeps bouncing between QA or review and the developer, or the board doesn't match what an agent reported, tad stops and says why.
Can I change how the agents work?
Yes. They're Markdown files in your repo's .claude/agents/, with your conventions in PROJECT.md. Edit them in a pull request like any other code.
Can QA click through my UI?
Not yet. QA runs the tests, calls the API and starts the app, but has no browser. It says so in its report, and the pull request lists what still needs a human click-through.
Which tools does it work with?
Linear for issues, GitHub for code, and Claude Code for the agents. Pull requests target main.
Is it really free?
Yes. There's nothing to pay for. The Claude usage tad's agents consume counts against your own Claude Code plan, as if you'd run those sessions yourself.