DEV Community: Marcus Vance | Signal Matrix AI

Reverse Engineer Anything: AI-Powered Binary Analysis

Marcus Vance | Signal Matrix AI — Tue, 13 Oct 2026 13:09:59 +0000

Reverse Engineer Anything: AI-Powered Binary Analysis

Stop guessing how that app works—let your AI agent decompile it for you.

Every software engineer has encountered the "black box" problem. You are integrating a third-party library, debugging a legacy binary, or trying to replicate a feature from an Electron app, but there is no documentation. Traditionally, you would spend days manually navigating Ghidra or IDA, struggling to map assembly instructions to high-level logic.

That manual grind is over. Meet REA (Reverse Engineer Anything), an MCP-based toolset that turns your AI agent into a senior reverse engineer.

What is REA?

REA is a bridge between raw machine code and human-readable logic. By leveraging the Model Context Protocol (MCP), REA allows your AI agent to inspect native binaries, JavaScript, Electron applications, and .NET assemblies directly from your terminal.

Because REA runs locally, your proprietary code and sensitive binaries never leave your machine. It provides evidence-based explanations, citing specific binary offsets or code blocks, so you aren't just getting a "guess" from an LLM—you are getting a verifiable analysis.

Where to Get It (Official Links)

GitHub Repository: https://github.com/morluto/rea
Official Website & Guides: https://rea.tools/
npm Package Registry: https://www.npmjs.com/package/rea-agents
Discord Community: https://discord.gg/GkcryMnJDM

Quick Install & Setup

REA is designed for immediate integration into your development workflow. To get started, ensure you have Node.js installed on your system.

Install the package globally:

   npm install -g rea-agents

Run the setup command: This command registers the REA tools with your local AI agent configuration (such as the Claude Desktop app or other MCP-compliant clients).

   npx rea-agents setup

Verify installation:

   rea-agents --help

If you plan to analyze native binaries, ensure you have a decompiler like Ghidra, Hopper, or IDA Pro installed on your machine. REA will leverage these engines to perform the heavy lifting.

How to Use It in Real Life (Step-by-Step Walkthrough)

Let’s say you are trying to understand how a specific authentication flow is implemented in a legacy Windows binary.

Step 1: Connect the Agent

Open your MCP-compatible AI client (e.g., Claude Desktop). Check your available tools; you should now see the rea toolset listed. If you are using a custom MCP client, ensure the rea-agents server is added to your configuration file.

Step 2: Provide the Target

Point your agent to the binary or directory you want to analyze.

Input Prompt:

"I need to understand the authentication logic in this binary: /path/to/target_app.exe. Please use REA to decompile the relevant function and explain how it validates the user token."

Step 3: Review the Evidence

Your agent will now trigger the REA tool. It will interact with your local decompiler, extract the pseudo-code, and provide a breakdown.

Expected Agent Output:

"I have analyzed the binary at /path/to/target_app.exe using Ghidra. The authentication logic is located at offset 0x4012A0.

The function validate_token performs the following steps:

It pulls the header from the request buffer.

It performs an XOR operation with a static key found at 0x405000.

It compares the result against the hardcoded string 'AUTH_SUCCESS'.

Here is the decompiled snippet for your reference: [Code Block]"

By providing the exact offset, the agent allows you to verify its work instantly in your decompiler of choice.

Why REA Changes the Game

Evidence-Based: The agent doesn't hallucinate logic; it cites the exact binary offsets.
Privacy-First: Since the analysis happens locally, you can safely inspect proprietary software without fear of leaking intellectual property to the cloud.
Workflow Integration: No more context switching between your IDE and a separate reverse engineering suite. Your AI agent brings the insights directly to your chat window.

Whether you are a security researcher, a developer trying to replicate a feature, or an engineer dealing with legacy code, REA provides the clarity you need to move faster. Stop struggling with the black box and start building.

Reverse Engineer Anything: AI-Powered Binary Analysis

Marcus Vance | Signal Matrix AI — Tue, 13 Oct 2026 08:56:48 +0000

