Keep a backlog your coding agents can work through

Once a coding agent is doing the building, the bottleneck moves: it's knowing what to ask for next. The ideas are in a notepad, a chat with yourself, or your head, and every new session starts with you retyping one of them.

A backlog fixes that, but only if the agents can use it. "Pull from the backlog" should be the whole instruction: the agent takes the next thing that's ready, nobody else takes it too, and it comes off the list when the work ships.

This guide covers what an agent-friendly backlog needs, what people try first, and how Gaitro's backlog works.

What an agent-friendly backlog needs

Writing things down has to be quick. If adding an item takes a form with six fields, the ideas stay in the notepad. One line should be enough, and a pasted list should become one item per line.

Half-formed ideas need somewhere to wait. Plenty of what you write down isn't ready to build: it needs a decision, a design, or a second look. Agents should leave those alone until you say otherwise.

Two agents must never take the same item. With three agents pulling from one list, two of them will ask for "the next one" at the same moment. Exactly one should get it.

A claim has to let go. An agent that crashes or gets closed shouldn't sit on an item forever.

Done should mean shipped. An item is finished when the change for it ships, not when an agent says it's finished.

What people try first

Approach	What it fixes	What it doesn't
A TODO.md in the repo that agents read	The list lives next to the code, and agents can read it	Two agents read it at once and start the same item; ticking items off makes changes that collide
An issue tracker the agents can reach	Proper statuses, labels and history	Agents claim items by convention, not by rule, and the board drifts from what actually shipped
Pasting the next task into each session	No tooling to set up	You're the queue. Nothing runs while you're away, and nothing records what's left

Each works with one agent. The trouble starts with the second: the list needs a rule about who takes what, and a link to what actually shipped.

How Gaitro does it

Every Gaitro project has a Backlog tab, and agents reach it through the gaitro backlog commands or the matching tools.

1. Add in one line. Type what to build next and press Enter. Pick Feature, Bug or Speed, or let Gaitro guess from the words. Paste a whole notepad and each line becomes an item.
2. Not ready until you say so. New items start as Not ready, which agents skip. Reword them while you think, then press Mark Ready when one is clear enough to build. Start a line with idea: and it stays Not ready.
3. Agents take the next Ready item. Tell an agent to "pull from the backlog" and it claims the oldest Ready item, or "grab the next 3 features" and it claims three. When several agents ask at once, each item goes to exactly one of them. Each claimed item gets a run name, like bakery-menu-photos, so you can tell the runs apart.
4. Claims let go on their own. A claim lasts as long as the agent keeps working on it. When the agent stops, the item goes back to Ready for the next one. An agent can also let an item go with a note on why.
5. Shipping completes it. The draft an agent starts for an item is linked to it. When you ship that draft, the item is marked Completed.
6. Agents suggest; people decide. An agent that spots a problem mid-task can add it to the backlog, but it lands as Not ready and marked as agent suggested. Only a person makes an item Ready or closes it.

Filters show Features, Bugs, Speed, or what agents suggested, each with a count.

Setting it up

1. Sign up, install the CLI and log in (Get started).
2. Bring your project in (Already building?) and connect your agent (Connect your agent).
3. Open the project's Backlog tab, add a few items, and mark the clear ones Ready.
4. Tell your agent to pull from the backlog. With several agents, give each its own working copy (Run several coding agents on one repo) and tell each the same thing.

The commands are in the CLI reference and the tools in MCP.

Questions

Can agents add to the backlog? Yes, and it's useful: an agent fixing one thing often notices another. What it adds is Not ready and marked agent suggested until you look at it.

Can I change an item after adding it? A Not ready item can be reworded: click its title. Its kind can be changed any time it's open. A Ready item's words are fixed, because an agent may already be building from them; mark it Not ready first.

What if an agent takes something and gives up? When it stops working, its claim runs out and the item is Ready again for the next agent. Nothing is lost.

Does the backlog replace my issue tracker? It doesn't have to. It's the short list of what agents should build next, kept next to the code they build it in.