Open source · GPL · MCP-native

Tell your agent to build the site. Ship 100/100/100/100.

fastsite is a self-hosted publishing engine that speaks the Model Context Protocol. Point Claude, ChatGPT, or Codex at it and let them author, design, translate, and publish. What lands on your CDN is fully static HTML with zero JavaScript.

claude desktop — fastsite mcp
you › add a pricing page to acme, then publish

fastsite get_authoring_guide(site: "acme")          
fastsite create_page(slug: "pricing", status: "published")
fastsite publish_site(site: "acme")                 

# build  → 1 page written, 41 unchanged
# audit  → 0 fails, 0 warnings, 0 KB JS
# commit → acme-dist@f3c81a2 → live in 4.1s
100
PageSpeed, every page
0 KB
JavaScript shipped
MCP
Native, not bolted on
Free
Self-hosted, GPL

Based on MCP

The agent is the interface.

Every capability in fastsite is exposed as a Model Context Protocol tool — creating pages, uploading media, editing the Twig shell, adding a locale, rolling back a revision, publishing. There is a dashboard, but you never have to open it.

Tools are scoped and consented per site, so an agent that can write your blog cannot touch your infrastructure. Every call is logged, every publish is one reviewable git commit.

  • OAuth consent
  • Per-scope control
  • Audited tool calls
  • One commit per publish
write

Author

Pages, posts, media, components and redirects — created and revised in place, sanitized on every ingest.

design

Shell

Templates and CSS tokens are files the agent can read and rewrite. Snapshot before, restore after.

translate

Localise

Add a locale and published content plus UI strings are translated, with correct hreflang across the tree.

ship

Publish

Incremental build, blocking audit, commit to your repo, live on the edge. Backups and rollback included.

Things people actually type

add a case study about the Aarhus project translate the whole site into German make the hero darker and republish what failed in the last build? roll the shell back to yesterday

What you get

Content goes in. Static HTML comes out.

No page builder, no runtime, no database at the edge. The engine is the build step — your visitors only ever receive pre-rendered files.

MCP server

Native Model Context Protocol over HTTP. Any MCP client — Claude, ChatGPT, Codex, your own — authors and publishes with scoped consent.

REST API

A clean, scoped, idempotent JSON API. Everything the dashboard does, the API does, for pipelines that are not agents.

Webhooks

HMAC-signed inbound webhooks map any payload to a post, page, media import, or component. Wire it up and forget it.

Automatic images

Every upload becomes AVIF and WebP at five widths plus an OG crop — EXIF-stripped, dimensioned, lazy-loaded, alt text enforced.

Auto-translation

Add a locale and the engine translates published content and UI strings, emits per-language trees, and keeps them in sync.

Components

Author HTML fragments or React components. React is compiled to static markup at build time — interactive authoring, zero shipped JS.

Screenshots

A dashboard you can ignore.

Everything the agent does is visible, editable, and reversible by hand — content, media, the shell, the build log.

app.getfastsite.com/sites

Sites overview — build status, locales, and last publish per site.

app.getfastsite.com/shell

Shell editor — Twig templates and CSS tokens, versioned with restore.

app.getfastsite.com/build

Build audit — every rule that would cost a PageSpeed point, before it ships.

Install

Self-hosted, one compose file.

fastsite runs on your own box. Docker and a domain are the whole dependency list — the engine builds static output and pushes it to a git repo your CDN watches.

No vendor account, no per-seat pricing, no data leaving your infrastructure.

bash
# clone, configure, run
git clone https://github.com/sitepointsystems/getfastsite.com.git
cd getfastsite.com && cp .env.example .env
docker compose up -d

# the dashboard and the MCP endpoint are now up
#   https://your-host/            dashboard
#   https://your-host/mcp         MCP server
#   https://your-host/api/v1      REST API

Works with

Bring your own agent.

fastsite is a standard MCP server over HTTP. If your client speaks MCP, it can run your sites.

Anthropic

Claude

Add the server URL under connectors in Claude Desktop or on claude.ai, approve the scopes once, and author from chat.

OpenAI

ChatGPT

Register fastsite as a connector in developer mode and it becomes available as a tool inside any conversation.

OpenAI

Codex

Add the server to your Codex config and drive fastsite from the CLI or the desktop app alongside your repo.

Anything else

Your own client

Standard MCP over HTTP with OAuth. If you would rather not use an agent at all, the REST API covers the same ground.

Why this exists

Publishing tooling kept getting heavier and more expensive, and then rented back to the people who depend on it.

fastsite is built by Lennart Øster, a Danish developer who has been writing software since 1995 and running it alone, on purpose, for the last fifteen years. The pattern is always the same: something in the stack is good but costly, so he builds the version he actually wants and gives it away.

That produced an open source consent platform and a CRM priced flat instead of per seat. fastsite is the same move applied to publishing.

principle

No per-seat pricing

Not now, not when the cloud version arrives. Charging per login rations the tool inside the teams that need it most.

principle

Self-hosting is first class

The free version is the whole engine, not a crippled tier. Your content and credentials stay on your hardware.

principle

Open so it cannot be taken

GPL means no one — including the author — can close the project or pull it out from under you.

principle

Weight is a bug

Zero shipped JavaScript is not a target you hit occasionally. The build refuses to publish a page that misses it.

Open source

GPL licensed. Yours to run, read, and fork.

fastsite is released under the GNU General Public License. Run it on your own hardware, audit every line, change what you need — and if you ship a modified version, share it back under the same terms.

Latest posts

Introducing fastsite

A static publishing engine that keeps every page at a perfect score — and treats AI agents as first-class authors. This site is its own proof.