ZCP MCP Server

ZCP is a CLI with Zerops MCP that makes your agent a Zerops power-user.

Documentation

If you were forced to work in a sandbox, you'd be having a hard time too. Treat your coding agents like real developers — give them a cloud platform that covers the full development lifecycle, and let them take your projects from remote development to highly-available production.

TRY WITH $65 CREDITS HOW IT WORKS

Select a tech stack the agent will start with and within minutes your agent will be ready to start working with fully prepared development environment.

Bun Deno Golang Java Python Rust Gleam Svelte Node.js Ruby React Vue Astro Solid Qwik Analog Nuxt .NET Angular Next.js Laravel Nest.js PHP

Or simply start from scratch — agent will start with an empty project and bootstrap it to your exact requirements.

ZCP configuration Configure

Coding Agent

Claude Code

Subscription LoginRemove agent

Cloud IDE

VS Code

Public Access

Quick addCodexAntigravityGrok Build

CREATE PROJECT

Where the agent runs

ZCP is a CLI with Zerops MCP that makes your agent a Zerops power-user.

It runs either inside your project, or is connected through zCLI's VPN functionality to the project from your terminal.

Remote. The remote version gives you an optional Cloud IDE (code-server) and an Ubuntu-based container with a preinstalled set of handy tools (git, curl, jq, psql, redis-cli, mysql, build essentials) and coding agents preinstalled and ready to be authorized through an integrated process.

Local. Or run it on your laptop. Install the ZCP MCP, run zcli vpn up, and your IDE, agent, and shell join the project's network with the same root SSH access the zcp running inside the project has. From there psql, redis-cli, and a file watcher on ./src all talk to the same managed services by hostname the agent would — db:5432, cache:6379, appdev:3000.

https://my-app.com

ProjectPrivate VXLAN network

Dedicated
infrastructure
core with routing
and balancing

Project ctrl & L3/L7 balancer + firewall + stats + logger

Dedicated infrastructure core

Project ctrl & L3 balancer + firewall

Stats

Logger

Dedicated routing and balancing

L7 HTTP balancer

Your services
with system containers

app:3000

worker:5432

cache:6379

load balancers

db:3000

nats:4222

Object storage External

storage:6379

The work loop

ZCP walks your agent through the same processes a senior developer would use.

No good software will ever come out of a single prompt. The process doesn't change, it just gets faster — follow dev → stage → prod and you're halfway there.

If a senior developer were to start a project, depending on the complexity they'd get their local development, CI/CD, databases, and storages working, bootstrap some framework skeleton, and then start iterating. Start a dev server, implement a feature, test it, push to a feature branch, trigger stage CI/CD, have testers / client verify, open a pull request, merge to main, trigger the deployment to production.

ZCP does exactly that, through bootstrap and develop flows — a thin layer that teaches the agent the appropriate knowledge of Zerops at any given time. There is no system prompt; the bulk of the work is just your agent and how you prompt it against the stack you're already familiar with.

Bring your own agent

Your agent. Your subscription.

Your code. Your infrastructure.
Your IDE.

Most coding-agent platforms went agent-first, then bolted on infrastructure — where it runs, how it reaches the database, how its output becomes production-ready, which third-party services to wire up.

Zerops went platform-first. The complete development lifecycle existed before coding agents did. That's why we don't need to resell tokens — we're selling a developer-first PaaS and teaching your agent how to be an expert in it.

You sign in with your subscription, your code is pushed to your repo, and the environment the agent operates in is identical to the isolated production environment. You communicate with the agent the way you do daily — through your IDE, your terminal, not proprietary UIs. The Ubuntu machine the agent runs on is fully customizable: bring in your processes, your initialization, your knowledge.

People say agent infrastructure, infra for Claude agents, agent hosting, or agent sandboxes to mean different things — usually one of the seven categories below. Here's where ZCP sits amongst them.

