VeriLoop Coder‑E1 Open‑Source: Evidence‑Governed Spiral Drives Verified Recursive Self‑Improvement

VeriLoop Coder‑E1, built on the Qwen3.6‑27B foundation model, is an open‑source vertical code model aimed at repository‑level bug fixing and agent‑style software‑engineering tasks.

On Hugging Face it scores 85.20 on SWE‑bench Verified, 62.38 on SWE‑bench Pro, 76.40 on Terminal‑Bench 2.0 and 33.63 on DeepSWE. Within the comparison range of open‑source models ≤32 B, it ranks first on the first three benchmarks and second on DeepSWE; among all open‑source models it places in the top‑five across the four metrics.

The model’s core advantage stems from the synergy of narrow‑domain PEFT fine‑tuning and the Self‑Harness framework. The base Qwen3.6‑27B is frozen; a small set of trainable parameters (the Surface Host Adapter) is added to endow the model with specialized abilities such as tool contract compliance, evidence‑conclusion binding, uncertainty detection, failure explanation, localized repair, and rollback control. These adapters are loaded as detachable modules without modifying the original base weights.

Self‑Harness organizes these abilities into a multi‑round execution chain. The first round generates candidate code, tests, and artifacts from the problem description, repository context, interface constraints, and acceptance criteria. Subsequent rounds transform the generated code, test failures, tool receipts, interface conflicts, refuted conclusions, and repair constraints into structured Markdown work packages. The model then revises its output based on the newly accepted evidence rather than mechanically retrying the same prompt.

The authors describe an “Evidence‑Governed Spiral” that formalises this process as a six‑step loop:

Evidence : collect and filter code, interfaces, tests, execution traces, and tool receipts that can materially change the current judgment, while clarifying known, unknown, and hypothesised evidence boundaries.

Falsify : actively test the premises, implementation, and correctness claims of candidate solutions, deriving observable failure conditions and locating contradictions or evidence gaps.

Explore : focus retrieval on the decisive gaps uncovered, searching code, call graphs, or necessary tools without expanding context aimlessly.

Repair : translate mismatches and falsified results into well‑bounded local or structural repair conditions, preserving change provenance and rollback paths.

Verify : re‑evaluate the revised artifact against the same task contract, test suite, and execution environment to confirm genuine, stable fixes and to rule out randomness or evaluation bias.

Consolidate : compress verified results, failure types, applicability conditions, and effective repair principles into evidence states, method constraints, and preventive rules for the next round.

This spiral ensures that each generation is constrained by newly gathered evidence, turning code generation into a verifiable, roll‑back‑capable, and recursively improving software‑engineering loop.

The project releases model weights, tokenizer, configuration files, the narrow‑domain PEFT adapters, and evaluation materials under the Apache 2.0 license. Developers may download, deploy, modify, and combine the adapters for secondary research, but the full Self‑Harness control stack remains closed source because it constitutes a complex runtime control plane rather than a simple prompt or agent script.

Within 48 hours of the public release, third‑party contributors produced GGUF low‑precision quantisations and published them on Hugging Face, enabling local inference with llama.cpp, Ollama, and LM Studio. The original repository recorded 413 daily downloads, while the GGUF repositories saw 955 daily downloads, demonstrating rapid community uptake and the model’s strong resistance to “abliteration” (the refusal rate dropped from ~95 % to ~82 % after 200 attempts).

“A theory that cannot be falsified by any conceivable event is not a scientific theory. Its unfalsifiability is a flaw, not a virtue.” – Karl Popper, *Conjectures and Refutations*

Looking ahead, the team plans to evolve the system into a general Code Agent. In this vision, the base model serves as a replaceable inference kernel, while a production‑grade Self‑Harness maintains task contracts, repository state, evidence obligations, and method versions. The agent will orchestrate multi‑round model calls and tool executions, predict code, dependency, and runtime changes, and validate predictions against Git diffs, compilation results, test logs, and execution traces. Mismatches trigger re‑exploration, rollback, or re‑planning, allowing the system not only to generate code but also to predict, execute, and take responsibility for its consequences.

This approach contrasts with AGI roadmaps that focus on ever larger models; instead, VeriLoop emphasises state‑centred, evidence‑driven recursion where conclusions, methods, and verification mechanisms remain falsifiable and updatable.

All benchmark data and repository links are cited in the article’s reference list.