Working with agents

Agents do the work in Taiga. You start them constantly, usually without thinking of it that way: describing a project, generating a document, generating a backlog, starting a build, remediating a maintenance finding.

Some agent work is not started by anyone at all: maintenance sweeps follow your pushes, and the most urgent findings are remediated without being asked.

Your job is the two ends of that. Give an agent enough to work from, and decide whether what comes back is right.

Two kinds of input

Everything an agent produces comes from two sources, and it is worth keeping them apart because they behave differently.

Standing context flows down. Policies are set for the organization. Instructions and knowledge are set at the organization, the team and the project, each level narrowing the one above it. None of this is attached to a particular piece of work. It applies to everything, every time, whether or not anyone thinks to mention it.

Work flows forward. Whatever an agent produces becomes input to whatever comes next.

Any output is a product of both. When something comes back wrong, one of the two is where it came from, and they are fixed in different places.

Errors travel, so fix them where they start

Forward. Review a thing where it first appears, not at the end. Everything produced afterward is built on it, and nothing produced afterward will look wrong, because faithfully building on a bad input produces exactly what it should. By the time a mistake is obvious, it has been reproduced several times over.

Down. A problem you correct more than twice is not a problem with that run. It is standing context that is missing or wrong, and correcting the output leaves it in place for everything you build afterward. Move the correction up to the level where it is true, and it stops being something you catch. Write intake agents can act on is about doing that well.

Read the work, not the account of it

An agent reports on what it did, including checking off acceptance criteria it believes it met. Those are marked as verified by an agent, which is the point: it is the agent’s own account of its work, not an independent check.

The diff is the work. Everything else is a summary of it written by the same system that wrote the code. For anything consequential, read the diff.

The merge stays yours. A build ends at a pull request, and nothing reaches your default branch until you merge it.

Take the turn back before you edit

While an agent is working on something, that thing is read-only, and Taiga says why. It reopens the moment the turn returns to you.

This is deliberate. Editing an initiative halfway through planning produces a plan for a description that no longer exists. If you need to change something mid-run, stop first, then edit, then continue.

The same input does not produce the same output

Ask for the same thing twice and you get two different results, both plausible. A retry is a fresh attempt, not a replay, so it can succeed where the last one failed and it can fail the same way again.

Retrying twice is reasonable. Retrying five times is a signal to change an input instead.