Skip to content

AI over MCP

Hand the project to a model. It works in the open and writes back.

Helix ships an MCP server. Point any compatible model at it and hand over the project. It opens artefacts, runs the same tools the desktop uses, and writes conclusions back as first-class findings - not a chat transcript that scrolls away.

Part of Helix / no separate price

See Helix
tshelix_
MCP stream
09:14:01.003helix_ping
Ping the Helix engine and report whether the GUI app gate is reachable (gui_reachable).
=>engine ok, gui_reachable: true
09:14:01.190helix_open_projectpath:"~/Projects/BankApp-v4.1"
Open a Helix project and set it as the active project for this session.
=>project active: BankApp-v4.1
09:14:01.420helix_binaries_importpath:"com.bank.app"
Import a binary file into the active project.
=>imported: com.bank.app (arm64)
09:14:02.011helix_files_unpack_containerentry:"com.bank.app"
Recursively unpack APK, IPA, JAR, ZIP, 7z (AES-256), and raw .bin firmware into real project folders.
=>unpacked 214 entries
09:14:04.880helix_analysis_ensure_stagesprofile:"decompile"
Start missing analysis stages for a binary without re-running completed stages. Profiles: quick, search, decompile, full.
=>9 stages queued
09:14:05.110helix_analysis_list_stagesbinaryId:"com.bank.app"
List current state of all analysis stages for a binary.
=>decompile profile: complete
09:14:05.340helix_analysis_searchquery:"pin"
Search across analysis results - strings, symbols, imports, and exports.
=>7 matches (3 symbols, 4 strings)
09:14:05.601helix_disasm_functionaddress:"0x100234ab"
Disassemble a function and return all instructions.
=>142 instructions
09:14:06.020helix_analysis_ensure_stagesprofile:"decompile"
Start missing analysis stages for a binary without re-running completed stages. Profiles: quick, search, decompile, full. Non-blocking...
~>stages queued - polling helix_analysis_list_stages
09:14:06.780helix_decompile_functionaddress:"0x100234ab"
Decompile a function at a virtual address. Returns pseudoCode + structured tokens.
=>pseudoCode: validatePinEntry(pin, account)
09:14:07.200helix_renames_setsymbol:"sub_100234ab"
Create or update a rename in the decompiler overlay.
=>renamed to validatePinEntry
09:14:07.430helix_findings_createname:"Insecure PIN validation"
Create a new finding with the given name.
=>finding created at /findings/Insecure PIN validation
09:14:07.6...
12 calls11 ok, 1 running
1 finding written

01 / Real tools

The full workbench, handed to the model.

Helix exposes its workbench to any compatible model over MCP: binary analysis and decompilation, a non-destructive decompiler overlay, patching and re-signing, wireless and network captures, findings, and more. Every capability below is a real tool the model can call, running the same surface the desktop uses.

Session and projects

Open, create, and switch between analysis projects, with live engine and GUI status.

Binaries

Import binaries into a project and manage their storage and architecture.

Analysis pipeline

Run a staged pipeline over a binary, from quick triage to full decompilation, or trigger individual capabilities on demand.

Decompile and disassemble

Turn native, .NET, DEX/APK, and JVM code into readable pseudocode and instructions.

Decompiler overlay

Layer non-destructive renames, types, signatures, comments, and labels over the decompiler view.

Symbols and classes

Demangle and resolve symbols across binaries and trace string and data references.

Mach-O and Apple

Read Mach-O code signing, entitlements, chained fixups, and Apple sandbox profiles.

Diff

Match functions between two binaries and diff their instructions, pseudocode, and control flow.

Patching, signing, run

Apply binary patches, rebuild and re-sign packages, and run binaries under a timeout.

Files and explorer

Browse the project tree, read files intelligently, and unpack nested archives and firmware.

Findings and notebook

Capture findings as rich notebooks with runnable code playgrounds.

Structured findings

Seed structured findings for wireless captures - Sub-GHz regions, NFC block ranges, and RFID fields.

Workflows

Build and run repeatable analysis workflows with their own data.

HTTP capture and replay

Import, browse, replay, and sniff HTTP traffic inside a project.

Packets (pcap)

Import and dissect pcap captures with layered, Wireshark-style protocol detail.

Network

Snapshot discovered network services and send audited TCP/UDP payloads.

BLE

Scan, capture, fingerprint, and interact with Bluetooth Low Energy devices and GATT.

Companion and Helper

Drive the paired phone companion for remote BLE actions and file transfers.

Bluetooth Classic and MFi

Decode Bluetooth Classic devices and phone-sourced MFi accessories.

NFC

Decode captured NFC tags, NDEF records, and APDU logs.

RFID, Sub-GHz, IR, iButton

Decode RFID, Sub-GHz, IR, and iButton captures and their raw timings.

Barcode

List and classify captured barcode and 2D-code payloads.

Timeline

Merge every wireless and network domain into one unified capture timeline.

Flipper Zero

Import Flipper Zero SD captures and read from connected devices.

