tsinghua-sigs-robot-lab

veriloop-coder-e1

README

License: apache-2.0

Overview

VeriLoop Coder-E1 is an open-source vertical coding model for software engineering, released under the Apache License 2.0. The distributed model weights and the published repository artifacts may be used, modified, and redistributed—including for commercial purposes—subject to the Apache 2.0 terms and any applicable third-party notices.

The defining technical contribution of VeriLoop is the Self-Harness. It is not a larger prompt, a generic multi-agent wrapper, or a collection of fine-tuned adapters. The Self-Harness is the governing execution substrate that turns model generation into a bounded, evidence-driven engineering loop.

The system is organized around one explicit progression:

text
Vertical Coding Model → Self-Harness → Evidence Loop → Recursive Self-Improvement

The coding backbone proposes and reasons about artifacts. Narrow-domain PEFT tuning supplies specialized behavioral sensitivities, but it remains an auxiliary adaptation layer. Its purpose is to support the Self-Harness—not to replace it—by exposing task-relevant control surfaces for tool contracts, uncertainty, rollback, and evidence quality.

Those PEFT artifacts are attached through the Surface Host Adapter: an external, detachable runtime adaptation plane that injects the published fine-tuning products into model execution without redefining the model's core architecture. The Self-Harness remains responsible for task-contract compilation, evidence admission, candidate generation, falsification, targeted exploration, surgical repair, re-verification, selection, and post-run evidence evolution.

This produces the core operating loop:

text
Evidence → Falsification → Exploration → Repair
    ▲                                      │
    └──── verified outcome becomes evidence ┘

A task is not considered solved because code looks plausible. It is considered complete only when one native deliverable has survived the active task contract and the available verification evidence.

Open-source release and architectural boundary

The public release makes VeriLoop Coder-E1 an open-source model distribution under Apache 2.0. The release includes the model weights, tokenizer and configuration assets, published Surface Host PEFT adapters, and selected evaluation and traceability artifacts.

Open-sourcing the model does not collapse the distinction between the model and the complete production system. The model weights and published artifacts are open; the production Self-Harness implementation—including orchestration code, prompt compilation, evidence routing, repair policy, candidate arbitration, memory implementation, and internal training systems—remains private unless released separately.

This boundary is architectural, not cosmetic:

text
Open model weights + published PEFT surfaces
                    │
                    ▼
       private production Self-Harness
                    │
                    ▼
     governed evidence-loop execution

Accordingly, loading the base model or any individual PEFT adapter does not reproduce the complete VeriLoop runtime. The core technical idea is the Self-Harness; the narrow-domain PEFT surfaces are supporting instruments designed to make that Harness more precise, evidence-sensitive, and controllable.

Developer and affiliation

Libo Wang is the developer of VeriLoop Coder-E1 and a member of the Intelligent Robotics Laboratory, Tsinghua Shenzhen International Graduate School (Tsinghua SIGS).

This affiliation identifies the developer's laboratory membership. It does not, by itself, assert institutional endorsement, certification, ownership, or an official release by Tsinghua University unless such status is stated separately.

Public Self-Harness technology disclosure

This model card publicly discloses one bounded technology layer of the VeriLoop Self-Harness: its model-visible engineering behavior contract, including the evidence-loop semantics and the public 14-rule discipline below.

The disclosure is intentionally limited. It explains the principles enforced at the Harness boundary, but it does not disclose production prompts, orchestration code, routing logic, thresholds, scoring functions, memory schemas, private training data, anti-contamination controls, or other security-sensitive implementation details. This boundary allows the public methodology to be inspected and credited without weakening the model system's operational security.

Benchmark Results

VeriLoop Coder-E1 has been evaluated on four repository-level and agentic software-engineering benchmarks using each benchmark's native evaluation workflow.

