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