> For the complete documentation index, see [llms.txt](https://docs.hex-rays.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.hex-rays.com/add-ons/assist/how-tos/parallel-execution-with-assist-mcp.md).

# Parallel execution across multiple instances with Assist MCP

Real programs rarely live in one file. Their logic is split across many libraries and programs: a check can start in the main executable, call into a shared library, and finish in a plugin loaded at runtime.

You don't need to map that out yourself. Open each module in IDA, connect a terminal agent such as Claude Code through Assist MCP, and ask your question. Assist discovers which module does what on its own. It all works together through the [Assist Mesh](/add-ons/assist/concepts/mesh.md): the linked IDA instances work in parallel, each one analyzing and emulating its own code, and Assist puts the pieces together into one answer.

## Prerequisites

* IDA 9.4 SP1 or later (IDA Home, IDA Pro)
* Assist installed, see [Getting Started](/add-ons/assist/getting-started.md).
* A terminal agent: Claude Code, Codex, Grok, Antigravity CLI, or another MCP client. This tutorial uses Claude Code.
* The Assist hands-on kit, downloaded and unzipped. This tutorial uses the `07-mesh-modules` folder.

{% file src="/files/naAH0JMRqFms5ipW1Zb2" %}

To demonstrate the mesh, we prepared `lockctl`, an x86-64 Linux program (GCC 12, glibc) that prints `ACCESS GRANTED` only for a valid unlock token. Its logic is spread across four modules:

* `lockctl`, the executable,
* `libkstore.so` and `libkcrypto.so`, two shared libraries,
* `libkproto.so`, a plugin loaded with `dlopen`.

Our goal is to compute the token `lockctl` expects for user alice on door 7.

## Step 1: Open every module

Open the four databases from the `07-mesh-modules` folder of the kit, each in its own IDA instance: `lockctl.i64`, `libkstore.so.i64`, `libkcrypto.so.i64`, and `libkproto.so.i64`. The databases are already analyzed. Keep the folder intact: the emulator needs the `sysroot/` folder next to the databases to run `lockctl` with its libraries.

![Four IDA instances, one for each module](https://492083732-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FFP6ibt8r6WPBHTqekG9u%2Fuploads%2Fgit-blob-6b1ec944ba6afd7f205f2581584eaa4e34873e5e%2Fassist-mesh-howto-instances.png?alt=media)

Assist is active by default, so every instance joins the mesh on its own. In the Assist panel, **Assist MCP** turns green and **Linked** shows how many databases are linked, counting the current one.

{% hint style="info" %}
To stop sending work to a database, click **Linked** and hide it. Hiding works in one direction only: a hidden node can still read the current database. See [Hide a node](/add-ons/assist/concepts/mesh.md#hide-a-node).
{% endhint %}

## Step 2: Connect Claude Code to Assist MCP

1. In a terminal, register Assist MCP with Claude Code. The onboarding wizard gives the exact command for your agent under [Bring your terminal agent](/add-ons/assist/getting-started.md#bring-your-terminal-agent-optional). For Claude Code on macOS, it looks like this:

   ```bash
   claude mcp add ida -s user -- "$HOME/.idapro/plugins/assist/bin/assist" --mcp
   ```

   ![Registering Assist MCP with Claude Code in a terminal](https://492083732-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FFP6ibt8r6WPBHTqekG9u%2Fuploads%2Fgit-blob-e171d8992c5ebcd00ef5ac03bdd8367e8c5a64cb%2Fassist-mesh-howto-mcp-add.png?alt=media)
2. Start Claude Code with `claude`. It starts `assist --mcp`, which connects to the mesh, so one connection reaches every linked database.

To check the connection, ask Claude Code *what binaries are loaded in ida?* It calls `list_databases` and lists the four open databases: `lockctl` as **local**, and the three libraries as **peer**.

![Claude Code listing the four open databases with list\_databases](https://492083732-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FFP6ibt8r6WPBHTqekG9u%2Fuploads%2Fgit-blob-8a6c924486f82fded6ddb7b5d2fa00694f54609d%2Fassist-mesh-howto-list-databases.png?alt=media)

## Step 3: Approve the client

The first time Claude Code connects, it has to be allowed before it can run tools. Undecided clients can browse the tool list but cannot run tools.

IDA asks whether to allow it: **Allow** remembers the client for all your open databases, **Decide later** leaves it undecided, and **Deny** blocks it.

![The MCP connection request for Claude Code](https://492083732-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FFP6ibt8r6WPBHTqekG9u%2Fuploads%2Fgit-blob-0fa66e332715fec69d650ea70dae4591c9d2c18e%2Fassist-mesh-howto-connection-request.png?alt=media)

Open **Settings → Permissions** and select the **MCP clients** tab. It lists every client you have decided on, with its working directory and state, and lets you change those decisions later. Approvals are remembered and shared across your open databases, so you approve Claude Code once for the whole mesh.

**New connections** decides what happens when a new client connects: **Ask for approval** (the default), **Review here (no prompt)**, **Approve all**, or **Deny all**. With **Approve all**, clients on this machine can run tools immediately, without the request. A client from another machine always asks for approval, unless **New connections** is set to **Deny all**.

## Step 4: Ask from Claude Code

In Claude Code, describe the outcome you want end to end. You don't have to say which module does what: that is for Assist to find out. Do say that each piece should be computed from the real code, in the database it lives in:

> `lockctl` prints ACCESS GRANTED only for a valid unlock token. For our audit report, work out end to end, across all the linked databases, how `lockctl` validates tokens, and compute the token it expects for user alice on door 7 as a test vector. Compute each piece by emulating the real library code in the database it lives in, then confirm the test vector by running `lockctl` in the emulator together with its real libraries.

## Step 5: Watch it discover the pipeline

Assist works through the mesh in a few stages. You can follow them in the tool calls Claude Code shows:

1. **Discover the modules in parallel.** It lists exports in every linked database at once (`get_exports` with `scope: "mesh"`), to find which module implements which part of the pipeline. Mesh-wide calls run read-only tools on up to 8 peers in parallel, so each IDA instance answers at the same time instead of one after another.
2. **Route each call to its module.** It sends each call to the database that holds the code (`target`), so every function is decompiled and read in its own database.

   ![Claude Code calling list\_functions and decompile in each library by target](https://492083732-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FFP6ibt8r6WPBHTqekG9u%2Fuploads%2Fgit-blob-a2952c21c56f6b623946e7070eaa48c826f762f2%2Fassist-mesh-howto-target-calls.png?alt=media)
3. **Emulate each piece where it lives.** It emulates the library functions in their own peers (`emulate_function`), so every intermediate value comes from running the real code.
4. **Confirm end to end.** It runs `lockctl` in the emulator together with its libraries (`emulate_process`), and checks that the computed token makes the program print `ACCESS GRANTED` for alice on door 7.

The answer walks through the unlock-token pipeline module by module, with addresses that lead back into each database.

## Step 6: Follow up

To have Claude Code rename or comment based on the answer, first set **Modify this IDA database** to **On** in the **Assist** tab of **Settings → Permissions**, in each instance you want it to change. Mesh and MCP calls can't ask for approval, and each database checks its own setting, not the setting of the instance the call came from. See [Permissions & Privacy](/add-ons/assist/concepts/permissions-and-privacy.md#assist-mesh-and-external-mcp-clients).

## Ask from the Assist panel instead

You can also give the same prompt in the Assist panel of the `lockctl` instance, where changes can still ask for approval.

## What's next?

* Read [Assist Mesh](/add-ons/assist/concepts/mesh.md) for how nodes join, how a call picks its database, and what happens when an instance closes.
* Read [Emulation](/add-ons/assist/concepts/emulation.md) for what emulation can recover from code that hides its logic.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.hex-rays.com/add-ons/assist/how-tos/parallel-execution-with-assist-mcp.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.