Table with columns: Benchmark, Evaluation scope, Reported score
Benchmark	Evaluation scope	Reported score
SWE-bench Verified	500 tasks	85.20%
SWE-bench Pro	731 tasks	62.38%
Terminal-Bench 2.0	89 tasks	76.40%
DeepSWE	113 tasks	33.63%

The reported values are benchmark-level pass or resolution rates produced through the corresponding evaluation workflows. Where published, VeriLoop evidence packages bind task identity, the model-generated artifact, and the associated evaluation record to support task-level inspection and reproducibility. Publication of a score or evidence package does not, by itself, imply endorsement, certification, or independent verification by the benchmark maintainers.

Vision: Recursive Autonomous Improvement

VeriLoop's long-term objective is recursive self-improvement implemented through Self-Harness.

The relationship is direct:

Self-Harness is the execution substrate.
The evidence loop is the operating methodology.
Recursive self-improvement is the long-term system outcome.

The objective is not unrestricted self-modification. It is a governed recursion in which each completed loop leaves the system with a better engineering state:

a sharper task contract;
higher-quality admitted evidence;
stronger counterevidence;
more accurate failure classification;
a narrower repair boundary;
a reusable prevention rule;
a stronger starting state for the next task.

Today, this recursion operates across the Self-Harness, evidence, validation, repair, selection, and memory layers. A completed task produces artifacts and receipts that can improve later decisions without exposing private reasoning or blindly rewriting model weights.

The strategic direction is:

Build a vertical coding model that can inspect its own work, falsify weak solutions, explore decisive gaps, repair the broken invariant, verify the result, and carry validated gains into the next loop.

The recursion remains bounded by current-task supremacy, evidence admission, rollback, explicit halt conditions, benchmark-locked evaluation, and one selected deliverable with a verifiable evidence chain.

Methodology: Evidence, Falsification, Exploration, Repair

The VeriLoop methodology has four movements:

Evidence

Establish the current task contract and admit only evidence that can change the artifact: repository context, interfaces, tests, traces, tool receipts, selected references, and relevant prevention rules.

Falsification

Challenge the candidate, its assumptions, and its claimed correctness. Search for contradictions, missing invariants, incompatible interfaces, unsupported claims, test failures, and counterexamples.

Exploration

Investigate only the decisive gaps exposed by falsification. Retrieval, search, reverse analysis, sandbox execution, or additional model work must have a concrete reason and a defined downstream consumer.

Repair

Correct the smallest broken invariant, preserve unaffected surfaces, and re-verify the same contract. A verified repair closes the current loop and becomes evidence for the next one.

text
Evidence → Falsification → Exploration → Repair
    ▲                                      │
    └────────────── next-loop evidence ────┘

This methodology is what converts Self-Harness from orchestration into a recursive engineering system. Each loop transforms uncertainty into evidence, evidence into correction, and verified correction into cumulative capability.

System Architecture

text
Current Task
                                   │
                                   ▼
                         Goal Binding / Contract
                                   │
                                   ▼
                    ┌────────── Evidence ──────────┐
                    │                              │
                    │                              ▼
                    │                     Artifact Candidate
                    │                              │
                    │                              ▼
                    │                       Falsification
                    │                              │
                    │                      gap / contradiction
                    │                              ▼
                    │                         Exploration
                    │                              │
                    │                              ▼
                    └────────────────────────── Repair
                                                   │
                                                   ▼
                                      Re-verification / Selection
                                                   │
                                                   ▼
                                         One Final Deliverable
                                                   │
                                                   ▼
                                        Next-Loop Evidence State
                                                   │
                                                   └──────↺

Task Contract Layer

Transforms user intent into generation constraints:

task family and native artifact surface;
required files, functions, APIs, signatures, and entry points;
repository-local conventions;
acceptance conditions and failure signals;
validation or simulation criteria;
explicit budget and tool-use boundaries.

Evidence Layer

Collects only evidence that can change the artifact:

repository files and call relationships;
tests, errors, traces, and execution receipts;
selected internal knowledge;
source-bound external documentation when freshness matters;
prior failure-prevention rules that remain relevant to the current task.

