The logic layer for agents and developers
A plain-language map of every flow in your codebase, updated with every change, so developers and agents work from the same understanding.
Code changes faster than anyone can follow
- 01
No one can hold the whole codebase in their head
Each person knows their own corner, the docs are out of date, and the full picture lives nowhere.
- 02
Agents have no shared understanding of how the system behaves
Each agent works it out again file by file, misses entry points like a webhook nothing calls, and two agents can give two answers about the same flow.
- 03
Too many changes to keep track of
There are so many pull requests that it’s hard to see what each one actually does. A diff shows which lines changed, not which paths now behave differently.
Every path mapped, every change explained
Follow any flow step by step, review a pull request by the flows it changes, and let agents read the same flows over MCP.
Every path through your code, as steps you can follow
Each flow runs from its trigger to its outcomes: what gets checked, called and written, and where it can fail. Every step points to the lines that run it, and the map redraws itself when the code changes.
Anyone can answer “what happens when…?” without reading the code first, and check the answer, because every step cites the code behind it.
One shared map for every agent
Agents ask Flowmaps over MCP. They find the flows behind a request, see which flows a file’s lines belong to, and open only those lines.
Agents start from what the code really does, so they read less, change the right place, and don’t miss the other flow that shares the code.
Every pull request shows which flows it changes
Each pull request gets a preview of every flow it touches: before and after, side by side, with changed, added and removed steps marked.
Reviewers catch a removed retry or a new failure path before it merges, without tracing the diff by hand.
See how your repos fit together
Each call is matched to the flow that answers it, whichever repo that flow lives in, along with every service a flow reaches. A call that can’t be matched is marked not mapped, never joined to a look-alike.
You see everything that calls a flow before you change it, including callers in other repos that a search inside one repo would miss.
Connect your agent in one step
Your agent reads the map over MCP: it finds the flows behind a question, opens only the lines a step cites, and checks what a change will touch before it edits.
claude mcp add --transport http flowmaps https://mcp.flowmaps.ai/mcp
Why your agents can rely on it
Discovery in any language
An agent finds entry points the way a new engineer would. Framework recipes pin down the common ones exactly.
TypeScriptGoPythonEvery step points to the code
Each step links to the file and lines that run it, so you can check any claim in one click.
Fewer tokens on every task
Agents read the shared flow and open only the lines it cites, instead of rereading files on every task.
Updated on every merge
Flows a merge touches are re-checked and carried to the new commit. Anything out of date is marked stale.
Stay in touch with your codebase
Map a repo, connect your agent, and see what your next pull request changes.