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

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

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

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.

Downloads last month: 2,822

Safetensors

Model size

28B params

Tensor type

BF16

Model tree for veriloop-lab/veriloop-coder-e1

Base model

Qwen/Qwen3.6-27B

Finetuned

(91)

this model