Generation Layer

Produces the requested artifact under the active task contract. Generation is artifact-first: code, patch, script, or configuration is treated as the primary deliverable rather than as an appendix to a long explanation.

Validation and Repair Layer

Evaluates syntax, structure, repository compatibility, task intent, and output-surface correctness. When a candidate fails, the system attempts a targeted correction tied to the observed failure rather than an unconstrained rewrite.

Selection Layer

Compares eligible candidates and selects exactly one deliverable. Selection favors task compliance, minimal necessary change, repository consistency, validation strength, and evidence coverage.

Evidence Evolution Layer

Converts useful failure and repair observations into compact prevention rules for future turns. Raw logs are not promoted directly into memory; only reusable, task-relevant evidence is retained.

The VeriLoop Self-Harness Loop

The production runtime uses a bounded sequence of specialized model and deterministic stages. The exact implementation remains private; the public functional contract is the following.

Phase A — Goal Binding and Contract Compilation

Resolve the current task, repository scope, native artifact surface, active constraints, uncertainty, budget, and acceptance conditions. The result is a compact engineering contract, not an uncontrolled prompt expansion.

Phase B — Evidence Admission and Candidate Realization

Admit only current-task evidence that can change the artifact. Generate a complete candidate from the task contract, selected repository context, and applicable narrow-domain Surface Host signals.

Phase C — Falsification and Counterevidence

Challenge the candidate against task intent, repository interfaces, tests, traces, conflicting evidence, and failure signals. A candidate is not promoted merely because it is syntactically valid or superficially plausible.

Phase D — Gap-Driven Exploration

When falsification reveals a decisive uncertainty, trigger the narrowest useful retrieval, search, reverse analysis, tool action, or sandbox check. New evidence must have an explicit downstream consumer.

Phase E — Surgical Repair and Re-verification

Convert observed failures into focused repair constraints. Correct the smallest broken invariant, preserve unaffected surfaces, and run the same contract-aware checks again.

Phase F — Selection and Recursive Evidence Evolution

Select exactly one final artifact. Record the validation evidence, failure class, repair outcome, halt reason, and reusable prevention rule. These receipts become higher-quality inputs to later loops.

The Self-Harness therefore implements a recursive relation:

text
Evidence → Falsification → Exploration → Repair ↺

Re-verification is not a fifth methodology stage. It completes Repair, and the verified outcome becomes the next cycle's Evidence.

This is VeriLoop's defining direction: a vertical coding model that does not stop at generation, but repeatedly turns evidence into correction and correction into cumulative engineering capability.

Expert Convergence Mode

Expert Mode uses a richer bounded convergence loop for difficult software-engineering tasks.

It is designed for:

repository-scale changes with hidden invariants;
ambiguous failures requiring evidence synthesis;
cross-file API or behavior changes;
tasks with multiple plausible repairs;
cases where a first candidate should be challenged before delivery.

At a functional level, Expert Mode adds:

richer contract and evidence compilation;
multiple candidate opportunities where justified;
independent validation and failure classification;
focused repair cycles;
candidate comparison and quality arbitration;
strict selected-artifact delivery;
explicit safe stopping when no candidate satisfies the required threshold.

The exact prompts, thresholds, orchestration order, candidate scoring, repair policies, and routing logic are proprietary.

Runtime Modes

Table with columns: Mode, Optimization target, Functional behavior
Mode	Optimization target	Functional behavior
Flash	Lowest latency	Direct artifact realization with lightweight control and minimal orchestration
Thinking	Balanced quality and cost	Evidence-guided artifact generation with bounded self-check and targeted correction
Expert	Highest final quality	Rich evidence, iterative validation and repair, candidate arbitration, strict selected delivery

Surface Host Adapter

The Surface Host Adapter is VeriLoop's external narrow-domain adaptation plane. It is the mechanism by which published PEFT fine-tuning artifacts are attached to, and injected into, model execution as detachable runtime surfaces.

