README.md

---
library_name: transformers
pipeline_tag: text-generation
license: other
base_model:
  - Qwen/Qwen3.6-27B
language:
  - en
tags:
  - safetensors
  - qwen3_6
  - qwen
  - code
  - coding-agent
  - software-engineering
  - harness-engineering
  - agentic-coding
  - repository-understanding
  - tool-use
  - evidence-binding
  - rollback
  - uncertainty-calibration
  - veriloop
  - weight-agnostic
---

# VeriLoop Coder-E1

**VeriLoop Coder-E1** is an open-weight coding model release built on a Qwen3.6-27B backbone and aligned for harness-driven software engineering workflows.

This release is designed for developers and researchers who want a coding model that is not only fluent at code generation, but also more prepared for tool-mediated, evidence-aware, rollback-safe, and uncertainty-calibrated coding pipelines.

VeriLoop Coder-E1 is released as a two-layer public package:

1. **Backbone weights** in the repository root, stored in standard `safetensors` sharded format.
2. **Four public PEFT adapters** for coding-agent behavior shaping:
   - `toolspec_adapter/adapter`
   - `uncertainty_adapter/adapter`
   - `rollback_adapter/adapter`
   - `evidence_adapter/adapter`

The public release follows the standard Hugging Face / PEFT adapter format. Internal production runtime components, private runtime heads, training data, logs, and orchestration code are not included in this public model card.

---

## Highlights

VeriLoop Coder-E1 is optimized for coding-agent workloads where a model must interact with tools, interpret validation signals, manage uncertain states, and produce safer revisions under runtime constraints.

Key capability directions include:

- **Harness-ready coding behavior** — trained to operate cleanly inside external coding runtimes, validators, tool routers, and repair loops.
- **Tool-spec awareness** — improves obedience to tool-call schemas, preconditions, postconditions, and execution-facing instruction formats.
- **Evidence-bound reasoning style** — encourages stronger alignment between claims, code changes, validation signals, and supporting context.
- **Rollback and revision discipline** — improves behavior around failed edits, validator feedback, worktree-sensitive repairs, and bounded correction loops.
- **Uncertainty calibration** — improves routing signals for answer uncertainty, evidence gaps, execution necessity, specification mismatch, and risk pressure.
- **Repository-scale workflow orientation** — intended for code understanding, patch drafting, iterative debugging, and agentic software engineering tasks.
- **Open standard artifacts** — released with `safetensors` backbone weights and PEFT-compatible adapter checkpoints for reproducible public loading.

VeriLoop Coder-E1 should be viewed as a **coding model foundation for harness-centric systems**, not as a complete hosted agent product by itself.

---

## Release Scope

### Included in this public release

- Qwen3.6-27B-compatible model files in the repository root.
- Standard `safetensors` model shards.
- Tokenizer and generation configuration files.
- Four public PEFT adapters:
  - ToolSpec adapter
  - Uncertainty adapter
  - Rollback adapter
  - Evidence Binding adapter
- Public adapter manifests and metric summaries.

### Not included in this public release

- 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 public repository provides standard model assets, while production-grade agent behavior may require a full runtime system around the model.

---

## Model Overview

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

The backbone inherits the long-context and coding-oriented capabilities of Qwen3.6-27B. The VeriLoop release adds four focused public adapters for agentic coding alignment, while keeping the public artifact format compatible with standard Hugging Face tooling.

---

## Adapter Overview

| Adapter | Folder | Public files | Role |
|---|---|---|---|
| ToolSpec | `toolspec_adapter/adapter` | `adapter_config.json`, `adapter_model.safetensors` | Tool-call discipline, schema obedience, pre/postcondition sensitivity |
| Uncertainty | `uncertainty_adapter/adapter` | `adapter_config.json`, `adapter_model.safetensors` | Runtime uncertainty calibration across answer, evidence, execution, spec, 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. Users can load one adapter at a time for focused experimentation, or build their own runtime policy for adapter selection and orchestration.

---

## Quickstart

### Install

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

For large-model inference, use an environment with adequate GPU memory and recent versions of `transformers`, `peft`, and `accelerate`.

### 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 a public VeriLoop adapter

