Deebo MCP Server for Multi-Agent Hypothesis Testing

Overview

Deebo MCP Server is a prototype Model Context Protocol (MCP) server designed to help AI coding agents collaborate on diagnosing and fixing difficult bugs. It implements an agentic debugging workflow where multiple isolated agents generate, test, and evaluate hypotheses in parallel against a codebase. Each agent operates with a bounded context and controlled side-effects, enabling safer exploration and reproducible experiments.

The server is useful when a single LLM-driven agent cannot confidently identify a root cause or produce a safe patch. By coordinating discrete hypothesis-testing agents, Deebo reduces noisy or speculative edits and surfaces the most promising fixes through automated verification. It is aimed at developer teams and tool builders integrating multi-agent debugging into CI, local development, or research workflows.

Features

• Multi-agent hypothesis testing: spawn multiple isolated agents that propose hypotheses, reproduce failures, and suggest fixes.
• Context isolation: agents run in bounded contexts/sandboxes to avoid contaminating the primary repository state.
• Experiment orchestration: schedule, run, and track experiments (hypotheses → patches → verification).
• Automated verification: run test suites and heuristics to validate candidate patches.
• Extensible adapters: integrate with different LLM providers, test runners, and execution sandboxes.
• Observability: collect logs, artifact diffs, and structured experiment results for human review.
• Prototype-friendly: lightweight server designed for experimentation and integration into developer workflows.

Installation / Configuration

Clone and prepare the repository (change commands to match your environment):

git clone https://github.com/snagasuri/deebo-prototype.git
cd deebo-prototype

Copy and edit environment configuration:

cp .env.example .env
# Edit .env to add your API keys and runtime settings
# Example .env entries:
# OPENAI_API_KEY=sk-...
# DEEBO_PORT=8080

Install dependencies and run (example using npm / Node.js; replace with Python/Cargo if repo differs):

# Node.js example
npm install
npm run build
npm run start

# Docker example (if a Dockerfile/docker-compose.yml is provided)
docker-compose up --build

Configuration notes:

• Set LLM provider and API keys in environment variables.
• Configure test runner commands and sandbox paths for isolated execution.
• Adjust maximum concurrent agents and timeout values to control resource usage.

Architecture and Available Resources

Core components:

Available resources you can expect to use or extend:

• REST API endpoints (for submitting experiments, querying results, and controlling agents)
• CLI utilities for local debugging and running experiments
• Adapter templates for LLM providers (OpenAI, local LLMs) and sandbox backends
• Structured experiment logs and artifact diffs (patches, test outputs)

(Refer to the repository README and docs for exact endpoint paths and adapter knobs.)

Use Cases

1. Fixing a flaky test suite

   • Scenario: CI intermittently fails on a test that is hard to reproduce locally.
   • Flow: Submit an experiment to Deebo that describes the failing test and includes logs. The server spawns several agents that each propose a hypothesis (race condition, test ordering, environment dependency). Each agent attempts to reproduce the failure in its sandbox, proposes a minimal patch or test change, and runs verification. The verifier ranks candidate patches and returns the best candidates and reproduction instructions.

2. Root-cause analysis for production errors

   • Scenario: An error appears in production logs with partial stack traces and uncertain causes.
   • Flow: Agents analyze the trace, generate hypotheses about likely causes (e.g., null dereference, configuration mismatch), and craft focused diagnostic runs (instrumentation, reduced repros) in isolated environments. Successful repros and validated fixes are surfaced for review.

3. Automated PR triage and patch suggestion

   • Scenario: A large refactor introduces subtle behavioral changes flagged by tests.
   • Flow: Deebo agents test small, targeted patches that revert or adapt the refactor, run the full test suite in sandbox, and produce patch candidates with test evidence to speed reviewer decisions.

4. Research into multi-agent debugging strategies

   • Scenario: Evaluate different agent prompting strategies or verification heuristics.
   • Flow: Use the prototype to run controlled experiments that vary prompt templates, sandbox constraints, or scoring functions and collect structured results for analysis.

Getting Started Tips

• Start small: run single-agent experiments locally to understand the workflow before enabling parallel agents.
• Keep sandboxes reproducible: mount fresh checkouts per agent to avoid state leakage.
• Tune verification: customize test and lint commands to match your codebase and reduce false positives.
• Review artifacts: always inspect candidate patches and reproduction logs before merging automated fixes.

For the source code and prototype examples, see the project on GitHub: https://github.com/snagasuri/deebo-prototype.