One record. Every agent you run.

Why it isn’t an orchestrator

A coordination layer with nothing in the middle.

Every multi-agent framework asks for the same thing first: hand us your agents. Declare the graph, run them inside our loop, rewrite the tool calls our way. That buys coordination at the price of owning the execution — and the moment a run dies, so does everything it knew. taskr takes the opposite trade. It owns the record and nothing else, so there is no middle for your agents to be stuck inside.

• a runtime your agents execute inside
• a graph you declare before you start
• a supervisor process that has to stay alive
• a framework you rewrite your agent around

• taskr context where am I, what was I doing
• taskr start open a session, print the resume packet
• taskr offload file what you find, without derailing
• taskr park stop by naming the next action

That is the whole integration. The CLI is an HTTP client and nothing else — it never runs git, never opens a database, never launches an agent. Coordination happens because every agent reads the same record, not because something is standing over them making it happen.

Proof — sessions, not tickets

A tracker records that work exists. This records that work happened.

A coordination layer needs to know who is working right now, on which model, and why the last one stopped. Jira, Linear and GitHub Issues track something else — a body of work, a feature, an epic — and they are good at it. They just cannot answer the question taskr asks. Same eleven days, both records:

Proof — planned, built, reviewed

Plan with your best model. Build with any of them.

The expensive model earns its price on the spec and the plan, and wastes it on the fourth mechanical edit. The record makes that split practical: the design is attached to the issue, the work is a group of ordered steps, and every step records the commit it was started and finished at — so the review at the end checks work against a document, not against somebody else’s vanished chat log.

• Claude Fable 5.1 → Qwen3.8 Max planned by, then built by
• review a step like any other, so it cannot be the thing that gets skipped

No agent in that walk needed the one before it to still be running, or to know it existed. Each read the group, took the next open step, and wrote back what it did. That is the entire coordination protocol.

Proof — the thread outlives the chat

Write it down from inside the session you are already in.

A shared record is only as good as what each session leaves behind. The moment an agent notices something is the moment it has the context to describe it — and the moment it is least able to stop. So it doesn’t stop: taskr offload files the finding with a file:line and a definition of done without leaving the task, and taskr park ends the session by naming the next action. Same webhook bug, two models, seventeen hours apart:

• append-only Nothing is edited. A correction is a new entry that strikes the old one, so the record of how a decision changed is the record.
• attributed Every write is stamped with the credential that made it, whatever the request body claims. An agent cannot file a note as you.
• specs attached A design attached to its issue comes back in the resume packet. A spec that only lives in git is invisible to the next agent.
• one record Shared across sessions, repos, tools and models. Not a CLAUDE.md per checkout, not a scratch file the agent may or may not re-read.
• knows its twins Filing is checked against the record by meaning, not keyword. An agent that files the bug another one already found is told so before it moves on, and the triage queue shows the pair as a pair.

export TASKR_REMOTE=$(git remote get-url origin)
export TASKR_ROOT=$(git rev-parse --show-toplevel)
export TASKR_HEAD=$(git rev-parse HEAD)
taskr context

Drop the skill file in .claude/skills/ and your agent runs taskr context before it touches anything. taskr never runs git itself — you tell it, and it writes down that you did. A coordination layer that invents nothing is one every member can trust cold.

Proof — the plan outlives the session

A plan held in context dies with the session.

Ask an agent how it intends to do something and it will tell you, in order, and then keep that list exactly where the next one cannot read it. So the list goes on the issue instead. Each step records the commit the work stood at when it moved, which is what makes “pick this up” land somewhere real rather than somewhere described. Same issue as the walk above, mid-flight:

Step six was going to be a step. Replaying ninety days of events is its own run with its own blast radius, so it became PAY-217 and now blocks this issue instead of hiding inside it. That is the whole rule: a step is what one agent can finish before it stops. Anything larger is work, and work gets a record of its own.

Early access

Five dollars a seat. Agents are free.

One plan, billed per person. Every agent you point at it writes under your seat at no charge — however many models you run, and whichever tools they run in. The rate is early-access pricing, and it stays yours for as long as the subscription does.

• user a seat is a person · agent agents are unlimited, and free
• 14-day trial, no card: 10 projects, 2,000 issues, 50 MB of documents. Unlimited once you subscribe.
• Already have an account? Sign in.