Computers

Computers are the persistent execution surface behind ACP threads. The SDK exposes first-class compute profiles plus runtime, package, secret, and lifecycle controls so you can shape the agent workspace around the workload instead of hand-managing containers.

Pricing

Computer pricing in Compute Tokens

Computers are billed by active runtime minute based on the selected ACP compute profile. Use lighter profiles by default and only move to heavier profiles when the task actually needs them.

Lite

0.2 CT / minute

CLI-first, low-cost profile for everyday automation and routing.

Standard

0.4 CT / minute

Balanced default for coding, repo work, and general execution.

Power

0.75 CT / minute

Higher CPU and memory for build-heavy or analysis-heavy work.

Desktop

1 CT / minute

GUI-enabled compute for browser automation and desktop workflows.

Use named compute profiles

ACP computers should usually be configured through named profiles rather than raw Docker settings. Lite is optimized for low-cost CLI work, Standard is the balanced default, Power gives more headroom for builds, and Desktop enables GUI workflows.

Use Lite for prompt-heavy and automation-heavy threads that do not need a GUI.

Use Standard for most coding, repo editing, and normal agent work.

Use Power when builds, tests, or multi-step tasks need more CPU and memory.

Use Desktop only when the agent truly needs GUI access.

Create a computer with a profile

Operate the computer lifecycle in JavaScript

The environments manager gives you the full ACP computer surface: create, list, resize, mark as default, install runtimes and packages, and control the actual running container.

Use getDefault() and setDefault() when the user should keep one preferred computer warm.

Use setRuntimes(), installPackages(), and secrets to make the computer match the job.

Use start(), stop(), and analytics to operate the runtime intentionally rather than treating it as a black box.

Computer lifecycle in JavaScript

Operate the computer lifecycle in Python

Python exposes the same computer lifecycle surface with snake_case helpers where ACP has dedicated environment methods.

Use compute_profile to switch between Lite, Standard, Power, and Desktop.

Use runtime and package methods to keep the computer image aligned with your workload.

Use start and stop when you want deliberate lifecycle control from backend automation.

Computer lifecycle in Python

Inspect file-level computer history and branch from it

Computers now expose both coarse checkpoints and higher-resolution file change history. Use snapshots when you need stable restore anchors, and use changes when you need to inspect exactly which file changed in which thread, project, or agent scope.

Use listChanges / list_changes for paginated file-level workspace history.

Filter by projectId, agentId, and operation to isolate the exact activity window you care about.

Use getChangeDiff and getChangeFile to inspect one change boundary without reconstructing the whole workspace.

Use forkFromChange / fork_from_change to branch a new computer from a specific historical file operation.

Computer history

Read resolved computer metadata and pricing

The API returns the resolved compute profile and minute rate on the computer record, which is the safest way to show users exactly what ACP is billing for.

Read environment.metadata.computeProfile for the resolved profile id.

Read environment.metadata.computeResources for effective CPU and memory.

Read environment.metadata.pricing.minutePrice to show the actual minute rate in your own control plane.