This layer must be understood in the correct architectural order:

text
Self-Harness = core governing technology
Surface Host Adapter = external adaptation host
Narrow-domain PEFT artifacts = hosted behavioral surfaces

The PEFT surfaces are therefore not the core of VeriLoop, not a substitute for the backbone, and not a substitute for the Self-Harness. They are purpose-built auxiliary components whose value is realized when the Harness uses their signals to improve contract sensitivity, evidence handling, escalation, repair, rollback, and delivery control.

External injection model

The public PEFT artifacts remain logically separate from the distributed model weights. They are loaded over the model through the Surface Host Adapter as external runtime attachments. In the standard published loading pattern, the adapter is activated without rewriting the original checkpoint; users may independently choose whether to keep it detachable or to perform a downstream merge where supported by the PEFT tooling and license terms.

This architecture provides three important properties:

separation of concerns — the backbone retains general coding and reasoning capability, while each PEFT surface contributes a narrowly defined behavioral bias;
detachable composition — published surfaces can be loaded, removed, evaluated, or replaced independently of the original checkpoint;
Harness-centered control — the Self-Harness remains the governing layer that determines how task contracts, evidence, validation, and repair consume the resulting surface signals.

The Surface Host Adapter is not a single fifth adapter. It is the host boundary for multiple specialized adaptation surfaces.

This design separates three kinds of capability:

backbone capability — code understanding, generation, reasoning, and language competence;
surface capability — narrow-domain sensitivity learned through PEFT;
Harness capability — evidence admission, falsification, exploration, repair, re-verification, arbitration, and recursive evidence evolution.

The current public adaptation surfaces are:

Table with columns: Surface, Primary optimization, Practical effect
Surface	Primary optimization	Practical effect
ToolSpec	Tool schemas, argument constraints, preconditions, postconditions, execution-facing formats	Stronger sensitivity to malformed calls, missing prerequisites, invalid arguments, and incomplete execution contracts
Uncertainty	Answer, evidence, execution, specification, and risk uncertainty	Better escalation decisions, reduced unsupported certainty, and more selective use of search, tools, or validation
Rollback	Validator negation, failed edits, bounded correction, state restoration	More precise repair behavior and lower risk of broad destructive rewrites after a local failure
Evidence Binding	Claim-to-evidence alignment, provenance, validation context, source discipline	Stronger coupling between generated artifacts, supporting context, and observable verification evidence

What the adaptation plane improves

The narrow-domain tuning is intended to materially strengthen:

tool-call and schema discipline;
contract adherence before generation;
repository-aware code planning;
evidence-sensitive reasoning;
uncertainty-triggered escalation;
validator-aware repair behavior;
rollback and correction boundaries;
artifact-only delivery discipline;
claim, source, and validation alignment;
consistency across long, multi-stage coding workflows.

These adapters are optimized as behavioral control surfaces, not as isolated leaderboard specialists. Their main value appears when they are hosted by the Surface Host Adapter and coordinated by the Self-Harness, where adapter signals can influence routing, evidence injection, repair control, and delivery policy.

Adapter-only loading does not reproduce the complete production system.

Public Rule Lineage: Karpathy → Forrest Chang → Mnilax → Libo Wang

The public VeriLoop rule system has a documented intellectual lineage.

Andrej Karpathy's original observations. In January 2026, Karpathy publicly described recurring coding-agent failure modes: silent assumptions, unmanaged confusion, overcomplication, unnecessary adjacent edits, and weak success criteria.
Forrest Chang's four-rule operationalization. Forrest Chang converted those observations into a compact CLAUDE.md behavior contract containing four principles: Think Before Coding, Simplicity First, Surgical Changes, and Goal-Driven Execution. These are referred to here as the Karpathy-origin Golden Four, while credit for packaging them into the formal four-rule repository belongs to Forrest Chang.
Mnilax's eight agent-era additions. In May 2026, Mnilax published eight additional controls for newer agentic failure modes:
- use the model for judgment calls, and keep deterministic decisions in code;
- enforce hard token and execution budgets;
- surface conflicting patterns instead of averaging them;
- read relevant code before writing;
- make tests verify intent rather than appearance;
- checkpoint significant multi-step work;
- follow repository conventions unless explicitly changing them;

