Cloud agent pricing: open-source credits, seats, tokens or machine hours

One workload, four bills

Ask what a cloud agent costs and most pages answer with a monthly number. That number hides the decision. Four vendors quote four figures that measure different things, and the gap between them shows up in month two, when the work changes shape.

Cursor sells a seat. Premium is $30 a month per person and Cloud Agents arrive on it. Everything an agent does draws on one weekly usage pool, shared with chat, the CLI and automations (Cursor pricing, checked 25 October 2026). Anthropic sells tokens and time: standard model rates, plus $0.08 per active session hour for Managed Agents. Web search adds $10 per 1,000 searches (Anthropic pricing, checked the same day). Railway sells machine time per second on its sandboxes (Railway pricing). Kortix sells credits against the agent computer, at 100 credits per dollar (Kortix pricing).

Which bill lands lowest depends on three facts: how many tasks, how long each holds a machine, and who pays for the tokens.

What each shape bills, and what it punishes

A seat is a price per person per month, and it fits a team whose agent use is uneven. Five people on Cursor pay $150 before a single agent runs. The parallelism they want comes out of the pool rather than the headcount. Cursor refreshes that pool weekly, so one heavy Monday borrows from the rest of the week instead of exhausting a month (Cursor docs). The shape punishes a team that wants many short tasks at once, because the pool becomes the limit.

A credit is money bought in advance and spent on the agent computer. Kortix sells them at 100 credits per dollar, one credit worth one cent, and 11 credits buy about an hour of the default 2 vCPU / 4 GB / 20 GB machine (Kortix pricing). Every tier buys credits at that same rate, so a larger tier buys more credits rather than a cheaper credit. The failure mode is narrower than the others. Credits pay for the computer and model calls stay separate, so the token bill sits beside the credit balance and someone has to watch both. Qoder runs the same shape from the other end, at $20 a month for 2,000 credits on Pro (Qoder pricing, checked 25 October 2026).

A token bill grows with everything the model reads. An agent that opens twenty files on its first turn opens them again on the second, unless the context is cached. Caching is priced well below fresh input: on Claude Opus a cached read costs $0.20 per million tokens against $4 for fresh input (Anthropic pricing). Long reasoning and large repositories are what this shape punishes. An agent that thinks for an hour can cost more than one that finishes in ten minutes, even when the slow one did less work.

A machine hour bills the computer while it is up, in proportion to the spec it reserves. Railway charges its sandboxes for the CPU they use and the memory they hold while running, and nothing for the time they spend waiting (Railway pricing). The shape punishes reservation. Four vCPUs kept warm between tasks pay for hours in which nothing happened. Qoder's QoderWake cloud computer is the flat version of that idea, listed at $10 a unit a month for a runtime that stays up (Qoder pricing).

A worked month: 880 short tasks

Take a team of five that runs 880 tasks a month, each holding its machine for 12 minutes. That is 176 agent hours. Each task sends about 50,000 input tokens and returns 15,000 output tokens, priced at $4 and $20 per million on Claude Opus.

880 tasks x 12 minutes                       = 176 agent hours Kortix, credits, own keys  176 hours x 11 credits                      = 1,936 credits, about $19  model calls on your own key                 = provider bill, nothing added                                                below $1,000 a month Railway, machine time  2 vCPU + 4 GB, 6 x $50 a month               = $300, so $73 for 176 hours  models                                      = your own key, extra Claude Managed Agents, tokens and time  880 x (50K input x $4 + 15K output x $20)   = about $440  176 hours x $0.08                           = about $14  web search, if the agent used it            = $10 per 1,000 searches Cursor, seat and pool  5 seats x $30                               = $150 a month, pool included  usage past the weekly pool                  = billed on top

The same workload lands at $19 on one bill and $440 on another, because each vendor meters a different thing. The $19 buys machine time on keys you already hold. The $440 is mostly tokens, which is what a token bill does to a workload that resends context. The $150 buys five people a week of pooled capacity they may not finish.

What Kortix charges, and where to read it

Free is $0 with 500 credits per month, on the user's own provider keys or ChatGPT subscription. The paid plan is credits: from $50 a month (5,000 credits), at 100 credits per dollar. Members are unlimited and the account shares one credit pool, and unused credits roll over one month (Kortix pricing).

Two things follow from those numbers. A task that runs 12 minutes costs about 2 credits of computer time, roughly two cents, and stops costing anything the moment the machine stops. The model side stays yours: any model provider with your own keys. Or the ChatGPT plan you already pay for. Model calls on your own key carry no surcharge below $1,000 a month, then a 5% fee paid from credits (Kortix docs).

Open source. Read it, fork it, audit it. The billing meter runs on that code, so a change to a rate or a fee is a commit you can read rather than a changelog entry.

Three questions to ask before a trial

Ask what one task costs. A vendor with a seat price will quote the seat, and a vendor with a token bill will quote a rate. Request both figures on a typical task and on a long one.

Ask what an idle agent costs. Stopped, waiting for a person, and running in the background are three different prices, and only one is usually published.

Ask whose keys the request leaves on. With your own keys the token price is visible and portable. With the vendor's, the rate is theirs and it moves with their model lineup.

When a seat is the cheaper answer

A seat wins when the team is small, the work is bursty, and nobody wants to hold provider keys. Five seats at $30 cost $150 a month and cover a moderate pool of agent use with the models bundled in. For a team that would spend its first month learning how tokens add up, that is the simpler bill.

It stops winning when tasks get short and numerous. At 880 short tasks the metered shapes land between $19 and $73 of machine time, and the seat price stays at $150 whatever the team does.