Most major PaaS providers have shipped an MCP — provision services, deploy code, list resources, read operational state. Great for let my agent ship to my Railway account. These are deploy and operate surfaces, driven from outside the platform — and they reflect what's underneath: platforms optimized for day-one deploy that tuck infrastructure behind a wall. Log and metric read tools landed in 2025 (and AWS only just hit GA), but the in-network, in-container surface an agent needs to actually develop — hit Postgres from inside the network, follow a build live, drive the dev loop — is still on the other side of the wall.

ZCP

ZCP exposes the full Bootstrap and Develop loop as MCP-addressable primitives because Zerops was built around the development lifecycle from the start — not a dev loop retrofitted onto a deploy-first platform.

Let your agent manage your Hetzner VPS. Vendor-API MCPs (DigitalOcean's official one) provision services from the outside; community-built SSH MCPs (Hetzner, Linode, Vultr) give the agent access to a Linux box — SSH in, install Docker and Postgres and nginx, set up systemd units, point a domain at it. Maximum control, lowest cost, full Linux to play with. The same reason senior developers reach for managed platforms applies here: even if you can harden SSH, write nginx configs, tune pg_hba.conf, rotate TLS, set firewall rules, and stay on top of CVEs across kernel, OpenSSL, Docker, Postgres, and nginx — you usually don't want to. Hand that work to an agent and you also hand it the blast radius: misconfigured firewall, debug endpoint left open, port 5432 exposed to the internet, keys never rotated.

ZCP

ZCP is the inverse trade-off — the guardrails of a managed platform. Private networking, TLS, isolated services, safe defaults, managed backups, no exposed ports unless you opt in. The agent operates through project-scoped MCP tools instead of sudo on a fresh Ubuntu box, so the mistakes that matter on a VPS aren't reachable from where it sits.

A managed Linux container in the cloud with your editor and an AI assistant attached. Solves where the agent runs so state survives between sessions and machine setup stops being a question. The category is repositioning toward governed agent runtimes (Copilot Coding Agent, Coder Agents, Ona) — same shape, more agent-first framing.

ZCP

The zcp service is the closest thing in this category — managed Linux container, Cloud IDE, your agent of choice — except it lives inside a Zerops project, addressing the project's runtimes, database, and cache by hostname, with deploys and logs as primitives the agent can call.

The agent, the workspace, the stack, and (often) the hosting target are fused into one closed product. Fast for prototypes. Decisions are made for you. Switching agents usually means switching platforms, and production-grade primitives — a real dev/stage/prod release flow, private networking, observability — are uneven across this category: v0, Bolt, and Devin have moved upmarket, others have not.

ZCP

ZCP doesn't bundle: the agent and model stay yours on your own subscription, and the platform underneath is normal Zerops with the full stack of managed services, networking, deploys, and observability.

The agent runs on your machine, edits your local checkout, runs local commands. Excellent at code changes. MCP is now native across these tools, so external reach — databases, networking, deploy targets, runtime logs — comes through plugins instead of bare hands. The agent still lives on your laptop, though: anything it touches off-machine has to be reached, not inhabited.

ZCP

Install the ZCP MCP locally and run zcli vpn up, and any of these agents can now reach a real Zerops project alongside your local code: services addressed by hostname, deploys, logs, events.

Mostly ephemeral Linux environments that AI applications spin up — often per request — to execute generated code safely (E2B, Modal). The right primitive when you're building a product that needs a model to run untrusted code and hand back the output. Some have pivoted toward stateful, resumable agent workspaces — Daytona now explicitly markets "every agent a computer," and CodeSandbox SDK's hibernation/resume sits between ephemeral and persistent. Still a different shape from ZCP; listed because the names cluster nearby.

Libraries for building and shipping agents to your users — tool calling, memory, orchestration, model providers, sometimes hosting. How somebody would build a product like ZCP, not where a coding agent runs against a project. Adjacent on the shelf, different shape.