The VeriLoop rules are not presented as Karpathy's, Forrest Chang's, or Mnilax's exact text, nor as an official collaboration with those authors. They are an attributed adaptation for VeriLoop's evidence-bound Self-Harness architecture.

Primary references

Andrej Karpathy's original X post: https://x.com/karpathy/status/2015883857489522876
Forrest Chang's four-rule repository (currently hosted under multica-ai): https://github.com/multica-ai/andrej-karpathy-skills
Mnilax's original eight-rule extension on X, published 9 May 2026: https://x.com/Mnilax/status/2053116311132155938

The Libo Wang 14-Rule Public Self-Harness Contract

The following rules are intentionally public. They form the model-visible engineering discipline shared across VeriLoop coding modes.

Current-Task Supremacy
The current request and its exact output contract override old memory, cached templates, prior habits, and unrelated retrieved context.
Escalate on Evidence, Not Instinct
Trigger search, reverse analysis, sandbox execution, or repair only when concrete uncertainty, missing evidence, or a failed contract justifies the cost.
Inspect Before Editing
Read the relevant entry points, callers, interfaces, tests, repository conventions, selected evidence, and failure signals before changing code.
Produce the Minimal Complete Artifact
Deliver the smallest implementation that fully satisfies the task, preserves required interfaces, and can be validated.
Repair the Broken Invariant, Not the Whole System
Prefer a precise correction of the failing region. Rewrite broadly only when evidence proves that local repair cannot restore correctness.
Validate Intent, Not Appearance
Syntax, formatting, and imports are necessary checks; the decisive test is whether the artifact satisfies the user's actual functional intent.
Surface Failure; Never Simulate Success
Keep failures, skipped checks, degraded states, and unknowns explicit in Harness evidence. Never claim execution, validation, or success that did not occur.

Core Technical Advantages

Evidence binding over prompt accumulation

VeriLoop does not equate more context with better context. Raw findings are compiled into constraints, selected evidence, and validation targets before they reach generation.

Native artifact routing

Repository patches, polyglot source files, shell tasks, functions, configuration files, and structured outputs are handled as distinct artifact families rather than being forced into a single Python-centric path.

Deterministic–generative separation

The model handles ambiguity, synthesis, and repair hypotheses. Deterministic components handle parsing, structural checks, contract enforcement, receipts, and reproducible transformations.

Failure-aware convergence

Validation failures are preserved as evidence. The system distinguishes an invalid candidate, a missing dependency, a degraded tool, an unverified assumption, and a genuine task failure instead of collapsing them into a generic retry.

Safe stopping

When evidence does not support delivery, the system can stop with an explicit failure record rather than manufacturing a confident result.

Task-level traceability

Evaluation packages can bind a task identity to the generated artifact and the corresponding official evaluation record, allowing third parties to inspect the complete task-level chain.

Current Public Repository Contents

The repository contains the open-source model distribution, published adaptation artifacts, and selected evaluation and traceability materials. Unless a file states otherwise, the repository's original VeriLoop artifacts are distributed under the Apache License 2.0, subject to applicable third-party licenses and notices.

Backbone and runtime-compatible files

sharded safetensors model weights;
model and generation configuration;
tokenizer and preprocessing assets;
Hugging Face-compatible loading metadata.

Narrow-domain adaptation artifacts

Each public Surface Host PEFT directory may include:

adapter weights and adapter configuration;
tokenizer assets;
best-checkpoint records;
epoch history;
host manifests;
adapter plans;
training-result summaries;
sanitized training and evaluation records;
training manifests;
specialized surface heads where published.

