Tutorials
The video library is being recorded. Until it is up, this page carries the written version — the install line, the three commands that carry every session, and an accurate reference for all eleven.
$curl -fsSL https://gaiaflow.brahmatechs.com/install | sh
GAIA FLOW — persistent project memory for AI coding agents Early access. Licensing and terminal sign-in are being finalised, so the installer is not open to the public yet. Join the list gaiaflow.brahmatechs.com/get ────────────────────────────────────────────────────── Already licensed? Inside your agent, one sentence sets a project up: Integrate GAIA FLOW
Start here
One lesson covers the whole loop: point an agent at a project you already have, let it read the code, and watch a Project_Brain get written into the repo.
No footage yet. Nothing here is a placeholder for a frame we have already shot.
Running Integrate GAIA FLOW on a project that already has history: stack detection, the three questions it asks, and every file it writes.
The recording is not up yet, so the walkthrough below is the lesson. It is the same ground in the same order, written out.
Every lesson on this page is in one of two honest states: being recorded, or planned. There are no published videos yet, and no page here pretends otherwise.
Quickstart
There is nothing to memorise. The first is a sentence you say to your agent; the other two are the bookends of a working day.
Say it in plain English inside Claude Code, the Codex CLI or the Gemini CLI. It detects the stack, asks only what it cannot observe, and scaffolds the brain plus a launcher for your OS. If a Project_Brain/ already exists it stops and asks — it never silently overwrites one.
›Integrate GAIA FLOW
Reads the brain in its fixed order, restores an interrupted session from the last checkpoint if there is one, reconciles the snapshot against the changelog, then confirms sync in a single line and waits. It does not start coding on its own.
›/gaia-resume
The locked update protocol. It appends a dated entry to the append-only changelog, overwrites the snapshot with what is true right now — including what was deliberately left undone — and takes a recovery checkpoint. A task is not finished until this has run.
›/gaia-ship
Four things land in your repository, all of them plain text you can read, diff and delete. Nothing is stored anywhere else.
$ cd ~/src/acme-platform && claude › Integrate GAIA FLOW stack Next.js · TypeScript · Postgres · pnpm git 412 commits · main · 9 contributors brain none found — safe to scaffold Three questions, then I write the brain. wrote Project_Brain/ 10 documents wrote CLAUDE.md agent entry point wrote RESUME.command one-click resume wrote cockpit statusline + mission control Brain integrated. Next session, type /gaia-resume
Memory and decisions
Each document has exactly one job. An agent reads them top to bottom at the start of a session, which is why the cheapest, most volatile layers come first.
# 02 — CURRENT STATE Last updated: 2026-09-04 ## Last shipped Multi-tenant row-level security across 9 tables. Verified: migration applied on staging, 34 tests pass. ## Next Split the billing service before the Q3 traffic ramp. ## In flight Invoice generation extracted; the payment orchestrator is not wired to it yet. ## Deferred - Rate limit on /api/export - Replace the ad-hoc retry loop in the webhook worker - Backfill decision records for phase 1 ## Known issues None open.
Two files hold the whole discipline. 02_CURRENT_STATE.md is replaced with the truth after every task. PROJECT_MEMORY.md only ever gains a dated entry on top. When they disagree, the changelog wins and the snapshot is the thing that is stale.
/gaia-decide writes a numbered entry into DECISIONS/: what was chosen, the reasoning, the alternatives that were rejected and why, the future impact, the risks, and the files it touches. A recurring failure can be filed the same way, as a lesson rather than a choice.
The library
The shape of the library is settled; the footage is not. Each card below is either being recorded or planned, and says which. Written coverage of the first track already exists further up this page.
Durations are the length we are writing to, not a measured runtime.
Running the setup sentence on a project that already has history, and reading what it wrote.
Adding the marketplace, installing, and confirming the commands appear in your agent.
Opening each generated document and explaining what belongs in it and what does not.
What /gaia-resume reads, in what order, and how it reconciles a stale snapshot.
Writing a changelog entry worth reading — scope, files, why, what you actually verified, what you skipped.
Using /gaia-phase to add, finish, re-order and split phases without hand-editing the tracker.
Which layer answers which question, and what happens when one of them is allowed to drift.
Capturing the reasoning and the rejected alternatives, not just the outcome, with /gaia-decide.
Filing a failure as an error record so the same class of mistake stops coming back.
Health, phase, trajectory, the live task panel and the activity stream — what each number is derived from.
One line, always on: project, mode, state, phase, the active task and sync health.
Using /gaia-mode to suppress every proactive output while persistence keeps running underneath.
What /gaia-scan collects deterministically, what it then reasons about, and how to read the Project DNA it writes.
Getting a trajectory read and confidence-ranked risks out of /gaia-suggest, and when to ignore it.
Running /gaia-doctor on a brain that was hand-edited: integrity, placeholders, drift and recovery health.
Reference
Three of these run every day. The rest are there when you want precision — and every one of them can be triggered by describing what you want instead.
| Command | What it does | What it writes |
|---|---|---|
Integrate GAIA FLOW |
Detects the stack from the repository, asks only what it cannot observe, then scaffolds a tailored brain. Refuses to overwrite an existing one. Also reachable as /gaia-init. |
Project_Brain/, CLAUDE.md, RESUME.command, cockpit |
/gaia-resume |
Reads the brain in its fixed order, auto-restores an interrupted session from the last checkpoint, loads only the memory the current work state calls for, then confirms sync in one line and stops. | Nothing, beyond restoring session state |
/gaia-ship |
The locked update protocol. Appends a dated changelog entry, refreshes the snapshot with what is true now — including deferred work — and takes a recovery snapshot. | PROJECT_MEMORY.md, 02_CURRENT_STATE.md |
/gaia-status |
A read-only pulse: last shipped, what is next, what is in flight, what is deferred, current phase. Flags the snapshot when it disagrees with the changelog. | Nothing — it never edits a file |
/gaia-scan |
The intelligence core. Deterministic scanners collect evidence, then the model reasons over it into a Project DNA: architecture pattern, maturity, posture, scaling read, top risk — each finding cited. | INTELLIGENCE/PROJECT_DNA.md, intelligence.json |
/gaia-suggest |
The strategic pass. Reads the brain and the real code, then reports trajectory and lifecycle phase, the highest-value next phase, and confidence-ranked risks and gaps. | Nothing until you accept a suggestion |
/gaia-decide |
Records an engineering decision, or a hard-won error lesson: what was chosen, why, the alternatives rejected, the future impact, the risks, and the files it links to. | A numbered entry in DECISIONS/ |
/gaia-phase |
Roadmap upkeep — add, done, next, split. A phase is only marked done when the work is shipped and logged, never on a promise. |
03_PHASE_TRACKER.md |
/gaia-mode |
Sets how present the system is: normal, deep-work, silent, recovery, lightweight, orchestration. Deep-work and silent suppress every proactive output. |
The session mode file |
/gaia-end |
The end-of-day wrap. Checks the latest task is logged, ships it if it is not, makes the snapshot truthful about half-finished work, then gives a short summary. | 02_CURRENT_STATE.md, session marker |
/gaia-doctor |
Health check and repair. Verifies every expected file, finds leftover placeholders, detects drift between the snapshot and the changelog, checks recovery health, and fixes what is safely fixable. | Repairs in place, with your confirmation |
You never have to type these. Describing the intent — “record this decision”, “where am I”, “wrap up for the day” — routes to the same command.
Before you start
Recording is under way on the first lesson. We are not putting a date on the rest, because a date we might miss is worse than no date. What we can commit to is this page: the written walkthroughs above cover the same ground and are kept accurate against the shipped commands.
They are filmed in Claude Code, because that is where most of the development happened. GAIA FLOW also runs in the OpenAI Codex CLI and the Google Gemini CLI. The brain is plain markdown and the commands are plain instructions, so the workflow is identical — only the pane around it changes.
That is the normal case, and it is what the first lesson covers. Setup reads the existing structure, git history, dependencies and build signals before it writes anything. If a Project_Brain/ is already present it stops and asks whether to leave it, check it with /gaia-doctor, or start over — it will not overwrite one silently.
You can read everything here now. Running it needs a licence, and checkout is not live yet — it opens after the public release. Until then the pricing page takes you to early access rather than a payment form.
One thing: run /gaia-ship before you call a task done. That appends the changelog entry and refreshes the snapshot together, so the two never drift. Everything else on this page is convenience around that single habit.
A terminal, git, and one of the three supported agent CLIs. The engine is pure shell with no hard dependencies — no Node, no daemon. python3 is optional: it deepens the intelligence layer, and everything degrades gracefully without it. macOS, Linux and Windows are all supported.
One sentence to begin
A licence is $25 once and covers unlimited projects on one machine. Checkout opens after the public release; until then the button below joins early access.
One licence, one machine · renameable per machine · extra machines are extra licences