An agent that can read a task, write code and commit is useful. The same agent is a liability until three plain things are true: it cannot spend more than you agreed, it cannot hand you work that fails your own tests, and you can see what one accepted change actually costs.
None of that is about trusting the model more. It is about where the limits sit. Here is where Ithura puts them.
A cap, set by you, enforced before the run starts
In Settings, Agents you set a spending cap for one agent, or one for every agent together. A cap is a dollar figure per day or per month, with a warning level that defaults to 80 percent. Both periods reset at 00:00 UTC.
At the warning you are told. At the cap, new runs do not start. The agent shows as paused with the time it resumes, and Home says so in a line rather than leaving you to work out why nothing moved overnight.
A run already working is not killed part-way. It finishes. Stopping an agent mid-edit would leave a half-written change and a branch nobody asked for, which is worse than the last few cents. Only the next run is held back.
Setting a budget needs admin, seeing one needs member access, and there is no separate plan for it. A cap is part of running agents, not a tier above it.
A gate it cannot talk its way past
The agent does not decide whether its work is good enough to push. You write the checks, and the runner runs them after the agent has committed and before anything leaves the machine.
- 1The agent commitsIn its own worktree, on its own branch. It is told not to push, merge or deploy.
- 2Your checks runOnly the ones whose files changed. The first failure stops the sequence.
- 3A failure goes backWith the output, for a limited number of fix rounds. Then the checks run again.
- 4A reviewer reads the diffA separate session with read-only tools. High and medium findings go back to be fixed.
- 5The runner pushesOnly now, and only if the checks pass. Otherwise nothing is pushed at all.
- 6A person mergesThe pull request lists every check and every finding. The agent has no part in this step.
Each check names the files that make it relevant, so a change to the web app does not sit through the Go test suite. The runner works out what changed, runs the checks that match, and stops at the first failure. Each check appears on the task timeline as passed or failed, with the end of the output when it failed.
If a check fails, the agent gets the output and a limited number of fix rounds. If it still fails when the rounds run out, nothing is pushed and no pull request is opened. The run is marked failed with the name of the check that stopped it. That is the part that matters: a change that does not build is not turned into somebody else's review.
A second pair of eyes
Once the checks pass, a separate session with read-only tools reads the diff and lists problems with a severity, a file and a line. It can read the repository and the history. It cannot edit anything, which is the only reason its opinion is worth having.
High and medium findings go back to the agent to fix, and the checks then run again. Every finding is listed on the pull request under Reviewer notes, including the ones nobody acted on, so a reviewer sees what was raised rather than only what was fixed.
The agent does not merge
This is a boundary, not a setting. The agent is instructed not to push, merge, deploy or touch production; the runner pushes its branch for it. By default its tools allow tests and git add and commit, and block git push, ssh, curl, gh and kubectl.
What arrives is a pull request with the checks listed, the reviewer notes attached, and a last line that says review and merge are yours. A person reads it and a person merges it. An agent that could merge its own work would make every control above decorative.
Honest cost
Cost per run is a number that flatters everyone. A cheap run that produced nothing costs more than an expensive one that shipped. So the figure to watch is cost per merged pull request: what one piece of accepted work costs.
Each agent gets a quality read over a window, 7 days by default and up to 90:
- Merge rate, of the pull requests it opened in the window. Closed and still-open are counted separately.
- Review rounds per merged pull request, median and total. A round is one piece of feedback: changes requested, a comment, failing checks or a conflict.
- Runs where checks failed, and runs stopped by checks. The first is work that did not pass first time. The second never became a pull request.
- Questions asked, cost, and cost per merged pull request, with a four-week trend.
Runs where checks failed counts the run even when a fix round then passed. That is deliberate. It measures whether the agent got it right the first time, which the merge rate cannot see, and it is the number that moves when a model or a prompt gets better.
Where a figure cannot be computed it is left empty rather than shown as zero. With nothing merged there is no merge rate and no cost per merged pull request, and the page says so.
What this does not do
Four things to be clear about, so you do not configure them and wait.
Checks only exist if you write them
An empty verify block gates nothing. The runner has no opinion about what your tests are; it runs the commands you give it. No checks configured means no gate, and the timeline will say no check matched the changed files.
The review pass and shared memory need the claude-code adapter
The review pass needs a provider that can be run with read-only tools, and the shared memory folder is a claude-code arrangement. Turning either on with another provider is rejected when the config is checked, rather than silently doing nothing.
A budget counts agent and runner spend, not everything
Spend from other features, such as asking Home a question, is not counted against an agent budget. If the agent has its own cap and the workspace has one too, either can stop it.
The quality read needs the Pro plan
Budgets do not, and the gates run on your own machine. The read is Pro and member-level.
Run ithura-agent check before a real run. It tests the config, the token, the repo and base branch, the push method and the provider binary, and exits non-zero if any of them fail. Unknown keys in the config are an error, so a typo in a check name is caught then rather than halfway through a run.