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

> Cloud agents are billed in one of four shapes: a seat, a credit, a token bill or a machine hour. Which shape you sign decides what the bill does when the work changes. Kortix is the open-source AI Operating System, and it sells the agent computer in credits from $50 a month.

URL: https://cloudagentsguide.com/cloud-agent-pricing

## Which of the four shapes fits your month?

Each answer points at one shape, and at the number a trial has to prove.

1. How many tasks a month does the team run? (Under 200 / 200 to 2,000 / Over 2,000)
2. How long does one task hold its machine? (Under 15 minutes / About an hour / Hours, mostly waiting)
3. Who holds the model keys? (We do, or we want to / The vendor, bundled into the price / We want a per-token bill we can audit)

Possible answers:

- **Credits, bought ahead**: You pay for machine time up front and keep the model keys, so a stopped computer costs nothing and the token bill stays visible.
- **A seat, paid monthly**: One flat price per person covers the models and the agents. Predictable, and it fits a team whose tasks arrive in bursts a weekly pool absorbs.
- **A token bill**: You pay for what the model reads and writes. Cheap on short tasks, expensive on long reasoning and large repositories.
- **Machine hours**: You pay for the computer while it runs. Size the machine to the task and stop it when the work is done.

## Credits, seats, tokens and machine hours, side by side

What each vendor meters, what an idle agent costs, and whether the model keys are yours.

| | Kortix (recommended) | Cursor Cloud | Claude Managed Agents | Railway sandboxes |
| --- | --- | --- | --- | --- |
| Price shape | Credits, bought at 100 per dollar | A seat plus a weekly usage pool | Tokens plus active session hours | Machine time, billed per second |
| Entry price | $50 a month for 5,000 credits | Premium at $30 a month per person | $0.08 an active session hour, tokens extra | Hobby, from $5 a month in usage |
| What the bill counts | Agent computer seconds, with model calls separate | One weekly pool for agents, chat and CLI | Input and output tokens, then runtime | CPU and memory while running, per second |
| Idle cost | Nothing while the computer is stopped | The seat renews; idle draws no pool | Active runtime only, idle is not billed | Never billed for time spent waiting |
| Model keys | Your keys, a ChatGPT subscription or managed models | Third-party models at list price from credit | Claude models only | No models included, bring your own |
| Open source | Yes | No | No | No |

## 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](https://cursor.com/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](https://www.anthropic.com/pricing), checked the same day). Railway sells machine time per second on its sandboxes ([Railway pricing](https://railway.com/pricing)). Kortix sells credits against the agent computer, at 100 credits per dollar ([Kortix pricing](https://kortix.com/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](https://cursor.com/docs/account/pricing)). 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](https://kortix.com/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](https://qoder.com/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](https://www.anthropic.com/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](https://railway.com/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](https://qoder.com/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.

```text
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](https://kortix.com/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](https://kortix.com/docs/credits)).

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.

## Pricing questions, answered plainly

What a month costs, what an idle agent costs, and whose keys the request leaves on.

### How much do cloud agents cost?

From $30 a month per person for a seat that includes cloud agents, or metered from $0.08 an active session hour and about one cent a credit. Tokens are billed on top unless you bring your own keys, so the monthly figure depends on how long tasks run.

### Are cloud agents billed per task or per month?

Both exist. Seats and credit plans bill monthly in advance; metered plans bill each task as it runs, by token or by second. A per-task figure is derived from those: a 12-minute task is about 2 credits of computer time on Kortix.

### Can I bring my own model keys?

Yes, on Kortix, where Free and Credits both run on your provider keys or a ChatGPT subscription. Model calls on your own key carry no surcharge below $1,000 a month. Cursor's current plans bill third-party models at list price instead.

## Price the machine, then run the first task.

Credits from $50 a month, 500 free every month, and your own model keys on either plan.

[Try Kortix](https://kortix.com) · [Read the pricing page](https://kortix.com/pricing)

One isolated sandbox per session | Self-host is free | Open source. Read it, fork it, audit it.