README.md

---
library_name: transformers
pipeline_tag: text-generation
license: apache-2.0
license_link: https://huggingface.co/Qwen/Qwen3.6-27B/blob/main/LICENSE
base_model:
  - Qwen/Qwen3.6-27B
base_model_relation: finetune
language:
  - en
  - zh
tags:
  - veriloop
  - veriloop-coder
  - code
  - coding-agent
  - software-engineering
  - repository-understanding
  - tool-use
  - peft
  - lora
  - safetensors
  - harness-engineering
  - evidence-binding
  - rollback
  - uncertainty-calibration
  - long-context
  - open-weights
---

# VeriLoop Coder-E1

**VeriLoop Coder-E1** is an open-weight coding model release built for harness-ready software engineering workflows. It combines a Qwen3.6-27B-compatible backbone with four focused public PEFT adapters designed to shape coding-agent behavior around tool discipline, evidence awareness, rollback-safe revision, and uncertainty-calibrated decision signals.

This repository is the **public standard release** of VeriLoop Coder-E1. It provides clean Hugging Face-compatible model artifacts for research, evaluation, and downstream experimentation while keeping private production runtime components, training data, and server-side orchestration logic out of the public package.

> **Release status**
>
> This is the first public VeriLoop Coder-E1 27B release package. Formal benchmark results will be added after the dedicated evaluation run. Until then, this model card should be read as a release description and loading guide, not as a leaderboard claim.

---

## Highlights

VeriLoop Coder-E1 is designed for coding-agent environments where a model must operate with repository context, tool calls, validation feedback, and iterative repair loops.

- **Harness-ready coding behavior** — optimized for systems that coordinate model generation with tools, validators, execution feedback, and bounded repair loops.
- **Tool-spec alignment** — improves response patterns around tool schemas, argument discipline, preconditions, postconditions, and execution-facing instruction formats.
- **Evidence-bound coding style** — encourages tighter alignment between claims, code edits, validation signals, and supporting repository context.
- **Rollback-aware revision behavior** — strengthens behavior around failed edits, validator negation, worktree-sensitive repair, and safe correction boundaries.
- **Uncertainty-calibrated routing signals** — supports better control decisions around answer uncertainty, evidence gaps, execution necessity, specification mismatch, and risk pressure.
- **Repository-scale workflow orientation** — intended for code understanding, patch drafting, debugging, refactoring assistance, and agentic software-engineering experiments.
- **Standard open artifacts** — released with sharded `safetensors` backbone weights and PEFT-compatible adapter checkpoints.

VeriLoop Coder-E1 should be understood as a **coding model foundation for harness-centric systems**. The full VeriLoop product experience may involve additional private runtime components such as tool orchestration, sandbox validation, evidence handling, memory, observability, and API-side routing.

---

## Model Overview

| Property | Value |
|---|---|
| Model family | VeriLoop Coder-E1 |
| Backbone | Qwen3.6-27B-compatible backbone |
| Public release type | Open-weight backbone + four public PEFT adapters |
| Primary domain | Coding, software engineering, coding-agent workflows |
| Languages | English, Chinese |
| Weight format | `safetensors` |
| Adapter format | PEFT / LoRA-style adapter checkpoints |
| Runtime target | Harness-driven coding systems, tool-mediated agents, repository workflows |
| Public benchmark status | Formal benchmark results pending |

The public release separates standard model assets from private production runtime infrastructure. Users can load the backbone directly, or mount one public PEFT adapter at a time for targeted experiments.

---

## Public Release Contents

### Included

- Qwen3.6-27B-compatible backbone files in the repository root.
- Standard sharded `safetensors` model weights.
- Tokenizer, generation, and configuration files.
- Four public PEFT adapter folders:
  - `toolspec_adapter/adapter`
  - `uncertainty_adapter/adapter`
  - `rollback_adapter/adapter`
  - `evidence_adapter/adapter`
- Public adapter README files, metric summaries, and public adapter manifests.

### Not Included

- Private runtime heads.
- Internal Harness orchestration code.
- Training JSONL files and evaluation JSONL files.
- Internal logs, checkpoints, optimizer states, and scheduler states.
- Private routing, sandbox, memory, evidence-gate, or production-serving logic.

This separation is intentional: the repository provides standard open model assets, while production-grade coding-agent behavior may require a full runtime system around the model.

---

## Adapter Overview

| Adapter | Folder | Public files | Role |
|---|---|---|---|
| ToolSpec | `toolspec_adapter/adapter` | `adapter_config.json`, `adapter_model.safetensors` | Tool-call discipline, schema obedience, precondition/postcondition sensitivity |
| Uncertainty | `uncertainty_adapter/adapter` | `adapter_config.json`, `adapter_model.safetensors` | Runtime uncertainty calibration across answer, evidence, execution, specification, and risk signals |
| Rollback | `rollback_adapter/adapter` | `adapter_config.json`, `adapter_model.safetensors` | Validator-aware repair behavior, rollback discipline, bounded revision control |
| Evidence Binding | `evidence_adapter/adapter` | `adapter_config.json`, `adapter_model.safetensors` | Stronger alignment between claims, evidence, provenance, and validation context |

