Instructions to use RedHatAI/OmniCoder-9B-FP8-Dynamic with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use RedHatAI/OmniCoder-9B-FP8-Dynamic with Transformers:

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

pipe = pipeline("text-generation", model="RedHatAI/OmniCoder-9B-FP8-Dynamic")
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)

# pip install -U transformers accelerate
# Load model directly
from transformers import AutoProcessor, AutoModelForMultimodalLM

processor = AutoProcessor.from_pretrained("RedHatAI/OmniCoder-9B-FP8-Dynamic")
model = AutoModelForMultimodalLM.from_pretrained("RedHatAI/OmniCoder-9B-FP8-Dynamic", device_map="auto")
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=256)
print(processor.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use RedHatAI/OmniCoder-9B-FP8-Dynamic with vLLM:

Install from pip and serve model

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

Use Docker

docker model run hf.co/RedHatAI/OmniCoder-9B-FP8-Dynamic

SGLang

How to use RedHatAI/OmniCoder-9B-FP8-Dynamic 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 "RedHatAI/OmniCoder-9B-FP8-Dynamic" \
    --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": "RedHatAI/OmniCoder-9B-FP8-Dynamic",
		"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 "RedHatAI/OmniCoder-9B-FP8-Dynamic" \
        --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": "RedHatAI/OmniCoder-9B-FP8-Dynamic",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Docker Model Runner
How to use RedHatAI/OmniCoder-9B-FP8-Dynamic with Docker Model Runner:
```
docker model run hf.co/RedHatAI/OmniCoder-9B-FP8-Dynamic
```

alexmarques commited on May 29

Commit

3d700a9

verified ·

1 Parent(s): dc17f56

Update README.md

Browse files

Files changed (1) hide show

README.md +290 -170

README.md CHANGED Viewed

@@ -1,227 +1,347 @@
 ---
 library_name: transformers
-base_model: Qwen/Qwen3.5-9B
-tags:
-  - qwen3.5
-  - code
-  - agent
-  - sft
-  - omnicoder
-  - tesslate
 license: apache-2.0
 language:
-  - en
 pipeline_tag: text-generation
-model-index:
-  - name: OmniCoder-9B
-    results:
-      - task:
-          type: text-generation
-        dataset:
-          name: AIME 2025
-          type: custom
-        metrics:
-          - name: pass@5
-            type: accuracy
-            value: 90.0
-      - task:
-          type: text-generation
-        dataset:
-          name: GPQA Diamond
-          type: custom
-        metrics:
-          - name: pass@1
-            type: accuracy
-            value: 83.8
-          - name: pass@3
-            type: accuracy
-            value: 86.4
-      - task:
-          type: text-generation
-        dataset:
-          name: Terminal-Bench 2.0
-          type: custom
-        metrics:
-          - name: Pass Rate
-            type: accuracy
-            value: 28.1
----
-<div align="center">
-<img src="omnicoder-banner.png" alt="OmniCoder" width="720">
-# OmniCoder-9B
-### A 9B coding agent fine-tuned on 425K agentic trajectories.
-[![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
-[![Base Model](https://img.shields.io/badge/Base-Qwen3.5--9B-purple)](https://huggingface.co/Qwen/Qwen3.5-9B)
-[![GGUF](https://img.shields.io/badge/GGUF-Available-green)](https://huggingface.co/Tesslate/OmniCoder-9B-GGUF)
-!! 3/12/26 Update -> [Install For Your Coding Agents](https://tesslate.com/install#omnicoder)
-[Get Started](#quickstart) | [Benchmarks](#benchmarks) | [GGUF Downloads](https://huggingface.co/Tesslate/OmniCoder-9B-GGUF)
 ---
-</div>
-## Overview
-**OmniCoder-9B** is a 9-billion parameter coding agent model built by [Tesslate](https://tesslate.com), fine-tuned on top of [Qwen3.5-9B](https://huggingface.co/Qwen/Qwen3.5-9B)'s hybrid architecture (Gated Delta Networks interleaved with standard attention). It was trained on **425,000+ curated agentic coding trajectories** spanning real-world software engineering tasks, tool use, terminal operations, and multi-step reasoning.
-The training data was specifically built from **Claude Opus 4.6 agentic and coding reasoning traces**, targeting scaffolding patterns from Claude Code, OpenCode, Codex, and Droid. The dataset includes successful trajectories from models like Claude Opus 4.6, GPT-5.4, GPT-5.3-Codex, and Gemini 3.1 Pro.
-The model shows strong agentic behavior: it recovers from errors (read-before-write), responds to LSP diagnostics, and uses proper edit diffs instead of full rewrites. These patterns were learned directly from the real-world agent trajectories it was trained on.
-### Key Features
-- **Trained on Frontier Agent Traces** : Built from Claude Opus 4.6, GPT-5.3-Codex, GPT-5.4, and Gemini 3.1 Pro agentic coding trajectories across Claude Code, OpenCode, Codex, and Droid scaffolding
-- **Hybrid Architecture** : Inherits Qwen3.5's Gated Delta Networks interleaved with standard attention for efficient long-context processing
-- **262K Native Context** : Full 262,144 token context window, extensible to 1M+
-- **Error Recovery** : Learns read-before-write patterns, responds to LSP diagnostics, and applies minimal edit diffs instead of full rewrites
-- **Thinking Mode** : Supports `<think>...</think>` reasoning chains for complex problem decomposition
-- **Apache 2.0** : Fully open weights, no restrictions
----
-## Benchmarks
-<div align="center">
-| Benchmark | **OmniCoder-9B** | Qwen3.5-9B | Qwen3-Next-80B | GPT-OSS-120B | GPT-OSS-20B | GLM-4.7-Flash | GLM 4.7 | Claude Haiku 4.5 |
-|:---|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
-| **AIME 2025** (pass@5) | 90 | | | | 91.7 | 91.6 | | |
-| **GPQA Diamond** (pass@1) | **83.8** | 81.7 | 77.2 | 80.1 | 71.5 | | | 73 |
-| **GPQA Diamond** (pass@3) | **86.4** | | | | | | | |
-| **Terminal-Bench 2.0** | **23.6** | 14.6 | | | | | 33.4 | 27 |
-</div>
-- **GPQA Diamond pass@1: 83.8%** (166/198). +2.1 points over the Qwen3.5-9B base model (81.7). At pass@3: **86.4** (171/198).
-- **AIME 2025 pass@5: 90%** (27/30).
-- **Terminal-Bench 2.0: 23.6%** (21/89). +8.99 points (+61% improvement) over the Qwen3.5-9B base model (14.6%, 13/89).
----
-## Quickstart
-### Transformers
 ```python
-from transformers import AutoModelForCausalLM, AutoTokenizer
-model_id = "Tesslate/OmniCoder-9B"
-tokenizer = AutoTokenizer.from_pretrained(model_id)
-model = AutoModelForCausalLM.from_pretrained(model_id, torch_dtype="auto", device_map="auto")
 messages = [
-    {"role": "system", "content": "You are a helpful coding assistant."},
-    {"role": "user", "content": "Write a Python function to find the longest common subsequence of two strings."},
 ]
-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=2048, temperature=0.6, top_p=0.95, top_k=20)
-print(tokenizer.decode(outputs[0][inputs.input_ids.shape[-1]:], skip_special_tokens=True))
 ```
-### vLLM
-```bash
-vllm serve Tesslate/OmniCoder-9B --tensor-parallel-size 1 --max-model-len 65536
-```
-```python
-from openai import OpenAI
-client = OpenAI(base_url="http://localhost:8000/v1", api_key="token")
-response = client.chat.completions.create(
-    model="Tesslate/OmniCoder-9B",
-    messages=[{"role": "user", "content": "Explain the difference between a mutex and a semaphore."}],
-    temperature=0.6,
 )
-print(response.choices[0].message.content)
-```
-### llama.cpp (GGUF)
-```bash
-llama-cli --hf-repo Tesslate/OmniCoder-9B-GGUF --hf-file omnicoder-9b-q4_k_m.gguf -p "Your prompt" -c 8192
 ```
-All quantizations: [Tesslate/OmniCoder-9B-GGUF](https://huggingface.co/Tesslate/OmniCoder-9B-GGUF)
----
-## Training Details
-| | |
-|:---|:---|
-| **Base Model** | [Qwen3.5-9B](https://huggingface.co/Qwen/Qwen3.5-9B) |
-| **Method** | LoRA SFT (r=64, alpha=32) |
-| **Dataset** | 425K agentic trajectories from 5 sources |
-| **Packing** | Sample packing with 99.35% efficiency |
-| **Hardware** | 4x NVIDIA H200 (DDP) |
-| **Framework** | Axolotl |
-| **Precision** | bf16 |
-| **Optimizer** | AdamW (lr=2e-4, cosine schedule) |
----
-## Architecture
-OmniCoder inherits Qwen3.5-9B's hybrid architecture:
-- **Gated Delta Networks** : Linear attention layers interleaved with standard attention for efficient long-range dependencies
-- **VLM Backbone** : Built on `Qwen3_5ForConditionalGeneration`
----
-## Recommended Sampling Parameters
-| Parameter | Value |
-|:---|:---|
-| Temperature | 0.6 |
-| Top-P | 0.95 |
-| Top-K | 20 |
-| Presence Penalty | 0.0 |
-For agentic / tool-calling tasks, consider lower temperature (0.2-0.4) for more deterministic behavior.
----
-## Limitations
-- Performance on non-English tasks has not been extensively evaluated
-- Tool-calling format is flexible but works best with the scaffolding patterns seen in training
----
-## Acknowledgments
-Special thanks to the [Axolotl](https://github.com/axolotl-ai-cloud/axolotl) team and the discussion in [axolotl#3453](https://github.com/axolotl-ai-cloud/axolotl/issues/3453) for helping get Qwen3.5 packing support working.
----
-## Citation
-```bibtex
-@misc{omnicoder2025,
-  title={OmniCoder-9B: A Frontier Open Coding Agent},
-  author={Tesslate},
-  year={2025},
-  url={https://huggingface.co/Tesslate/OmniCoder-9B}
-}
 ```
----
-<div align="center">
-**Built by [Tesslate](https://tesslate.com)**
-</div>

 ---
 library_name: transformers
 license: apache-2.0
 language:
+- en
 pipeline_tag: text-generation
+tags:
+- fp8
+- vllm
+- llm-compressor
+- compressed-tensors
+- qwen3.5
+- code
+- agent
+- sft
+- omnicoder
+- tesslate
+base_model: Tesslate/OmniCoder-9B
 ---
+# OmniCoder-9B-FP8-Dynamic
+## Model Overview
+- **Model Architecture:** Qwen3_5ForConditionalGeneration
+  - **Input:** Text
+  - **Output:** Text
+- **Model Optimizations:**
+  - **Weight quantization:** FP8
+  - **Activation quantization:** FP8
+- **Release Date:** 2026-05-29
+- **Version:** 1.0
+- **Model Developers:** RedHatAI
+This model is a quantized version of [Tesslate/OmniCoder-9B](https://huggingface.co/Tesslate/OmniCoder-9B). See the Evaluation section below for accuracy relative to the unquantized model.
+### Model Optimizations
+This model was obtained by quantizing the weights and activations of [Tesslate/OmniCoder-9B](https://huggingface.co/Tesslate/OmniCoder-9B) to FP8 data type, ready for inference with vLLM.
+This optimization reduces the number of bits per parameter from 16 to 8, reducing the disk size and GPU memory requirements by approximately 50%.
+Only the weights and activations of the linear operators within transformer blocks are quantized using [LLM Compressor](https://github.com/vllm-project/llm-compressor).
+## Deployment
+### Use with vLLM
+1. Initialize vLLM server:
+```
+vllm serve RedHatAI/OmniCoder-9B-FP8-Dynamic --reasoning-parser qwen3 --enable-auto-tool-choice --tool-call-parser qwen3_coder --language-model-only --max-model-len 262144
+```
+2. Send requests to the server:
 ```python
+from openai import OpenAI
+openai_api_key = "EMPTY"
+openai_api_base = "http://<your-server-host>:8000/v1"
+client = OpenAI(
+    api_key=openai_api_key,
+    base_url=openai_api_base,
+)
+model = "RedHatAI/OmniCoder-9B-FP8-Dynamic"
 messages = [
+    {"role": "user", "content": "Explain the difference between a mutex and a semaphore."},
 ]
+outputs = client.chat.completions.create(
+    model=model,
+    messages=messages,
+    temperature=0.6,
+)
+generated_text = outputs.choices[0].message.content
+print(generated_text)
 ```
+## Creation
+This model was created by applying [LLM Compressor](https://github.com/vllm-project/llm-compressor) with FP8 dynamic (W8A8) quantization and exported in compressed-tensors format.
+<details>
+```python
+from transformers import AutoProcessor, Qwen3_5ForConditionalGeneration
+from llmcompressor import oneshot
+from llmcompressor.modifiers.quantization import QuantizationModifier
+MODEL_ID = "Tesslate/OmniCoder-9B"
+# Load model and processor.
+model = Qwen3_5ForConditionalGeneration.from_pretrained(MODEL_ID, dtype="auto")
+processor = AutoProcessor.from_pretrained(MODEL_ID)
+# Configure FP8 dynamic quantization:
+#   * weights: FP8 with per-channel static scales
+#   * activations: FP8 with dynamic per-token scales
+recipe = QuantizationModifier(
+    targets="Linear",
+    scheme="FP8_DYNAMIC",
+    ignore=[
+        "lm_head",
+        "re:.*model.embed_tokens.*",
+        "re:.*visual.*",
+        "re:.*conv1d.*",
+    ],
 )
+# Apply quantization (no calibration data required).
+oneshot(model=model, recipe=recipe)
+# Save in compressed-tensors format.
+SAVE_DIR = MODEL_ID.rstrip("/").split("/")[-1] + "-FP8-Dynamic"
+model.save_pretrained(SAVE_DIR)
+processor.save_pretrained(SAVE_DIR)
 ```
+</details>
+## Evaluation
+This model was evaluated on GSM8K-Platinum, MMLU-Pro, IFEval, Math 500, GPQA Diamond, AIME 25, and LiveCodeBench v6 using [lm-evaluation-harness](https://github.com/EleutherAI/lm-evaluation-harness) and [lighteval](https://github.com/huggingface/lighteval), served with [vLLM](https://github.com/vllm-project/vllm). SWE-Bench Verified was evaluated using [mini-swe-agent](https://github.com/SWE-agent/mini-swe-agent) and the [SWE-bench](https://github.com/SWE-bench/SWE-bench) harness.
+### Accuracy
+<table>
+  <thead>
+    <tr>
+      <th>Category</th>
+      <th>Benchmark</th>
+      <th>Tesslate/OmniCoder-9B</th>
+      <th>RedHatAI/OmniCoder-9B-FP8-Dynamic</th>
+      <th>Recovery</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td rowspan="5"><b>Reasoning</b></td>
+      <td>GSM8K-Platinum (0-shot)</td>
+      <td>94.27</td>
+      <td>93.19</td>
+      <td>98.9%</td>
+    </tr>
+    <tr>
+      <td>MMLU-Pro (0-shot)</td>
+      <td>82.42</td>
+      <td>81.69</td>
+      <td>99.1%</td>
+    </tr>
+    <tr>
+      <td>Math 500 (0-shot)</td>
+      <td>83.20</td>
+      <td>84.47</td>
+      <td>101.5%</td>
+    </tr>
+    <tr>
+      <td>AIME 25 (0-shot)</td>
+      <td>77.08</td>
+      <td>74.17</td>
+      <td>96.2%</td>
+    </tr>
+    <tr>
+      <td>GPQA Diamond (0-shot)</td>
+      <td>81.99</td>
+      <td>81.48</td>
+      <td>99.4%</td>
+    </tr>
+    <tr>
+      <td rowspan="2"><b>Instruction Following</b></td>
+      <td>IFEval prompt-level strict (0-shot)</td>
+      <td>74.92</td>
+      <td>69.19</td>
+      <td>92.4%</td>
+    </tr>
+    <tr>
+      <td>IFEval inst-level strict (0-shot)</td>
+      <td>76.42</td>
+      <td>70.70</td>
+      <td>92.5%</td>
+    </tr>
+    <tr>
+      <td rowspan="2"><b>Coding</b></td>
+      <td>LiveCodeBench v6 (0-shot)</td>
+      <td>54.10</td>
+      <td>54.86</td>
+      <td>101.4%</td>
+    </tr>
+    <tr>
+      <td>SWE-Bench Verified (resolve rate)</td>
+      <td>28.20</td>
+      <td>30.20</td>
+      <td>107.1%</td>
+    </tr>
+  </tbody>
+</table>
+### Reproduction
+The results were obtained using the following commands:
+<details>
+The model was served with vLLM using the following command:
+```
+vllm serve RedHatAI/OmniCoder-9B-FP8-Dynamic --reasoning-parser qwen3 --enable-auto-tool-choice --tool-call-parser qwen3_coder --language-model-only --max-model-len 262144
+```
+Each benchmark was run multiple times with different random seeds. Most tasks used 3 seeds (42, 1234, 4158). AIME 25 used 8 seeds (42, 1234, 4158, 5322, 1356, 9843, 3344, 5678). Scores are averaged across all seeds.
+#### lm-eval benchmarks
+##### IFEval (0-shot)
+```
+lm_eval --model local-chat-completions \
+  --tasks ifeval \
+  --model_args "model=RedHatAI/OmniCoder-9B-FP8-Dynamic,max_length=262144,base_url=http://0.0.0.0:8000/v1/chat/completions,num_concurrent=64,max_retries=3,tokenized_requests=False,tokenizer_backend=None,timeout=2400" \
+  --apply_chat_template \
+  --output_path results_ifeval.json \
+  --seed 42 \
+  --gen_kwargs "do_sample=True,temperature=0.6,top_p=0.95,top_k=20,min_p=0.0,max_gen_toks=64000,presence_penalty=0.0,seed=42"
+```
+##### MMLU-Pro (0-shot)
+```
+lm_eval --model local-chat-completions \
+  --tasks mmlu_pro_chat \
+  --model_args "model=RedHatAI/OmniCoder-9B-FP8-Dynamic,max_length=262144,base_url=http://0.0.0.0:8000/v1/chat/completions,num_concurrent=128,max_retries=3,tokenized_requests=False,tokenizer_backend=None,timeout=1200" \
+  --num_fewshot 0 \
+  --apply_chat_template \
+  --output_path results_mmlu_pro.json \
+  --seed 42 \
+  --gen_kwargs "do_sample=True,temperature=0.6,top_p=0.95,top_k=20,min_p=0.0,max_gen_toks=64000,presence_penalty=0.0,seed=42"
+```
+##### GSM8K-Platinum (0-shot)
+```
+lm_eval --model local-chat-completions \
+  --tasks gsm8k_platinum_cot_llama \
+  --model_args "model=RedHatAI/OmniCoder-9B-FP8-Dynamic,max_length=262144,base_url=http://0.0.0.0:8000/v1/chat/completions,num_concurrent=64,max_retries=3,tokenized_requests=False,tokenizer_backend=None,timeout=1200" \
+  --num_fewshot 0 \
+  --apply_chat_template \
+  --output_path results_gsm8k_platinum.json \
+  --seed 42 \
+  --gen_kwargs "do_sample=True,temperature=0.6,top_p=0.95,top_k=20,min_p=0.0,max_gen_toks=64000,presence_penalty=0.0,seed=42"
+```
+#### lighteval benchmarks
+**litellm_config.yaml**
+```yaml
+model_parameters:
+  provider: "hosted_vllm"
+  model_name: "hosted_vllm/RedHatAI/OmniCoder-9B-FP8-Dynamic"
+  base_url: "http://0.0.0.0:8000/v1"
+  api_key: ""
+  timeout: 2400
+  concurrent_requests: 256
+  generation_parameters:
+    temperature: 0.6
+    max_new_tokens: 50000
+    top_p: 0.95
+    presence_penalty: 0.0
+    top_k: 20
+    seed: 42
+```
+##### Math 500, GPQA Diamond, LiveCodeBench v6 (0-shot)
+```
+lighteval endpoint litellm litellm_config.yaml \
+  "math_500|0,gpqa:diamond|0,lcb:codegeneration_v6|0" \
+  --output-dir results_lighteval \
+  --save-details
+```
+##### AIME 25 (0-shot)
+```
+lighteval endpoint litellm litellm_config.yaml \
+  "aime25|0" \
+  --output-dir results_aime25 \
+  --save-details
+```
+#### SWE-Bench Verified
+SWE-Bench Verified was evaluated with [mini-swe-agent](https://github.com/SWE-agent/mini-swe-agent) for agent rollouts against the vLLM server, and scored with the [SWE-bench](https://github.com/SWE-bench/SWE-bench) evaluation harness.
+**registry.yaml**
+```yaml
+{
+  "RedHatAI/OmniCoder-9B-FP8-Dynamic": {
+    "max_tokens": 262144,
+    "input_cost_per_token": 0.0,
+    "output_cost_per_token": 0.0,
+    "litellm_provider": "hosted_vllm",
+    "mode": "chat"
+  }
+}
+```
+Set the model endpoint in `swebench.yaml`:
+```yaml
+model:
+  model_name: "hosted_vllm/RedHatAI/OmniCoder-9B-FP8-Dynamic"
+  model_kwargs:
+    api_base: "http://0.0.0.0:8100/v1"
+    api_key: ""
+    temperature: 0.2
+    top_p: 0.95
+    presence_penalty: 0.0
+    top_k: 20
+    max_new_tokens: 240000
+```
+Run agent rollouts:
+```
+LITELLM_MODEL_REGISTRY_PATH=registry.yaml \
+mini-extra swebench \
+  --subset inference-optimization/SWE-bench_Verified \
+  --split test \
+  --config swebench.yaml \
+  --workers 64 \
+  --output verified_swe_instances
 ```
+Score predictions with the SWE-bench harness:
+```
+python -m swebench.harness.run_evaluation \
+  --dataset_name inference-optimization/SWE-bench_Verified \
+  --predictions_path ./verified_swe_instances/preds.json \
+  --max_workers 8 \
+  --run_id validate-verified_swe_instances \
+  --cache_level instance
+```
+</details>