Tooling

Detect and install the external toolchains that analysis depends on.

Terminal (PTY)

Open and drive real PTY shell sessions inside the workbench.

02 / Findings

Conclusions write into the project, not a chat window.

When the model concludes something, it calls helix_findings_create and writes a first-class finding into the project tree. The finding carries a node in the tree, .mdx content, base64 artefacts, and structured domain blocks that tie a conclusion to the exact captured record it came from.

The finding playground runs for real: python, node, bash, cpp, rust, and asm. stdout, stderr, and the folder diff come back on every run.

  • First-class findings

    The model writes named findings straight into the project tree, not a chat transcript.

  • Rich notebook bodies

    Each finding stores a structured document alongside a JSON sidecar.

  • Structured wireless findings

    Purpose-built findings for Sub-GHz regions, NFC block ranges, and RFID fields.

  • Runnable playgrounds

    Findings embed code blocks the model executes - python, node, bash, cpp, rust, asm - and reads back stdout, stderr, and the folder diff.

03 / Auditability

Auditable, replayable, consent-gated.

Driving a workbench from a model only earns trust if every move is on the record and the dangerous ones ask first.

01

Consent before any radio or network write

helix_ble_host_probe_gatt, helix_ble_host_gatt_write, and helix_network_send_payload all require consented=true in the call. If the flag is absent the tool refuses and returns an error before anything is sent. The response is audited to the project.

consented=true required
02

Analysis is staged and polled

There is no single one-shot full-analysis call. The model runs helix_analysis_run_stage to start a specific stage, then polls helix_analysis_list_stages until the stage reaches Done or Failed. Every intermediate state is visible. helix_analysis_ensure_stages with a named profile queues only the missing stages.

run_stage -> list_stages
03

Results persisted on every path

helix_findings_create writes a typed finding into the project. That record is persisted the same way whether the work ran over the MCP path or through the app itself. The model can retrieve it after the fact.

helix_findings_create
04

Local by design, no cloud orchestration

Helix runs as a local process on the same machine as the project. There is no remote or cloud orchestration layer involved. Everything the model touches lives on that machine, and helix_ping confirms the engine is reachable before any GUI-routed call.

helix_ping

04 / Full surface

Every capability domain.

Every capability domain in the Helix MCP server, mapped as a single structured index of the complete surface.

helix_Helix reverse-engineering workbench
Session and projectsOpen, create, and switch projects. Ping the engine.
BinariesImport, list, set arch, reconcile, delete binary entries.
Analysis pipelineStaged pipeline: run, poll, cancel, search, call graph.
Decompile and disassembleFunction decompile, managed-code decompile, disassemble, IL/smali edit/reassemble.
Decompiler overlayRenames, types, comments, labels, equates, function signatures - non-destructive.
Symbols and classesDemangle (Swift, C++, ObjC, Rust), cross-binary resolution, string cross-refs.
Mach-O and AppleEntitlements, chained fixups, sandbox profile parsing.
DiffFuzzy function match, text diff, CFG block-diff, generic file diff.
Patching, signing, runStrict same-size patch, package rebuild, re-sign, verify, execute with timeout.
Files and explorerProject file tree read/write, container unpack (APK, IPA, JAR, ZIP, 7z, firmware).
FindingsCreate, tree, load, save, move, delete findings. Folders. Base64 artifact reads.
Structured finding creatorsTyped Sub-GHz region, NFC block range, RFID field blocks tied to captured records.
WorkflowsCreate, load, save v2 workflow documents. Read/write workflow run data.
HTTP capture and replayImport Burp/HAR/raw HTTP, browse tree, replay requests, sniff live traffic.
Packets (pcap)Import pcap/pcapng/wireshark-json, tree, dissect (Wireshark-style field offsets), sniff.
NetworkList Bonjour/Wi-Fi snapshots. Send TCP/UDP payload (consented=true required).
BLEList, scan, decode, fingerprint. Live GATT probe and write (consented=true required).
Companion and HelperCompanion server status, pairing PIN, queued GATT actions, transfer history.
Bluetooth Classic and MFiClassic devices with CoD decoding. MFi accessories with name/manufacturer/protocols.
NFCList, decode NDEF/APDU, get structure for captured NFC tags.
RFID, Sub-GHz, IR, iButtonList, get, decode RFID/Sub-GHz/IR/iButton records. Sub-GHz timing data.
BarcodeList barcode and 2D-code records with payload classification.
TimelineUnified newest-first view across BLE/NFC/RFID/BT/MFi/barcode/network.
Flipper ZeroImport .nfc/.rfid/.sub/.ir/.ibtn files. Live USB device: browse, read, write, import.
ToolingDetect, configure, and install analysis toolchains. Capability preference per binary.
Terminal (PTY)Create, attach, write, resize, close headless PTY sessions.

Ready to start

Connect a model. Let it work.

Point any MCP-compatible model at the Helix server and hand it the project. The workbench opens artefacts, runs real tools, and every conclusion lands as a finding.