The Ithura Blog
Deep dive6 min read

The task follows the pull request

Hand a task to a coding agent and the work comes back to the task: the steps it took, the tests it ran, the pull request it opened and what the run cost. It talks in chat while it works, every run is in the agent ledger and reversible, and a finished run fires a signed webhook. Then the review round runs itself. Delegating needs member access; how many agents and runs you get depends on your plan.

Handing a task to a coding agent is easy. Knowing what happened next is the hard part. The agent opens a pull request somewhere, a reviewer asks for a change, and the task sits in your board saying "In progress" for three days while all the actual news happens in a different tool.

A delegated task now follows its own pull request. When a review round starts, the task says so. When a reviewer asks for changes, the task goes back to working and carries the review text with it.

Delegate, do not assign

An agent is a delegate, not an assignee. The task still belongs to a person, and that person is still the one who answers for it. The delegate is a second field that says who is currently doing the work.

There are two kinds, and the difference is worth knowing:

  • A coding agent using an Ithura API token. It polls for work and reads the task itself.
  • A registered runner. Delegating to one starts the run immediately, and feedback later arrives as a fresh run.

How a pull request finds its task

By the task reference, in the branch name or the pull request title. A branch called PAR-128-fix-overflow links to PAR-128, and so does a title that mentions it. One pull request can carry several references and link to all of them.

Nothing needs configuring for this. The prefix has to match a project in that workspace, and case does not matter.

IdleYou hand the task to an agent
WorkingThe agent is on it
In reviewA pull request carrying the task ref is open
WorkingA reviewer asks for changes
In reviewThe agent pushes again
DoneMerged

What each step actually means

A merge does not force the task to Done. The delegation finishes, and the task itself follows whatever pull-request-to-state mapping your workspace already has, so a team that moves merged work to "Ready to release" keeps doing that.

Two rules keep the automation from talking over a person. If the agent has asked you a question, no pull request event overrides it; the question stays until you answer. And a pull request closed without a merge returns the task to idle only if it was in review.

When a reviewer asks for changes

A "changes requested" review on GitHub sends the task back to working and puts the review text on the task, so the next person to look at it sees what was asked without opening GitHub. A runner gets a new run carrying that feedback; a token agent reads it from the task.

A new push to the same pull request moves the task back to in review. Worth being precise here, because it is less clever than it sounds: any pull request event on a working delegated task with an open pull request does that, not only a push that answers a review.

A linked pull request says what it actually knows

A pull request that arrives through the GitHub webhook carries its state with it, so the task is right from the moment it links.

A link you paste in by hand is a different matter. Ithura will ask GitHub for its real state where it can, which needs the GitHub App installed on that repository. Where it cannot ask, and that includes every GitLab and Bitbucket link, the link reads Status unknown until an event arrives to settle it.

An unknown link never moves a task into review. That is the point of it. A pasted link that we quietly assumed was open would put a task into review on the strength of a guess, and a guess that reads like a fact is worse than an admission.

What the run leaves behind

The pull request is the output. The run is the account of how it got there, and it lands on the task while the agent is still working.

You get the provider and model, the files it read, the tools it ran, the tests and whether they passed, the commit, and the pull request. You can watch it live or read it after. When it finishes it reports its usage, so what the work cost sits beside the result: a cost when it ran against an API key, an estimate when it ran against a subscription, because that is honestly all a subscription figure is.

We do not show you the diff. The pull request already does that well. What is missing elsewhere is the part around it: why the work started, what the agent tried, what it cost, and how to take it back.

Where you see it

  1. On the task

    The run timeline, with the status, the summary, the cost and the pull request link. The delegation chip says who is working and what state it is in, and a changes-requested review shows the review text inline.
  2. In chat

    Picking up a task opens a thread, and the agent replies there as it starts and finishes, with what it changed and what it cost. Nothing to wire up. Answering its question in the thread answers it on the task. The thread goes to the workspace agents channel, or to the project's own channel when the project is private.
  3. On Home

    Agent questions come first, because a person is blocked. Review rows follow, with a next step card that takes you straight to the pull request waiting on you.
  4. In the agent ledger

    Workspace settings, Agent ledger: what your agents ran across the workspace and what they changed, with the option to put a change back.

A finished run also fires an agent_run webhook, so your own systems hear about it: signed, once per run, with every delivery kept and retryable.

Delegating a task needs the Pro plan and member access. An agent holds no seat of its own. It acts under a named API token with the scopes you granted it, and a run can only start on a task that was delegated to that agent.