I Built a Fully Autonomous AI Reverse-Engineering Agent in Go

Jurig (Sundanese: ghost) — an autonomous AI agent that haunts your binaries.

 .-.         ██ ██    ██ ██████  ██  ██████

(o o)        ██ ██    ██ ██   ██ ██ ██

| u |        ██ ██    ██ ██████  ██ ██   ███

|   |   ██   ██ ██    ██ ██   ██ ██ ██    ██

'~-~'    █████   ██████  ██   ██ ██  ██████

        autonomous reverse-engineering agent · android · binary · frida

Point it at an APK, XAPK, or native binary and it plans, decompiles, searches,

hooks, captures traffic, and writes you a report — by itself. In one live run it

took a real Android loan app, auto-extracted the XAPK, decompiled 13,367

classes, grepped the sources, and surfaced a hardcoded AES key with a

zero IV plus the full API endpoint map — then asked me whether it should go

dynamic with Frida.

This post is the build story: the architecture, the design bets, and the three

bugs that genuinely fought back.

Repo: https://github.com/ReverserID/JURIG

Why build another agent?

Existing "AI reverse engineering" is mostly a pile of MCP servers you wire into a

chat client. That's fine, but I wanted something opinionated:

• 
  Autonomous, not chat — it drives a real toolchain end to end.


• 
  A single portable binary — no Python venv soup, no MCP daemons.


• 
  Multi-model — my Claude subscription, OpenRouter, local Ollama, Kimi, Qwen.


• 
  A TUI that feels like a hacker tool, not a log dump.

So: Go. Charmbracelet for the TUI (Bubble Tea + Lipgloss + Glamour). And a hard

rule — no MCP. Every capability is a native Go function that shells out to a

portable RE binary, or does the work in pure Go.

Architecture

┌─ agent loop ─┐   plan → ask scope → recon → locate → dynamic → report

│              │

│  LLM router  │   anthropic · openai-compat (openrouter/ollama/kimi/qwen) · claude-cli

│              │

│  25+ tools   │   jadx · apktool · radare2 · ghidra · frida · adb · proxy

│              │   + secret_scan · url_extract · manifest · elf/pe_info · search_code

│              │

│  TUI         │   animated ghost header · code cards · model picker · NET panel

└──────────────┘

One wire format, many providers

The whole thing speaks the Anthropic Messages protocol internally. A router

adapts it to each backend:

• 
  anthropic — native Messages API.


• 
  openai — an adapter that translates Messages ↔ OpenAI Chat Completions
  (tool calls included). This single adapter covers OpenRouter, Ollama, Kimi
  (Moonshot), and Qwen (Alibaba DashScope) — they're all OpenAI-compatible.


• 
  claude-cli — shells out to the claude binary for subscription use.

Switching model is live in the TUI (Ctrl+O):

func (r *Router) SetSelection(provider, model string) error {

    r.mu.Lock()

    defer r.mu.Unlock()

    if _, ok := r.providers[provider]; !ok {

        return fmt.Errorf("unknown provider %q", provider)

    }

    r.active = config.Selection{Provider: provider, Model: model}

    return nil

}

Tools are just Go

A tool is an interface. The agent loop calls the model with the tool schemas,

gets back tool_use blocks, dispatches them, and feeds results back — the

classic loop, but every tool is native:

type Tool interface {

    Name() string

    Description() string

    Schema() map[string]any

    Run(ctx context.Context, input json.RawMessage, env *Env) (string, error)

}

The high-signal ones matter most. Instead of letting the model read files one by

one (it will burn 60 steps doing that), I gave it recon tools:

• 
  manifest — package, permissions, exported components


• 
  url_extract — dedup every URL into a host/API map


• 
  secret_scan — AWS/GCP/Stripe/JWT/private-key/AES-literal regexes


• 
  search_code — regex grep across decompiled sources

The system prompt then enforces search before read. Efficiency went from

"hit the step limit" to "done in ~10 steps".

The bugs that fought back

1. jadx NullPointerException on Java 21

First real APK, and jadx 1.5.1 face-planted:

