Fixie

Inspiration

Fixing a bug usually means reproducing it, guessing a cause, trying a patch, and re-running tests until something passes. Each of those steps is mechanical enough for an agent to do, and trying several candidate fixes at once is faster than trying them one at a time. We wanted to see how far that idea goes with an open model.

What it does

Fixie takes a bug report and:

1. Ranks the repository files most likely to be involved.
2. Reproduces the bug by running the project's failing test.
3. Asks the model for a diagnosis (root cause).
4. Forks several candidate patches in parallel. Each is applied as exact search/replace edits in its own isolated working copy and tested.
5. Picks the winner with deterministic code: the first candidate whose tests pass. The others are cancelled.
6. Delivers the diff and the root cause.

A web UI streams the whole run as a step timeline, a terminal view and a branch view.

How we built it

• Models: NVIDIA Nemotron 3 Super (nvidia/nemotron-3-super-120b-a12b) called through the Nebius Token Factory OpenAI-compatible API, for diagnosis and patch generation.
• Backend: Python, FastAPI, Server-Sent Events, SQLite. The agent loop emits typed events that follow a frozen JSON schema, so the UI and the saved replays share one contract.
• Frontend: Next.js, React, Tailwind, Motion. Saved real runs can be replayed in the UI.
• Safeguards: candidate patches may not edit existing tests (an integrity rule), secrets are redacted from logs, and spend is capped in code.
• We developed and tested the loop offline with a fake provider and a cassette recorder, then switched to Nebius for the real runs.

Challenges we ran into

• Models returned patches as malformed diffs or fenced text. We switched to JSON search/replace edits that the code converts into diffs, and made every rejected candidate visible with a reason.
• Reasoning models can spend a small token budget entirely on thinking. Nemotron 3.5 Lightning used a 50-token budget without producing an answer, so we used Super for the recorded run.
• Time. We built and merged backend and frontend lanes in parallel against a frozen contract.

Accomplishments that we're proud of

• A complete run on Nebius with Nemotron 3 Super: reproduce, diagnose, parallel candidates, a verified winning patch and a delivered diff, in about 15 seconds on a demo bug.
• Winner selection is plain code, not a model's opinion.
• Every event is schema-validated, and a run can be replayed exactly.

What we learned

• Letting the model propose edits while code applies and verifies them is much more reliable than trusting model-written diffs.
• Parallel candidates only help if failures are visible. Silent failures hid real problems early on.
• Be honest about what each result came from. Our UI and README state which provider produced which run.

What's next for Fixie

Honest scope today: the recorded run uses a small demo project, candidates run in local working copies (not containers or Nebius Sandboxes), no pull request is opened, and the evaluation page holds placeholder numbers rather than measured results.

Next: run candidates in Nebius Sandboxes, use a smaller Nemotron model for triage, connect real GitHub issue URLs and open pull requests, and publish a measured evaluation over a larger set of bugs.

Built With

• 3
• css
• events
• factory
• fastapi
• nebius
• nemotron
• next.js
• nvidia
• openai-compatible
• python
• react
• server-sent
• sqlite
• super
• tailwind
• token
• typescript