AutoFix Swarm

A multi-agent system that autonomously diagnoses software failures, generates targeted fixes, and verifies every patch before delivery.

Comment

Inspiration

Developers spend a large amount of time finding bugs, writing patches, running tests, and explaining changes during code review. AI can generate code quickly, but an unverified patch is difficult to trust.

We built AutoFix Swarm to close that gap: an autonomous, explainable bug-remediation pipeline that detects issues, writes targeted fixes, verifies them against real tests, and presents the result in a developer-friendly dashboard.

What it does

AutoFix Swarm coordinates three specialized agents:

  1. Watcher Agent scans a repository using semantic analysis and static-analysis signals to identify security, logic, and code-quality issues.
  2. Codex Fixer Agent reads the affected code and generates a focused patch while preserving the repository’s existing conventions and behavioral contracts.
  3. Reviewer Agent runs deterministic tests against the patched code and produces a grounded explanation based on the actual diff and test results.

The dashboard displays:

  • detected issues with severity and confidence;
  • affected files and line ranges;
  • attempted and successful fixes;
  • changed files and patch summaries;
  • test-verification results;
  • complete pipeline timing and activity.

The system also supports pasted code and uploaded source files for analysis.

How we built it

The backend is built with Python and FastAPI. A LangGraph-style orchestration flow coordinates the Watcher, Fixer, and Reviewer stages.

We used:

  • GPT-5.6 for semantic bug analysis and evidence-grounded explanations;
  • OpenAI Codex for generating and applying code fixes;
  • Semgrep for deterministic static-analysis signals;
  • pytest for behavioral verification;
  • Docker for isolated local fix execution;
  • SQLite for run history and pipeline logs;
  • Next.js, React, TypeScript, and Tailwind CSS for the dashboard.

The frontend is deployed on Netlify, while the hosted API health service is deployed on Vercel. The complete Docker-powered remediation pipeline is available through the repository’s local setup because hosted serverless environments do not provide the same long-running Docker execution model.

Challenges we faced

The main challenge was making AI-generated fixes reliable rather than merely plausible.

A generated patch can look correct while breaking an existing function contract. During testing, one SQL-injection fix correctly parameterized a query but initially used a placeholder convention different from what the repository and tests expected. This reinforced an important design decision: the Fixer must inspect nearby tests and preserve project-specific conventions before modifying code.

We also had to handle:

  • long-running pipeline requests without leaving the interface permanently stuck;
  • clear separation between live, cached, and offline results;
  • safe execution of generated code;
  • frontend and backend deployment limitations;
  • consistent result aggregation across issues, fixes, and verdicts.

Accomplishments that we're proud of

  • Built an end-to-end multi-agent bug lifecycle.
  • Detected all seven intentionally seeded issues in our evaluation repository.
  • Generated targeted fixes rather than replacing entire files.
  • Verified patches using deterministic behavioral tests.
  • Kept GPT-5.6 explanations grounded in the actual diff and test evidence.
  • Added Docker isolation for local code execution.
  • Created a polished dashboard for inspecting the complete reasoning trace.
  • Deployed a public frontend for judges and reviewers.
  • Designed an explicit cached-data fallback that is never presented as a live model run.

What we learned

We learned that reliable AI developer tools need more than a strong model. They need:

  • explicit agent responsibilities;
  • repository-aware prompts;
  • deterministic test gates;
  • safe execution boundaries;
  • transparent failure states;
  • honest distinction between live and cached results.

The most valuable lesson was that tests are not simply the final step. They are part of the context that the fixing agent should understand before generating a patch.

What's next for AutoFix Swarm

Next, we plan to add:

  • asynchronous background jobs for production pipeline runs;
  • GitHub repository import;
  • automatic pull-request generation;
  • retry and repair loops for rejected patches;
  • multi-language repository support;
  • CI/CD integrations;
  • persistent cloud storage for run artifacts;
  • team approvals and audit trails.

Built With

Share this project:

Updates