# Build with Cursor, Claude Code and Codex | Volcano

URL: https://volcano.dev/solutions/agentic-coding

> Volcano installs its instructions and fifteen skills into the coding agents already on your machine, so Cursor, Claude Code and Codex know your project shape, the real CLI surface and the SDK's own types — and cannot deploy to production without your say-so.

## Your coding agent already knows Volcano

One command briefs Cursor, Claude Code and Codex on how a Volcano project is shaped, then keeps production behind an explicit confirmation.

```console
$ volcano setup --yes
[updated]   cursor       15 skills -> ~/.cursor/skills (4 changed)
[updated]   claude-code  0.2.14 → 0.2.16 (restart your agent to apply)
[installed] codex        0.2.16 (restart your agent to apply)
Installed Volcano for 3 harness(es) (2 updated).
# re-run any time; each run lands on the latest skills
```

## The model is fine. The context is missing.

An agent in your editor will invent a CLI flag, a config key, or an SDK method that never existed, and you find out at deploy time. It is not writing bad code — it is writing code for a platform it has never been told anything about, from a training set that predates yours.

So fix the input. volcano setup installs Volcano's instruction file and fifteen skills into the agents you already run, which turns guesses into lookups: the real project layout, the real deploy contract, the SDK's own type definitions, and a safety model that keeps your cloud project out of reach until you explicitly ask for it.

## It installs into the agents you already run

*Setup*

One command finds the coding agents on your machine and sets each one up. Claude Code and Codex get Volcano through their own plugin marketplace; Cursor, opencode and pi get the skills written into their skills directory. When nothing is detected, a manual install drops them under ~/.volcano instead.

- Cursor, Claude Code, Codex, opencode and pi
- --dry-run reports the changes and writes nothing
- --yes for a non-interactive run inside CI or an agent

```console
[planned]   cursor       would update
[planned]   codex        up to date
[planned]   opencode     would install
Would install Volcano for 3 harness(es).
```

## Fifteen skills instead of a plausible guess

*Grounding*

The skills carry the parts an agent cannot infer: how a project is laid out and deployed, what the SDK actually exposes, and the rules a durable function has to follow to replay correctly. One rule in the instruction file removes most of the remaining waste — check volcano \<area\> --help before inventing a flag.

- volcano-platform: project shape and the deploy contract
- volcano-durable: durable functions that replay correctly
- volcano docs mcp answers questions from the real docs

```console
volcano-platform    volcano-sdk         volcano-typescript
volcano-auth        volcano-database    volcano-functions
volcano-durable     volcano-locks       volcano-logs
volcano-storage     volcano-realtime    volcano-nextjs
volcano-uiux        volcano-error-handling   install-volcano
# AGENTS.md sits alongside them as the entry point
```

## It cannot ship to production behind your back

*Guardrails*

Building, running and deploying locally happen without interruption, because local mode only ever targets localhost:8000. Everything that touches your cloud project is confirm-first, and the agent cannot even sign you in — a device code has to be approved by a human with a browser.

- Local deploys are automatic; cloud deploys never are
- Deletions, secrets and domain changes ask first
- No agent can approve a volcano login device code

```console
$ volcano start
$ volcano functions deploy --all
$ volcano functions invoke create-order --json
{ "statusCode": 201, "orderId": "o_4f2a" }
# localhost:8000 throughout — production was never touched
Next: deploy to the cloud with volcano cloud functions deploy --all
```

## How it works

1. **Brief your agent**: volcano setup finds Cursor, Claude Code, Codex, opencode or pi and installs the skills into each one. The two that use a plugin marketplace pick them up after a restart.
2. **Let it scaffold**: The agent runs volcano init first, because every deploy command expects that layout. Templates cover JavaScript, Next.js, Python and Ruby.
3. **Prove it locally**: volcano start brings up the local environment, the agent deploys into it and invokes what it wrote, then reports the result. No cloud credentials needed.
4. **Ship it yourself**: volcano login, pick the project with volcano use, then run the cloud deploy. The agent suggests the command; you are the one who runs it.

## From a fresh machine to a deployed project

### Setup

```bash
# Detect every coding agent on this machine and set each one up
volcano setup

# Look before you leap
volcano setup --dry-run

# Or target just one: claude-code, codex, cursor, opencode, pi
volcano setup --agent claude-code

# Non-interactive, for CI or for an agent running the command itself
volcano setup --yes

# Re-running is the update path. Each agent reports one of
# [installed], [updated] or [current], and marketplace plugins
# show the version delta they moved through.
```

### Docs MCP

