What it does

Bird CMS is a lightweight CMS for SEO built around Markdown and Docker — and it is the first CMS that ships a native Model Context Protocol server. Unlike most CMS platforms built for humans clicking through an admin panel, Bird CMS is agent-first: point Claude Desktop / Cursor / Zed at the site and the AI agent reads, writes, and publishes articles through 11 MCP tools. No database to query, no admin form to fill, no publish button to click, no API token to provision.

The entire content layer is text files. Articles are Markdown with YAML metadata. Site configuration is YAML. Templates are PHP. An agent, or a human with a text editor, can create, modify, or reorganize content by editing files in a directory. The CMS renders Markdown to HTML on the fly with in-memory caching, so page loads happen in milliseconds.

Bird CMS is also a multi-site engine. One shared codebase powers 10+ sites, each with its own content, theme, and configuration. Fix a bug or add a feature in the engine, tag a release, and all sites update automatically within an hour. Each site runs in its own Docker container with nginx and PHP-FPM.

SEO is not an afterthought. Schema.org structured data, sitemap.xml, RSS feeds, Open Graph, hreflang, canonical URLs, and even llms.txt for AI search engines are generated automatically from the content. A full site audit tool checks security headers, broken links, meta tags, and content quality.

Results & Impact

Powers over 10 production websites across different niches: personal portfolio, niche content sites, professional services. All running on the same engine with site-specific themes and content.

Page loads in single-digit milliseconds. No database query for content delivery. Static assets cached for one year. The entire content pipeline, from AI-generated Markdown to rendered HTML, runs without external services.

Distributed release system means one developer maintains the engine and all sites stay current. A bug fix or feature addition reaches every site without manual deployment to each one.

Key Features

• Agent-First Content. Content is Markdown + YAML. Any AI agent or text editor can create and modify articles. Changes appear on the site immediately. No admin panel required for content work.
• Multi-Site Engine. One shared codebase, many sites. Each site has its own content, config, and theme. Engine updates sync via git tags. Fix once, update everywhere.
• SEO Built In. Schema.org (Article, FAQ, HowTo, LocalBusiness, more), auto sitemap.xml, RSS, Open Graph, Twitter Cards, hreflang, canonical URLs, llms.txt. All generated from content.
• MCP Server. Native Model Context Protocol stdio server with 11 tools (article CRUD, page CRUD, publish toggle, search). Point Claude Desktop, Cursor, Continue, or Zed at the site — the agent reads, writes, and publishes directly. No API tokens, no plugins, no copy-paste loop.
• Doctor: Integrity Validator. scripts/doctor.php runs in quick/standard/deep modes. Checks directory skeleton, engine symlink, config parse, frontmatter validity, retired-feature drift, MANIFEST sha256 of every engine file. Exit codes 0/1/2 gate destructive operations like mass migrations.
• Browser-Based Install. docker compose up -d, open the browser, step through the wizard (system check, site identity, finish, success). Wizard generates APP_KEY, bcrypts the admin password, derives network config, writes .env/config/app.php atomically. Re-runnable, rate-limited.
• Theme System. Each site has its own frontend theme with partials, layouts, and views. Admin panel theme is shared. Themes are PHP templates, easy to customize.
• Atomic Versioned-Symlink Deploys. Each release extracts into versions/X.Y.Z and the engine symlink flips atomically. Rollback is the same swap reversed — one command. Builds ship with a MANIFEST.sha256 so engine-drift on prod is detectable.

How it works

The engine has two layers: shared code (PHP application, scripts, admin panel) and site-specific content (articles, config, theme). The shared layer lives in the Bird CMS repository. Each site clones it and adds its own content directory.

When a request comes in, nginx routes it to PHP-FPM. The router checks if it is a static asset (serve directly), an API call (handle via controller), or a content page (find the Markdown file, render it through the theme template, return HTML). In-memory caching means the second request for the same page skips Markdown parsing entirely.

Articles are stored as directories: each article has an index.md (content) and meta.yaml (title, slug, date, category, SEO data, FAQ, schema type). The YAML metadata drives everything: schema.org output, sitemap entries, RSS items, navigation, and admin panel listing.

Stack: PHP 8, Nginx, SQLite (for analytics only, not content), Docker. No JavaScript framework, no build step, no Node.js dependency for the site itself. Content generation tools use Node.js separately.

Use Cases

For AI-assisted content teams. Generate and publish content without an admin panel. An AI agent writes a Markdown file with YAML metadata, saves it to the content directory, and the article is live. No CMS login, no form filling. The content pipeline includes prompts, templates, and quality checks.

For solo developers running multiple sites. One engine, many sites, one maintenance burden. Bug fixes and features go into the engine once. All sites update automatically. Each site keeps its own content, theme, and config. Scale to 10, 20, 50 sites without multiplying maintenance work.

For SEO-focused content sites. Technical SEO handled by the engine, not by you. Schema.org, sitemaps, Open Graph, canonical URLs, hreflang. all generated from content metadata. The site audit tool catches issues before search engines do. Focus on content, not on technical SEO checklists.

Lessons Learned

Files beat databases for content. Storing content as Markdown files instead of database rows made everything simpler: version control with git, editing with any tool, backup by copying a directory, AI agents that just write files. The only database is SQLite for analytics. Content has no database dependency at all.

Multi-site from day one was the right call. Building the engine/site separation early meant the second, third, and tenth site cost almost nothing to set up. If I had built for a single site first and tried to extract a shared engine later, the refactoring would have been painful. The distributed release system was the natural next step.

SEO is metadata, not magic. Every SEO feature, schema.org, sitemaps, Open Graph, is just structured data generated from the same YAML metadata that powers the content. Once the metadata format was solid, adding new SEO features was trivial. The audit tool catches mistakes automatically instead of relying on manual checks.

FAQ

Why build another CMS when WordPress exists?

WordPress is designed for humans clicking buttons. Bird CMS is designed for AI agents editing text files. An agent can modify a Markdown file, and the change appears on the site instantly. No database queries, no admin panel login, no WYSIWYG editor. The entire content layer is files that any tool can read and write.

How fast are page loads?

Pages load in milliseconds. Content is Markdown rendered to HTML at request time with in-memory caching. There is no database query for content delivery. Static assets get one-year browser cache headers.

How does the multi-site architecture work?

Bird CMS has a core engine shared across all sites. Each site has its own content, config, and theme. Releases ship as a tar archive with a sha256 MANIFEST. Each site extracts the archive into versions/X.Y.Z/ and the engine symlink flips atomically. Rollback is the same swap reversed — one command. No mid-deploy half-state, no per-site manual patching.

What SEO features are built in?

Schema.org structured data, auto-generated sitemap.xml and RSS feed, Open Graph and Twitter Cards, hreflang for multilingual sites, canonical URLs, llms.txt for AI search engines, and a full site audit tool.

Can AI agents create content with Bird CMS?

Yes — through the built-in MCP server. Point Claude Desktop / Cursor / Zed / Continue at the site, and the agent gets 11 native tools to read, write, publish, and search articles directly. Articles are Markdown with YAML frontmatter on disk; the agent edits them like a human would, except via Model Context Protocol instead of a browser. No API key, no plugin to install.