Platform · Computer Use Agents

Agents that click, type and scroll. The screenshots stay on your servers.

Some work still lives behind screens: an older desktop package with no API, an internal portal, a form that has to be filled the same way every day. A computer-use agent looks at a screenshot, decides what a person would do next, and asks your program to do it. With ZenithAI the model that reads the screen runs on your own servers, and your program performs every action. Nothing runs unless your code runs it.

Live on our servers since 25-10-2026, with held keys and action lists since 26-10-2026. It isn’t in the 4.6.0 installer: it ships with the next installer, and a server gets it when it’s updated.

How it works

A loop your program owns. ZenithAI only proposes.

ZenithAI has no computer or browser of its own for this, and it never touches a mouse or keyboard. Your program owns the screen, whether it is a desktop, a virtual machine or a browser. It decides what is allowed, and when to stop.

  1. Your program takes a screenshot and sends it with the task to your ZenithAI server.
  2. ZenithAI proposes the next action, such as a click at a point, a key combination, text to type or a scroll. With the built-in computer tool it can propose up to five steps that need no new look at the screen, such as a click on a field and the text to type.
  3. Your program performs it, after any check or confirmation you build in.
  4. A new screenshot goes back, and the loop continues.
  5. The loop ends when the model answers in plain text, or when your program reaches its step limit.

Two ways to build it

Bring existing agent code, or define your own actions.

Both run through ZenithAI’s OpenAI-compatible /v1 API, so the usual client libraries work after you change the server address and the model name.

Built-in computer toolYour own function tools
What you sendThe computer_use_preview or computer tool, as existing computer-use code already doesYour own tools, such as click, type_text and scroll
EndpointPOST /v1/responsesPOST /v1/chat/completions
POST /v1/responses
TierGeniusSmart or Genius
Positions you receiveScreen pixels, converted on the serverA 0 to 1000 grid of the screenshot, which your code maps to the screen
Steps per turnOne, or up to five in orderOne call per turn
Best forCode and agent frameworks written for the computer toolChat Completions code, the Smart tier, or actions of your own

How it looks to a developer

A screenshot in. A click in pixels, out.

Declare the size of the screen your program clicks on, send the task with a screenshot, and act on the computer_call that comes back. The full loop, with Python and Node code, is in the developer guide.

Request (shortened)
curl https://your-server/v1/responses \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "Genius",
    "truncation": "auto",
    "tools": [{"type": "computer_use_preview",
      "display_width": 1920,
      "display_height": 1080,
      "environment": "windows"}],
    "input": [{"role": "user", "content": [
      {"type": "input_text",
       "text": "Click Sign in."},
      {"type": "input_image",
       "image_url": "data:image/png;..."}]}]
  }'
Answer (shortened)
{
  "type": "computer_call",
  "call_id": "call_1a2b3c...",
  "pending_safety_checks": [],
  "action": {
    "type": "click",
    "button": "left",
    "x": 1748, "y": 58
  }
}

// click there, take a screenshot,
// send it back as computer_call_output
  • clickPoint and press. Left, right, middle, back or forward buttons, and double-click. Modifier keys can be held, so a ctrl-click or shift-click works.
  • typeText and keys. Text for the focused field, and key combinations such as Ctrl+S or Enter.
  • scrollMove around the page. Scrolling at a point, a drag along a path, or a pointer move to open a hover menu.
  • waitLet the screen catch up. A pause or a fresh screenshot without changing anything, for pages that are still loading.
  • storeHistory, your choice. Send the whole conversation each turn, or ask the server to keep it with store: true and continue from the last response. Old screenshots can be dropped automatically with truncation: "auto".

Where teams put it

Work that only exists on a screen.

When a system has an API, use the API: it is faster and more predictable. A screen agent is for the systems that don’t. These are illustrative patterns, each run in a test environment first and with a person confirming anything that changes data.

WhereA typical taskControl to keep
Older desktop software with no APIOpen a record and read the figures shown on screen into a reportRead-only: allow clicks and scrolling, block typing
Internal web portalFill a routine form from a spreadsheet rowA person confirms before Submit
Testing your own applicationWalk through a sign-up or checkout screen on a test server and report what it sawTest server and test data only
Back-office checksCompare what two internal screens show for the same customerA step limit, and an allow-list of applications