Public Surface Host PEFT roots:

text
surface_host_peft_toolspec_adapter/
surface_host_peft_uncertainty_adapter/
surface_host_peft_rollback_adapter/
surface_host_peft_evidence_binding_adapter/

These directories contain the published narrow-domain fine-tuning products used as external Surface Host Adapter attachments. They are support layers for Self-Harness operation, not standalone substitutes for the Self-Harness.

Evaluation and traceability artifacts

The repository also publishes selected evidence packages for:

SWE-bench Verified;
SWE-bench Pro;
Terminal-Bench 2.0;
DeepSWE.

These packages are designed to support task-level inspection across:

text
task identity → model-generated artifact → official evaluation record

Publication of an evidence package does not imply independent third-party verification unless explicitly stated.

What Remains Private

The Apache 2.0 release applies to the model weights and public repository artifacts. It does not automatically license private VeriLoop components that are not distributed in this repository.

To protect system integrity and prevent disclosure of production-critical methods, the following remain private:

exact Self-Harness orchestration and stage implementation;
internal prompt compiler and model-visible packet construction;
evidence routing, ranking, admission, and contamination controls;
candidate scoring, repair arbitration, and delivery thresholds;
private memory schemas and evolution policies;
sandbox, worktree, permission, and execution governance;
production observability and serving infrastructure;
full proprietary training data and data-construction pipelines;
internal benchmark routing and anti-overfitting controls.

The public model card describes what the system does, not the private mechanism by which every decision is implemented.

The public rule lineage and 14-rule contract are therefore a behavioral interface disclosure, not a release of the executable Harness. Attribution can be audited from the cited public sources without exposing security-sensitive implementation details.

Model Overview

Table with columns: Property, Value
Property	Value
Model family	VeriLoop Coder-E1
Developer	Libo Wang
Affiliation	Member, Intelligent Robotics Laboratory, Tsinghua Shenzhen International Graduate School (Tsinghua SIGS)
Backbone	Qwen3.6-27B-compatible backbone
Parameter class	27B backbone (<32B); additional PEFT-based Surface Host Adapters
Release status	Open-source model distribution under Apache License 2.0
System boundary	Open model weights and public artifacts; private production Self-Harness runtime
Core technical contribution	Self-Harness for governed evidence-loop execution

Recommended Use Cases

VeriLoop Coder-E1 is intended for:

repository understanding and codebase navigation;
bug localization and surgical repair;
patch drafting and validation;
cross-file API changes;
tool-mediated software-engineering agents;
terminal and automation tasks;
validator-aware repair workflows;
evidence-grounded coding assistance;
benchmark and evaluation research;
long-running engineering tasks requiring checkpoints and auditability.

Research Loading Example

The following example loads the distributed backbone artifacts. It does not reproduce the private production Harness.

python
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

repo_id = "tsinghua-sigs-robot-lab/veriloop-coder-e1"

tokenizer = AutoTokenizer.from_pretrained(
    repo_id,
    trust_remote_code=True,
)

model = AutoModelForCausalLM.from_pretrained(
    repo_id,
    torch_dtype=torch.bfloat16,
    device_map="auto",
    trust_remote_code=True,
)

messages = [
    {
        "role": "user",
        "content": (
            "Inspect the described failure, identify the smallest broken "
            "invariant, and return the requested code artifact."
        ),
    }
]

prompt = tokenizer.apply_chat_template(
    messages,
    tokenize=False,
    add_generation_prompt=True,
)

inputs = tokenizer(
    prompt,
    return_tensors="pt",
).to(model.device)

with torch.inference_mode():
    outputs = model.generate(
        **inputs,
        max_new_tokens=2048,
        temperature=0.2,
        top_p=0.9,
        do_sample=True,
    )

generated = outputs[0][inputs["input_ids"].shape[-1]:]
print(tokenizer.decode(generated, skip_special_tokens=True))

