Built for coding agents

Give your agent
the bigger picture.

Agents can write code faster than we can read it all.

Roam gives them a local map of your code and free static checks, so they can find what matters, check a change’s impact, and catch structural problems as they work.

Equip your agent See how it helps

Free and open source. Local static analysis. No model calls for the checks.

Before your agent changes a function.

“What else uses this function?”

The function your agent plans to changecalculate_total()checkout/pricing.py

Called by

  • place_order()orders.py
  • preview_order()preview.py
  • apply_discount()discounts.py

Your agent can check the callers, not just the edited file.

roam impact calculate_total
Illustrative checkout example, not a live report. Your agent gets these connections as structured results through the CLI or MCP.

Useful at every change

A wider view.
A better-informed agent.

You shouldn’t have to chase every generated line. Give your agent tools to explore the codebase, check its changes, and bring back findings worth your attention.

Before it calls the work ready

Your agent can review the patch for structural concerns and, when clone evidence is available, related copies that may need the same fix. It still needs to run tests.

git diff | roam critiqueLook beyond the patch

These are tools for your agent to call, not a checklist you need to run by hand. In CLI examples, replace <symbol> with a function or class in your project. Explore more examples

Static analysis does the groundwork

Let the model reason.
Let Roam do the lookups.

Finding callers, tracing dependencies, spotting duplicate code: much of this is work software can do locally. Roam gives your agent those results without asking another model to work them out.

Connect through MCP — a standard way for agents to use tools — or let your agent call the CLI. Results include code locations, findings, and limits it can act on. Add Roam to the agent’s workflow so those checks become routine.

Connect your coding agent

Setup guides for Claude Code, Cursor, Codex, VS Code, and more.

A workflow for your agent

Find the context.
Check the work.

  1. ExploreAsk Roam for relevant code and connections.
  2. CheckInspect likely impact before editing.
  3. ReviewCheck the patch, run tests, and report findings and gaps.

Already using Claude Code? Optional hooks can prepare context before a prompt.

Free static power for your agent

More to check.
No model call to run it.

Roam builds a reusable local index. Your agent can query it as it works, instead of asking a model to rediscover the same code connections.

Local compute, not another model bill.

The CLI and MCP server are free under Apache 2.0. Static checks need no account, API key, or model call. They use your machine’s resources; your agent’s model usage, including reading results, is separate.

Your code stays under your control.

Roam does not automatically upload your repository or telemetry. Connected agents receive tool results under their own provider settings. Installation, parser downloads, and optional online features have a documented network boundary.

Evidence for the next decision.

Static analysis reads code without running your app. Its map can be incomplete; a finding is a lead to investigate, not a guarantee. Keep tests and security checks in the workflow. You decide what ships.

See where Roam fits

Set up once. Let your agent use it.

Give your agent
a new set of tools.

You’ll need Python 3.10+ and a Git repository. Install Roam, index the project, then connect your coding agent.

  1. 01 / Install the agent tools
    pip install "roam-code[mcp]"

    Prefer an isolated install? Use pipx install "roam-code[mcp]" or uv tool install "roam-code[mcp]".

  2. 02 / Open your repository
    cd path/to/your/repo
roam init

    Replace the path with your project. This builds the index and creates project configuration.

  3. 03 / Connect your agentChoose your agent’s setup guide

    Connect the tools and add the workflow instructions. Ask your agent to use Roam before editing and when checking its work.

Want only the index, without project configuration? Use roam index instead of roam init.

Walk through the getting-started guide

If your agent uses shell commands, pip install roam-code is enough for the CLI. You can inspect the same results yourself. Learn about MCP.

A few things worth knowing

Good questions.

Something else on your mind?
Ask us on GitHub

Is Roam for agents or for people?

Roam is built for coding agents to use as they work. Connect it through MCP or let your agent call the CLI, and include Roam checks in its instructions. You can inspect the same results in the terminal, but manually running every check is not the intended workflow. Connecting tools alone does not guarantee your agent will use them.

Is Roam free?

The CLI and MCP server are free and open source under Apache 2.0, for individuals and teams. Static checks use local compute, not model calls or a paid Roam API. Your coding agent's own model usage is separate. Paid services and planned team products are separate too; you do not need them to use the local tools. See team options.

Does my code leave my machine?

Ordinary analysis is local, with no automatic source-code or telemetry upload. A connected coding agent receives tool results and may send them to its model provider under its own settings. Installation and the first parser download need network access. Optional online features have explicit triggers; opt-in MCP model summarization can include source snippets. Read the network boundary for the full details.

What languages and computers does it work with?

Roam runs on Windows, macOS, and Linux with Python 3.10+. It supports 28 languages, including Python, JavaScript, TypeScript, Go, Rust, Java, C#, PHP, and Ruby. The depth of analysis varies by language and framework. Explore the documentation.

How long does the first index take?

It depends on the size of your repository, its history, your machine, and whether parsers are already downloaded. The first index does more work; later refreshes reuse it and process changed files. Run roam index to refresh after changes.

Does Roam replace tests or code review?

No. Roam gives your agent evidence to investigate code connections and potential risks. Static analysis can miss connections, a suggested test list is not test coverage, and a health score is not permission to merge. Use Roam alongside tests, security checks, and human review of the changes that matter. You still set the goals and decide what ships.

Can our team use it in CI?

Yes. Run Roam checks in your build, review changes, and export findings for code-scanning tools. You can also enable a local run ledger and proof bundles to record which checks ran. Signed records help detect later changes to evidence; they do not prove every relevant check was captured. See integration guides and review records for teams.

Already shipping with agents?

Give recent work another check.

Have your agent run a local sample review of recent merged pull requests, then investigate the structural findings worth following up.

roam pr-replay --tier sample

Requires Roam and local merge history. This replay sends no email and performs no repository upload.

Explore review and team options