For integrations that call ZenithAI directly rather than through a screen, see API integration use cases and the Enterprise Knowledge API.

Safety is designed in your code

The model proposes. Your program decides.

A screen agent sees whatever is on the screen, and text on a web page or in a document can try to tell it what to do. ZenithAI runs no safety classifier on actions, and says so: the check that matters is the one in your program, before an action runs.

  • 01Screenshots stay on your servers · the screen is read by the model on your own ZenithAI deployment. By default nothing is kept after the answer.
  • 02Kept only when asked · with store: true a response and its screenshots are kept on your server, for that API key only, for up to 30 days, and can be deleted at any time.
  • 03Confirmation is yours · ask a person before payments, messages, deletions, form submissions or anything that enters credentials. When several steps come in one turn, check each of them.
  • 04A sandbox, not a daily desktop · run agents in a virtual machine or a spare account with nothing valuable open, with a step limit and a way to abort.
  • 05Usage you can see · agent requests count as API use per key, and administrators can switch the API off or tighten its limits.

Before you build

What it does, and what it won’t do.

  1. Check every step. The shape of every action is guaranteed. Whether it is the right action is the model’s judgement, so a click can still land on the wrong target.
  2. Keep screenshots small. About 1280 pixels wide is enough, and it keeps more of the history inside the request limits.
  3. Prefer an API where one exists. A screen agent is slower than a direct call, and screens change between software versions.
TiersBuilt-in computer tool on Genius. Your own function tools on Smart and Genius.
Steps per turnOne. With the built-in computer tool, up to five run in order before the next screenshot.
ScreenshotsUp to 8 images and 20 MiB per request. truncation: "auto" drops the oldest when a long run no longer fits.
HistorySent again each turn, or kept on the server with store: true for 30 days.
Requests60 a minute per API key by default, across the /v1 API.
AccuracyIn our own small test on Genius, 15 of 15 clicks landed within 6 pixels of the target. That is not a benchmark.
Safety checksNone on the server. Your program confirms sensitive actions.
AvailabilityLive on our servers since 25-10-2026; not in installer 4.6.0. It ships with the next installer.

Questions

Computer use agents, answered.

What is computer use in ZenithAI?

Computer use lets your own program run a screen agent with ZenithAI. The program sends a screenshot and a task, ZenithAI proposes the next action, such as a click, typing or a scroll, and your program performs it and sends a new screenshot. It works through the OpenAI-compatible /v1 API on your own servers.

Does ZenithAI control our computers?

No. Your program owns the computer, whether it is a desktop, a virtual machine or a browser. ZenithAI only reads the screenshots you send and proposes actions. Nothing runs unless your code runs it, and your code decides which actions are allowed.

Does existing computer-use code work with ZenithAI?

Yes, if it uses the OpenAI-compatible Responses API. On the Genius tier, /v1/responses accepts the computer_use_preview and computer tools and returns computer_call items with positions already in screen pixels. Change the server address and the model name. Agents built on their own click and type functions work on Smart and Genius.

Where do the screenshots go?

To your own ZenithAI server. By default nothing is kept after the answer. If your program asks to keep a response with store: true, it is kept on your server, for that API key only, for up to 30 days, and can be deleted at any time. If you use an agent framework, switch off any tracing that uploads to a third party.

Is it safe to let an AI agent operate a screen?

Only with controls in your code. ZenithAI runs no safety classifier on actions, so your program must ask a person to confirm payments, messages, deletions and anything that enters credentials. Run agents in a virtual machine or a spare account, cap the number of steps, and treat text on the screen as untrusted.

How accurate is it?

The shape of every action is guaranteed. Whether it is the right action is the model’s judgement, so a click can still land on the wrong target. In our own small test on Genius, 15 of 15 clicks landed within 6 pixels of the target. That is not a benchmark, so check the screen after every step.

Which ZenithAI servers have it?

It went live on our servers on 25-10-2026, with held keys and action lists on 26-10-2026. It is not in the 4.6.0 installer; it ships with the next installer, and a server gets it when it is updated. The developer guide is on docs.zenithai.si.

Developer guide: overview · built-in computer tool · your own function tools · errors, safety and limits

Bring one real task

Pick a screen your team works through every day. Watch an agent try it.

In a demonstration, we show a computer-use agent working through a test screen, with every step shown before it runs, and talk through how it would fit one of your tasks.