ZCP · Zerops Control Plane

You drive. Your agent drives.
Same container. Same wire as production.

A cloud dev environment deployed into your Zerops project. Full Ubuntu, full root, on the same private VXLAN as your database and your API. Bring your own editor, your own agent, your own flow. Nothing is hidden, nothing is locked.

See how the handover works ↓

The handover is the feature.

Most "AI coding" products split the work across tools. You write in one editor. The agent runs in another process, or on someone else's cloud, or in a sandbox that can't see your real services. Code gets synced back. You review a diff. You pull changes. You wonder why the agent's version of the codebase doesn't match what you just wrote.

ZCP collapses that into one container.

A single VS Code Server tab. Editor pane on one side, terminal pane on the other. Claude Code — or Cursor, or OpenCode, or whatever you have — runs in the terminal. It edits the same files the editor is showing. It runs against the real Postgres two services away on the private network. When you take over mid-session, you're picking up from the agent's most recent save, because there's nothing between you and the filesystem. When the agent takes over, same deal.

Open a second terminal tab and run psql -h db. The agent keeps working. Run curl api:3000 against the real running API. The agent keeps working. Push to staging with zcli push --service apistage and verify against a real URL. The agent keeps working.

No sync. No copy. No merge. No "agent cloud" separate from your cloud. It's one container.

ssh root@zcp.zerops

you

users.ts schema.sql routes.ts

import db from './db';
export async function getUser(id: string)
const rows = await db.query(
`SELECT * FROM users WHERE id = $1`,
[id],
);
if (!rows.length) throw new NotFound();
return rows[0]|

agent

root@zcp:~/api$ claude

Reading src/users.ts

Querying db:5432 for schema

Editing src/users.ts

@@ getUser(id) @@

- return rows[0]

+ if (!rows.length) throw new NotFound()

+ return rows[0]

✓ Saved. Dev server hot-reloaded.

Testing against db:5432, api:3000

✓ All tests passing

▋

Bring your own editor. Your own agent. Your own flow.

The spine of ZCP — three commitments to how you actually work.

Bring your own editor.

Four equivalent ways to work against a Zerops project:

Web terminal and VS Code Server on ZCP itself, in the browser.
SSH from your local editor — Cursor, VS Code Remote SSH, JetBrains Gateway, or plain ssh root@zcp.zerops.
zcli vpn up, and your laptop joins the project's private VXLAN. db:5432 resolves from your local terminal. Point Postico at it. Run your local dev server against redis:6379. ZCP isn't in the loop — you've just offloaded the services you don't want to run locally.
Any mix. Your agent can sit in ZCP while you work from your laptop via VPN against the same services.

Same hostnames, same credentials, same topology — browser, SSHed in, or on café wifi over WireGuard. Network identity is consistent across all of it.

A human on the VPN and an agent inside ZCP are hitting the same db:5432. Handoff between the two is free, because nothing moves.

Bring your own agent.

Claude Code, Cursor, OpenCode, and whatever ships next week — all preinstalled on the agent flavor of ZCP. Pick the one you like.

Or install one we've never heard of. ZCP is a full Linux box, not a plugin surface. Any CLI agent, any MCP-compatible client, any custom binary you have lying around — it runs.

The agent flavor also ships an MCP server exposing typed Zerops tools. Every tool tagged read-only, destructive, or operational, so the host agent can gate permissions cleanly.

Read-only

zerops_discover
zerops_events
zerops_export
zerops_guidance
zerops_knowledge
zerops_logs
zerops_preprocess
zerops_verify

Destructive

zerops_delete
zerops_deploy
zerops_deploy_batch
zerops_env
zerops_import
zerops_manage
zerops_scale

Operational

zerops_browser
zerops_dev_server
zerops_mount
zerops_process
zerops_recipe
zerops_subdomain
zerops_workflow

None of it is required. Everything the MCP does is also doable through zcli and ssh — the MCP is a convenience layer, not a control surface.

Bring your own flow.

ZCP is Ubuntu. Root. Writable. Persistent. Want a proxy? apt-get install squid. Want tmux? Install it. Want a custom shell, a background daemon, a systemd unit, a specific Python version built from source? Do it. Your changes survive restarts.

