deebo-prototype

Yeah, you can’t do sh*t in an hour. I spend a good 6-8 hours every day using Claude Code, and I actually spend an hour every day trying new AI tools, it’s a constant process. Here’s what my today’s task looks like: 1. Test TRAE/Refact.ai/Zencoder: 70% on SWE verified 2. https://github.com/kbwo/ccmanager: use git tree to manage multiple Claude Code sessions 3. https://github.com/julep-ai/julep/blob/dev/AGENTS.md: Read and implement 4. https://github.com/snagasuri/deebo-prototype: Autonomous debugging agent (MCP) 5. https://github.com/claude-did-this/claude-hub: connects Claude Code to GitHub repositories.

Re:simulation Deebo does this for debugging: https://github.com/snagasuri/deebo-prototype

Hi! Deebo is an agentic debugging system wrapped in an MCP server, so it acts as a copilot for your coding agent. Think of your main coding agent as a single threaded process. Deebo introduces multi threadedness to AI-assisted coding. You can have your agent delegate tricky bugs, context heavy tasks, validate theories, run simulations, etc. The cool thing is the agents inside the deebo mcp server USE mcp themselves! They use git and file system MCP tools in order to actually read and edit code. They also do their work in separate git branches which provides natural process isolation. Deebo scales to production codebases, too. I took on a tinygrad bug bounty with me + Cline + Deebo with no previous experience with the tinygrad codebase. Deebo spawned 17 scenario agents over multiple OODA loops, and synthesized 2 valid fixes! You can read t

AI coding agents are powerful but shallow. They work great when the problem is linear, scoped, and easy to describe. But debugging is none of those things. The moment something subtle breaks, you fall into a loop. Prompt, response. Prompt, response. The agent forgets what it tried. It repeats itself. You start feeding it context just to keep it grounded. Eventually, you give up and fix the bug yourself. It feels like watching GEB unfold in real time. The agent tries to reason about its own reasoning but gets lost inside its own frame. It has syntax, not semantics. The result is recursion without insight. A strange loop that cannot close. I built Deebo to break that pattern. It is a separate agent that runs debugging sessions in parallel. It forks the codebase, creates branches, and tests different fixes at once. Every hypothesis is isolat

Deebo is the first ever agent MCP server. Your coding agent can start a session with Deebo when it runs into a tricky bug, allowing it to offload tasks and work on something else while Deebo figures it out asynchronously. Deebo works by spawning multiple subprocesses, each testing a different fix idea in its own Git branch. It uses Claude to reason through the bug and returns logs, proposed fixes, and detailed explanations. The whole system runs on natural process isolation with zero shared state or concurrency management. Look through the code, it’s super simple. Deebo scales to real codebases too. Here, it launched 17 scenarios and diagnosed a $100 bug bounty issue in Tinygrad: https://github.com/snagasuri/deebo-prototype/blob/master/mem... Full logs from that run: https://github.com/snagasuri/deebo-prototype/tree/master/mem... Woul