A coding agent that runs in the cloud, on open-weight models.
Sign in with GitHub and point it at a repository. It works in a container of its own — reading files, running commands, driving git, and clicking through a real browser it can see. You pay for the tokens it burns and nothing else.
You are charged for the tokens the agent uses. Nothing per seat, and nothing while it is idle.
How it works
The agent runs on our infrastructure. Your machine only needs a browser.
Sign in with GitHub
Your identity and your repository access both come from GitHub. Choose the repository you want worked on, and the agent gets a token scoped to that one repository for the length of the session.
A container starts for the session
Each session gets its own container with a checkout, a shell and a browser. It stops itself after thirty minutes without input, so a session you walk away from stops costing money.
Model calls are metered
Every call goes through our proxy and is charged against your balance at the rate it actually cost. The API key stays on the server, so it cannot be copied off a laptop.
What makes it different
Three decisions that most agents get the other way round.
Open-weight models, priced per token
The default is DeepSeek v4.1-flash served through OpenRouter. A measured turn that wrote a file, ran it with node and reported the output cost $0.0013 across four model calls. Long runs over a large codebase are where the money goes, and those are still counted in cents.
A browser it can actually see
Not a scraper. A real Chromium with a visible cursor, screenshots fed back to the model, and clicks that land where it meant them to. It can check its own front-end work instead of describing it.
Limits that hold server-side
Budgets, model allow-lists and step ceilings are enforced where the model call happens, not in the client. The running cost of a turn is on screen while the turn is happening, reconciled against real usage rather than estimated from token counts.
Questions
What does a run cost?
Model usage is charged as credits: input tokens, cached tokens and output tokens, each at the rate the upstream charged us. A measured turn that wrote a file, ran it and reported back came to a tenth of a cent. Idle time costs nothing, because the container is not running.
Where does my code go?
The agent works on a clone inside a container that exists for one session. We store usage numbers, not your prompts and not your source. The container is destroyed when the session ends.
What happens to the work when a session ends?
The agent commits to a branch in your own repository as it goes. When the container is destroyed that branch is still there, so the work outlives the session that produced it.
Can I stop it spending?
Three ways. Stop ends a turn mid-tool. A monthly budget refuses calls past a ceiling you set. And the balance itself is a hard floor — at zero the agent stops rather than running up a bill.
Why GitHub sign-in only?
It is the account you already have, it carries the identity your teammates already know you by, and it means we never store a password. Nothing else is planned.