Simple Host

Simple Host

Ship a real website with one sentence to your coding agent — and every site gets a little backend for free.

Live: https://simple-host.app · For your agent: /llms.txt · API: /openapi.yaml

---

The idea

Hosting a static website is a solved problem. The thing nobody made simple is the little bit of backend almost every site quietly needs.

Look at the websites real people actually build: a portfolio, a wedding RSVP, a neighborhood poll, a class project, a small landing page collecting emails, a guestbook for a side project. The overwhelming majority — call it ninety-something percent of the web ordinary people need — are static pages with one sliver of dynamic behavior: save an RSVP, count a vote, append to a guestbook, remember a preference.

Today that one sliver is absurdly expensive. To store a single list of RSVPs you're told to stand up a separate backend service, run a database, register a domain, and thread environment variables through a build pipeline. The backend ends up heavier than the website it serves.

Simple Host folds both halves into one tiny binary. Static hosting and a lightweight per-site datastore — lighter than Supabase, no schema, no separate service — in the same upload. Your agent ships the HTML and the data layer together, the site goes live at https://yourname.simple-host.app, and it just works.

And because it stays small, it runs small. Simple Host serves all of its sites from a box with 1 CPU and 1 GB of RAM — no CDN, no object store, no orchestration. One binary, one Postgres, one folder on disk. Most of the websites everyday people need, hosted on hardware you could forget under your desk.

Get going

You don't deploy by hand. You tell your coding agent to, and it uses the Simple Host skill to do the rest.

If you found this on GitHub, you almost certainly already have an agent — Claude Code, Cursor, Codex, opencode, GitHub Copilot, and a dozen more. Install the skill once, for any of them:

npx skills add vineetu/simple-host

On Claude Code you can also install via the bundled marketplace:

/plugin marketplace add vineetu/simple-host
/plugin install website-deploy@simple-host

Using Hermes or OpenClaw? The skills are plain SKILL.md, so they install natively too — e.g. Hermes: hermes skills install https://simple-host.app/skills/website-deploy/SKILL.md --name website-deploy. Per-agent paths are on the get-started page.

Then just talk to your agent:

> "Build me a wedding RSVP page and deploy it." > "Deploy this folder." > "Add a guestbook to my site."

It signs you up (magic-link email → API key), builds the site, wires in state if the page needs it, and deploys. No terminal, no dashboard, no config files.

On the web instead? ChatGPT, Gemini, and Copilot can do it too — paste simple-host.app/llms.txt into the chat, describe what you want, and it hands you a site to publish. Or use the Build with AI chat right on simple-host.app, which builds and previews a site for you on the box itself.

What you get

• One-call deploy — upload a folder, get a live https://{name}.simple-host.app. Every deploy is a new immutable version; roll back instantly.
• A little backend, free — per-site JSON state with atomic ops (set / increment / append), plus append-only collections for guestbooks, signups, and submissions. No schema, no database to run yourself.
• Drop-in widgets — threaded comments and a feedback pin, one script tag each, theme-aware.
• Private pages — password-lock any site behind a signed-cookie gate.
• Starter templates — RSVP, waitlist, landing, résumé, and more, ready to fill in.
• Build with AI — a chat on the homepage that designs, previews, and publishes a site for you.
• Magic-link auth — register with an email, get an API key. That's the whole setup.

How it works

Three moving parts, and you can hold all of them in your head at once:

1. A single Go binary serves every site's static files and exposes the REST API.
2. A Postgres tracks users, sites, and versions.
3. A folder on disk holds the versioned site files.

A wildcard DNS record points *.simple-host.app at the binary, which maps each subdomain to its folder. That's the whole system — no object store, no CDN, no build farm, which is exactly why it fits on a 1 GB box. The per-site datastore lives next to the files and is origin-checked, so only a site's own subdomain can read or write its data from the browser.

Run your own

# 1. Postgres
docker run -d --name simple-host-postgres -p 5432:5432 \
  -e POSTGRES_USER=simplehost -e POSTGRES_PASSWORD=simplehost -e POSTGRES_DB=simplehost \
  postgres:16-alpine

# 2. Schema (one-time)
docker exec -i simple-host-postgres psql -U simplehost -d simplehost `; JSON in, JSON out. The headline endpoints:

| Endpoint | Method | Description |
|---|---|---|
| `/v1/auth`, `/v1/auth/verify` | POST | Magic-link sign-in → API key |
| `/v1/sites` | GET | List your sites |
| `/v1/sites/{name}/files` | POST / PUT | Deploy a site from a JSON `{path: content}` map |
| `/v1/sites/{name}` | POST / PUT / DELETE | Deploy from a tarball / roll a new version / delete |
| `/v1/sites/{name}/state` | GET / PUT / PATCH | Per-site JSON state with atomic ops (origin-checked) |
| `/v1/sites/{name}/collections/{coll}` | GET / POST | Append-only collections |
| `/v1/templates` | GET | Starter templates |
| `/v1/generate` | POST | Build with AI (when enabled) |

## The Website Deploy plugin

[`simple-host-website/`](simple-host-website/) is the agent integration that the install commands above pull in. It bundles:

- **Two skills** — `website-deploy` (the deploy workflow) and `website-deploy-builder` (helping decide what to build that fits a static-plus-light-state model).
- **An MCP server** (Node) exposing `register`, `deploy`, `status`, and `list` as agent-callable tools.

The plugin is embedded into the Go binary, so a running instance also serves it at `/skills.zip`, `/plugin.zip`, and per-skill ZIPs for manual upload (e.g. Claude.ai). It reports its version on every API call; if the server's bundle is newer, responses carry a `_notice` the agent surfaces so users know to update.

## License

MIT — see [`LICENSE`](LICENSE).

## Source & license

This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [vineetu](https://github.com/vineetu)
- **Source:** [vineetu/simple-host](https://github.com/vineetu/simple-host)
- **License:** MIT
- **Homepage:** https://simple-host.app

Install and usage instructions live in the source repository linked above.