Argus MCP server
Commit Nov 4, 2026Provides AI agents with runtime evidence from running Windows processes, including memory reading, disassembly, and API resolution.
Also known as r0ptik/argus
- Stars
- 0
- Tools
- —
- Downloads, 30 days
- —
- Latest version
- 0.1.1
- Last commit
- Nov 4, 2026
- License
- MIT
What is Argus MCP?
Argus provides AI agents with runtime evidence from running Windows processes, including memory reading, disassembly, and API resolution.
Summary generated from the project's README
About Argus MCP server
Reverse engineers and security researchers can use Argus to observe the live behavior of Windows processes through an AI client. Unlike static analysis tools that only examine files on a disk, this server attaches to running programs to capture real-time data such as decrypted memory buffers, resolved API targets, and actual execution paths. It is designed to work alongside tools like Ghidra or IDA by providing the runtime truth that static inspection often misses.
Users set up the server by pointing their MCP client to the argus-router executable, which automatically handles architecture routing between x86 and x64 targets. The server provides a wide array of specialized tools including mem_read for inspecting memory, disasm_at for code disassembly, and resolve_iat_thunks for identifying API calls. It also features an evidence ledger that allows an agent to record hypotheses and verify them with concrete data, ensuring that conclusions are based on proven facts rather than guesses.
What you can do with it
- 1Recovering dead game protocolsAn AI agent can reconstruct network protocols by observing how a legacy client encrypts and dispatches packets in memory.
- 2Verifying security research hypothesesResearchers can use the evidence ledger to track which claims about a process have been proven by actual memory observations.
Written from the project's README. Every use case is checked against a quote from it.
Automated checks
Ran Nov 14, 2026Full report →Not verified yet. A server needs a score of 80, no serious finding, and enough data for us to check. How checks work · What to fix for more points
- Source repository linked and reachabler0ptik/argus is public and reachablegithub.com/r0ptik/argus ↗Pass
- Package names this repository as its sourceNot checked
- Build provenance (Sigstore attestation)Not checked
- Open source license (OSI)MITspdx.org/licenses/MIT.html ↗Pass
- Commit or release in the last yearLast commit or release 2026-11-04github.com/r0ptik/argus ↗Pass
- OpenSSF ScorecardNot checked
- Package name not close to a popular packageNot checked
- No critical advisory in the package or its dependenciesNot checked
- No hidden instructions to the model0 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPass
- Destructive tools are labelledNot checked
- Remote endpoint answers the MCP handshakeNot checked
README
View on GitHubArgus
English · 繁體中文 · 简体中文 · 日本語 · 한국어
An MCP server that gives AI agents evidence from a running process.
Every reverse-engineering MCP server so far bridges a static analyzer — Ghidra, IDA, apktool. They hand your agent the file on disk. None of them can tell the agent what the program is actually doing right now: what got decrypted into that buffer, which address the vtable slot resolved to at runtime, which call site sent that packet.
Argus is the other half. It attaches to a live Windows process and returns runtime evidence: real bytes at real addresses, disassembly of the code that actually executed, resolved IAT thunks, caller chains walked from live memory, and a hypothesis ledger that tracks what has been proven versus what is still a guess.
It does not draw conclusions for the model. It returns addresses, module/RVA context, instructions, callers, callees, and local evidence, then gets out of the way.
Why this exists
Games die. The publisher shuts the servers down, the studio folds, the genre moves on. What survives is a client sitting on somebody's hard drive that can no longer connect to anything — no source, no protocol documentation, no server left to talk to. Just an executable that still remembers how to speak a language nobody is listening to anymore.
Argus was built to bring those back.
Reconstructing a server for a dead game means recovering its protocol: packet layouts, encryption, opcode dispatch, the state machine on the other side of the wire. The only surviving specification is the client binary itself. Nobody wrote the document you need, and the people who knew have long since moved on.
Static analysis gets you partway. But a twenty-year-old client is packed, its strings are encrypted, its handlers dispatch through tables that only exist once the process is up. So you run it, and you watch it work — which is where the next section comes in.
That is what this tool is for: not breaking into something alive, but getting something dead to speak again.
Why go to the running process at all
A CPU cannot execute ciphertext.
Whatever a program does to protect itself on disk — packing, string encryption, virtualized instructions, imports resolved at load time — all of it has to be undone before the processor can run the code. At the instant of execution, the real instructions and the real data are sitting in memory in the clear. They have to be. That is not a flaw in any particular protector; it is a consequence of how processors work, and no amount of obfuscation gets around it.
So the two approaches are reading different things:
- Static analysis reads the file. What the author shipped.
- Runtime analysis reads what the file turned into. What the machine is actually running.
When those two differ, the second one is the truth.
| Situation | Static analyzer | Argus |
|---|---|---|
| Packed / self-decrypting code | sees the packer | disassembles the unpacked bytes in memory |
| Indirect call through a vtable | sees call [rax+0x18] |
resolves the slot to a concrete target |
| Import resolved at runtime | sees a thunk stub | resolves the thunk to the real API |
| Buffer contents after decryption | nothing | reads the plaintext |
| Which of 40 call sites actually fires | guesses | records the one that ran |
Where static analysis wins
The trade runs the other way too, and it is worth being blunt about it: a static analyzer sees every path, including the ones that never execute. Argus only sees what actually ran. A branch that was never taken leaves no runtime evidence at all, and a function nobody called may as well not exist.
Neither view is complete on its own. That is what correlate_addr is for — map a
runtime address back to a module and RVA, look it up in Ghidra or IDA, and work with
both halves. Argus is built to sit alongside a static analyzer, not to replace one.
Tools
Process and memory
processes_list · processes_find · mem_attach · mem_modules · memory_regions
mem_read · mem_read_chain · mem_write
Scanning
scan_bytes · scan_string · scan_regex · scan_pointers_to · scan_callers
scan_x86_call_sites · value_scan_start · value_scan_refine · value_explain · real_rate
Disassembly and structure recovery
disasm_at · analyze_function · find_vtable · extract_dispatch_tables
analyze_send_call_sites · read_struct · diff_struct
Import and API resolution
runtime_imports · runtime_exports · resolve_iat_thunks · resolve_api_targets
Tracing and correlation
trace_call_chain · correlate_addr · locate
Evidence ledger
record_hypothesis · verify_hypothesis · query_hypotheses · add_evidence
Two design decisions worth knowing about
Automatic architecture routing
Attaching a 64-bit analyzer to a 32-bit (WOW64) target is a classic source of silently
wrong pointer arithmetic and garbage PE parsing. Argus ships a thin front-end,
argus-router, which inspects the target process, determines whether it is x86 or x64,
and dispatches to the matching argus-rs build. You configure one binary; the correct
engine is selected per target.
The evidence ledger
Agents are good at producing plausible explanations and bad at noticing when a plausible
explanation is unsupported. record_hypothesis / verify_hypothesis / add_evidence
force the distinction: a claim is stored as a hypothesis, and only becomes an established
fact when evidence is attached and verification passes. query_hypotheses lets a later
session pick up where the previous one stopped without re-deriving everything.
Install
Prebuilt binaries
Download the latest release and unpack it anywhere:
The archive contains argus-router.exe plus both engine builds
(argus-rs-x64.exe, argus-rs-x86.exe). Keep them in the same directory.
From source
Requires a Rust toolchain with both Windows targets installed:
rustup target add x86_64-pc-windows-msvc i686-pc-windows-msvc
git clone https://github.com/r0ptik/argus
cd argus
cargo build --release --target x86_64-pc-windows-msvc
cargo build --release --target i686-pc-windows-msvc
Configure
Claude Code
claude mcp add argus -- C:\path\to\argus-router.exe
Any MCP client
{
"mcpServers": {
"argus": {
"command": "C:\\path\\to\\argus-router.exe"
}
}
}
Scope and intended use
Argus is a reverse-engineering and program-analysis tool. It is built for work such as game and server preservation, network protocol analysis, interoperability and clean-room reimplementation, malware analysis, crash and corruption debugging, and security research.
It is explicitly not built for attacking live services. No cheat features are accepted into this repository — see CONTRIBUTING.md.
It requires the ability to open and read another process, so use it only against processes you own or are authorized to analyze. Attaching to software you do not have permission to analyze may violate that software's terms or your local law. That is your responsibility, not the tool's.
Platform support
Windows only. The memory access layer (argus-winmem) is built on the Win32 process
and memory APIs; there is no Linux or macOS backend today.
Both x86 and x64 targets are supported, including 32-bit processes running under WOW64.
Crates
| Crate | Role |
|---|---|
argus-router |
front-end binary; architecture detection and dispatch |
argus-rs |
MCP server; tool definitions and request handling |
argus-engine |
analysis engine; disassembly, structure recovery, tracing |
argus-winmem |
Win32 process and memory access |
argus-scan |
pattern and value scanning primitives |
evidence-core |
address, module, RVA and evidence data models |
License
MIT. See LICENSE.
Argus MCP questions
What makes Argus different from static analysis tools like Ghidra?
While static analysis reads the file on disk, Argus attaches to a live Windows process to return runtime evidence like decrypted buffers and resolved vtable slots.
Does Argus support both 32-bit and 64-bit processes?
Yes, it uses an automatic architecture router to detect whether the target is x86 or x64 and dispatches the correct engine.
What operating systems are supported?
Argus is currently only supported on Windows.
How does the evidence ledger work?
It forces a distinction between claims and facts by storing claims as hypotheses that only become established facts once evidence is attached and verified.