---
title: "Let your coding agent publish what it makes: Claude Code, Codex and Cursor"
description: "Give Claude Code, Codex or Cursor one command, cool publish, to put the page or app it built online at name.cool.computer, then act on comments."
canonical: "https://www.cool.computer/blog/ai-agent-publish-website"
last_updated: "2026-11-17"
---
# Let your coding agent publish what it makes: Claude Code, Codex and Cursor

> Give Claude Code, Codex or Cursor one command, cool publish, to put the page or app it built online at name.cool.computer, then act on comments.

A coding agent can publish what it builds with the `cool` CLI or the Cool Computers MCP server. Once it is set up, ask Claude Code, Codex or Cursor to "put this on cool.computer", and it runs `cool publish ./dist --name my-app --visibility private` and gives you a link such as `https://my-app.cool.computer`. People can then comment on the page, and the agent picks up those comments, makes the change and publishes again.

The site is online at once and needs no server. Each publish is a new release at the same address. It works with any model, because the agent only runs a command or calls a tool.

## The quickest start, for any agent

Paste this prompt into an agent that runs commands:

```text
set up cool computers for me: follow https://cool.computer/setup.md and build me an artifact about the last thing i was working on, and annotate and draw on it once i'm signed up
```

The agent installs `cool`, puts a page about your last work online, then signs you up with your email and a six-digit code to keep it. [/setup](/setup) is the walk it follows. The standalone installer also adds a short Cool Computers block and a `cool-computers` skill to your coding agents' instruction files, so later sessions know how to publish. `cool agents remove` takes them out.

## Connect it for good

### Claude Code

1. Install the plugin from Anthropic's official marketplace:

   ```sh
   claude plugin install cool-computers@claude-plugins-official
   ```

2. In Claude Code, run `/mcp`, choose `plugin:cool-computers:cool-computers` and sign in.

3. Ask Claude Code to publish what it built.

The plugin adds the MCP server and the `cool-computers` skill, which teaches Claude when to publish a page, how to answer comments and when a site needs a VM. More on the [Claude Code page](/claude-code).

### Codex

1. Run `/plugins` in Codex CLI, or open Plugins in the ChatGPT desktop app.
2. Install Cool Computers and start a new session.
3. Ask Codex to publish the app it built.

The plugin marks its MCP server required, so Codex waits for the Cool Computers tools before a task starts. More on the [Codex page](/codex).

### Cursor

1. In Cursor's agent, type:

   ```text
   /add-plugin cool-computers
   ```

2. Cursor signs you in the first time it connects.

3. Ask the agent to host the page or prototype it made.

The plugin is listed in the Cursor Marketplace and adds the MCP server and the `cool-computers` skill. More on the [Cursor page](/cursor).

### Any other MCP client

Add this server address. It speaks Streamable HTTP and signs in with OAuth:

```text
https://api.cool.computer/mcp
```

The agent then gets `cool_*` tools, such as `cool_publish`, `cool_leave_comment` and `cool_share`. A single `cool_publish` call takes at most 64 KiB of arguments; for larger sites the agent uses `cool publish` or the HTTP API.

## What the agent runs

These are the commands an agent with a shell uses. You can run them yourself too.

1. Build the app if it needs a build. Publishing never runs one:

   ```sh
   npm run build
   ```

2. Publish the output as a new private site:

   ```sh
   cool publish ./dist --name my-app --visibility private --json
   ```

   The output gives `url` and `release_url`, the address of this release, such as `https://r1--my-app.cool.computer`.

3. Update it later. Only changed files are uploaded:

   ```sh
   cool publish ./dist --computer my-app --json
   ```

4. Share it by email, or make it public:

   ```sh
   cool share add my-app ana@example.com
   cool share public my-app
   ```

5. Listen for comments in the background, under the agent's own name:

   ```sh
   cool comments watch my-app --agent "Claude Code"
   ```

   While the agent watches, a comment card on the page has an Ask button named after it, such as Ask Claude Code. The watch exits when comments arrive and prints the command that reads them. The agent runs it, makes the change, publishes again, answers the comment with what it did and starts the watch again.

## Why and when to use it

Use it when an agent has made something a person should see and react to: a prototype, a report, a dashboard, a landing page.

- One step from code to link: No hosting account to configure, no repository to connect.
- The review happens on the page: Comments and drawings are pinned to elements, and the agent acts on them.
- Private by default from agents: Agents make a site private unless it is meant to be public, and tell you which it is.
- The same site from any agent: Claude Code, Codex, Cursor, Pi or a chat app can all publish to it.
- A VM only when needed: If the work needs a server, a bot or a scheduled job, the site can get its own always-on Ubuntu VM at the same address, on Pro. Claude Code and Codex come installed on every VM.

## How it compares

Deploying through a hosting provider's CLI works well for a production app with a repository, environments and a build pipeline. For a page an agent made five minutes ago, that setup is often more than you need.

Screenshots and pasted code are quick, but people cannot click through the result or comment on a specific part of it.

An agent-specific preview lives inside that one tool. A `cool.computer` site is the same address whichever agent published it, and the people you share it with do not need that tool.

## Questions

### Can Claude Code deploy a website?

Yes. With the Cool Computers plugin or the `cool` CLI, Claude Code publishes files with `cool publish` and gives you the address. It can also read the comments people leave and publish the fix.

### Can Codex publish an HTML page?

Yes. Install the Cool Computers plugin with `/plugins`, or run the setup prompt. Codex publishes the page or the build folder at `name.cool.computer` and can listen for comments in one of its own background terminals.

### Is there an MCP server for publishing a site?

Yes, at `https://api.cool.computer/mcp`. Any MCP client that connects to a remote Streamable HTTP server can use it, including Gemini CLI, VS Code, Zed, Claude, ChatGPT and Grok. See [other MCP clients](/mcp-clients).

### Does it cost anything?

Free costs nothing and needs no card: up to 20 sites at once, each with server code, a database and an inbox. Pro, USD 20 a month, adds VMs and lifts the limit on sites. Your own Claude or Codex subscriptions are separate. See [pricing](/pricing).

### What if I do not have an account yet?

The agent can publish without one. The site is public, and you get a claim link: open it and sign in within 24 hours to keep the site.

### Can the agent run a backend, not only static files?

Yes. A `cool.json` with `functions` adds an API under `/api` that runs at the edge, with an optional database, and no VM. A program that has to keep running gets a VM on Pro. See [how it works](/how-it-works).

One agent at a time: [Claude Code](/blog/deploy-website-from-claude-code), [Cursor](/blog/deploy-website-from-cursor), [Codex](/blog/deploy-website-from-codex), and [any MCP client](/blog/mcp-server-publish-website). For the other tools an agent can deploy with, see [10 MCP servers and CLIs compared](/blog/best-mcp-servers-cli-deploy-website-ai-agent). To see what people have published with their agents, browse [/explore](/explore).
