About GAIA FLOW
A coding agent can hold your architecture in its head for an hour, argue you out of a bad abstraction, and then lose all of it the moment the window closes. GAIA FLOW exists to close that one gap — not with a longer prompt, but with memory that lives in the repository and is read before a line is written.
Why it exists
Every new session opens on an empty context window. The first stretch of it goes to the same catch-up you gave yesterday: what this service does, why the auth layer looks the way it does, which of two approaches you already rejected and why, and what you were halfway through when you stopped.
That briefing is a tax. It is paid in tokens, in time, and in the quiet erosion of trust that comes from explaining yourself to something that felt, an hour ago, like it already understood.
The fix is not a longer system prompt, and it is not a hosted memory service that takes custody of your context. It is a folder. A small set of markdown files with a fixed read order, versioned beside the code, written at the end of every task and read at the start of the next one. The state of the project stops living inside a conversation and starts living in the repository, where it belongs.
A project should outlive the session that made it.
# 0007 · Redraw the cockpit on # change, not on a clock date: 2026-05-27 type: decision status: locked links: core/ui · SYSTEM_LAW.md ## Decision The second pane redraws when a watched file changes. Never on a timer. ## Why A polling loop burns CPU beside the model. Law 3: never slow the agent. An idle tick costs a few stat calls. ## Rejected - 1s refresh — simple, always warm - per turn — misses live progress ## Impact Any future panel declares its change signal before it is allowed to render.
From GAIA FLOW's own Project_Brain — the product is developed against itself.
Principles
Most AI tooling competes for your attention. GAIA FLOW is built on the opposite conviction: a system you depend on daily should be present and quiet, and should earn its place by what it never does.
Performance is treated as a product feature, not a target. Expensive analysis sits behind a cheap change signal — if nothing structural moved, nothing runs and nothing is spent. A per-turn hook appends a line or compares a hash, then gets out of the way.
GAIA speaks rarely, and only when it has something specific to say — a senior engineer quietly noticing something, not a chatbot narrating its own work. There is no motivational filler, no advice you did not ask for, and no summary that restates what you just wrote.
When the analysis would be shallow, the correct output is nothing at all. That is a rule in the codebase, not a preference.
Shell scanners collect facts and are forbidden from judging them. The model reasons over those facts and cites what it used. Nothing is claimed that the evidence cannot carry.
The Project_Brain is markdown, committed with your code, diffed in review like anything else. Nothing is stored on our side, so there is nothing to export and nothing to request back.
Remove the plugin and every note you have written is still sitting in the repository. Trust is the product; lock-in would be the exact opposite of it.
The model
Three layers, running in one direction. Facts are collected by scripts that are not allowed to have opinions. The model reasons over those facts and is not allowed to invent any. What survives is written to disk as markdown you can read, diff and revert.
Layer 01 · Evidence
Shell scanners walk the filesystem, git history, dependency graph and build signals, and emit facts as key-value lines. No network. No judgement words. A scanner that fails emits nothing, and the bundle still assembles.
Layer 02 · Reasoning
The model reads that bundle and produces the reading: architecture pattern, maturity, posture, scaling direction, the one risk worth naming. Each finding points back at the fact it came from.
Layer 03 · Cognition
What survives is written to the Project_Brain: a snapshot that is overwritten each task, a changelog that is only ever appended to, decisions that record why rather than what. Reviewable, revertable, yours.
The constitution
GAIA FLOW is governed by a written constitution that sits above any feature idea. It is checked into the repository, referenced from the conventions file of every project it scaffolds, and applied to every change before the change is written.
When a proposed change conflicts with a law, the change is wrong — not the law.
Five of the fifteen do most of the work. They are the reason the system stays quiet, stays fast, and stays worth having open.
| Law | In practice |
|---|---|
| Law 03Performance first | No perceptible latency may be added to a turn. Session start gets about fifty milliseconds of budget; a per-turn hook about twenty. |
| Law 04Token economy | Unchanged systems are never re-analysed. Reads are bounded — the top of the changelog, not the whole file. |
| Law 08Event-driven | Expensive reasoning runs when a cheap change signal says something structural moved, and not otherwise. |
| Law 12No fake intelligence | No generic advice, no cosmetic thinking effects, no summary that restates its input. If the analysis would be shallow, the output is silence. |
| Law 15It must feel expensive | Spacing, restraint, startup time, density, the quality of a single interaction. Premium is the sum of decisions nobody itemises. |
Who builds it
GAIA FLOW is built by BRAHMA TECH, the software practice of Crown Troca Private Limited. It is a small team that works the way the product does — terminal-first, in long sessions, with an agent in the loop and a repository as the only source of truth.
The product is developed against itself. This repository carries its own Project_Brain, and every release goes through the protocol it asks of you: append the changelog, overwrite the snapshot, record the decision. When one of the laws is inconvenient, we are the ones who find out first.
Where it is going
The protocols that read the brain never name a model. That is deliberate: the same folder is legible to Claude Code, to the OpenAI Codex CLI and to the Google Gemini CLI, because it is a folder — not an integration.
What sharpens with use is the methodology rather than any model. Every decision recorded, every phase closed, every error written down as a lesson makes the next resume more precise — and the engine reads a project that has been kept, not a project that has been described.
The layers below are architected and named in the codebase, with the seams already in place. None of them is built yet, and we would rather say so than imply otherwise.
Sequencing a multi-agent task end to end from the phase tracker, with each specialist reading the one shared cognition source.
An optional retrieval layer for repositories whose history has outgrown reading the top of the changelog. Optional, because most projects will never need it.
Policy, single sign-on, audit export and encrypted cognition at rest. The boundaries exist in the architecture so none of it becomes a rewrite.
GAIA FLOW is $25 once, for as long as you use it. One licence covers one machine and can be renamed when you change machines; additional machines take additional licences. Checkout opens with the public release — until then the link takes you to early access.