Reverse Engineer Anything: AI-Powered Binary Analysis

Stop guessing how that app works—let your AI agent decompile it for you.

That manual grind is over. Meet REA (Reverse Engineer Anything), an MCP-based toolset that turns your AI agent into a senior reverse engineer.

What is REA?

Where to Get It (Official Links)

GitHub Repository: https://github.com/morluto/rea
Official Website & Guides: https://rea.tools/
npm Package Registry: https://www.npmjs.com/package/rea-agents
Discord Community: https://discord.gg/GkcryMnJDM

Quick Install & Setup

REA is designed for immediate integration into your development workflow. To get started, ensure you have Node.js installed on your system.

Install the package globally:

   npm install -g rea-agents

Run the setup command: This command registers the REA tools with your local AI agent configuration (such as the Claude Desktop app or other MCP-compliant clients).

   npx rea-agents setup

Verify installation:

   rea-agents --help

How to Use It in Real Life (Step-by-Step Walkthrough)

Let’s say you are trying to understand how a specific authentication flow is implemented in a legacy Windows binary.

Step 1: Connect the Agent

Step 2: Provide the Target

Point your agent to the binary or directory you want to analyze.

Input Prompt:

"I need to understand the authentication logic in this binary: /path/to/target_app.exe. Please use REA to decompile the relevant function and explain how it validates the user token."

Step 3: Review the Evidence

Your agent will now trigger the REA tool. It will interact with your local decompiler, extract the pseudo-code, and provide a breakdown.

Expected Agent Output:

"I have analyzed the binary at /path/to/target_app.exe using Ghidra. The authentication logic is located at offset 0x4012A0.

The function validate_token performs the following steps:

It pulls the header from the request buffer.

It performs an XOR operation with a static key found at 0x405000.

It compares the result against the hardcoded string 'AUTH_SUCCESS'.

Here is the decompiled snippet for your reference: [Code Block]"

By providing the exact offset, the agent allows you to verify its work instantly in your decompiler of choice.

Why REA Changes the Game

Evidence-Based: The agent doesn't hallucinate logic; it cites the exact binary offsets.
Privacy-First: Since the analysis happens locally, you can safely inspect proprietary software without fear of leaking intellectual property to the cloud.
Workflow Integration: No more context switching between your IDE and a separate reverse engineering suite. Your AI agent brings the insights directly to your chat window.

google/embeddinggemma-2 on Hugging Face: How to Download & Run Multimodal Embeddings

Marcus Vance | Signal Matrix AI — Mon, 12 Oct 2026 16:21:23 +0000

... markdown ...

Unsloth + Ollama: Fine-Tune and Run Local LLMs

Marcus Vance | Signal Matrix AI — Mon, 12 Oct 2026 14:36:13 +0000

Unsloth + Ollama: Fine-Tune Open-Source LLMs 2x Faster and Run Them Locally

Stop burning thousands of dollars on cloud LLM API tokens. Fine-tuning an 8B parameter model no longer requires a cluster of enterprise A100 GPUs or endless cloud compute budgets. By pairing Unsloth with Ollama, you can perform QLoRA local fine tuning on a consumer GPU using under 8GB of VRAM, convert the model directly to GGUF format, and serve it on your local machine with a single CLI command.

Here is how to set up the entire end-to-end pipeline in under 30 minutes.

Why Unsloth + Ollama?

Standard Hugging Face pipelines often encounter CUDA Out-Of-Memory (OOM) crashes on 16GB or 24GB GPUs when training 8B parameter models. Unsloth rewrites PyTorch attention layers and cross-entropy loss functions into hand-crafted OpenAI Triton kernels.

This optimization yields concrete advantages:

2x Faster Training: Bypasses PyTorch autograd overhead.
70% to 80% Less VRAM: Train Llama 3 8B or Mistral 7B in 6.6GB to 8GB VRAM with QLoRA.
Zero Conversion Overhead: Exports directly to quantized GGUF format and auto-generates the Ollama Modelfile.
Zero API Bills: Serve your proprietary tuned model locally on macOS, Linux, or Windows via Ollama.