java.lang.NullPointerException

    at jadx.plugins.tools.JadxPluginsTools.getEnabledPluginJars(...)

user.home was set. The plugin loader in 1.5.x just breaks on Java 21 / Windows.

Fix: pin jadx 1.4.7 (pre plugin-loader). Decompiled 13k classes on the first

try. Sometimes the fix is a version number.

2. Kimi rejects "required": null

Switched a run to Kimi and every request 400'd:

tools.function.parameters is not a valid moonshot flavored json schema,

details: <At path 'required': required must be an array>

My schema helper used a Go variadic. Called with no required fields it's nil,

which marshals to JSON null. Anthropic and OpenAI tolerate it; Kimi/Moonshot

don't. One line, plus a regression test so it never comes back:

func schema(props map[string]any, required ...string) map[string]any {

    if required == nil {

        required = []string{} // never marshal to null — Kimi rejects it

    }

    return map[string]any{"type": "object", "properties": props, "required": required}

}

3. The TUI box kept shattering

adb output would tear the bordered viewport apart — stray border chars

scattered mid-screen. I first blamed word-wrapping and hard-wrapped everything.

Still broke.

The real culprit: Windows adb emits CRLF. After splitting on \n, the

leftover \r yanks the cursor back to column 0 and the next characters overprint

the border. Sanitizing tool output fixed it instantly:

func sanitize(s string) string {

    s = strings.ReplaceAll(s, "\r\n", "\n")

    s = strings.ReplaceAll(s, "\r", "")

    return strings.Map(func(r rune) rune {

        if r == '\n' || r == '\t' { return r }

        if r < 0x20 || r == 0x7f { return -1 } // drop control bytes

        return r

    }, s)

}

Lesson: when a TUI "randomly" corrupts, suspect control characters before layout.

Making it feel alive

A few touches that turned a functional tool into one people actually want to run:

• 
  Animated ghost header — the mascot blinks, glances around, and a neon
  color shimmer travels across the wordmark. It's pinned; the transcript scrolls
  beneath it.


• 
  Code cards — when the agent reads a source file, the TUI shows a small
  syntax-highlighted (Chroma) preview. The model still gets the full file; your
  eyes get 12 tidy lines.


• 
  Ask menu — when the agent needs scope ("secrets? auth flow? may I run
  Frida on a device?"), a multi-select checkbox menu pops up (↑/↓, Space, Enter).


• 
  Esc to interrupt — stop the agent mid-run and steer it, Claude-Code style.


• 
  Live NET panel — start the built-in MITM proxy and captured
  request/response pairs stream into a side panel. The layout is responsive: wide
  terminal splits, narrow terminal hides the panel.

The native proxy (no Burp)

Dynamic network capture is a first-class tool, built on elazarl/goproxy — a

real in-process MITM proxy with an exported CA:

proxy start → adb set http_proxy + install CA → frida_preset ssl_unpin

            → drive the app → proxy flows

The agent orchestrates all of that; you just watch the requests land.

Dynamic instrumentation, presets included

The model shouldn't have to hand-write Frida JS every time, so frida_preset

ships battle-tested scripts:

• 
  ssl_unpin — universal Android pinning bypass (TrustManager + OkHttp +
  Conscrypt)


• 
  hook — hook every overload of Class!method, dump args + return


• 
  dump_class, list_classes, trace_http
  

Combined with the proxy, that's a full static → dynamic → network pipeline in one

binary.

Try it

Grab a build from the releases page:

jurig doctor      # check providers + toolchain

jurig             # first run launches an interactive setup wizard

First run walks you through provider + model, drops you into the TUI, and

auto-installs missing tools (jadx, apktool) on demand.

⚠️ For authorized security research and education only. Analyze apps you own or

have explicit permission to test.

What's next

• ACP backend so the Claude subscription path drives tools natively


• Ghidra decompile scripting for deeper native analysis


• Linux/macOS builds + CI

If you build agents, write Go, or do mobile RE — I'd love feedback. Star the repo

and tell me what tool you'd add next.

GitHub: https://github.com/ReverserID/JURIG

Built with Go, Bubble Tea, Lipgloss, Glamour, Chroma, and goproxy.