Drive Clever Cloud from an AI agent

An AI agent is good at driving a platform when three things are true: the documentation is readable without a browser, every action has an API, and the feedback loop is short enough to correct itself. Clever Cloud was built that way before agents existed, for its own tooling, and the same properties now make it straightforward to operate from Claude Code, Cursor, Codex or any assistant that can run a command.

Nothing here is an AI-specific product. The Console runs on the same public API your agent calls, the CLI it drives is the one your team uses, and the documentation it reads is the page you are reading. There is no separate surface to learn, and no gap between what a human and an agent can do.

Documentation an agent can read

Every documentation page is available as raw Markdown, either by asking for it in the HTTP request:

curl -H "Accept: text/markdown" https://www.clever.cloud/developers/doc/deploy/applications/nodejs/

or by appending index.html.md to any page URL. Both return the Markdown source rather than the rendered page, which removes the parsing step and the token cost of HTML.

An llms.txt index lists the documentation with a one-line description per page, so an agent picks what it needs instead of crawling. The Clever Tools reference documents every command, option and accepted value in a single page, which is enough for an agent to compose a correct command without trial and error. The whole documentation is open source.

Ways to drive the platform

Pick the interface that fits the agent, they all reach the same API:

Clever Tools ships a skill in its own repository, so an assistant that reads skills learns the CLI from the source rather than from a guess. The MCP server takes a different route: instead of exposing hundreds of tools, one per endpoint, it offers three: search to discover commands, execute to run pre-authenticated JavaScript against the API, and doc to read the documentation. The agent composes a call rather than picking from a menu, which keeps its context small.

Both are built on @clevercloud/client, the typed client the Console itself uses, with a command per API operation across 46 families of resources.

Disposable infrastructure

The shortest useful loop is create, deploy, verify, destroy. It runs in a handful of commands, which is what makes it worth automating:

clever create --type node my-experiment
clever deploy
clever domain
clever delete --yes

An agent can spin up an environment to reproduce a bug, run an integration test against a real database rather than a mock, check that a migration applies, then remove everything. Resources are billed by the second, so an environment that lives ten minutes costs ten minutes.

The same loop covers backing services. A test needing PostgreSQL, object storage and a message broker creates them, links them, and reads the injected credentials from the environment:

clever addon create postgresql-addon test-db
clever service link-addon test-db
clever env

Linking an add-on injects its credentials as environment variables, so the application code stays the same between a throwaway environment and production.

Docker widens what fits in that loop. Any image the agent can build runs on the platform, inside a virtual machine rather than a shared container host, so a stack no runtime covers still deploys with a git push. Point CC_DOCKERFILE at the file to build, and CC_DOCKER_LOGIN_* at a private registry when the image is not public.

The reverse also works: Clever Tools ships as a Docker image, so an agent running in a container or a CI job drives the platform without installing anything:

docker run --rm -e CLEVER_TOKEN -e CLEVER_SECRET clevercloud/clever-tools status

An ecosystem that fits together

Deployment is a git push, and the platform detects the runtime, installs dependencies and starts the application behind a load balancer with TLS already configured. That covers a static site built automatically from its sources, Node.js and Bun, Rust, Scala, Python with uv, V, and Docker for the rest. The Linux runtime with Mise handles anything else: declare the tools and versions your build needs in a mise.toml, and they are installed before the build.

Around the application, the managed services are meant to be assembled. PostgreSQL, MySQL and Redis for the classics, Materia KV and TS when a serverless store with nothing to size fits better, Pulsar for messaging, Cellar for S3-compatible object storage, MailPace for transactional email, Keycloak for identity.

Two of them deserve a mention for what they take off an agent’s plate. Otoroshi is an API gateway with a Coraza web application firewall, an LLM extension for routing and governing model calls, a workflow engine, and a long list of plugins covered in a dedicated blog post. Redirection.io handles redirects, cache rules and traffic analysis from an interface a marketing team can use without a deployment.

Each of them is driven by API, so an agent assembles a full stack rather than a single application.

Production is the same platform

A throwaway environment and a production one differ by their plan, not by their nature. The same application gets logs and access logs, metrics stored in Warp 10, automated backups on its databases, horizontal and vertical auto-scaling, and Kubernetes when a cluster is the right shape.

An agent reads all of it through the same CLI it used to deploy:

clever logs --since 10m
clever activity
clever status

When something needs to be checked inside a running instance rather than from the outside, one command runs it and returns:

clever ssh -c "node --version"

That closes the loop: the agent deploys, observes, inspects the instance, and corrects, without a human relaying the state between steps.

Where to look next

Clever Cloud publishes its tooling openly, so an agent can read the source of what it drives rather than infer it.

API clients exist beyond JavaScript, for Python, Go and Rust, so generated code fits the language of the project rather than the other way round.

• Clever Tools reference
• API documentation
• Getting started