Your terminal just learned to ship internal apps
Gaia is a Claude Code plugin that builds, validates, and deploys complete internal apps. You describe, the harness compiles, the result goes live.
for the skeptic
Yes, you could build this yourself.
That was never the problem. Whether it is worth your week was the problem.
You can write the fiftieth internal CRUD app in your sleep. You just have better things to build. Gaia takes the chore so you keep the craft.
Hand-build them and you own every one: a dozen auth flows, a dozen security reviews, a dozen stacks to patch. Gaia ships one validated stack for all of them.
This is not low-code. Every build is real Express and MongoDB you can pull, edit, and own. You stay the engineer, you just skip the boilerplate.
the hook
The request you used to decline
An operator walks over with a spreadsheet and asks, can you make an app from this? The honest answer has always been no. Not because it is hard, but because it is two weeks of scaffolding, auth, CRUD endpoints, and deployment for an app with eleven users. Gaia changes the answer to: give me six minutes.
$ gaia import upload ./deals.xlsx # ImportAgent reads messy real-world sheets: headers, label rows, # cross-sheet relations. It asks only what it can't infer. $ gaia build # deterministic pipeline: models → seed → UI → copilots → autonomy → audit # 2-3 minutes, streamed as a live checklist inside Claude Code $ gaia publish {"event":"app_published","payload":{"url":"https://deals-pipeline.gainable.app"}}
Spreadsheet to public URL without leaving Claude Code.
the result
One gaia build, live at a public URL. Sidebar navigation, seeded data, charts, KPIs, and an embedded Ask AI copilot, all generated and deployed in one pass.
how it works
Near-zero error rate, by construction
A guided conversation defines data, derivations, seed, UI, and autonomy.
The result is a signed contract, not a vague prompt.
Compilers emit the code. The LLM decides, the compiler writes.
Around 100 validation rules, structural validators, and a multi-pass audit run server-side before anything reaches you.
Fewer turnarounds, less debugging, faster time to deploy.
the comparison
We measured one build
A real one-shot gaia build, no retries and no manual fixes: an event operations app with tasks, speakers, sponsors, budget, and venue management.
120 files, 18,600 lines of code
20 data models, 31 API route modules, 8 views
Two orders of magnitude cheaper and faster. The engineering time you save is the real multiplier.
fleet economics
Millions a year, from one plugin install
$1M to $5Msaved per year
For an organization routing 300 to 1,000 internal apps a year through the harness instead of building them from scratch.
One plugin install puts the harness in every Claude Code seat, and every internal app request resolves through it instead of becoming an engineering project. The number above is not a projection, it is multiplication:
Each app saves roughly $150 to $300 in tokens and 2 to 5 days of engineer attention, about $3,000 to $5,000 fully loaded.
The math is deliberately conservative: even at a single engineer day per app, the thousand-app row still clears $1M. And the bigger number is the demand that never gets served today: when an app costs minutes instead of sprints, the declined backlog becomes buildable, and the spreadsheets and per-seat point tools those apps replace stop renewing. Session economics scale the same way: a harness build consumes a few thousand relay tokens of a seat's budget instead of 100,000 or more tokens of generated code, so the same fleet rate limits go dramatically further.
what you get
Complete apps, one stack, no lock-in
Complete apps, not prototypes
One build produces 30 to 40 files: views, CRUD API endpoints, data models, derivations, seeded data, charts, embedded chat, and AI copilots. The feature set is rich from the first build.
One framework for thousands of apps
Every app ships on the same stack with the same SSO, role-based access, seat-managed invites, audits, tracing, and analytics. One security review and one upgrade path instead of a sprawl of one-off tools.
Agent-native by default
Every account gets an MCP server, so the app you build this morning is a queryable, writable data source for Claude Code, Claude Desktop, or ChatGPT this afternoon. Apps embed their own copilots and can run autonomous autopilot behaviors.
The harness does the legwork, your session stays light
A gaia chat or gaia build turn sends one command and receives compact progress events. The generated files never enter your Claude Code context, so a full build costs your session only a few thousand relay tokens. Server-side, a complete app runs $0.50 to $1.50 in tokens on the most capable model.
Operators and developers, same app
Operators iterate in natural language from the Gainable UI while you work from the terminal. Both surfaces edit the same app, so handing off no longer means handing over.
Real code, no lock-in
Generated apps are plain Express, MongoDB, Alpine, and Tailwind. Inspectable, exportable, and always one command away from hand authoring.
one turn
Iterate like you talk
$ gaia chat "add a probability column to the deals table" ✓ completion ready: 2 files changed
Each refinement is a single HTTP turn. The harness's planner decides, the BuildAgent edits, validators check, and the summary streams back.
two modes
No cliff between no-code and code
gaia (harness mode, the default)
$ gaia chat "rename the Stage column to Pipeline Stage"
One cheap turn. The planner and BuildAgent do the work server-side. Right for most edits, KPIs, fixes, and layout changes.
gaia code (author mode, explicit opt-in)
$ gaia code pull # read conventions + preflight, edit ./app/ yourself $ gaia code validate $ gaia code push --summary "hero KPI section"
Full creative control with the same conventions and validators the BuildAgent uses. Your hand-written code passes the same guardrails.
get started
Get started in three steps
Install the gaia CLI, then the plugin in Claude Code
$ npm i -g @gainable.dev/cli
/plugin install https://github.com/gainable-inc/cli.git#gainable
Mint an API key at /account/api-keys, then authenticate
$ gaia login --key gak_xxx_yyy
Describe what you want, or hand it a spreadsheet
$ gaia build "a CRM for tracking SaaS deals"