How to scale AI agent computers to thousands on Orgo

If your platform gives each of its users an AI agent, you can give each user a computer too. On Orgo, that computer is a full cloud desktop with a browser, terminal, and files. Your agent controls it through the API, and you can watch it over VNC.

Scaling comes down to three things: pick a size for each computer, stay inside your plan's pools, and add capacity from code before you run out. You can add up to 100 computers on your own. Past that, Orgo raises the cap for your account, to thousands of computers, at the same prices.

What does it mean to scale Orgo to thousands?

Two layers work together:

1. One computer per user. Each of your users gets their own computer, so their desktop, browser, and files stay separate from everyone else's.
2. Account capacity. Your account has a limit on how many computers it can run and how much RAM and vCPU they share. You check what is free with GET /account/capacity, add more with POST /account/capacity, then create computers against it.

The scaling guide shows the pattern. Linux and Windows computers are self-serve (Windows is included on Scale and an add-on on other plans). Mac and iPhone are available by request.

What instance types can I pick?

Orgo has five named sizes. When you create a computer, send cpu, ram, and disk_size_gb for the size you want, along with the required workspace_id and name (Create computer).

• Small is API only. The dashboard offers Medium and up.
• If you send only ram, you get that size's vCPU: 2 for 8 GB, 4 for 16 GB, 6 for 32 GB. With neither cpu nor ram, you get 1 vCPU and 4 GB, unless a template sets its own size. Leave out disk_size_gb and you get your plan's default disk.
• XL is the largest size you can create on your own, on any plan, when your pools have room for it. Anything larger returns 403 with code CONTACT_US_FOR_SIZE, and Orgo sets it up on request.
• No computer goes above 8 vCPU, 64 GB RAM, or 300 GB disk, on any plan or with any add-on.
• A new macOS computer has 10 GB of RAM.

Every size includes API and SDK control, screenshots, mouse and keyboard input, bash, file upload and download, and VNC.

How do plan pools work?

Each plan sets account-wide limits: how many computers you can run and how much RAM they share. vCPU is a shared account pool too.

A computer draws its RAM and vCPU from those pools, up to XL on your own. Disk has a per-computer limit instead: 40 GB on Starter, 80 GB on Growth, and 150 GB on Scale, raised by added storage.

A create that would go past a limit is refused with a code that names it:

• 403 VM_SLOT_ADDON: every computer your plan and add-ons allow is in use.
• 403 RAM_ADDON: not enough RAM is free for that size.
• 403 VCPU_ADDON: not enough vCPU is free for that size.
• 400 disk_exceeds_quota: the disk is above your per-computer limit.

Added capacity fixes each of them. A free account gets $5 of signup credit, which runs one Medium Linux computer by the hour. Adding capacity needs a paid plan: on a free account, the capacity API answers 402 with code no_subscription. Current plan prices and add-on rates are on the pricing page.

How do I add capacity from code?

The scaling guide uses a check-then-add loop:

1. Check capacity with GET /account/capacity. Your open computer slots are computers.limit minus computers.in_use. The response also says how many more of each size you can add (can_add) and what each size costs a month.
2. If too few are free, POST /account/capacity with a size (such as medium) and a count, up to 500 per request.
3. Price it first by setting dry_run to true. Nothing is bought.
4. Create computers against the new capacity.

What a purchase needs:

• An account-wide API key. Capacity is billed to the whole account, so a workspace-scoped key returns 403 with code account_key_required.
• A paid plan. Added computers go on your plan's subscription: the charge for the rest of the current period is made now, and the full amount joins each renewal after it.

Send an Idempotency-Key header with every purchase. A retry with the same key returns the first answer and never buys twice.

The API base is https://www.orgo.ai/api. This Python sample follows the scaling guide, with dry_run on so it only prices the purchase:

import os
import uuid
 
import requests
 
API = "https://www.orgo.ai/api"
headers = {"Authorization": f"Bearer {os.environ['ORGO_API_KEY']}"}
 
response = requests.get(f"{API}/account/capacity", headers=headers)
response.raise_for_status()
computers = response.json()["computers"]
free = computers["limit"] - computers["in_use"]
 
if free < 10:
    purchase = requests.post(
        f"{API}/account/capacity",
        headers={**headers, "Idempotency-Key": str(uuid.uuid4())},
        json={"size": "medium", "count": 50, "dry_run": True},  # remove dry_run to buy
    )
    purchase.raise_for_status()
    print(purchase.json())

Remove "dry_run": True to buy. The sample makes a new key on every run, so to retry a purchase whose answer you lost, send it again with the same key.

You can also add a custom shape, or memory, vCPU, and storage on their own (Add capacity). Then create each user's computer. Templates give every new computer the same apps and setup, and embedding puts a user's live screen in your app.

What are the self-serve caps and how do I go past them?

The self-serve caps apply together, so the size decides which one you reach first: 100 Mediums, 50 Larges, or 25 XLs.

To give added computers back, use Reduce capacity: PATCH /account/capacity with added_computers, the number to keep. It takes effect at the next renewal. Capacity your computers are using can't be given back until you delete them.

What persists when I stop and start a computer?

From the Stop computer docs:

• Kept: the disk, so files, installed software, and configuration.
• Not kept: memory and running processes.
• Changes: the instance_id, which is new on every start. The host and IP address may change too. Use the computer's UUID as your handle.

Stop works for Linux and Windows computers. To keep memory and running processes, suspend a Linux computer without a GPU instead. Deleting a computer removes it, so keep anything that must outlive one computer somewhere else, for example agent memory in Mem0 or your own store.

Limits to know

• Capacity is computers, not an agent. Bring your own agent loop, or run one with Orgo's computer use API.
• Self-serve capacity stops at 100 added computers, 800 GB RAM, 200 vCPU, and 4 TB disk until Orgo raises it for your account.
• One computer tops out at 8 vCPU, 64 GB RAM, and 300 GB disk, and anything past XL is set up on request.
• Adding capacity needs a paid plan.

FAQ

Can every user get their own computer? Yes. That is the pattern the scaling guide describes: one computer per user, with capacity added from code as free computers run low.

Which size should I start with? Medium (2 vCPU, 8 GB) is the size the dashboard starts at and the size a free account runs. Small (0.5 vCPU, 4 GB) is API only.

Do I need an account-wide API key to buy capacity? Yes. A workspace-scoped key returns 403 with code account_key_required.

What does dry_run do? It returns what a purchase would cost, monthly and due now, without buying anything.

When does reducing capacity take effect? At the next renewal. The current period is already paid for, so you keep the capacity until then.

Where do I see plan limits and prices? On the pricing page. GET /account/capacity also returns each size's monthly price and the per-part rates.

Related

• What is computer use?
• Cloud desktops vs. headless browsers
• Templates and triggers on Orgo
• Embed an agent's computer in your app
• Agent memory with Mem0