Instructions to use veriloop-lab/veriloop-coder-e1 with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use veriloop-lab/veriloop-coder-e1 with Transformers:

# Use a pipeline as a high-level helper
from transformers import pipeline

pipe = pipeline("text-generation", model="veriloop-lab/veriloop-coder-e1")
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/p-blog/candy.JPG"},
            {"type": "text", "text": "What animal is on the candy?"}
        ]
    },
]
pipe(text=messages)

# Load model directly
from transformers import AutoProcessor, AutoModelForImageTextToText

processor = AutoProcessor.from_pretrained("veriloop-lab/veriloop-coder-e1")
model = AutoModelForImageTextToText.from_pretrained("veriloop-lab/veriloop-coder-e1")
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/p-blog/candy.JPG"},
            {"type": "text", "text": "What animal is on the candy?"}
        ]
    },
]
inputs = processor.apply_chat_template(
	messages,
	add_generation_prompt=True,
	tokenize=True,
	return_dict=True,
	return_tensors="pt",
).to(model.device)

outputs = model.generate(**inputs, max_new_tokens=40)
print(processor.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

PEFT
How to use veriloop-lab/veriloop-coder-e1 with PEFT:
```
Task type is invalid.
```
Notebooks
Google Colab
Kaggle
Local Apps

vLLM

How to use veriloop-lab/veriloop-coder-e1 with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "veriloop-lab/veriloop-coder-e1"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "veriloop-lab/veriloop-coder-e1",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker

docker model run hf.co/veriloop-lab/veriloop-coder-e1

SGLang

How to use veriloop-lab/veriloop-coder-e1 with SGLang:

Install from pip and serve model

# Install SGLang from pip:
pip install sglang
# Start the SGLang server:
python3 -m sglang.launch_server \
    --model-path "veriloop-lab/veriloop-coder-e1" \
    --host 0.0.0.0 \
    --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "veriloop-lab/veriloop-coder-e1",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker images

docker run --gpus all \
    --shm-size 32g \
    -p 30000:30000 \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HF_TOKEN=<secret>" \
    --ipc=host \
    lmsysorg/sglang:latest \
    python3 -m sglang.launch_server \
        --model-path "veriloop-lab/veriloop-coder-e1" \
        --host 0.0.0.0 \
        --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "veriloop-lab/veriloop-coder-e1",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Docker Model Runner
How to use veriloop-lab/veriloop-coder-e1 with Docker Model Runner:
```
docker model run hf.co/veriloop-lab/veriloop-coder-e1
```

veriloop-coder-e1 / README.md

ConorWang

Upload README.md

97d4f9f verified 17 days ago

12 kB

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:
  - qwen3_6
  - qwen3
  - qwen
  - veriloop
  - veriloop-coder
  - code
  - coding-agent
  - agentic-coding
  - software-engineering
  - repository-understanding
  - tool-use
  - peft
  - lora
  - safetensors
  - transformers
  - harness-engineering
  - evidence-binding
  - rollback
  - uncertainty-calibration
  - long-context
  - open-weights
  - reasoning
  - conversational

VeriLoop Coder-E1

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

The public release provides a standard, Hugging Face-compatible model package: sharded safetensors backbone weights in the repository root, plus four focused PEFT adapters for coding-agent behavior shaping. It is designed for developers and researchers who want a coding model that is not only fluent at code generation, but also better prepared for tool-mediated execution, evidence-aware reasoning, rollback-safe revision, and uncertainty-calibrated coding workflows.

Release note
This is the first public VeriLoop Coder-E1 27B release package. Public benchmark results will be added after the formal evaluation run. The current repository focuses on releasing clean, standard model artifacts without exposing internal production Harness code, private runtime heads, training data, or server-side orchestration logic.

Highlights

VeriLoop Coder-E1 is built for coding-agent environments where a model must cooperate with external tools, validators, repository context, and iterative repair loops.

Harness-ready coding behavior — shaped for coding runtimes that use tool calls, validation feedback, staged execution, and bounded repair loops.
Tool-spec alignment — improves obedience to tool schemas, argument discipline, preconditions, postconditions, and execution-facing instruction formats.
Evidence-bound coding style — encourages stronger alignment between claims, code edits, validation signals, and supporting repository context.
Rollback-aware revision behavior — improves response patterns around failed edits, validator negation, worktree-sensitive repair, and safe correction boundaries.
Uncertainty-calibrated routing signals — supports more reliable 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 tasks.
Open standard artifacts — released with safetensors model shards and PEFT-compatible adapter checkpoints for public loading and reproducible experimentation.

VeriLoop Coder-E1 should be viewed as a coding model foundation for harness-centric systems. The full VeriLoop product experience may involve additional 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 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 base model directly, or mount one of the four public PEFT adapters for targeted experimentation.

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 adapters:
- toolspec_adapter/adapter
- uncertainty_adapter/adapter
- rollback_adapter/adapter
- evidence_adapter/adapter
Public adapter README files, metric summaries, and 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 public 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. Users can load one adapter at a time for focused evaluation, or build their own adapter-selection policy around the public artifacts.

Quickstart

Install

pip install -U transformers peft accelerate safetensors

Load the Backbone

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

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

toolspec_adapter/adapter
uncertainty_adapter/adapter
rollback_adapter/adapter
evidence_adapter/adapter

Minimal Generation Example

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

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

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:

@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.