Close a database and terminate its worker process.

Specify database when multiple are open. Fails if the DB is not attached to the current session unless force=True. When other sessions still use the DB, detaches this session but keeps the worker alive.

Save the current database to disk (may take minutes for large DBs).

Specify database when multiple are open. Fails if the DB is not attached to the current session unless force=True. Progress notifications are sent every 5s during long saves.

List all open databases with metadata (includes opening/analyzing status).

Block until database(s) finish opening and optional auto-analysis.

Single: pass database to wait for one DB. Multi: pass databases list — returns when at least one is ready. Work on the ready one, call again for the rest.

While analysis runs, the backend thread is blocked — tool calls queue.

List available targets (processors, loaders, languages, etc.).

Open a binary or existing IDA database (.i64/.idb) for analysis.

Returns immediately with "opening": true — call wait_for_analysis before using other tools on this database. Re-opening an already-open database returns the existing worker.

Multiple binaries: use a separate subagent per binary. Each agent calls open_database then wait_for_analysis. Do NOT serialize open+wait calls — that blocks parallel loading.

force_new=True is destructive: deletes existing .i64/.idb and all prior analysis. Use only for stale/incompatible DBs.

Fat Mach-O: requires explicit fat_arch (e.g. arm64). Error lists available slices. Use distinct database_id per slice for concurrent analysis. fat_arch must be omitted for non-fat files and existing databases.

Search hidden tools by regex (pinned tools excluded; use .* for all).

Returns one-line signatures by default. Use detail="detailed" for parameter schemas, or follow up with get_schema(tools=[...]).

Hidden tools must be called via call, batch, or execute — direct calls will fail because they are not in the client tool list.

Get parameter schemas for specific tools by name (pinned and hidden).

Use after search_tools or before execute/batch to check parameter types and return shapes. Pass detail="full" for complete JSON schemas.

Hidden tools must be called via call, batch, or execute — direct calls will fail because they are not in the client tool list.

Run Python code that chains tool calls. Use await invoke(name, params) to call tools; use return to produce output.

database is auto-injected into every invoke — omit it from params. Override per-call with explicit database for cross-database work.

When NOT to use execute

• Single tool call → use the call meta-tool (or the direct tool if pinned).

• N independent calls → use batch (lower overhead, per-item errors). → Otherwise, use the batch meta-tool for sequential multi-tool execution with per-item error collection and progress reporting.

• Check if a tool has a built-in batch parameter first (e.g. get_strings filters=[...]).

When to use execute

Multi-step pipelines — chaining one tool's output into another:

decomp = await invoke("decompile_function", {"address": "0x1234"})
addrs = re.findall(r'sub_([0-9A-Fa-f]+)', decomp["pseudocode"])
xrefs = [await invoke("get_xrefs_to", {"address": f"0x{a}"}) for a in addrs]
return {"decomp": decomp, "xrefs": xrefs}

Cross-database parallel queries — use asyncio.gather with explicit database params. Same-database calls are serialized by the worker.

Reference

• Blocked tools: open_database, close_database, wait_for_analysis, list_targets, and meta-tools (search_tools, get_schema, execute, batch, call) must be called directly. save_database and list_databases are allowed.

• Addresses are strings: "0x401000", "4010a0", or symbol names.

• filter_pattern is Python regex — use re.escape() for literals.

• Available imports: asyncio, collections, functools, itertools, json, math, operator, re, struct, typing. No FS/network I/O.

• Paginated results have items, total, offset, limit, has_more — always check has_more.

• Use get_schema(tools=[...]) to look up parameter names and types.

• Return only what you need — filter before returning to save context.

Run 2+ independent tool calls in a single request with per-item error collection.

Preferred over execute for independent calls (no sandbox overhead). Examples: decompile/disassemble N functions, rename N symbols, set N comments, fetch N xrefs.

Use execute only when chaining one tool's output into another.

database is auto-injected into each operation — omit from params. Override per-operation with explicit database for cross-DB work.

Call any tool by name, including hidden tools not in the client tool list.

Use for single hidden-tool calls. For multiple calls, prefer batch.