```python
from peft import PeftModel

repo_id = "veriloop-lab/veriloop-coder-e1"

model = PeftModel.from_pretrained(
    model,
    repo_id,
    subfolder="evidence_adapter/adapter",
)

model.eval()
```

Available adapter subfolders:

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

### Generate

```python
prompt = "Write a robust Python function that validates and normalizes a repository file path. Include a minimal self-test."

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

inputs = tokenizer.apply_chat_template(
    messages,
    add_generation_prompt=True,
    return_tensors="pt",
).to(model.device)

outputs = model.generate(
    inputs,
    max_new_tokens=2048,
    do_sample=False,
)

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

---

## vLLM / Serving Notes

The backbone can be served as a standard Hugging Face model in inference engines that support the underlying architecture.

For LoRA adapter serving, use a serving runtime that supports PEFT/LoRA adapters and point it to one of the adapter folders after downloading the repository snapshot locally. Exact command-line flags may vary by vLLM version.

A typical deployment pattern is:

1. Serve the backbone model from the repository root.
2. Mount one VeriLoop PEFT adapter as a LoRA module.
3. Route requests to the adapter that matches the task profile.
4. For production coding agents, add external validation, sandboxing, and tool orchestration outside the model.

---

## Recommended Use Cases

VeriLoop Coder-E1 is intended for:

- Repository understanding and codebase navigation.
- Patch drafting and bounded code revision.
- Tool-mediated coding workflows.
- Validator-aware debugging loops.
- Evidence-aware code explanation.
- Coding-agent research and runtime integration.
- Experiments with uncertainty-aware code generation.

It is especially suitable for users building coding systems where the model is paired with an external runtime, tool layer, validator, or repository-aware workflow.

---

## Limitations

This public release is not a full hosted coding agent. It does not include VeriLoop's private production runtime, private custom heads, sandbox execution system, memory service, evidence gateway, or internal orchestration policies.

Important limitations:

- The public adapters provide model-level alignment signals, not a complete execution environment.
- Users should validate generated code before using it in production.
- Repository-scale behavior depends heavily on retrieval, context construction, and tool execution outside the model.
- Adapter composition should be tested carefully; do not assume that naively merging or stacking all adapters is optimal for every task.
- Public benchmark results for this release will be updated after standardized external evaluation.

---

## Evaluation Status

Public benchmark results are not yet included in this release.

The current repository is a public model-asset release focused on:

- Standard weight availability.
- Adapter availability.
- Reproducible loading.
- Harness-oriented coding model alignment.

External leaderboard and benchmark results will be added after controlled evaluation on standardized coding and agentic software-engineering benchmarks.

---

## Safety and Responsible Use

VeriLoop Coder-E1 is a coding-oriented model and may generate incorrect, insecure, incomplete, or harmful code if used without validation.

Recommended safeguards:

- Run generated code in a sandbox before execution on real systems.
- Review file-system, network, credential, and destructive-operation behavior.
- Use static analysis and unit tests for generated patches.
- Do not grant unrestricted shell, repository, or deployment permissions without external policy checks.
- Treat the model as an assistant for software engineering, not as an autonomous authority.

For high-risk environments, deploy VeriLoop Coder-E1 behind explicit permission controls, audit logging, validation gates, and rollback procedures.

---

## Public vs. Production Capability

This Hugging Face repository provides the **public standard model layer**:

```text
27B backbone weights
+ four public PEFT adapters
+ public adapter manifests
```

A full production coding-agent stack may additionally include:

```text
runtime orchestration
sandbox validation
evidence management
memory/context systems
self-check and repair loops
policy gates
observability
external expert routing
```

The public model is useful on its own for research and development. The strongest production behavior is expected when the model is integrated into a robust coding-agent runtime.

---

## File Layout

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

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
```

---

## Citation

If you use VeriLoop Coder-E1 in your work, please cite this repository:

```bibtex
@misc{veriloop_coder_e1_2026,
  title        = {VeriLoop Coder-E1: Harness-Aligned Open-Weight Coding Model},
  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 model family. We thank the open-source model ecosystem, the Hugging Face community, and the broader coding-agent research community for making reproducible model development possible.

---

## License

This repository includes model assets derived from an upstream open-weight backbone and VeriLoop adapter artifacts. Users are responsible for complying with the upstream base-model license and any applicable VeriLoop release terms described in this repository.