Launching public preview of ZCP — infrastructure for coding agents.

Coding agents write code, test it, iterate, deploy.

So why do we still hand them sandboxes and mocks instead of the environment a senior developer would actually use?

Most AI dev tools are built for people who don't code. We're building for people who do — and for everyone who'll outgrow vibe-coding the moment they need to ship something real. Bring your own agent and subscription. Ship to real production infrastructure, not a sandbox. Keep humans in the loop with a Cloud IDE you can jump into anytime.

Sometimes the clearest description is what something isn't. Our AI approach isn't like Lovable, Bolt, or v0, where the agent, stack, and hosting are fused into one closed prototype box. It isn't like Railway's or Render's MCP, where the agent gets a deploy surface and hits a wall the moment it tries to develop against real infrastructure. It isn't like running an agent on a Hetzner or DigitalOcean VPS, where it gets sudo on a fresh Ubuntu with the full blast radius that comes with it, or like Codespaces or Gitpod, where the AI sits on a dev container with no production-shape services underneath.

We're doing something different, and the difference comes from the infrastructure, not the agent. Most coding-agent products started with the agent and then bolted infrastructure on underneath: where it runs, how it reaches the database, how its output becomes production-ready, which services to wire up. Zerops works the other way. Years ago we bet on building the cloud platform first, on our own bare-metal orchestration, Incus system containers (the middle ground between the lightness of app containers like Docker/OCI and the flexibility of full-fledged VMs), and per-project VXLAN networking. ZCP layers on top of that substrate.

That substrate is what makes the same setup run your remote development, staging, and production. Resources and HA topology scale up across environments; the services, the private network, and the deploy pipeline stay identical. That parity is what ends the "but it works on my machine" loop, and what makes a proper private network with managed databases, storage, and search next to runtimes possible across the full development lifecycle.

And because everything stays inspectable, the agent reads the same zerops.yml, sees the same topology graph, and accesses the same logs and runtime a human developer would.

Giving an agent a full development environment with production parity, and teaching it the way a senior developer would actually use it, changes what comes out. The agent stops guessing. It develops against the same Postgres, the same private network, and the same deploy pipeline that production will use, and verifies on a real stage URL before handing off.

Here's what's in this post.

• So what is it again?
• Why should I care?
• How it works
• Every piece is yours
• Public preview now available

So what is it again?

ZCP runs in one of two places, and you pick based on where your agent already lives. Local: our CLI ships with a WireGuard VPN, so you (and your agent) join the project's private network with root SSH into runtime containers. That access is scoped to your project's system containers and sealed inside the project's own VXLAN, not host-level access like on a fresh VPS. Remote: deploy the `zcp` service into the project itself, a full Ubuntu OS container with the agent, optionally a cloud IDE, and devtools preinstalled.

There's no "Zerops system prompt" hogging your context window. The MCP server is a thin layer over the local zcp binary that, when called, teaches the agent how the platform works:

• how networking, scaling, debugging, build & deployment, environment variables, and service provisioning work on the platform
• the development loop: start a dev server → implement → deploy to stage → verify

The depth of the platform underneath is what gives the agent room to actually work. A single agent can scaffold and iterate on projects with multiple runtimes (app, api, worker) backed by multiple managed services (object storage storage, Postgres db, Elasticsearch search, NATS broker, Valkey cache), just as easily as it can work on a simple Next.js presentational website.

You can find a more detailed description of the whole system in our docs.

Why should I care?

Underneath it all is Zerops itself: the ideal mix of developer experience, flexibility, scalability, and affordability. A platform made developer-first by design, and AI agents can now reap the benefits too. We just raised $2M to keep building it that way.

How it works

We treat the agent as a human developer.

As a human developer, to be successful at implementing a project, you:

1. start with a scaffold / template or generate a fresh project
2. prepare the infra (databases etc.)
3. start the dev server
4. work on the thing
5. test the thing by writing tests, calling APIs, or looking through a browser
6. debug by looking at logs and traces and statistics
7. deploy to stage to verify the production build works, everything is accessible, CORS is set up, etc.
8. send it to clients to preview / to testers to test
9. either proclaim it a success or go back to step 3

The ZCP MCP, whether it runs locally or on a container inside the project, guides the agent through this process. All steps are contextual. They're not loaded upfront and don't hog your context. The main part is step 4, which is completely up to you. Not only are you fully responsible for prompting, you're also free to modify the container the agent runs on, prepare your skills in advance, add a proxy for agent traces, install additional tools, and teach the agent how to best work with your particular project.

Every piece is yours

Your agent. Your subscription. Your code. Your infrastructure. Your IDE.

You sign in with your own subscription. Your code lives in your repo. The agent runs on a customizable Ubuntu container you can shape with your own processes, init, and knowledge. And you talk to it through your normal tooling, not a proprietary UI: Browser VS Code (Cloud IDE), your desktop VS Code over SSH, JetBrains Gateway, Cursor, Zed, plain SSH, or just a terminal.

Public preview now available

Here's where ZCP is today: tested and optimized for Claude Code, with integrations for other coding agents next. We've used it internally across a range of projects, from static sites and small APIs to bigger multi-service builds.

Try it through one of our recipes below. Inspect the topology, the YAML, and the cost before deploying. Select the "AI agent" environment, follow the quickstart, and you're in.

Join us on Discord, follow us on X, or connect with us on LinkedIn to share what you build and follow the next ZCP updates.

The cloud platform that shows its work to humans and AI.