Agentic Reverse Engineering

What is it

Agentic Reverse Engineering (ARE) is the practice of giving autonomous coding agents the ability to inspect, decompile, and reason about software — from observable app behavior down to native binaries — without a human driving every step. Concretely, REA (the reference implementation surfacing on GitHub and OSChina) wraps disassemblers, decompilers, syscall tracers, and network inspectors into tool calls that an LLM agent can invoke in a loop: run the binary, observe behavior, decompile the hot function, patch a hypothesis, repeat.

The technical essence is tool-augmented agents replacing the manual RE workflow that has lived in IDA Pro and Ghidra for two decades. The business significance is bigger than security research. Every team doing interoperability, migration, legacy modernization, malware triage, or competitive teardown faces the same bottleneck: reverse engineering is slow, expensive, and gated behind scarce senior talent. ARE turns a $200/hour specialist task into an agent loop that runs overnight. That reframes RE from a boutique consulting service into a developer tool with SaaS economics.

Why now

Three things converged in the last 18 months. First, coding agents got good enough to hold long tool-use loops — Claude Code, Cursor, and open-source frameworks like OpenHands can now chain 50+ tool calls without losing the thread, which is exactly what binary analysis requires. Second, the Model Context Protocol (MCP) standardized how agents call external tools, so wrapping Ghidra or Frida as an agent-callable tool is now a weekend project instead of a custom integration. Third, and most underrated: local model capability crossed a threshold. Qwen and Llama-class models running on a workstation can now read decompiled C and explain it competently, which matters enormously because reverse engineering data is legally and commercially sensitive — nobody wants to upload a competitor's binary to a US cloud API.

The demand side moved too. Software supply-chain regulation (the EU Cyber Resilience Act, US SBOM mandates) forces companies to understand binaries they didn't build. Meanwhile the talent pool didn't grow — experienced RE engineers remain scarce and expensive. ARE is the first credible answer to that gap that doesn't require hiring.

Market Evidence

The signal is thin but directional: 2 independent sources (GitHub and OSChina), 2 total mentions, 100% growth rate, stage "nascent," first seen 2026-10-11, trend score 66/100. Read that honestly — 2 mentions is not a market. It's an early whisper. A 100% growth rate on a base of 1 is mathematically meaningless; it tells you the term appeared twice, not that it's compounding.

But the surrounding signals are real. Agentic tooling is the hottest category in DevTools, and "agent + security" is where the money is moving. The reason ARE scores 0/100 on opportunity, market, competition, and demand is not that the opportunity is absent — it's that there's no measurable data yet. The scoring model needs volume; this term has none. Treat that as a timing signal, not a verdict.

The correct read: this is a pre-consensus term. The underlying behavior (agents doing RE work) is already happening in private repos and internal tools at security firms. The public vocabulary hasn't formed yet. That's the window — vocabulary forms before markets do, and whoever ships the reference product gets to define the category.

Who's Behind It

No dominant company yet — that's the point. The visible drivers are three overlapping groups. First, the agent infrastructure players: Anthropic (Claude Code, MCP), Cursor, and the OpenHands/SWE-agent open-source community, who are building the agent loops ARE depends on. Second, the classic RE incumbents — Hex-Rays (IDA Pro), the NSA-backed Ghidra project, Binary Ninja (Vector 35) — who own the analysis engines but have zero agent-native product. Third, a wave of AI security startups: XBOW, RunSybil, and the LLM-for-pentesting crowd, who are adjacent but focused on offensive testing rather than binary comprehension.

The "whales" to watch are Hex-Rays and Vector 35. If either ships an MCP server for their decompiler, they instantly own the tool layer. Neither has. Ghidra is open source, which means the community could wrap it first — and that's the realistic path for an indie developer: build the agent orchestration layer on top of Ghidra, not a decompiler from scratch.

TAM & Market Size

The buyer is not "every developer." It's three specific segments. Security researchers and pentesters: roughly 500K globally, but only the top ~50K do serious binary work and have budget. Software supply-chain and compliance teams: this is the growth segment — the EU CRA alone puts binary-comprehension obligations on tens of thousands of companies shipping to Europe. And legacy modernization consultancies plus platform teams: every bank, insurer, and government agency with COBOL or undocumented native code.

Price tolerance is high because the alternative is a $150K–$250K salary for a scarce specialist. A tool that lets one mid-level engineer do 60% of what a senior RE specialist does is worth $500–$2,000/month to an enterprise security team without a second thought. Individual researchers will pay $30–$80/month, grudgingly.

The honest caveat: opportunity and demand both score 0/100 because there's no measurable market data. I'd size the realistic serviceable market at $50M–$150M ARR within five years — real but not a venture-scale land grab on its own. It's a strong indie business and a credible seed-stage company, not a unicorn.

