Beyond MCP: A Workspace for Reverse Engineering

Suppose you could leave a reverse-engineering investigation running overnight. Not just the initial analysis pass, but an agent following references, examining candidate functions, testing explanations, and keeping a record of what it found.

What would you want to come back to?

A long answer in a chat window would be something. I would want to know which parts of the program it examined, where it got stuck, what it changed, and which claims I could actually verify. If someone else had joined the investigation and launched another agent, I would want to understand how their work related to mine.

That is the question I keep coming back to. Connecting an agent to a decompiler gives it access to useful tools. Letting several people leave agents working for hours raises a different set of questions about where the investigation lives.

Can you take a look at this?

Suppose you're examining a signed Windows driver found during a malware investigation. You're checking for possible BYOVD abuse: malware taking advantage of a vulnerability in an otherwise legitimate driver.

You've annotated its request handler and written notes about a suspicious code path. Before calling it a vulnerability, you want another researcher to check whether you've missed an access check.

Sending a database is a lot of setup for that question. The other person may need to download it, open it in a compatible tool, and find the functions you mean. A screenshot is easier, until they want to follow a reference or inspect something just outside the frame.

I'd rather send one URL.

They open the research notes alongside the disassembly and decompilation in their browser. They can follow the addresses in the notes, inspect the caller, and look beyond the functions I highlighted. No database download, decompiler installation, or account needed for the read-only view.

We can get straight to the question: "Have I missed a check here?" The notes don't have to be a finished report. They can include what I've ruled out and what I still don't understand.

Here's a shared investigation you can explore. Read the notes, follow an address, and look around the code. You don't need an account or a local installation.

Shared investigation / Read-only

Open full workspace ↗

Let it run

The other thing I want is fairly mundane: to close my laptop while the work carries on.

One binary might be manageable locally. Several related binaries, analysis databases, debug symbols, and agent workers can take a lot more memory and compute. I want to try those jobs without keeping my everyday computer occupied.

That's why I put the setup in the cloud. I can allocate larger machines and more workers when the work calls for them. The agent runner lives there as well as the analysis tools. Moving just the decompiler wouldn't help if the agent deciding what to do next still stopped with my laptop.

A lab server could do this too. The important part is that the job has its own resources and doesn't depend on someone's desktop session staying open.

It also gives other people somewhere to launch their own agents. One person can trace the driver's request handling while another examines a related driver or tries a different explanation. Independent jobs can run alongside each other. If one step needs the previous step's answer, extra machines won't change that.

I still want limits on how much a run can spend and what it's allowed to change. Some jobs should stop and ask for a review. Leaving something running overnight shouldn't mean giving it permission to do anything it wants.

Working in the same session

That URL opens the live investigation, not an exported copy. If I add an explanation to the notes while you're reading, you see the saved update in the same session. Analysis changes and agent activity are broadcast there too. I don't have to send another file or ask you to open a newer link.

It has the familiar feel of a shared Google Doc: you can see who's there and work together while the research is changing. A read-only link lets someone watch. Inviting them as an editor lets them contribute to the analysis and notes.

For the driver, that might mean discussing a check in the caller while an agent examines another path. The correction stays beside the code it refers to, where the next person can find it.

We still have to verify the finding. Two agents can agree because they're both reading the same wrong type or misleading name. Decompilation depends on types, function boundaries, and calling conventions, as Ghidra's advanced analysis material illustrates. A shared view makes that discussion easier; it doesn't settle whether the suspected vulnerability is real.

What I'm building

Reverser Space is my attempt at this. The workspace runs in the browser: upload a binary, inspect the analysis, write notes, and launch built-in agents. There's no local decompiler, plugin, or MCP server to install for that workflow. The analysis, notes, findings, and run history stay with the shared session.

The built-in agents run on the server. Different users' missions can run concurrently within the configured limits; tasks inside each mission run in order. If the server restarts, queued work stays queued. Work that was running is marked interrupted and can be retried. I don't want a task shown as finished just because the process that was doing it disappeared.

Ghidra is the current backend. IDA or Binary Ninja would need their own adapters. I think of the workspace as separate from that choice: changing the analysis engine shouldn't mean throwing away the surrounding investigation. Results still need to say which engine and state they came from. If an old state can't be recovered, that needs to be visible too.

If you're working with one agent on your own machine, integrations such as GhidraMCP or Binary Ninja's MCP servers may be all you need. I'm building for the point where you want to leave several jobs running, bring other people in, and not spend the next morning explaining what happened in each chat.

For that driver, I'd want to come back to the paths we've checked, the access checks we've found, and the questions still open. If another researcher has time to help, I can send them the link. They can see the work so far and, with editor access, pick up a thread themselves.

I want the investigation to outlive my session. Otherwise I'm just leaving the next person a folder of files and a story they have to reconstruct.