Skip to content
← Blog

How do you give every customer of your vertical agent its own computer?

One client account, one scoped key and one or more computers per customer: how to set it up from code, keep secrets and limits per customer, embed the screen safely, and offboard cleanly.

Updated

Quick answer: on Orgo, give each customer of your vertical agent its own client account. That is a workspace plus an API key that reaches only that workspace. Create the customer's computers inside it with that key, save their per-customer secrets as workspace secrets, and embed the screen in your app. A customer's key can't reach another customer's computers or files. Account-wide secrets are the exception: they go to every customer's computer, so per-customer values belong on the workspace.

TL;DR

  • One customer, one workspace. POST /v1/accounts creates a client with its own workspace and a key scoped to it. The customer never signs up to Orgo (Add a client).
  • Handle retries. A repeat create with the same external_id answers 409 ACCOUNT_EXISTS and does not return the key again. Get a new one with POST /v1/accounts/{id}/key.
  • Computers go in that workspace, created with the customer's key, optionally from a template.
  • Per-customer secrets are workspace secrets. Account-wide secrets reach every customer's computer.
  • The embed password is root on that computer. Fetch it per session from your server.
  • To offboard, delete the customer's computers, then close the client.

You own the agent. Orgo owns the computer.

What does "one computer per customer" mean?

One computer per customer means each end customer of your agent product gets a real, persistent cloud desktop (browser, terminal, files) that belongs to them alone. Your agent works on that desktop on their behalf, and logged-in sessions, downloads and installed apps stay on their computer between runs.

Orgo provides the computer, not the agent. Bring Claude computer use, OpenAI's CUA, Hermes Agent, OpenClaw or your own loop (llms.txt).

Why give each customer a separate computer?

Because a vertical agent leaves state behind in each customer's tools (cookies, sessions, files, connected apps), and that state should never mix. The full argument is in Why do vertical agent products still need a real computer?. This post is the how-to.

Which per-customer boundary should you use?

Both options end with one workspace per customer. For a product where customers don't sign in to Orgo, the client account is the shorter path.

Client account (POST /v1/accounts)Plain workspace (POST /workspaces)
What you getA workspace plus a key scoped to it, shown onceA workspace you own
Customer signs up to OrgoNoOnly if you invite them
Per-customer limitsmax_computers, monthly_ai_cap_usdNone set on the workspace
Hand it over laterTransfer to the customer's own Orgo accountInvite them, then Make owner in the menu next to their name in Settings → Members
Plan neededAny paid planAny plan
Counts toward the 9999 workspace limitNoYes

Billing customers through Orgo, branding and handoff are covered in Cloud computers for AI automation agencies.

How do you set it up from code?

1. Create the client account (safe to retry)

Use your account-wide key, on your server only. A new client answers 201 with api_key, which is shown once. If your first response was lost and you retry, the 409 does not include the key, so look the client up and mint a new key. Minting a new key stops every earlier key for that client.

python
import os, requests
 
API = "https://www.orgo.ai/api"
admin = {"Authorization": f"Bearer {os.environ['ORGO_API_KEY']}"}
ext_id = "cust_123"
 
res = requests.post(
    f"{API}/v1/accounts",
    headers=admin,
    json={"name": "Customer 123", "external_id": ext_id, "max_computers": 3},
)
 
if res.status_code == 201:
    client = res.json()
    customer_key = client["api_key"]  # shown once: store it with the customer
elif res.status_code == 409 and res.json().get("code") == "ACCOUNT_EXISTS":
    found = requests.get(f"{API}/v1/accounts", headers=admin, params={"search": ext_id}).json()["accounts"]
    client = next(a for a in found if a["external_id"] == ext_id)
    customer_key = requests.post(f"{API}/v1/accounts/{client['id']}/key", headers=admin).json()["api_key"]
else:
    res.raise_for_status()
 
workspace_id = client["workspace_id"]

The client key can create and control computers, run the Computer Use API and read files. It can't reach your other workspaces or create workspaces, keys or clients (Invoicing).

2. Save per-customer secrets on the workspace

Secrets resolve by your account plus the workspace. A computer launched from a template, even with the customer's key, gets your account-wide value for any name the template declares, unless that workspace has its own value of the same name. A workspace value overrides the account value (Template secrets). Anyone with a shell on that computer can read what lands there.

So keep only values every customer may see at account scope, and save the customer's own credentials on their workspace from your server. A client's workspace stays out of your workspace list, so the picker in Settings → Secrets doesn't offer it:

python
requests.post(
    f"{API}/secrets",
    headers=admin,
    json={"name": "CRM_API_KEY", "value": crm_key_for_customer, "workspace_id": workspace_id},
).raise_for_status()

One more catch: a computer in a client workspace never gets ORGO_API_KEY, even when its template declares orgo_api_key, because the client's key reaches that workspace (Key scopes and computer keys). If your agent runs on the computer and calls Orgo, plan for that.

3. Create the customer's computer

