BRAHMA TECH · terminal-native
Every session starts cold — the architecture, the decisions, what broke last week, what is next. GAIA FLOW gives the project a Project_Brain that lives in the repo, so the context is already there before you type a word.
╭──────────────────────────────────────────────────────────────────────────────╮ │ ◆ GAIA FLOW │ Acme Platform │ │ phase P2.4 health ● clean git main mode ARCHITECTING │ ├──────────────────────────────────────────────────────────────────────────────┤ │ PROJECT HEALTH │ │ ✦ Production SaaS · Next.js + Postgres · 41k LOC · 12 services │ │ next Split the billing service before the Q3 traffic ramp │ │ Arch ▓▓▓▓▓▓▓▓▓▓▓▓▓░░░ 82% │ │ Scale ▓▓▓▓▓▓▓▓▓▓░░░░░░ 64% │ │ Risk ▓▓▓▓▓░░░░░░░░░░░ 31% │ │ Maturity production │ │ trajectory scaling Moving from single-region to multi-tenant isolation │ │ ◆ insight ● No rate limit on /api/export — three incidents cite it │ │ ● stable · recovery ready │ ├──────────────────────────────────────────────────────────────────────────────┤ │ ✦ Refactoring the billing service… (4m 12s) │ │ ▰▰▰▰▰▰▰▰▰▰▰▱▱▱▱ 72% │ │ ■ Extract invoice generation into its own module │ │ □ Wire the new module into the payment orchestrator │ │ ✓ Write characterization tests for current behaviour │ │ … +4 completed │ ├──────────────────────────────────────────────────────────────────────────────┤ │ ◆ AI ACTIVITY │ │ 14:22:07 ❯ edit services/billing/invoice.ts │ │ 14:22:31 ❯ bash pnpm test billing ✓ 34 passed │ │ 14:23:02 ❯ edit services/payments/orchestrator.ts ×3 │ ├──────────────────────────────────────────────────────────────────────────────┤ │ RECENT SHIPS │ │ ✦ 2026-09-04 — Multi-tenant row-level security across 9 tables │ │ ✦ 2026-09-02 — Decision #0031: Postgres over DynamoDB for the ledger │ ╰──────────────────────────────────────────────────────────────────────────────╯ r refresh · q quit · live · GAIA FLOW · BRAHMA TECH
$curl -fsSL https://gaiaflow.brahmatechs.com/install | sh
The problem
The model is brilliant and amnesiac. The cost is not the tokens — it is you, re-deriving the same decisions week after week.
The Project_Brain
GAIA does not dump notes into a file. Deterministic scanners collect evidence, the model reasons over it, and the conclusion is persisted as plain markdown you can read, diff and delete.
Shell scanners collect facts. The model reasons over those facts and cites them. Scripts never judge, and the model never asserts what it cannot point at.
A multi-service backend needs different documents from a mobile app. /gaia-init detects the stack, asks only what it cannot observe, and writes the layers the project actually needs.
A task is not done until it is in the brain: append the changelog, refresh the snapshot. If the two ever disagree, the changelog wins.
Read order
Each document has one job. The snapshot is rewritten after every task; the architecture and the locked conventions change almost never. That difference is what keeps the brain trustworthy.
The brain is plain markdown, versioned beside your code. Remove the plugin and every layer is still there — nothing you wrote lives inside GAIA. Walk through a brain
Mission control
Two surfaces, both pure shell: an always-on statusline inside the agent pane, and a live mission-control view in a second pane. Calm by design — it redraws only on change and never makes the model wait.
GAIA Acme Platform · deep-work · ARCHITECTING · P2.4 ▓▓▓▓░░░░ 48% · Refactoring billing 5/7 · synced
One line, redrawn only when something actually changes. It tells you the phase you are in, the mode GAIA has inferred from real signals, the task in flight and whether the brain is in sync with the repo. Nothing about it is a spinner.
Illustrative reading from the cockpit above. Every figure is computed from evidence in your own repository — never a placeholder animation.
GAIA infers what you are actually doing — architecting, coding, debugging, deploying — from real signals, and adapts what it surfaces to match.
The current operation, real elapsed time and honest progress. The percentage comes from task state, not from a timer pretending to be one.
GAIA speaks only when it has something specific and evidenced to say. /gaia-mode deep-work silences proactive output entirely.
How it works
Point GAIA at a project once. From then on, two commands open and close every session — and you can simply talk to the agent instead if you prefer.
Detects your stack, asks only what it cannot observe, then scaffolds the brain, the agent entry point and a one-click launcher for your OS.
Integrate GAIA FLOW
The agent reads the brain in order, restores anything the last session interrupted, and confirms it is in sync before it touches code.
/gaia-resume
Appends the changelog entry and refreshes the snapshot, so tomorrow's session opens already current instead of already stale.
/gaia-ship
Compounding intelligence
GAIA studies how engineering actually happens — how problems get decomposed, how decisions get made, how an agent plans, delegates and corrects itself. Those patterns come back as better protocols and better defaults.
Learning is opt-in and secret-scrubbed. Your source code is never uploaded.
Tutorials
Short, unedited screen recordings of GAIA working on a project with existing history. They are being filmed now — nothing here is a placeholder for something that already exists.
Running Integrate GAIA FLOW on a project that already has history.
Resume, work, ship — and what the brain looks like before and after.
Writing the why, the alternatives rejected and the risk into the ledger.
Pricing
No subscription, no seats, no usage metering.
$25one-time
One licence covers one machine, and every project on it.
Checkout opens after the public release
Activates on a single machine and covers every project on it. No seat count, no per-repo fee.
Name each licence for the machine it runs on, and rename it whenever that machine changes.
A second laptop or a work desktop needs a second licence. Each is $25, once, for good.
The brain is markdown in your repository. Remove GAIA and every note you wrote is still there.
About
GAIA FLOW came out of a plain frustration: the model was extraordinary at writing code and hopeless at remembering why any of it existed. Every session opened with the same ritual of re-explanation.
The fix was not a better prompt. It was memory that lives with the project — versioned in the repo, readable by any agent, and structured well enough to be trusted as the source of truth.
Her purpose is to help developers build memory, so a project outlives the session that made it.
Pure shell at the floor. No Node, no daemon in the background; python3 is optional and only deepens the intelligence.
The first law of the codebase. Expensive work is gated behind cheap change signals, so the model is never waiting on GAIA.
The brain is plain markdown in your repository. Nothing is uploaded, and nothing is held hostage if you leave.
Early access
One command sets it up. After that, your agent opens every session already knowing what you are building and why.
Licensing and terminal sign-in are being finalised · checkout opens after the public release