# Host a Codex prototype

Put the clickable prototype OpenAI Codex built online: Codex publishes it with one command, every version gets its own link, and nothing to set up first.

On the web at https://lobsite.com/hosting/codex-prototypes

```sh
npx -y lobsite --yes --preview
```

Codex runs this from the project folder; each version gets its own preview link.

OpenAI Codex can build a working, clickable prototype from a brief: screens that link to each other, sample data, a flow you can actually walk through. Codex doesn't give you a public link, though. The prototype sits in a sandbox or on your disk. Lobsite is the missing step. Codex runs `npx -y lobsite --yes`, and you get a live HTTPS address to send to your team, a client or test participants, plus a link that keeps it. There's nothing to set up first.

## How it works

1. **Ask Codex for a static prototype.** HTML pages or a Vite build, with no server and no secrets. The AGENTS.md section below tells it how.
2. **Let Codex publish it.** It runs `npx -y lobsite --yes` from the project folder. The command needs network access; see [network access for Codex](https://lobsite.com/hosting/codex#network).
3. **Share the address.** Codex relays the URL and the claim link. Claim it within 6 hours to keep the prototype in a free account, at the same address.

## Tell Codex it's a prototype

Codex reads `AGENTS.md` before it starts. Add a section so every task builds something you can share without fixing it first:

````md
## Prototypes

This repository holds clickable prototypes, not production code.

- Build static files only: HTML, CSS and JavaScript, or a Vite build into `dist/`. No backend, no real API calls, no keys.
- One page or route per screen. Use relative links so pages open from any address.
- Put sample data in the code. Every button leads somewhere, even to a placeholder screen.
- To share it, run:

```bash
npx -y lobsite --yes --preview
```

- Give the user the preview URL, and relay the "Tell the user:" line from the output word for word.
````

Starting with `--preview` means a new version never replaces the one people are already looking at. You decide when it becomes the main link.

## Compare directions side by side

Codex can try a task several times and give you more than one version. For a prototype, that's two or three directions for the same screen. Publish each as a preview, and every direction gets its own address:

```sh
npx -y lobsite --yes --preview
```

Put the addresses in the design review, or send each one to a few users. When one direction wins, make it the main version:

```sh
npx lobsite promote <id>
```

The others keep their addresses for 7 days in a free account (30 on Standard), in case the next review changes its mind. `npx lobsite deploys` lists them all.

## Getting feedback on it

- **Usability tests:** a hosted prototype is an ordinary website. Give its address to Maze, Lyssna or UserTesting, or send it to participants directly. Every screen has its own path, so tasks can start and end on a given page.
- **Answers from the page:** a feedback or survey screen can post to `/_lobsite/forms/feedback`. Once the prototype is in an account, each answer is emailed to you, with spam filtering. See [forms](https://lobsite.com/features/forms).
- **Keeping it to the people invited:** an unclaimed prototype isn't indexed by search engines, and preview addresses never are. On Standard, a site password covers every address of the prototype, and reviewers type it once per browser.

## Codex prototypes: Lobsite, Tiiny Host and GitHub Pages

| | Lobsite | Tiiny Host | GitHub Pages |
|---|---|---|---|
| How Codex publishes | One command, or the MCP server | Through its MCP server, or you upload a zip | Commit, push, and a workflow for builds |
| Account to start | None for 6 hours | An account | GitHub account and repository |
| Free plan | 1 site up to 50 MB, last 7 days of versions as previews | 1 site, 3 MB uploads, with a banner | Public repositories |
| A link per version | `--preview`, then promote or roll back | Upload again over the same link | Not built in |
| Password | On Standard | On its Solo plan and up | No |
| Custom domain | Free, one per account | On its Solo plan and up | Free |

Tiiny Host suits a single file you drop in by hand. Lobsite fits when Codex should publish each version itself and you want the earlier ones still to have a link.

## Frequently asked questions

### Where does Codex put a prototype I can share?

On your disk or in its sandbox, and neither has a public address. The deploy command uploads the built files from the project folder to Lobsite and prints the live URL.

### Can Codex publish a prototype from a cloud task?

Yes, if the environment allows internet access for the agent. Allow `lobsite.com`, `upload.lobsite.app` and the npm registry. Without network access, ask Codex to commit the prototype, then run the command yourself from a checkout.

### Do I need to know how to code to share a Codex prototype?

No. Ask Codex to share it and it runs the command. The only step that's yours is opening the claim link and signing in, which keeps the prototype online.

### How long does a shared prototype stay online?

Six hours without an account. Once claimed, it stays until you delete it, with deploys from the last 7 days kept as previews in a free account.

### Can a Codex prototype send me what testers type?

Yes. Point a form at `/_lobsite/forms/<name>` and each submission is emailed to you once the site is in an account. Free accounts get 25 submissions a month per site, and Standard has no cap.