No opinionated CLI wrapping every operation. No proprietary runtime. No "supported languages" list. The things you already do on a Linux box, you do here. Your shell config, your editor config, your toolchain — dotfile it, commit it, SSH in and it's yours.

This is the commitment most agent products can't make because they're built on sandboxes or kernel-isolated micro-VMs with restricted semantics. ZCP isn't. It's a container you own.

"Works on my machine." Now imagine the machine is a toy.

"Works on my machine" is a meme when a human says it — an afternoon spent tracking down an environment gap. When an agent says it, it's catastrophic. Agents reason from what they can see:

If the database is a mock, the code is built for a mock.
If the runtime is a simplified sandbox with different semantics than prod, the code assumes those semantics.
If the network is isolated, the code never learns about the service next door.

The agent doesn't know production is somewhere else. It can't know. Most "AI coding" products bake this failure in by design.

ZCP's dev environment is the same infrastructure as production. Same Ubuntu. Same Postgres. Same private VXLAN. Same zerops.yml. The only thing that changes between dev, staging, and prod is resource allocation and replicas. The agent isn't reasoning against a simulation — it's reasoning against the real thing, scaled down.

It's just a service in your project.

ZCP isn't a separate product, a separate environment, or a separate bill. It's a service in your zerops.yml, deployed into the same project as your database and your application, on the same private VXLAN. CPU, RAM, disk — allocated explicitly like any other service. One project, one bill, one network.

zerops:
  - setup: zcp
    build:
      base: ubuntu@24.04
      prepareCommands:
        - apt-get install -y git nodejs python3
    run:
      ports:
        - port: 8443
          httpSupport: true
      startCommand: /usr/bin/code-server --bind-addr 0.0.0.0:8443

  - setup: apidev
    # ...

  - setup: db
    type: postgresql@17

project · VXLAN

zcp apidev db storage

browser editor (SSH) laptop (VPN)

Not a handoff. Not a sandbox. Not a toy.

There's a pattern across "AI coding" products: the agent and the developer work in different places.

Lovable, Bolt, v0 — the agent generates a code artifact. You export it and figure out how to run it. The handoff IS the product.
E2B — the agent runs in an isolated microVM. Useful for executing untrusted code. Not a place a developer works. Handoff required to do anything beyond execution.
Replit Agent — runs inside Replit's simplified runtime. The agent's environment and a production environment are different things. Handoff required when the app outgrows Replit.
Codespaces + Copilot — Copilot ships suggestions into a Codespace. Two products, one bolted onto the other. The agent doesn't share the environment — it completes inside it.

ZCP is the one where the agent and the developer share the box. Same container, same editor, same terminal, same private network as production. Nothing to hand off.

	Codespaces / Gitpod	Replit	E2B	Railway / Render / Vercel	ZCP
Real dev environment	✓	✓	~	✗	✓
Real managed services	✗	~	✗	✓	✓
Deploy pipeline included	✗	~	✗	✓	✓
Dev env == prod infra	✗	✗	✗	~	✓
Shared env with developer	✗	✗	✗	✗	✓

Most AI coding tools are built for people who don't write code. This one is built for the ones who do — and the agents that do too.

FAQ

Is this just for agents?

No. ZCP is a cloud dev environment that happens to host agents well. Plenty of people run ZCP as a CDE and never touch the agent flavor. The properties that make it good for agents are the same properties that make it good for humans.

Is it persistent?

Yes. Filesystem, installed packages, running processes survive across sessions.

What does it cost?

Per-resource, like every other service. See pricing. No per-seat fee.

Can I use my own editor?

Yes — SSH, VS Code Remote SSH, JetBrains Gateway, Cursor, or zcli vpn up and use your local editor.

Does the agent flavor cost more?

No. Same resource pricing. The agent flavor just has more preinstalled.

Do I need to use ZCP to use Zerops?

No. zcli vpn up gives your laptop the same network access. ZCP is the most convenient option, not the only one.

Is anything proprietary?

No. Standard Ubuntu. Standard SSH. Standard runtimes. The MCP server is optional.

Start with a recipe.

Every recipe spins up a ZCP alongside the app — AI agent flavor or plain Remote CDE, your call. Pick a stack, get a working project with its control plane already wired up.

Browse recipes →

You drive. Your agent drives. Same container. Same wire as production.