Describe what you want. Your agent ships it — and proves it's done.
A website, a blog, a shop, a full SaaS — describe it in chat, and your coding agent — Claude Code, Codex, Gemini, any of them — builds it on one pre-wired, open-source foundation and loops until it's verifiably done: checks green, user journeys tested. Not a website builder. Not a template. A production Next.js codebase you own.
From one prompt to a shipped product
The whole story in about 80 seconds — a real install, a full admin dashboard, and the real product reshaped live on request. Real footage from the live demo. Tap for sound.
Getting started is one prompt
Hand your agent the repo URL — it reads the instructions for agents in the README, installs everything, and asks you the questions in chat: modules, site name, admin account. Then it runs the whole install itself.
No terminal at all? In the Claude Code desktop app, pick an empty folder for a new session and say the same thing — with "here" instead of a folder name.
claude "Set up a new project named my-app from https://github.com/indigo-fw/starter — ask me what you need"
codex "Set up a new project named my-app from https://github.com/indigo-fw/starter — ask me what you need"
gemini "Set up a new project named my-app from https://github.com/indigo-fw/starter — ask me what you need"
bunx degit indigo-fw/starter my-app
cd my-app && bun install
bun run init # answer its questions in the terminal
bun run dev # http://localhost:3000
A loop, not a leap of faith
Hand the agent one request — or a whole goal, /loop-style, and let it run unattended. It can, because on Indigo 'done' isn't an opinion: it's checks going green and personas completing the journeys.
1 · Describe
You say what the product should be, in plain language, in chat. That is the whole job description.
2 · Build
The agent orients from the map — nested CLAUDE.md files and live diagrams — and extends through config and modules, never by editing shared core.
3 · Verify
Typecheck, tests and indigo doctor grade the pass. Then the agent logs in through MCP as a seeded persona and uses the feature like a customer would.
4 · Improve
Failures feed straight into the next pass — no human relaying error messages. The loop only exits when done goes green: checks pass, journeys verified.
The loop, mid-flight
One request, start to finish: the agent builds, gets graded, fixes its own miss, and proves the whole install still holds — the full test suite, the health checks, everything. Terminal output verbatim from real runs. What reaches you is a readable diff.
Because a prototype isn't a product
Your agent isn't just your developer — on Indigo it's the whole team: the designer, the tester who logs in and clicks through every journey, the translator who ships all 17 languages, the maintainer who keeps improving after launch. That's what turns a demo into a business that holds up.
Not a site builder. Not a boilerplate. Built for the loop.
Agents don't fail from lack of intelligence — they fail from lack of environment. Whatever you'd use instead, the gap is the same: the loop needs a map of the system, a signal when something breaks, and hands to test what it built. Indigo is designed around all three.
vs. hosted AI builders
They generate your app on their platform — great for a prototype, but the day it must become a product, you hit the export cliff. Indigo starts where they end: a real repo on your machine, typed and tested, that your own agent keeps building. No platform. No cliff.
vs. boilerplates
A boilerplate is a snapshot: you inherit its glue code, maintain it forever, and it tells your agent nothing. Indigo is a framework — the agent extends it through config and modules, never edits shared core, and upgrades land cleanly under your features.
vs. vibe-coding from scratch
The agent improvises a foundation, then drifts — nothing tells it what broke, and it can't use what it built. Indigo removes the drift: types, tests and indigo doctor grade every pass, and seeded personas let it log in and verify like a customer.
A real business, not a scaffold
The free core every install ships with — working product surfaces the agent extends, so no pass of the loop is ever spent writing glue.
Integrated CMS
Config-driven content types, revision history, media library, scheduled publishing, shortcodes and a content calendar.
Auth & organizations
Better Auth with RBAC, multi-tenant organizations, social login and team management.
Admin panel on day one
Content, media, users, forms, custom fields, audit log and analytics — a full back office you didn't have to build.
Real-time & background jobs
WebSocket updates with Redis pub/sub, BullMQ workers with a database fallback — live features and async work, wired.
Type-safe, end to end
PostgreSQL through Drizzle and tRPC to the client in one typed chain — which doubles as the loop's error signal.
17 languages, agent-translated
Locale routing, hreflang, multilingual sitemaps, JSON-LD and RSS. Describe the site once; your agent ships every locale — this site's 17 languages were translated exactly that way.
Agent-built is half the story. Your product is agent-operable, too.
The same MCP endpoint the build loop uses ships with your app to production. Every API procedure is a typed tool behind API keys or OAuth — so "connect your AI to our product" is a day-one fact about your business, not a roadmap item.
/llms.txt gives any visiting agent the guided tour of your productPOST /api/mcp every API procedure, as a typed tool
GET /llms.txt the front door for visiting agents
GET /api/v1/openapi REST, OpenAPI 3.1 — generated
Need a store? A support desk? Just a blog? Say so.
Modules are self-contained git subtrees — routers, schema, seeds and admin pages included. You name the capability; the agent adds it in one command, or removes everything your project will never use. The core and 14 modules are free — only three are paid, each a whole product of its own, and most projects never need one.
core-supportAI support chat, tickets and live agentFreecore-apiOrg-scoped REST API with keys and meteringFreecore-affiliatesReferral tracking, attribution and commissionsFreecore-multisiteMulti-tenant sites — schema-per-site, domain mappingFreecore-storeE-commerce — products, cart, checkout, EU VATPaidcore-chatAI character chat — providers, conversationsPaidcore-ai-writerAI content generation, SEO, translationPaidStill just code. Still yours.
Agent-built doesn't mean black box. Every pass of the loop lands as a readable diff in a codebase that stays typed, tested, Apache-2.0 yours — take the wheel whenever you want.
Readable diffs
Agents extend through config and registration, so changes are small, local and reviewable — not sprawling rewrites.
Guardrails on
Strict TypeScript, Zod-constrained inputs, ownership checks and soft-delete conventions hold for agents and humans alike.
No lock-in
degit ships no history; bun run init makes a fresh repo. It's your code, your database, your deploy target.
Modern foundations, no compromises
Next.js 16 · React 19 · TypeScript · tRPC · Drizzle ORM · PostgreSQL · Better Auth · Tailwind CSS v4 · BullMQ · Redis · WebSocket · Bun · Zod
You're looking at one
This site is itself an Indigo install — and every page, in 17 languages, was translated by a coding agent in a single pass. Switch languages in the header and see for yourself.
17 languages, one loop
Describe the site once; the agent shipped every locale. Going international is a prompt, not a project — and this page is the receipt.
Dogfooded end to end
indigo-fw.dev, the live demo and the docs are all Indigo installs. The framework builds its own front door.
Open by default
Apache-2.0 core, every free module you see here included. Clone it, read the diffs, make it yours — no license to buy.
Start the loop
Describe what you want to build, and let your agent run. The framework and its free modules are Apache-2.0 — yours to use for anything, including commercial work. And if you want proof it holds up, you're reading it: this site is an Indigo install.