python
computer = requests.post(
    f"{API}/computers",
    headers={"Authorization": f"Bearer {customer_key}"},
    json={"workspace_id": workspace_id, "name": "agent-1", "os": "linux", "ram": 4},
).json()

workspace_id and name are required, and a name must be unique within the workspace (Create computer). Add template_ref so every customer starts from the same setup. Any paid plan can launch Orgo's curated templates, and publishing your own needs Scale or Enterprise. Which templates fit sales, legal research and agency desktops is covered in Templates for vertical AI agents. The MCP server also has client tools, such as orgo_create_client and orgo_replace_client_key, for an agent that onboards customers (MCP).

How do customers see what the agent is doing?

Embed the live screen in your app. Your server holds the key, reads the computer's VNC password with it, and hands only that password to the page, where a client such as noVNC connects. The walkthrough is in How to embed a live AI agent computer in your app.

The computer password is root on that computer. The same value opens the terminal WebSocket and the bash proxy, not only the screen. Fetch it per session from your backend, never put it in a client bundle, and don't rely on rfb.viewOnly: a visitor can turn it off (Embed computers).

If you invite the customer into Orgo instead, Can chat lets them watch screens, but despite the name it doesn't let them chat with the workspace's agents. Full access adds that, along with managing computers and connecting apps (Workspaces, members and clients).

What limits do customers share?

Every client workspace is owned by you, so all customers share your account's limits:

  • Computer count. An account on a paid plan can have 50 computers, running or stopped. Past 50, new ones run by the hour from your credit, up to 999 an account, or a number Orgo sets up to 9999 (Account limits). Past 50, only blank Linux computers or ones from a curated starter template can be created. Clones, forks, GPUs, images, snapshots and your own templates are refused there.
  • Plan room. Plan computers share your plan's vCPU and RAM. Past that, a create from a key with full access or Billing write, a customer's key included, runs by the hour from your credit on its own. Windows and your own templates can't run by the hour, so add capacity first (Create computer).
  • Rate limits. Orgo publishes limits on new computers by plan. On Scale they are 60 a minute, 1,000 an hour and 5,000 a day.
  • Per customer. A client at its max_computers gets 403 ACCOUNT_COMPUTER_LIMIT.
  • Client-paid workspaces don't count against your plan, but can't cost more a month than the client pays (403 CLIENT_PRICE_EXCEEDED).

Sizes, pools and the capacity API are in How to scale AI agent computers to thousands on Orgo.

What happens when a job ends or a customer leaves?

  • A job with a known length: create the computer with ends_in_hours (1 to 720). It is deleted with everything on it when time is up. Linux and Windows only; any other os gets 400 ENDS_NOT_SUPPORTED (Set when a computer ends).
  • A customer who pauses: stop their computer. The disk is archived and the host released, and Start brings it back. A plan computer still holds its vCPU and RAM until you delete it (Account limits).
  • A customer who wants to own it: transfer the client account to their own Orgo account. The workspace, its computers and its key become theirs (Invoicing).
  • A customer who leaves: delete their computers, then close the client with DELETE /v1/accounts/{id}. Closing never deletes computers for you, so a client that still has any gets 409 ACCOUNT_HAS_COMPUTERS. Once closed, its keys stop working at once (Close client).

Which errors will you hit?

StatusCodeWhen
403UPGRADE_REQUIREDAdding a client without a paid plan
409ACCOUNT_EXISTSSame external_id again, even after that client is closed. No key returned; use POST /v1/accounts/{id}/key
403ACCOUNT_COMPUTER_LIMITThe client is at max_computers
402insufficient_creditA create past your plan, with too little credit to run it by the hour
403CLIENT_PRICE_EXCEEDEDA client-paid workspace would cost more than the client pays
400ENDS_NOT_SUPPORTEDends_in_hours on an OS other than Linux or Windows
403WINDOWS_REQUIRES_SCALEWindows on Starter or Growth without a license
409ACCOUNT_HAS_COMPUTERSClosing a client that still has computers

FAQ

Do my customers need an Orgo account or a seat?

No. A client account gives each customer a workspace and a key your app uses for them. The people your agents or app serve never need a seat, on any plan (pricing).

Can one customer's agent reach another customer's computer?

Not with a key scoped to their workspace. A workspace key reaches only that workspace and the computers and files in it, whatever its permissions.

Are secrets isolated per customer?

Only if you save them on the workspace. Account-wide secrets go to every computer whose template asks for them, in every workspace.

Can a customer have more than one computer?

Yes. Set max_computers on the client account to cap one customer.

Can I limit what a customer's agent spends on AI?

Yes, for AI billed through Orgo. Set monthly_ai_cap_usd when you add the client, and that AI stops at the amount each month. A model key of their own isn't capped.

Which operating systems can a customer's computer run?

Linux and Windows are self-serve. Windows is included on Scale. On Starter and Growth each Windows computer is $47 a month in all, a $15 license plus a Medium's memory, vCPU and disk (as of November 2026). Without one, the create gets 403 WINDOWS_REQUIRES_SCALE. A Mac or an iPhone comes from Orgo's stock in the app while it's in stock, billed on its own (pricing).

Sources