Competitive Landscape

Today the landscape is empty at the agent layer and crowded at the engine layer. IDA Pro owns the professional market with a $1,879–$3,679 perpetual license and near-universal loyalty — but it's a manual tool with no agent story. Ghidra is free, capable, and the default for anyone without a budget, but its UX is hostile and its scripting is Java/Python glue, not agent-native. Binary Ninja sits in between at $299–$1,499 with a genuinely good API — the most likely incumbent to ship agents first.

The gap is obvious: nobody offers an agent that can be pointed at a binary and asked a question. The moat for an indie is not the decompiler — it's the agent orchestration, the tool-call design, the prompt/eval harness that makes decompiled output actually comprehensible, and the local-model packaging that keeps data off the cloud.

If Big Tech enters — and Microsoft (with Ghidra-adjacent tooling) or Google could — you have roughly 6–12 months of head start. That's enough to win a niche (say, malware triage or firmware analysis) and build switching costs through workflow integration. It is not enough to win "general RE agent" against a well-funded incumbent. Pick a niche.

Business Model

Recommendation: freemium desktop tool with a paid cloud/team tier. Why not pure SaaS? Because the core value — analyzing sensitive binaries — happens locally, and forcing upload kills the deal in security-conscious buyers. Why not pure one-time license? Because agent tooling improves continuously (new models, new decompiler targets) and you want recurring revenue to fund that.

Pricing: Free tier — local agent, 10 analysis sessions/month, community support. Pro at $49/month (or $399/year) — unlimited local sessions, MCP server for Cursor/Claude Code, malware-triage templates, priority model updates. Team at $199/month per seat, 3-seat minimum — shared analysis workspace, audit logs, private model endpoints, SSO. Enterprise custom, starting $25K/year — air-gapped deployment, custom decompiler integrations, support SLA.

12-month forecast. Conservative: 400 Pro users + 15 Team seats = ~$23K MRR → ~$280K ARR. Base: 1,200 Pro + 60 Team seats = ~$71K MRR → ~$850K ARR. Optimistic: 3,000 Pro + 200 Team seats = ~$187K MRR → ~$2.2M ARR.

CAC: content-led and community-led (RE Twitter/X, r/ReverseEngineering, DEF CON, malware analysis Discords). Blended CAC $80–$150 for Pro, $2K–$5K for Team. Payback under 4 months for Pro, under 6 for Team. The math works because the product is self-serve and the audience is technical.

MVP Blueprint

Ship in 5–7 days. Do not build a decompiler. Build the orchestration layer.

Core features only:

1. MCP server exposing 4 tools: run_binary (sandboxed execution with syscall/file/network capture), decompile_function (wraps Ghidra headless), search_strings, and explain_behavior (LLM call over captured evidence).
2. A local agent loop (use an existing framework — OpenHands or a thin LangGraph wrapper) that takes a natural-language question like "what does this binary do when it starts?" and returns an evidence-backed answer.
3. A CLI: are analyze ./sample.bin --ask "does it phone home?" that prints a structured report.
4. Local-model support via Ollama (Qwen2.5-Coder or Llama 3.3) plus optional cloud API for users who don't care about data residency.

Cut: GUI, plugin marketplace, multi-binary correlation, Windows support (Linux/macOS first), any custom decompiler work.

