The CMS where AI does the work.
Squilla is an open-source, Go-based CMS designed around one idea: an AI agent should be able to build, populate, and operate an entire website with zero hand-holding. Every operation lives behind an MCP tool. Every feature lives in a sovereign gRPC extension. The kernel stays small. The shrimp stays fast.
AI-Native, MCP-First
Roughly 50 MCP tools across 15 domains. An agent registers custom node types, seeds content, activates themes, manages extensions, renders previews — all through structured calls. No filesystem access, no shell, no human-in-the-loop required.
core.node.create({
type: "recipe",
fields: {…}
})
Kernel + Extensions
The core is a minimal kernel: nodes, rendering, auth, CoreAPI, event bus. Anything feature-specific (media, email, forms, sitemap, blocks) is a sovereign gRPC extension that owns its full stack — its own tables, business logic, admin UI, migrations.
$ ls extensions/ forms/ media-manager/ email-manager/ sitemap-generator/ content-blocks/ resend-provider/
Sub-millisecond strike
Atomic, hot-swapped config maps. Pre-resolved layout trees. JSONB + GIN-indexed content. PostgreSQL connection pooling. The kernel gets out of the way so the response gets out the door — fast.
GET /docs/quickstart → 200 OK template = pre-resolved query = single round-trip
A kernel
for kernels.
Squilla's architecture is borrowed from operating systems: the kernel does the minimum required to be a CMS, and everything else is a sovereign extension. Disable an extension and there is no dead code in core. Add an extension and it brings its own database tables, HTTP routes, admin UI pages, scripts, and migrations.
If disabling an extension would leave dead code in core, that code belongs in the extension, not the kernel.
Every operation
is a tool an
AI can call.
Squilla exposes a Model Context Protocol surface across 15 domains — nodes, node types, taxonomies, terms, settings, events, menus, media, themes, extensions, layouts, blocks, render, users, files. An agent drives the entire CMS through structured tool calls, with capability scopes enforced server-side.
Seven extensions in the box.
Built like a third-party would build them.
Squilla ships with reference extensions that exercise every part of the extension API — gRPC plugins, Tengo-only providers, manifest-only block libraries. They are not core code in disguise; they're the same extensions you'd build yourself.
Forty production-ready content blocks plus ten page templates. Pure manifest — no plugin binary required.
Email templates, base layouts, sending rules, and a delivery log — fronting any email-provider extension via the event bus.
Production-grade form builder. File uploads, CAPTCHA, conditional logic, GDPR fields, webhooks, email notifications.
Tiny demo extension. Reads its manifest, declares an asset, does nothing scary. Read the source, then build your own.
Upload, organise, and serve images, documents, and any other file. Public routes for /media/* and /media/cache/*.
Send transactional email via Resend.com. Pure Tengo — the entire transport is a settings page and a script.
Themes are
sovereign too.
A Squilla theme is a self-contained package: layouts, partials, content blocks, assets, plus a Tengo seed script that registers node types, taxonomies, and seeds pages on activation. No restart, no manual install — activate and the CMS reorganises itself around the theme.
nodes := import("core/nodes")
nodetypes := import("core/nodetypes")
events := import("core/events")
// register the recipe node type
nodetypes.register({
slug: "recipe",
label: "Recipe",
field_schema: [
{name: "hero_image", type: "image"},
{name: "prep_minutes", type: "number"},
{name: "servings", type: "number"},
{name: "ingredients", type: "repeater"},
{name: "instructions", type: "richtext"}
]
})
// seed a starter recipe
nodes.create({
node_type: "recipe",
title: "Caramelised scallops",
status: "published",
fields_data: { prep_minutes: 18, servings: 2 }
})
events.emit("theme.seeded", { theme: "hello-vietnam" })Built for the metric
that matters: TTFB.
- ▸Atomic configuration maps — hot-swapped without locks
- ▸Pre-resolved layout trees — no template lookup at request time
- ▸JSONB + GIN indexes for content — sub-millisecond field queries
- ▸PostgreSQL connection pooling via pgx — saturated under load
- ▸Eager-loaded relations — no N+1 queries on read paths
- ▸Hot theme/extension activation — no restart, no downtime