Flow learns your codebase into documents your whole team shares, maps it as the capabilities it provides rather than the folders it sits in, runs the work on a board where agents take tickets and hand back pull requests — and records your browser and your server into one timeline when something breaks.
Three runtimes ship. You choose one per project, and each keeps its own credentials — so a work account and a personal one never mix.
Flow reads each part of your system and writes down what it learned: the purpose, the flows traced end to end, the invariants it verified against the code, and a file-by-file map. These are plain markdown files that live in your project — turn sharing on and they commit, review and merge exactly like code.
Every document is hash-stamped against the exact files it describes. The moment that code moves, the document is flagged stale and re-learned — staleness is decided by content, never by a timestamp. Code is ground truth; a README somebody dropped in is a claim, checked against the code before it is believed.
Which means a codebase is learned once, by whoever gets there first. When a teammate pulls, they already have what you understood — they do not re-learn it, and they do not pay for it again. Only the derived layer, the part Flow can rebuild from the markdown and the code, stays out of the repository.
It is also what keeps a session cheap. Instead of crawling hundreds of files every turn, an agent reads the indexed answer, and a capability explains itself inside a hard cap of roughly 1,500 tokens.
Not a folder tree, and not a diagram somebody has to maintain. Every rectangle is a capability, and its area is the code it stands on — so the shape of the map is an argument about where the weight of your system actually is.
It is derived from the code on every pass, never drawn by hand, so it cannot quietly stop being true. Diving into a capability flies its rectangle out to fill the sheet: parts, then files.
Connect a tracker and your assigned work arrives in a Remote column — GitHub, Jira or Azure. Take a ticket on and it becomes a card with its own agent thread. When that agent finishes cleanly it opens a pull request and moves the card to Review, where one click squash-merges it.
Every thread gets its own checkout, so nothing runs in your working tree — work lands by merging a branch, never by editing the files under you.
Flow runs your app in an embedded browser and your backend in its terminals. Debugging across them normally means you are the integration layer — copying a failed request out of one pane and a stack trace out of another, and hoping the two moments line up.
Press start, reproduce the bug, press finish. Browser console, network requests, what you clicked, and every terminal’s output are collected into one timeline stamped on a single clock — so “what did the server print in the 400 ms after I pressed Save” is answered by sorting. What reaches the conversation is the summary: what failed, what the server said around it, and what you did just before.
Point Flow at a repository and it derives the map on first open. Nothing to configure, nothing to hand-maintain.