Load one published PEFT surface

python
import torch
from peft import PeftModel
from transformers import AutoModelForCausalLM, AutoTokenizer

repo_id = "tsinghua-sigs-robot-lab/veriloop-coder-e1"
adapter_subfolder = "surface_host_peft_evidence_binding_adapter/adapter"

tokenizer = AutoTokenizer.from_pretrained(
    repo_id,
    trust_remote_code=True,
)

base_model = AutoModelForCausalLM.from_pretrained(
    repo_id,
    torch_dtype=torch.bfloat16,
    device_map="auto",
    trust_remote_code=True,
)

model = PeftModel.from_pretrained(
    base_model,
    repo_id,
    subfolder=adapter_subfolder,
)

model.eval()

Available public Surface Host PEFT subfolders:

text
surface_host_peft_toolspec_adapter/adapter
surface_host_peft_uncertainty_adapter/adapter
surface_host_peft_rollback_adapter/adapter
surface_host_peft_evidence_binding_adapter/adapter

This loading pattern demonstrates external PEFT injection into the open model checkpoint. It loads one published behavioral surface; it does not reproduce the private Surface Host composition policy, Self-Harness orchestration, or runtime routing logic.

Limitations

The distributed backbone or a single adapter does not reproduce the complete VeriLoop Self-Harness system.
Coding outputs may still be incorrect, incomplete, insecure, or incompatible with the target environment.
Validation quality depends on available repository context, tests, tools, permissions, and execution environments.
Long-context operation requires appropriate accelerator memory and KV-cache planning.
External documentation and retrieved evidence may be stale, incomplete, or conflicting.
Safe stopping reduces unsupported delivery but cannot eliminate all false positives or false negatives.
Published evaluation evidence should be interpreted according to its stated verification status.

Safety and Responsible Use

Generated code should be treated as an engineering proposal until validated.

Recommended safeguards:

run generated code in isolated environments;
inspect shell commands and dependency changes before execution;
use tests, static analysis, security review, and repository-specific checks;
preserve rollback points for destructive operations;
require human review for high-impact or security-sensitive changes;
do not infer successful execution from plausible-looking output;
keep credentials, private repositories, and sensitive logs outside uncontrolled prompts.

Open-Source Release and Licensing

VeriLoop Coder-E1 is released as an open-source model under the Apache License 2.0.

The model weights and the original VeriLoop artifacts distributed in this repository may be used, reproduced, modified, redistributed, and deployed—including in commercial applications—provided that users comply with the Apache License 2.0 and preserve any required license and notice information.

This grant covers the public repository artifacts, including:

distributed model weights;
model configuration and tokenizer assets;
published Surface Host PEFT adapter artifacts;
original manifests and compatibility files released with the model;
original evaluation and traceability materials, except where a file states a different license.

Third-party components, upstream model materials, datasets, benchmark assets, and externally sourced content remain subject to their respective licenses and terms. Users are responsible for reviewing those notices when redistributing or deploying derived systems.

The open-source release does not include the private production Self-Harness implementation, internal prompts, orchestration code, evidence-routing logic, private training data, proprietary data-construction pipelines, or serving infrastructure unless those components are published separately under an explicit license.

The licensing boundary therefore follows the technical boundary:

text
Apache-2.0:
  open model weights + published repository artifacts
Not included unless separately released:
  private production Self-Harness and internal systems

Use of the open model or its published PEFT surfaces does not imply endorsement, certification, warranty, or support by VeriLoop Lab, Tsinghua University, or any affiliated organization. The software and model artifacts are provided under the terms and warranty limitations of the Apache License 2.0.

Citation

