Servers

Computers for agents. Servers for products.

ACP gives agents stateful computers to work on and gives teams deployable resources to ship. Threads, projects, computers, and published servers all stay in one execution system.

Server architecture

Why choose
computer agents
servers?

Virtual operators, not fixed endpoints

Any agent can receive input from email, uploads, APIs, threads, schedules, or webhooks, work on it in a real computer, and publish the result as a live resource. ACP behaves more like a system for digital employees than a narrow endpoint wrapper.

INPUT FROM ANYWHERE. OUTPUT TO ANYTHING.
Fair pricing that follows real usage

ACP pricing tracks actual runtime and deployed resource usage instead of forcing teams into oversized always-on infrastructure. Start small, prove value, and scale the parts that are actually doing work.

PAY FOR WORK. NOT FOR IDLE CAPACITY.
Highly optimized compute with four container sizes

Choose Lite, Standard, Power, or Desktop depending on the workload. Keep simple automation lean, move heavier coding and research to stronger profiles, and only pay for larger environments when the work needs them.

RIGHT-SIZED COMPUTE FOR EACH WORKLOAD.
Bring your own model when you need control

Run with managed ACP models by default or connect your own inference endpoint when procurement, security, or provider strategy requires it. ACP does not force a single model path on every team.

MANAGED OR CUSTOMER-ROUTED MODEL EXECUTION.
Deep runtime customization

Customize environments with runtimes, packages, secrets, MCP tools, setup scripts, and Docker-level behavior. ACP is not just a glossy abstraction over a fixed sandbox. You can shape the runtime around the system you are building.

CUSTOMIZE THE EXECUTION LAYER, NOT JUST THE PROMPT.
Infrastructure without infrastructure work

ACP handles the operational plumbing: execution, state, deployment, triggers, coordination, and persistent project context. Teams stay focused on systems and outcomes instead of stitching infra together by hand.

SHIP THE SYSTEM. SKIP THE PLUMBING.

Choose the runtime. Ship the surface.

Computers define how agents work internally. Servers define what ACP can publish externally. Together they cover the full path from execution to product.

Container types

Lite container
Lite

Lean compute for lightweight automation, routing, short follow-ups, and agents that mostly orchestrate other work.

CLI-firstLeanLow-cost
Standard container
Standard

The balanced default for most ACP threads: coding, browsing, file work, research, and day-to-day agent execution.

BalancedDefaultGeneral purpose
Power container
Power

More headroom for heavy coding, larger installs, deeper analysis, and build-heavy or tool-heavy execution.

High computeBuild-heavyLonger runs
Desktop container
Desktop

Interactive compute with GUI access for workflows that need real desktop apps, visual tooling, or browser-first tasks.

GUI-enabledInteractiveApp workflows

Server types you can deploy

Web Apps server type
Web Apps

Ship frontend experiences directly from ACP projects and threads.

Read docs
Functions server type
Functions

Publish callable server-side execution for product logic and automation.

Read docs
Auth server type
Auth

Provision authentication services that stay attached to your ACP system.

Read docs
Databases server type
Databases

Add persistent data backends and keep them tied to the same project boundary.

Read docs
Agent Runtimes server type
Agent Runtimes

Expose agents themselves as long-lived operational surfaces.

Read docs

Publish from humans, agents, or both.

ACP gives teams one resource model across the platform, the SDKs, and running agent workflows. Humans can ship manually. Agents can publish as part of the work.

Resource publishing

Humans can ship directly

Publish from the ACP platform or from the SDK when you want explicit control over what gets deployed and when it goes live.

Agents can publish as part of work

Threads can generate assets, prepare code, and ship functions, auth services, web apps, databases, and runtimes without leaving the same project boundary.

One model, many surfaces

The same computers, projects, permissions, and state can power internal workflows and public-facing infrastructure. You do not need a separate publishing stack.

Loading...