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.

See how it works
The problem

Code changes faster than anyone can follow

  1. 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.

  2. 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.

  3. 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.

Features

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.

Flow map

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.

Why it matters

Anyone can answer “what happens when…?” without reading the code first, and check the answer, because every step cites the code behind it.

Agents

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.

Why it matters

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.

Connect your agent →
Pull requests

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.

Why it matters

Reviewers catch a removed retry or a new failure path before it merges, without tracing the diff by hand.

Connections

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.

Why it matters

You see everything that calls a flow before you change it, including callers in other repos that a search inside one repo would miss.

MCP

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.

Run in your terminal, then sign in with /mcp in Claude Code
claude mcp add --transport http flowmaps https://mcp.flowmaps.ai/mcp
Trust

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.

TypeScriptGoPython

Every 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.

Read the docs