Tech stack: TypeScript for the MCP server and CLI (the tag says TypeScript, and it's the right call — MCP tooling is TS/Python native). Ghidra headless in a Docker container for decompilation. Frida for dynamic instrumentation in v2. SQLite for local analysis cache. Ship as an npm package plus a Docker image.

Fastest path to launch: publish the MCP server to the MCP registry on day 3, post a demo analyzing a known malware sample on day 5, launch on Hacker News and r/ReverseEngineering on day 7. The demo IS the marketing.

Commercial Opportunities

Direction 1: Malware triage for SOC teams. Product: an agent that takes a suspicious binary from a phishing email and produces a plain-English verdict with IOCs in under 10 minutes. Target: Tier-1/Tier-2 SOC analysts at mid-market companies who currently wait hours for a senior analyst. Expected revenue: $5K–$20K MRR from 10–30 team subscriptions. Why it beats alternatives: existing sandboxes (VirusTotal, Joe Sandbox) give reports, not answers — they don't reason.

Direction 2: Legacy binary modernization. Product: an agent that documents undocumented native code and generates interface specs for reimplementation. Target: consultancies and platform teams at banks/insurers. Expected revenue: $10K–$50K per engagement, $15K–$40K MRR if productized. Why it beats alternatives: manual RE for modernization is billed at $200+/hour; this cuts a 6-week discovery phase to 1 week.

Direction 3: MCP tool server as infrastructure. Product: sell the decompiler/execution MCP server as a standalone API for other agent builders. Target: AI security startups and agent framework developers. Expected revenue: $2K–$15K MRR, usage-based. Why it beats alternatives: everyone building security agents needs this layer and nobody wants to build it.

Product Ideas

🥇 REA CLI + MCP Server — "Point an agent at any binary and ask what it does." Target user: security researchers, malware analysts, and agent developers who want RE as a tool call. Why now: MCP just standardized agent-tool integration, and Ghidra is free and wrappable. This is the wedge — ship it first, own the vocabulary, build the audience.

🥈 TriageBot — "Malware verdicts in 10 minutes, not 10 hours." Target user: SOC analysts and incident responders. Why now: alert volumes are up, senior analyst supply is flat, and LLMs can finally read decompiled code competently. This is the monetizable product — higher ACV, clearer ROI, less price sensitivity. Build it on top of the CLI once you have 50 users.

🥉 LegacyLens — "Document the binary nobody understands." Target user: platform teams and modernization consultancies at regulated enterprises. Why now: EU CRA and SBOM mandates force binary comprehension, and enterprises will pay for compliance-driven tooling. This is the enterprise play — slow sales cycle, big contracts, needs the CLI and TriageBot to prove credibility first.

Priority logic: CLI first (distribution), TriageBot second (revenue), LegacyLens third (scale). Don't start with enterprise.

SEO Opportunity

Search volume is near zero today — "agentic reverse engineering" has no established query volume, and that's the opportunity, not the problem. SEO difficulty: 0/100. You can own this term completely.

Target long-tail keywords: "MCP server for Ghidra," "AI agent decompile binary," "LLM malware analysis tool," "automate reverse engineering with AI," "local LLM binary analysis." These have small but real volume and almost no competition.

Content strategy: publish the definitive technical explainer — "How to build an agentic reverse engineering workflow with Ghidra and MCP" — with working code. Technical how-tos with code rank fast and attract exactly the developer audience that converts. Own the term before the volume arrives.

Risk Assessment

The thesis breaks if agent accuracy on decompiled code stays too low to trust. If agents hallucinate function behavior 30% of the time, no security team will rely on them, and the product becomes a toy. This is the number-one risk and it's technical, not market.

Risk 2: legal and ethical blowback. Reverse engineering sits near DMCA §1201 and EULA anti-RE clauses. If the first high-profile use of an ARE tool is a license-violation lawsuit, the category gets poisoned. Mitigation: ship with clear use-policy guardrails and target legitimate use cases (security, interop, compliance) loudly.

Risk 3: incumbent absorption. If Hex-Rays or Vector 35 ships an MCP server in the next 9 months, your differentiation evaporates. Mitigation: win a niche they won't prioritize (malware triage) and build workflow lock-in.

Cheap validation: post a working demo analyzing a real malware sample to r/ReverseEngineering and Hacker News. If you get 100+ upvotes and 20+ "how do I use this" comments in 48 hours, the demand is real. If you get crickets, walk away. Total cost: one weekend.

Action Plan

Today: install Ghidra headless, write a 50-line TypeScript MCP server exposing decompile_function, and get Claude Code or Cursor to call it on a simple binary. If that works end-to-end in under 4 hours, the technical premise is validated.

Week 1: build the full 4-tool MVP (run, decompile, strings, explain), record a 3-minute demo analyzing a public malware sample, post to Hacker News, r/ReverseEngineering, and the MCP registry. Goal: 100 GitHub stars, 20 Discord joins, 5 people asking for a hosted version.

Month 1: ship the Pro tier at $49/month, add Ollama local-model support, publish the SEO explainer post. Goal: 50 paying users, $2.5K MRR, and a clear signal on whether users want TriageBot (SOC) or LegacyLens (enterprise).

Month 3: pick the winning niche from month-1 data, build the vertical product (most likely TriageBot), and start outbound to 50 SOC teams. Goal: $15K MRR, 3 team contracts, and either a seed conversation or a decision to stay bootstrapped. Kill criteria: if month 3 shows under $5K MRR and flat signups, the market isn't ready — park it and revisit in 6 months.

Related Terms

Model Context Protocol (MCP) — the standardization layer that makes ARE buildable in days instead of months. ARE is essentially "MCP applied to reverse engineering tooling."

Agentic Security — the broader category of AI agents doing offensive and defensive security work (XBOW, RunSybil). ARE is the binary-analysis subsegment; it will rise and fall with this category's credibility.

Local LLM Tooling — Ollama, llama.cpp, and Qwen-class models. ARE's enterprise viability depends entirely on local models getting good enough to read decompiled code, because security buyers won't upload sensitive binaries. Watch this trend as the leading indicator for ARE's real adoption.