Each adapter is published independently. For standard PEFT loading, use one adapter at a time unless your runtime explicitly implements adapter composition or routing.

---

## Quickstart

### Install

```bash
pip install -U transformers peft accelerate safetensors
```

### Load the Backbone

```python
from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

repo_id = "veriloop-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,
)

model.eval()
```

### Load One Public PEFT Adapter

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

repo_id = "veriloop-lab/veriloop-coder-e1"
adapter_subfolder = "evidence_adapter/adapter"  # choose one public 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 adapter subfolders:

```text
toolspec_adapter/adapter
uncertainty_adapter/adapter
rollback_adapter/adapter
evidence_adapter/adapter
```

### Minimal Generation Example

```python
prompt = "Write a Python function that validates whether a patch should be accepted after unit tests."

messages = [
    {"role": "user", "content": prompt},
]

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

inputs = tokenizer(text, return_tensors="pt").to(model.device)
outputs = model.generate(
    **inputs,
    max_new_tokens=1024,
    temperature=0.6,
    top_p=0.95,
    do_sample=True,
)

print(tokenizer.decode(outputs[0], skip_special_tokens=True))
```

---

## Serving Notes

The repository root contains the backbone model files and can be served with standard inference engines that support the underlying architecture. PEFT adapters may require framework-specific LoRA loading support.

### vLLM Backbone Serving

```bash
vllm serve veriloop-lab/veriloop-coder-e1 \
  --trust-remote-code \
  --tensor-parallel-size 2 \
  --max-model-len 131072
```

For public PEFT adapters, use the serving engine's LoRA/adapter loading mechanism if supported by your deployment configuration. The full VeriLoop production setup may use additional private runtime components that are not part of this public release.

---

## Recommended Use Cases

VeriLoop Coder-E1 is intended for research and development in:

- Coding-agent model evaluation.
- Tool-mediated code generation.
- Repository understanding and patch drafting.
- Validator-aware repair experiments.
- Evidence-aware coding workflows.
- Uncertainty-aware software-engineering agents.
- Harness and runtime policy research.

---

## Limitations

- Public benchmark numbers are not yet included in this release and will be added after formal evaluation.
- The public repository does not include private runtime heads or internal Harness orchestration.
- Public adapter loading does not reproduce the complete VeriLoop production API behavior.
- Long-context and high-throughput serving require appropriate GPU memory, KV-cache planning, and inference-engine configuration.
- Users should validate generated code with tests, static analysis, sandboxing, and security review before deployment.

---

## Safety and Responsible Use

VeriLoop Coder-E1 is a coding-focused model and may produce incorrect, insecure, incomplete, or environment-specific code. Users are responsible for validating outputs before use.

Recommended safeguards include:

- Run generated code in isolated environments.
- Review dependencies and shell commands before execution.
- Use automated tests and linters.
- Treat security-sensitive code paths as high risk.
- Avoid using generated code for destructive actions without human review.

---

## File Layout

```text
README.md
config.json
configuration.json
model.safetensors.index.json
veriloop-coder-e1-model-00001-of-00010.safetensors
...
veriloop-coder-e1-model-00010-of-00010.safetensors
tokenizer.json
tokenizer_config.json
generation_config.json
special_tokens_map.json

toolspec_adapter/
  README.md
  metrics_summary.json
  veriloop_adapter_manifest.json
  adapter/
    README.md
    adapter_config.json
    adapter_model.safetensors

uncertainty_adapter/
  README.md
  metrics_summary.json
  veriloop_adapter_manifest.json
  adapter/
    README.md
    adapter_config.json
    adapter_model.safetensors

rollback_adapter/
  README.md
  metrics_summary.json
  veriloop_adapter_manifest.json
  adapter/
    README.md
    adapter_config.json
    adapter_model.safetensors

evidence_adapter/
  README.md
  metrics_summary.json
  veriloop_adapter_manifest.json
  adapter/
    README.md
    adapter_config.json
    adapter_model.safetensors
```

---

## Evaluation Status

Formal benchmark results are planned. Future updates may include coding-agent benchmarks, repository-level tasks, tool-use evaluations, validation/rollback tests, and long-context software-engineering workflows.

Until benchmark numbers are published, this model card should be interpreted as a release description and loading guide, not as a performance leaderboard claim.

---

## Citation

If you use VeriLoop Coder-E1 in research, prototypes, or agent systems, please cite:

```bibtex
@misc{veriloop_coder_e1_2026,
  title        = {VeriLoop Coder-E1: Harness-Ready Open-Weight Coding Model Release},
  author       = {VeriLoop Lab},
  year         = {2026},
  howpublished = {Hugging Face model repository},
  url          = {https://huggingface.co/veriloop-lab/veriloop-coder-e1}
}
```

---

## Acknowledgements

VeriLoop Coder-E1 is built on top of the Qwen3.6-27B open-weight backbone. We thank the open-source model and tooling communities for enabling reproducible model development, adapter-based experimentation, and open deployment workflows.