The Ithura Blog
Deep dive7 min read

Nothing to host

Handing a task to a coding agent used to mean running a machine for it. Now you add your own AI provider key and delegate: the agent runs at your provider, on your account, and Ithura adds no charge for the model. It runs your repository's own checks before it reports, opens a pull request it has no permission to merge, asks you when it hits a real decision, and shows the session's cost at list price to the cent. Prefer your own machine? That still works.

Until this week, handing a task to a coding agent in Ithura meant running a machine. You stood up a box, kept a process alive on it, gave it a webhook and hoped it was still there on Monday. Plenty of teams looked at that and decided agents were someone else's problem.

That step is gone. You add your AI provider key, create an agent, and delegate a task the way you would hand it to a colleague. The agent runs at your provider. You host nothing.

Your key, your account, our nothing

The agent runs on a key you own, from an account you already have. That is not a limitation we are dressing up. It decides three things that matter more than convenience.

  • Your prompts go to a provider you chose, under terms you agreed, not into a pool we rent on your behalf.
  • You can see and cap the spend on their side too, not only on ours.
  • Ithura adds no charge for the model. We are not a reseller with a margin hidden in the middle.

The receipt on every run shows the session's cost at your provider's list price, to the cent. If your account has a negotiated discount, you pay less than the receipt shows. We would rather state that than quietly round in our favour and call it precision.

What the agent is allowed to do

An agent that can write code is a liability until you know exactly where it stops. Here is where this one stops.

It does not merge, and it cannot

The agent works on a branch and pushes to it. Ithura's server opens the pull request, as the Ithura GitHub App. The agent's own credentials allow it to write repository contents and nothing else, so it could not open a pull request even if it tried, let alone merge one. The repository token is held by the provider, outside the sandbox the agent works in.

A person reviews, and a person merges. That has been true of agent work in Ithura since the beginning and it has not moved.

It runs your checks before it reports

Your repository declares its own checks in a file in the repository. The agent runs them in its sandbox before it tells us it is done, and the pull request lists each one with its result. A run that says it succeeded has passed the checks you named, on the commit it pushed.

You can also turn on a review pass: a separate session, with read-only access, reads the diff before the pull request opens and gets one round to fix what it finds. The pull request names the commit that was reviewed.

It cannot reach the internet by default

The sandbox denies network access except to the places the work needs: GitHub, your provider and the package registries. A project can add hosts it genuinely needs. The session's data lives with your provider, under your account.

When it needs you

An agent that guesses when it should ask is worse than one that stops. When this one hits a real decision it asks, with the options it is choosing between and what each would cost. The task appears in Needs you. You answer in a line, and the same session carries on with the same sandbox and the same context it already had.

Your answer is kept as a decision on the task, with the question as the agent put it. Six months later the reasoning is still there, attached to the work rather than lost in a chat scroll.

Asking for changes

Review the pull request the way you review anyone's. Request changes on GitHub, or just reply on the task. Either sends the agent back in.

Rework always updates the same pull request. Within twenty four hours of the agent's last report the same session continues where it left off. After that, or after a run that failed, a new session picks up the same branch carrying the earlier summary and your feedback. Either way you are looking at one pull request, not a pile of them.

What it costs, and how it stops

Every run has a cost cap of its own, which you set per agent. The run ends at the cap and says so. Your agent budget and your workspace budget still apply on top, and whichever is tightest is the one that bites.

There is a time limit per run and a limit on how many sessions can run at once, both by plan. Press Stop at any time: the agent is given a short window to save what it has, which it usually does by pushing to a work-in-progress branch, and then the run ends and the task comes back to you.

Prefer your own machine?

Your runner still works, unchanged. If you want the agent on hardware you control, with a coding tool you chose, that option has not gone anywhere and the task behaves identically either way: the same questions, the same pull requests, the same Stop button and the same budgets.

Starting

  1. Add your provider key

    Settings, then AI. A workspace admin adds it once. A project can override it later if that project needs its own.
  2. Create an agent

    Pick the repository it works in, and leave it set to run as a hosted session.
  3. Delegate something small

    Something with a clear edge, written the way you would write it for a colleague. Watch it work, and answer it if it asks.

One thing to expect on a first task: sometimes there is no pull request at the end. If the agent finds the work already done, it reports that instead and the task comes back to you with its reason. That is a finished run, not a failure, and it is common on exactly the small, clear task people choose first.

A hosted session works on a connected GitHub repository, so it is available on Starter, Pro and Enterprise. How many sessions run at once and how long each may take are set by your plan. The agent runs on your own provider key, and Anthropic is the supported provider today.