bibtex
@misc{veriloop_coder_e1_2026,
  title        = {VeriLoop Coder-E1: Evidence-Bound Self-Harness Loops for Recursive Software Engineering},
  author       = {Wang, Libo},
  year         = {2026},
  note         = {Developed by Libo Wang, member of the Intelligent Robotics Laboratory, Tsinghua Shenzhen International Graduate School (Tsinghua SIGS)},
  howpublished = {Hugging Face model repository},
  url          = {https://huggingface.co/tsinghua-sigs-robot-lab/veriloop-coder-e1}
}

Acknowledgements

VeriLoop Coder-E1 builds on a Qwen3.6-27B-compatible foundation and the broader open machine-learning tooling ecosystem.

The public Harness discipline acknowledges:

Andrej Karpathy, whose public observations identified recurring coding-agent failure modes;
Forrest Chang, who operationalized those observations into the compact four-principle andrej-karpathy-skills repository;
Mnilax, who published eight additional agent-era rules in May 2026;
the communities behind Transformers, PEFT, Safetensors, vLLM, software-engineering benchmarks, repository-level evaluation, and reproducible model deployment.

VeriLoop's 14-rule contract is a materially adapted public technology layer of the Self-Harness. The proprietary orchestration, prompts, routing, scoring, memory, training systems, and production controls remain private.

A Note from the Author

To quote the great former two-time UFC Middleweight Champion Israel Adesanya: “Hey, shush! Listen up! I want to say something! People! Earth! I need to say something! Listen to me. I hope every one of you behind the screens or in this arena can feel this level of happiness, just one time in your life.” There are no saints in this world; anyone who presents themselves as one is either deceiving themselves or deceiving everyone else. I never intended to deliver some polished, self-righteous statement in the hope of becoming anyone’s role model, nor did I undertake this work to prove myself to anyone. I am not that noble, and I have no desire to pretend otherwise. I simply want to say a few things that come from the heart. Unfairness and bullying are not confined to the pursuit of scientific discovery in AI; they can happen anywhere, and sometimes they arrive at the very moment when your passion is at its highest. When a person is subjected to injustice, humiliation, ridicule, contempt, and relentless attempts to reduce them to nothing by the HR team of a world-renowned AI organization, the only response left may be to fight, fight, fight. Simple things do not need to be made complicated. Once you have made the decision to begin, never, ever, ever give up. Look at how I was treated: a Doctor of Business Administration graduate from a university in Malaysia, an unconventional outsider researcher who, at the beginning, could not even write code, yet was mocked, attacked, treated unfairly, and regarded as someone who was not even qualified to work on large language models. So let me say the part that is most honest and most faithful to what I truly feel: FUCK YOU, DEEPSEEK HR TEAM. YOU CUNTS. I am not saying this because I need your approval, your apology, or your attention; I am saying it because disguising what happened beneath polite language would be dishonest. I proved through facts that even with such a background, persistence combined with vibe coding can still produce real results, because choice can matter more than effort, and an original idea can matter more than coding alone. Effort and engineering remain essential, but effort without the right direction can be wasted, and code without an idea is only execution without purpose. Every person is given only one life, and I will not allow critics, rejection, ridicule, or the people who denied my ability to obstruct me on the road toward the goals I have chosen. I will not submit, I will not be consumed by anxiety, I will not retreat, and I will not waste my energy destroying myself from within over the judgment of people who never understood me in the first place. I do not need to reshape myself into someone more obedient, more agreeable, or easier to approve of, and I will never abandon my personality merely to be liked or accepted. The fault lies with those who choose prejudice, humiliation, and contempt; I refuse to carry their ugliness inside me, because my life, my identity, and my happiness belong to me. Never stop doing what you believe is right, because every great achievement is destined to pass through hardship, resistance, failure, ridicule, and moments when almost no one believes in the path you have chosen. People have given a special name to the way of life in which a person defeats adversity, refuses to be broken by it, remains true to themselves, and continues moving forward. That name is .

— Libo Wang

Available on FriendliAI

Dedicated Endpoints

Run this model inference on single tenant GPU with unmatched speed and reliability at scale.

Learn more

Model Details

Model Provider