Medusa

When you're handed a codebase you didn't write, whether it's a class assignment, a research artifact, or your new employer's old monorepo, the cost is the same: hours spent mapping what talks to what before you can even find where a bug lives. Once you find it, most AI tools jump to a confident fix, with no way to check if it works or why the code broke. Students end up trusting the model instead of learning to reason about the system. Nobody gets proof, only an assertion. Medusa treats understanding a system and proving a fix as two separate, honest steps, on any codebase: point it at a public GitHub repo or an uploaded zip. First, it maps the architecture. A static analysis pass parses the source, builds an import graph, ranks files by importance, and lays out a diagram with the tech stack, entry points and external services, no LLM involved, nothing executed. Large repos degrade to a partial map with a clear reason, not a guess. From the issue list, Medusa's own scan plus the repository's real GitHub Issues, you can reproduce and debug any problem. Two independent investigators work it in parallel and never see each other's answer: IBM Bob, headless and read-only, and IBM Granite on watsonx.ai. On our built-in demo, against OptiLearn, a real offline-first learning platform for refugee classrooms, this runs for real in a locked-down Docker sandbox, then races competing fixes in their own containers. For any linked Python repository with its own tests, Medusa can do the same for real: it asks a model to write a failing test, confirms it inside an isolated gVisor sandbox with its own snapshot and a PyPI-only network, then races proposed fixes against that reproducer. That path is built and tested, and switched off by default until we finish reviewing it live. Everywhere else, Medusa reasons instead of running code, and always says so: plausible, with a confidence score, never reproduced. A deterministic verifier, never a model, decides what passed, what regressed, and what's smallest, and hands back the winning patch as a zip or a git-applyable patch file. That distinction, evidence over confidence, is the point: most AI coding tools will tell you a bug is fixed, while Medusa only says that once a sandbox has proven it. Students get to watch two different models reason about the same bug, then watch a real test suite settle the argument. Researchers get competing hypotheses and the runtime evidence behind each one. Developers onboarding onto an unfamiliar service get the map before the debugger, and can run the same workflow on their own repository, with real verification if they turn it on. This isn't a toy scenario. The demo bug lives in a real LMS with a voice pipeline and an adaptive mastery engine, not a synthetic one-liner built for the pitch. The sandbox, the architecture parser and the verifier are deterministic Python, with the two models doing exactly what they're good at: reasoning, not deciding.