```json
{
  "mcpServers": {
    "volcano-docs": {
      "command": "volcano",
      "args": ["docs", "mcp"]
    }
  }
}
```

### Local loop

```bash
# 1. Scaffold first. Deploys look for this layout.
volcano init nextjs

# 2. Bring up the local environment (Docker and Compose; volcano doctor checks)
volcano start

# 3. Deploy the pieces it actually touched
volcano variables deploy
volcano functions deploy --all
volcano migrations deploy --all -d app
volcano config deploy

# 4. Exercise it and report back
volcano functions invoke create-order --json
volcano functions logs create-order --type runtime

# Nothing here needs a login: local mode only ever talks to
# http://localhost:8000.
```

### Ship it

```bash
# Sign in. This is a device-code flow: the CLI prints a code and a URL
# and then polls, sometimes for a minute. A human approves it in a browser
# — there is no way for an agent to do this part.
volcano login

volcano projects list
volcano use incident-tracker

# Cloud commands are the ones an agent must never run unprompted
volcano cloud config deploy
volcano cloud variables deploy
volcano cloud functions deploy --all
volcano cloud frontends deploy --name web --path ./web

# In CI there is no browser, so authenticate with a token instead
export VOLCANO_TOKEN=pk-xxxxxxxxxx
export VOLCANO_PROJECT_ID=<project-id>
volcano cloud functions deploy --all
```

## What briefing the agent saves

- **One command to brief every agent**: volcano setup detects the coding agents you have and installs into all of them, then keeps them current on re-run.
- **15 skills of real API surface**: Project shape, the deploy contract and the SDK's own type definitions, versioned in one place instead of recalled from memory.
- **Zero unattended production deploys**: Cloud deploys, deletions, secret changes and visibility changes are confirm-first, with no exceptions.

## Outcomes

- **Less rework**: The commands and methods it reaches for are ones that exist.
- **Safe to let run**: The unattended loop is local only, and stops at your cloud project.
- **Current by default**: Re-running setup lands every agent on the latest skills.

## Built on Volcano

- [Functions](https://volcano.dev/features/edge-functions): What the agent writes and deploys first: handlers that see the caller's verified identity and scale to zero.
- [Postgres databases](https://volcano.dev/features/postgres): Migrations are plain SQL files the agent can read and review, with policies rather than a generated access layer.
- [Next.js hosting](https://volcano.dev/features/nextjs-hosting): volcano init nextjs scaffolds it and one deploy command puts it on a global CDN with TLS.
- [Durable functions](https://volcano.dev/features/durable-functions): The volcano-durable skill teaches the agent the replay rules, so the workflows it writes checkpoint and resume correctly.

## Frequently asked questions

### Which editors and agents are supported?

Cursor, Claude Code, Codex, opencode and pi. Claude Code and Codex install through their own plugin marketplace; the rest have the skills written into their skills directory. If none is detected, volcano setup --manual puts the skills and AGENTS.md under ~/.volcano so any agent can read them. There is no VS Code extension and no JetBrains plugin.

### Do I have to install a plugin by hand?

No. volcano setup does the detection and the install. For Claude Code and Codex it adds the Kong/volcano-agentic-plugins marketplace and installs the volcano plugin from it, which loads once you restart the agent.

### Can the agent deploy to production on its own?

No, and that is deliberate. The instructions it follows say never to auto-deploy to the cloud, so every volcano cloud command needs your explicit go-ahead — as do deletions, secret changes, visibility changes and anything billing-related. What it will do unprompted is the local equivalent, which only ever targets localhost:8000.

### How does the agent sign me in?

It doesn't. volcano login is an OAuth device-code flow: the CLI prints a code and a URL, then polls while a human approves it in a browser. Agents are told not to look for tokens on disk or try to approve a code programmatically. For CI, where no browser exists, set VOLCANO\_TOKEN instead.

### Is there an MCP server?

Two. volcano docs mcp serves the documentation over stdio as volcano-docs, with docs\_search, docs\_get and docs\_list; volcano docs search gives the same answers without MCP. The hosted server at api.volcano.dev/mcp gives an agent a scoped tool surface over one project, authenticated with a project access token — a read-only token can inspect functions, frontends, deployments and logs, and a full-scope one can also set variables and list databases.

### How do I keep the skills up to date?

Re-run volcano setup. It refreshes the source and reports each agent as installed, updated or already current, showing the version delta for marketplace plugins and the number of changed files for the rest. Claude Code and Codex need a restart to pick the new version up.

## Get started

Ready to build with your agent? Create a free account at https://volcano.dev/signup, or have your coding agent follow the setup playbook at https://volcano.dev/setup.md.