Inspiration
We wanted a coding agent we'd actually use every day on our laptops, running on open models. But most agents go straight from a bug report to a patch, which leaves you with the hard part: is the bug actually fixed? A careful maintainer starts by writing a test that fails. ember does the same.
What it does
ember is an interactive terminal coding agent written in Rust and powered by NVIDIA Nemotron on Nebius Token Factory. It reads and searches your project, edits files, and runs commands. Each edit is shown as a diff, and each command is shown before it runs, for your approval. The conversation stays in your terminal's normal scrollback.
Its standout feature is /fix :
Investigate. Nemotron Super explores the code with read-only tools and reports the root cause. Reproduce. Super reads the code under test and writes a new test that must fail on the current code. A Nemotron Nano judge rejects tests that fail for the wrong reason (wrong method name, import error, unrelated assertion). If ember can't reproduce the bug, it stops instead of guessing. Plan. Nemotron Ultra proposes several genuinely different fix strategies. Branch. Each strategy runs in its own git worktree, in parallel, with its own tool-using patching loop. Test files are read-only inside a branch, so no branch can "pass" by weakening the test. Verify. A branch wins only if the repro test passes and the full test suite has no new failures compared with a baseline run. Review & apply. Ultra picks the best passing candidate and explains why. You approve the final diff (fix plus regression test) before anything touches your working tree.
How we built it
Rust, shipped as a single binary: tokio and reqwest for streaming; ratatui in inline-viewport mode so the transcript lives in normal scrollback; ignore (ripgrep's walker) for .gitignore-aware search; similar for diffs; pulldown-cmark for Markdown. Nebius Token Factory's OpenAI-compatible API with streaming and native tool calling. We wrote a client that assembles streamed tool-call fragments and shows Nemotron's reasoning_content live, without cluttering the transcript. Three Nemotron tiers, each where it pays off:
NVIDIA-Nemotron-3-Nano-30B-A3B: fast, cheap judgements (does this failing test really reproduce the bug? did the suite regress?) nemotron-3-super-120b-a12b: the everyday coding model, for the interactive agent and every /fix branch Nemotron-3-Ultra-550b-a55b: the two decisions where deeper reasoning changes the outcome (choosing strategies and choosing the patch to merge)
git worktrees as cheap sandboxes. They start from git stash create, so uncommitted work is included without touching your tree, and they're always cleaned up.
Challenges we ran into
Testing against real Nemotron changed the design in three ways:
The judge earned its place immediately. In the first live /fix run, Nano correctly rejected all four of Super's reproduction tests: each one called a method that doesn't exist (add_line_item, add_item, ...). The cause was ours: the test writer only got a summary of the code. We made reproduction an agentic loop where the writer reads the real API before calling submit_test, and the next run reproduced the bug on the first attempt. Edits failed on indentation. Super kept sending old_string with 6-space instead of 4-space indentation: it was folding the separator after the line numbers in our read_file output into the code. A cat -n-style tab separator fixed it at the source, and edit_file now also tolerates a consistent indentation shift. Global state slipped through review. Ultra once chose a patch that changed Python's global decimal context. The review and planning prompts now strongly prefer local changes. Pivoting mid-hackathon. We started with a Python web service and rewrote it as a Rust CLI, because the tool we actually wanted to use was a terminal agent.
Accomplishments that we're proud of
/fix never ships an unverified patch, and can't cheat: tests are read-only while fixing. On the demo bug, a real run went from bug report to two independently verified fixes plus a regression test, fully automatically, in about 130k tokens. On a fixed 20-instance SWE-bench Verified sample, ember's agent with Super resolved 41 of 60 attempts across three runs (68%) at about $0.063 per resolved task, graded by the official harness. One small binary that we now use as our daily coding agent.
What we learned
All three Nemotron 3 tiers handled OpenAI-style tool calling (including forced tool_choice) reliably on Token Factory, with first tokens in about a second. Reasoning arrives in reasoning_content, separate from the answer. Many reliability problems for agents come from the tool interface, not the model: the way output is formatted directly shapes what the model sends back. A cheap verifier model (Nano) is worth a lot when it checks a strong generator (Super).
Beyond /fix (shipped during the hackathon, v0.9.0)
The interactive agent grew into a full daily driver: /review (Ultra reviews uncommitted changes), /commit and /pr (drafted, then approved), /resolve for merge conflicts, /undo, /resume for saved sessions, /compact, MCP servers (behind an explicit /mcp trust), Nemotron 3.5 Super VL for screenshots and diagrams, and web search and fetching through Tavily. It installs as one binary with a one-line installer.
ember is also tuned for Nemotron on Token Factory: reasoning off for mechanical drafting, batched file reads, a stable prompt prefix so repeat requests hit the cache, and Super's reasoning kept between steps. On ember's coding benchmark, Super with kept reasoning passed 14 of 15 runs at 8.7 s and $0.0034 per task.
What's next for ember
Our north star is dollars per resolved SWE-bench Verified task. The sample above is the set we tuned on, so the next step is the held-out set, then running /fix itself on SWE-bench, and running /fix branches in Nebius Sandboxes for full isolation of model-written code.
Code: https://github.com/aneesh-pradhan/ember (MIT)
