ErrorMinds

Inspiration

We were inspired by a common frustration developers face every day: debugging the same types of errors again and again. Even with powerful AI tools like Copilot or ChatGPT, every debugging session starts from scratch. These tools don’t remember past mistakes, failed fixes, or successful solutions.

We wanted to build something different — a system that doesn’t just assist once, but learns over time. That idea led to ErrorMind: an AI that gains experience from debugging, just like a human developer.

What it does

ErrorMind is a memory-powered debugging agent that helps developers detect, understand, and fix bugs faster.

It automatically captures runtime errors from terminal commands, stores debugging sessions including failed and successful fixes, retrieves similar past issues using vector search, warns against repeating failed approaches, and suggests smarter fixes based on past experience.

It also supports an autonomous agent mode, where it can analyze the error, generate a fix, apply it to the code, re-run the program, and repeat until the issue is resolved.

How we built it

We built ErrorMind as a full-stack system combining memory, retrieval, and autonomous execution.

We used FastAPI for the backend, MongoDB Atlas to store debugging episodes and embeddings, and the Gemini API for semantic reasoning. MongoDB Atlas Vector Search is used to find similar past issues. The CLI is built with Typer and Rich for a developer-friendly workflow, and Streamlit is used for the dashboard.

The system runs code using subprocess, parses stack traces, stores structured debugging episodes, and uses embeddings to retrieve similar past issues. The agent loop follows an observe, think, act, and evaluate cycle for autonomous debugging.

Challenges we ran into

One of the biggest challenges was LLM reliability for code generation. Gemini sometimes produced incomplete or inconsistent fixes, especially for multi-step debugging.

We addressed this by adding structured prompts, extracting only valid code blocks, implementing file backups before applying fixes, and combining LLM reasoning with deterministic execution.

Another challenge was making the system feel natural for developers. We moved from a UI-based approach to a CLI-first workflow that integrates directly into the terminal.

Accomplishments that we’re proud of

We built a fully working autonomous debugging agent. We enabled cross-file learning, where fixing one bug helps solve another. We created a complete debugging lifecycle system from open to fixing to resolved. We achieved significant token savings by using memory instead of sending full context to the model. We also designed a system that fits directly into real developer workflows.

What we learned

We learned that building agent systems is not just about using LLMs, but about combining memory, reasoning, and action.

We also learned that LLMs alone are not always reliable, memory significantly improves usefulness, developer tools must fit into real workflows, and tracking every step is essential when building AI systems.

What’s next for ErrorMind

We plan to extend ErrorMind into a full developer intelligence layer.

We want to support more programming languages and error types, improve fix accuracy using hybrid rule-based and LLM approaches, integrate directly into IDEs like VS Code, enable team-level shared memory, and explore multi-agent debugging systems.

Our long-term vision is to make ErrorMind the memory layer for AI coding tools, so developers never have to debug the same problem twice.