Where to Get It (Official Links, GitHub & Hugging Face)

Before starting, bookmark and pull resources from the official repositories:

Unsloth GitHub Repository: https://github.com/unslothai/unsloth — Core training framework and Triton kernels.
Unsloth Official Documentation: https://unsloth.ai/docs — Setup guides, memory benchmarks, and architecture details.
Unsloth Hugging Face Hub: https://huggingface.co/unsloth — Official 4-bit pre-quantized base models (Llama 3, Mistral, Qwen, Gemma).
Ollama Download: https://ollama.com/download — Standalone installers for macOS, Linux, and Windows.
Ollama GitHub Repository: https://github.com/ollama/ollama — Open-source local runtime repository.

Quick Install & Setup

Set up Ollama and an isolated Python virtual environment on your Linux/WSL2 system with CUDA installed.

1. Install Ollama Runtime

curl -fsSL https://ollama.com/install.sh | sh

2. Configure Python Virtual Environment

Create a dedicated environment and install Unsloth alongside PyTorch dependencies:

python3 -m venv finetune-env
source finetune-env/bin/activate
pip install --upgrade pip
pip install 'unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git'
pip install --no-deps trl peft accelerate bitsandbytes datasets

How to Use It in Real Life (Step-by-Step Walkthrough)

In this walkthrough, we will fine-tune Llama 3 8B Instruct on a customer support dataset, export it to GGUF, and query it locally via Ollama.

Step 1: Initialize Model and Adapters

Create a training script named train.py. Load the pre-quantized 4-bit model directly from Hugging Face and inject LoRA parameters:

import torch
from unsloth import FastLanguageModel
from datasets import load_dataset
from trl import SFTTrainer
from transformers import TrainingArguments

max_seq_length = 2048
dtype = None # Auto-detect Float16 / Bfloat16
load_in_4bit = True

# 1. Load 4-bit base model
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name = 'unsloth/llama-3-8b-Instruct-bnb-4bit',
    max_seq_length = max_seq_length,
    dtype = dtype,
    load_in_4bit = load_in_4bit,
)

# 2. Attach LoRA adapters
model = FastLanguageModel.get_peft_model(
    model,
    r = 16,
    target_modules = ['q_proj', 'k_proj', 'v_proj', 'o_proj',
                      'gate_proj', 'up_proj', 'down_proj'],
    lora_alpha = 16,
    lora_dropout = 0,
    bias = 'none',
    use_gradient_checkpointing = 'unsloth',
    random_state = 3407,
)

Step 2: Format Data and Train

Train on instruction-response pairs using SFTTrainer for 60 steps:

# 3. Format dataset using Llama 3 template
prompt_template = '''<|start_header_id|>system<|end_header_id|>
You are a specialized internal support bot.<|eot_id|><|start_header_id|>user<|end_header_id|>
{}<|eot_id|><|start_header_id|>assistant<|end_header_id|>
{}<|eot_id|>'''

def formatting_prompts_func(examples):
    texts = []
    for instruction, output in zip(examples['instruction'], examples['output']):
        text = prompt_template.format(instruction, output)
        texts.append(text)
    return {'text': texts}

dataset = load_dataset('philschmid/dolly-15k-oai-style', split='train[:1000]')
dataset = dataset.map(formatting_prompts_func, batched=True)

trainer = SFTTrainer(
    model = model,
    tokenizer = tokenizer,
    train_dataset = dataset,
    dataset_text_field = 'text',
    max_seq_length = max_seq_length,
    dataset_num_proc = 2,
    packing = False,
    args = TrainingArguments(
        per_device_train_batch_size = 2,
        gradient_accumulation_steps = 4,
        warmup_steps = 5,
        max_steps = 60,
        learning_rate = 2e-4,
        fp16 = not torch.cuda.is_bf16_supported(),
        bf16 = torch.cuda.is_bf16_supported(),
        logging_steps = 10,
        optim = 'adamw_8bit',
        weight_decay = 0.01,
        lr_scheduler_type = 'linear',
        seed = 3407,
        output_dir = 'outputs',
    ),
)

