The bottleneck isn't writing code anymore
Coding agents can already run unattended toward a goal — /loop, goal mode, autonomous runs. What they can't get from a blank repo is a way to know the goal is met. Indigo is the framework that closes the loop: describe, build, verify, improve, repeat — until "done" is green checks and verified journeys, not a feeling.
Why 'just let the agent build it' fails without a framework
Point an agent at an empty Next.js repo and ask for a product, and it will improvise a foundation: hand-rolled auth, a bespoke billing table, glue between a dozen libraries that have no shared model. Every following pass of the loop builds on sand.
The failure isn't intelligence — it's the environment. The loop has no map of the system, no signal telling it what broke, and no way to use the app it just changed.
Improvised foundations
Auth, billing, content and jobs get reinvented on the fly — differently each session. The seams between them are where agent-built apps rot.
No feedback signal
Without strict types, tests and health checks, nothing tells the loop an iteration went wrong. Drift compounds silently.
No way to verify
An agent that can only read code ships blind. It needs to log in, click around and check its work like a user would — most codebases give it no way to.
Six things a self-improving loop needs. Indigo ships all six.
This is the whole design brief. Everything in the framework exists because one of these was missing everywhere else.
A map
Nested CLAUDE.md files explain intent at every layer; indigo visualize and indigo map render the live architecture as diagrams and code maps the agent can parse. Orientation is a command, not an expedition.
A signal
Strict TypeScript, Zod-constrained inputs, tests and indigo doctor grade every pass. The loop knows immediately — and mechanically — when it's wrong, and when it's done.
Hands
The MCP endpoint turns every tRPC procedure into a typed tool, and seeded personas let the agent log in and use the app as a free user, a subscriber or an admin. It verifies like a customer, not a linter.
Guardrails
Open-closed by design: a content type is a config entry, a feature is a module, a job is a registration call. The agent extends without touching shared code, so the blast radius of any pass stays small.
Cheap iterations
Pointer-first docs, generated wiring and typed registries mean the agent orients from a map instead of re-reading the codebase on every pass. Each iteration stays small and repeatable — so the loop is still safe to run tomorrow, and the day after.
Nothing that blocks
Setup, module installs, migrations and checks all run through non-interactive CLIs. No hidden terminal prompt ever stalls the loop; when a decision is yours, the agent asks you in chat.
One cohesive framework the agent extends, never edits
Every layer already knows about the others
Indigo is a single, type-safe system. Auth knows about organizations. Billing knows about auth. The CMS, jobs, real-time layer and admin panel share one data model and one set of conventions — so the plumbing month disappears for humans and agents alike.
Open-closed by design
New capabilities register themselves. A content type is a config entry. A feature is a module. A background job is a registration call. The agent adds what you describe without touching shared code — so upgrades stay clean, and the loop is safe to run again tomorrow.
The loop doesn't retire when the feature ships
Feature-complete is where most codebases stop being safe to touch. Indigo is built for the opposite: the same rails that make the first build converge make continuous improvement routine. The agent can keep looping on the product it built — fixing what doctor flags, extending test coverage where a regression slipped through, translating new content across your locales, keeping sitemaps, feeds and structured data valid as the product grows.
Every improvement pass has the same shape as the first one: read the map, make a small registered change, get graded, verify as a user. That's what self-improving means here — not magic, just a loop that never loses its footing. The recipe, including scheduling and guardrails, is documented in the Improvement Loop guide.
What building on Indigo actually gets you
The compounding upsides — for the agent that does the work and the human who owns the result.
CLAUDE.md docs, indigo map, live Mermaid diagrams and /llms.txt give the agent a map to read instead of the whole codebase to re-derive. Every pass starts from understanding, not archaeology.indigo doctor validates the whole install.degit ships no history, bun run init makes a fresh repo. Typed, tested, readable, Apache-2.0 yours.Full service, not black box
You describe; the agent executes — including the commands. Setup, module installs, migrations and checks run through non-interactive CLIs designed so nothing ever blocks on a hidden terminal prompt. When a decision is yours to make, the agent asks you in chat.
And everything stays a real codebase: typed, tested, reviewable, Apache-2.0 yours. degit ships no history, bun run init creates a fresh repository, and you can take the wheel at any moment.
Open core, permissively licensed
The framework and its free modules are open source under the permissive Apache-2.0 license — use them for anything, including closed-source commercial work, with no copyleft obligation and nothing to buy. Three premium vertical modules — e-commerce, AI character chat and AI content generation — are commercially licensed and fund continued development of the free core.
See the loop for yourself
The fastest way to understand Indigo is to point your agent at it. The live demo is a full install with every module enabled — and the site you're reading is an Indigo install too.