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

23bfcd7 verified 17 days ago

12.8 kB

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:

Backbone weights in the repository root, stored in standard safetensors sharded format.
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

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

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

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:

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

Generate

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:

Serve the backbone model from the repository root.
Mount one VeriLoop PEFT adapter as a LoRA module.
Route requests to the adapter that matches the task profile.
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:

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

A full production coding-agent stack may additionally include:

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

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:

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