This release adds three focused passes over re-curated data, each targeting a behaviour measured missing in the previous one: writing failure-injection regression tests before closing, iterating on multi-defect repositories past the first green suite, and honouring per-harness completion contracts. Every pass was gated by calibrated probes and a held-out benchmark ladder before being promoted.
How it works
It digs deeper into the repository, follows evidence to the root cause, and keeps iterating until the fix holds under real tests instead of stopping at a plausible-looking patch.
Fixes the bug, not the symptom : traces the actual defect, not the first thing that looks broken
Inspects more before editing, and re-runs tests after : more reads, more checks, fewer false successes
Emits tool calls the harness can actually run : dramatically fewer rejected calls
Revisits files when new evidence appears
Reasons about state and invariants across components
Continues iterating when the first implementation is incomplete
Ends its turns with a real report of what was done — no empty summaries, no truncated turns
Writes its own failing test before declaring victory : adds regression tests that fail on the unfixed code, then proves the fix against them
Iterates past the first green suite : coupled defects don't survive the second pass
Follows each harness's closing convention : a Codex task ends with a final report, a Cline task ends with a proper attempt_completion call
Tightens what a fix requires : removes deprecated or unauthorized call forms instead of quietly keeping them accepted
The fine-tune also significantly reduced malformed JSON arguments.
It provides native Codex integration for GPT-OSS on MLX. Rather than exposing GPT-OSS only through a generic OpenAI-compatible compatibility layer, it is designed so that Codex can use GPT-OSS as a native local model while preserving the GPT-OSS/Codex protocol details.
This includes the native Codex Responses protocol, GPT-OSS Harmony handling, reasoning continuity across tool turns, and Codex-specific routing and metadata.
Agent loops work smoothly without the stalls and rejections you get with generic OpenAI-compatible endpoints.
Format: MLX, MXFP4 experts + bf16 attention, ~61 GB on disk. Weights are consolidated — nothing to fuse or merge. Runs on Apple silicon with 96 GB unified memory; a full agent session peaks around 82 GB.
116.8B parameters (MoE, ~5.1B active per token — which is why it decodes
faster than much smaller dense models). The Hub badge shows ~24B because MLX
packs eight 4-bit weights per uint32 element and the badge counts elements,
not parameters.
How it was trained
Supervised fine-tuning on ~10 000 steps carefully selected from real coding-agent sessions to isolate the targeted behavior : some of my personal sessions with Opus/Fable 5 and GPT 5.6 Sol, public SWE-agent, OpenHands, SWE-smith and Fable trajectories, keeping only runs that actually resolved their issue. A run that gave up, or ran out of context and submitted anyway, teaches exactly the habit this model is meant to shed, so those were filtered out.
Each training example is a real repository state plus the next action the successful agent took, so what is learned is the loop itself: look, edit, run, read the result, correct.
The fine-tune itself is deliberately small, a low-rank update on the last layers only, then consolidated back into the weights. The goal was to shift behaviour, not to overwrite what the base model already knows.
Custom small in-house benchmarks were used to validate the training. Models such as Qwen3.6, DeepSeek v4 Flash and other distilled gpt-oss variants all failed these benchmarks. Opus 5 and GPT 5.6 Sol served as references proving the tasks were solvable.
Built by exalandru. If you use it in a real
agent loop, the failure reports are more useful than the success ones.
