Orgo computer use API: run an AI agent with one request

TL;DR

The Orgo computer use API is POST https://www.orgo.ai/api/v1/chat/completions, an OpenAI-compatible endpoint that runs a whole computer use agent on an Orgo computer. You send a task in messages plus the computer_id of a running computer. The agent reads the screen, clicks, types, and runs commands on that computer until the task is done, then returns its final message in OpenAI's chat completions format (Create chat completion). Point an OpenAI SDK at https://www.orgo.ai/api/v1 and add one field. You don't write the agent loop yourself.

What is the Orgo computer use API?

It is the "let Orgo run the agent" path. Orgo also exposes each computer action as its own endpoint (screenshot, click, type, key, scroll, bash), so you can run the loop yourself with any model (Use any model). The chat completions endpoint moves that loop to Orgo's side: one request in, one final answer out.

You don't have to choose once. You can bring your own agent and drive the computer directly, or send a task to this endpoint and let Orgo's engine, or a Claude model, run the loop for you.

How do I call it?

Set ORGO_API_KEY to your Orgo API key and COMPUTER_ID to the id of a running computer, then use the OpenAI SDK you already have:

import os
from openai import OpenAI
 
client = OpenAI(
    base_url="https://www.orgo.ai/api/v1",
    api_key=os.environ["ORGO_API_KEY"],
)
 
response = client.chat.completions.create(
    model="orgo-agent",
    messages=[{"role": "user", "content": "Open Chrome and search for the weather in Paris"}],
    extra_body={"computer_id": os.environ["COMPUTER_ID"]},
)
 
print(response.choices[0].message.content)
print(response.orgo["thread_id"], response.orgo["steps"], response.orgo["cost_cents"])

computer_id is an Orgo field, so the Python SDK sends it through extra_body. The OpenAI SDKs require model, so the example names orgo-agent. With cURL you can leave model out and get the default (Create chat completion).

Should I let Orgo run the loop or run it myself?

Sources: Create chat completion, Use any model, Gemini computer use. Pick the hosted endpoint when you want an agent working in a few lines. Pick your own loop when you need a model the endpoint does not list, or you need to inspect each action.

Which models can it run?

model is optional. Left out, Orgo runs orgo-agent, shown as Computer Use: Orgo's computer use engine on GPT-6 Astra, fast tier. It adapts its shell and shortcuts to the computer, for example PowerShell on Windows and Cmd shortcuts on macOS. On Android computers, or when you send your own x-anthropic-key with no model, the default is claude-sonnet-5. The response's model field names the model that ran (Create chat completion).

You can also name a model: orgo-agent, orgo-agent-opus-5.5 (the same engine on Claude Opus 5.5), claude-sonnet-5, claude-opus-5.5, claude-opus-5, claude-opus-4.8, claude-sonnet-4.6, or claude-opus-4.6. A named model always runs as named. Any other value returns 400 invalid_model, and naming either orgo-agent model for an Android computer returns 400 model_unsupported_os. Model IDs here use a dot for point versions (claude-opus-5.5), where Anthropic's own API uses a hyphen (claude-opus-5-5).

How long can one run go?

A step is one model call plus the computer actions it makes. A run takes up to 250 steps by default, and max_steps can raise that to 500 but never lower it. A run that hits its limit returns normally with finish_reason: "length" and a final message saying it stopped, so you can resend the transcript with a new user turn to continue (Create chat completion).

Can I stream progress?

Yes. With "stream": true the response is a standard stream of chat.completion.chunk events ending in data: [DONE]. Only the agent's text streams. Screenshots, clicks, and commands happen on Orgo's side and are not sent. The thread ID arrives in the X-Thread-Id header before the first chunk. The final chunk carries finish_reason and usage, and a streamed response has no orgo block. Closing the connection stops the run at its next step (Create chat completion).

How do threads and multi-turn conversations work?

A thread is a stored transcript attached to one computer. It is a record, not a memory (Threads):

• Passing a thread_id does not replay earlier turns to the model. The agent sees exactly the messages you send.
• When a run ends, the thread's stored messages are replaced with that request's transcript plus the new reply. Sending only the new turn erases earlier turns from the stored copy.

So keep the full transcript in your own code, resend all of it on every request, and pass the same thread_id each time so the stored copy stays complete:

computer_id = os.environ["COMPUTER_ID"]
history = [{"role": "user", "content": "Open Chrome and go to github.com"}]
 
first = client.chat.completions.create(
    model="orgo-agent",
    messages=history,
    extra_body={"computer_id": computer_id},
)
 
history.append({"role": "assistant", "content": first.choices[0].message.content})
history.append({"role": "user", "content": "Search for 'orgo'"})
 
follow_up = client.chat.completions.create(
    model="orgo-agent",
    messages=history,  # the full transcript, not only the new turn
    extra_body={"computer_id": computer_id, "thread_id": first.orgo["thread_id"]},
)

A thread_id that is not a valid ID or does not exist is not an error: a new thread starts instead. Threads are listed, created, read, and deleted through https://www.orgo.ai/api/v1/threads, which needs an account-wide API key (Threads).

How is it billed?

Runs draw on the AI credits of the computer's workspace owner, not the caller. A run costs the model provider's list price for the tokens used, plus 10%, and orgo.cost_cents reports it rounded up to a whole cent. orgo-agent runs GPT-6 Astra on its fast tier, which Orgo bills at twice Astra's standard rates. orgo-agent-opus-5.5 bills at standard rates (Create chat completion).

A flat hold is placed when the request starts and settled against actual usage after the response. The run stops early when its cost comes within 25 cents of the balance available at the start. A request from a workspace member that spends the owner's credits can use at most $5. Paid plans include monthly AI credits (pricing details).

To pay with your own Anthropic account, send an x-anthropic-key header with a Claude model or orgo-agent-opus-5.5 (in the Python SDK, pass it with extra_headers). No Orgo credits are held or spent, and cost_cents is 0. The header is ignored for orgo-agent, which runs on GPT-6 Astra and bills the workspace owner's credits (Create chat completion).

What errors should I handle?

Branch on the error code, not the message. The ones worth handling first (Create chat completion):

Once a stream has started, the status is already 200, so a failure arrives as one error event followed by data: [DONE]. If you read the stream yourself, treat a stream that ends without a chunk carrying finish_reason as failed.

FAQ

Is the Orgo computer use API the same as OpenAI's computer use tool? No. As of October 2026, OpenAI's computer tool returns actions that your code carries out, and you send back a screenshot after each batch (OpenAI computer use guide). Orgo's endpoint runs the whole loop on an Orgo computer and returns the final message in the chat completions format.

Do I need a computer first? Yes. computer_id is required and must point at a running Orgo computer in a workspace you can write to. You can make one with Create computer.

Can I set a system prompt? No. Messages with a role other than user or assistant, such as system, are dropped, because the agent brings its own instructions. Put yours in the first user message.

Can I send images? Yes, in user messages, as an https:// URL or a base64 data URL of a PNG, JPEG, GIF, or WebP image (Create chat completion).

Can I stop a run? Close the streaming connection and the run stops at its next step. Steps already taken are billed.

Related

• What is computer use?
• Run Claude computer use on Orgo
• Run OpenAI computer use on Orgo
• Gemini computer use with Orgo
• Cloud desktops vs. headless browsers