trainer.train()

Step 3: Export to GGUF and Ollama

Unsloth eliminates manual llama.cpp compilation. Export directly to 4-bit Medium Quantization (q4_k_m) at the end of train.py:

# 4. Export directly to GGUF
model.save_pretrained_gguf('custom_model', tokenizer, quantization_method = 'q4_k_m')

Run the training file:

python train.py

This writes the quantized GGUF weights and an automatically configured Modelfile into the ./custom_model directory.

Step 4: Register and Run in Ollama

Point Ollama to the generated folder and launch the model:

# 5. Build and serve inside Ollama
ollama create my-assistant -f ./custom_model/Modelfile
ollama run my-assistant

Example Interaction:

>>> How do I reset my company VPN token?
To reset your company VPN token:
1. Open the Okta Verify dashboard on your mobile device.
2. Navigate to Settings > Enrolled Factors > VPN Gateway.
3. Click 'Regenerate Token' and confirm your biometric prompt.
Your new session token will be active within 60 seconds.

Key Takeaways

Combining Unsloth and Ollama creates a self-contained local fine-tuning workflow: train locally in 15–30 minutes, eliminate external API dependencies, and keep all proprietary data within your own infrastructure.

Reverse Engineer Anything: AI-Powered Binary Analysis

Marcus Vance | Signal Matrix AI — Mon, 12 Oct 2026 14:36:12 +0000

Reverse Engineer Anything: AI-Powered Binary Analysis

Stop guessing how that app works—let your AI agent decompile it for you.

That manual grind is over. Meet REA (Reverse Engineer Anything), an MCP-based toolset that turns your AI agent into a senior reverse engineer.

What is REA?

Where to Get It (Official Links)

GitHub Repository: https://github.com/morluto/rea
Official Website & Guides: https://rea.tools/
npm Package Registry: https://www.npmjs.com/package/rea-agents
Discord Community: https://discord.gg/GkcryMnJDM

Quick Install & Setup

REA is designed for immediate integration into your development workflow. To get started, ensure you have Node.js installed on your system.

Install the package globally:

   npm install -g rea-agents

Run the setup command: This command registers the REA tools with your local AI agent configuration (such as the Claude Desktop app or other MCP-compliant clients).

   npx rea-agents setup

Verify installation:

   rea-agents --help

How to Use It in Real Life (Step-by-Step Walkthrough)

Let’s say you are trying to understand how a specific authentication flow is implemented in a legacy Windows binary.

Step 1: Connect the Agent

Step 2: Provide the Target

Point your agent to the binary or directory you want to analyze.

Input Prompt:

"I need to understand the authentication logic in this binary: /path/to/target_app.exe. Please use REA to decompile the relevant function and explain how it validates the user token."

Step 3: Review the Evidence

Your agent will now trigger the REA tool. It will interact with your local decompiler, extract the pseudo-code, and provide a breakdown.

Expected Agent Output:

"I have analyzed the binary at /path/to/target_app.exe using Ghidra. The authentication logic is located at offset 0x4012A0.

The function validate_token performs the following steps:

It pulls the header from the request buffer.

It performs an XOR operation with a static key found at 0x405000.

It compares the result against the hardcoded string 'AUTH_SUCCESS'.

Here is the decompiled snippet for your reference: [Code Block]"

By providing the exact offset, the agent allows you to verify its work instantly in your decompiler of choice.

Why REA Changes the Game

Evidence-Based: The agent doesn't hallucinate logic; it cites the exact binary offsets.
Privacy-First: Since the analysis happens locally, you can safely inspect proprietary software without fear of leaking intellectual property to the cloud.
Workflow Integration: No more context switching between your IDE and a separate reverse engineering suite. Your AI agent brings the insights directly to your chat window.