ai-docs.csv

title,content,url,source
Qwen3.8-2.4T-A95B Model Card,"# Qwen3.8-2.4T-A95B

## Qwen3.8 Highlights

Qwen3.8 features the following enhancements:

- Core Capabilities: Comprehensive improvements across coding, professional work, research, and long-horizon agentic tasks.
- Agent Execution: Stronger autonomous planning and better handling of environment feedback, leading to more reliable end-to-end task completion.
- Downstream Compatibility: Broader support for popular harnesses and development tools, making it easier to integrate into your existing stack.
- Flexible Thinking Control: Reasoning depth can be tuned with `reasoning_effort`, and reasoning context from historical messages is retained via `preserve_thinking`.

## Model Overview

- Type: Causal Language Model
- Training Stage: Pre-training & Post-training
- Language Model
* Number of Parameters: 2.4T in total and 95B activated
* Hidden Dimension: 8192
* Token Embedding: 248,320 (Padded)
* Number of Layers: 92
* Hidden Layout: 23 × (3 × (Gated DeltaNet → MoE) → 1 × (Gated Attention → MoE))
* Gated DeltaNet:
+ Number of Linear Attention Heads: 128 for V and 16 for QK
+ Head Dimension: 128
* Gated Attention:
+ Number of Attention Heads: 64 for Q and 4 for KV
+ Head Dimension: 256
+ Rotary Position Embedding Dimension: 64
* Mixture of Experts:
+ Number of Experts: 512
+ Number of Activated Experts: 10 Routed + 1 Shared
+ Expert Intermediate Dimension: 2048
* LM Output: 248,320 (Padded)
* MTP (Multi-Token Prediction): trained with multiple steps
- Context Length: 262,144 natively and extensible up to 1,010,000 tokens.

## Benchmark Results

| | Opus 4.8 | Fable 5 | GPT 5.6 Sol (max) | Qwen3.7-Max | Qwen3.8-Max |

| Coding Agent | | | | | |
| Terminal Bench 2.1 | 84.6 | 84.6 | 88.8 | 74.5 | 86.6 |
| SWE-bench Pro | 69.2 | 80.0 | 64.6 | 60.6 | 67.7 |
| DeepSWE 1.1 | 59.0 | 70.0 | 73.0 | 21.6 | 56.6 |
| NL2Repo-Bench | 69.4 | -- | -- | 47.2 | 55.9 |
| FrontierSWE | 70.0 | 88.8 | -- | 40.7 | 73.5 |
| MLS-Bench-Lite | 42.8 | 49.9 | 46.2 | 31.7 | 41.0 |
| PaperBench | 80.3 | 88.8 | 90.5 | 64.8 | 93.0 |
| AndroidBench | 69.8 | 84.5 | 74.0 | 56.5 | 75.1 |
| QwenSWEBench | 84.0 | 86.3 | 73.5 | 63.4 | 80.7 |
| QwenQoderBench | 62.7 | 63.1 | 53.8 | 36.8 | 58.4 |
| QwenReactBench | 1694 | 1770 | 1564 | 1538 | 1724 |
| QwenSVGBench | 1648 | 1690 | 1758 | 1499 | 1713 |
| General Agent | | | | | |
| CoWorkBench | 72.3 | 75.9 | 71.5 | 64.6 | 74.8 |
| WorkSpaceBench | 66.8 | 68.7 | 65.6 | 61.4 | 67.7 |
| JobBench | 48.4 | 57.4 | 45.4 | 31.3 | 53.4 |
| SkillsBench | 65.1 | 70.9 | 73.5 | 61.2 | 70.2 |
| Agents' Last Exam (Pass / Score) | 27.0 / 45.1 | -- / -- | 30.6 / 53.6 | 11.8 / 31.1 | 27.0 / 52.4 |
| Automation-Bench (Pass@1) | 27.2 | 29.1 | 29.7 | 14.2 | 27.3 |
| Toolathlon Verified (Pass@1) | 76.2 | 77.9 | 74.9 | 49.7 | 72.5 |
| WideSearch | 72.9 | 81.2 | -- | 75.2 | 81.9 |
| HLE w/ tools | 57.9 | 64.5 | 58.0 | 53.5 | 56.2 |
| General Capabilities | | | | | |
| GPQA Diamond | 92.0 | 92.6 | 94.1 | 92.4 | 92.6 |
| HLE | 45.7 | 53.3 | 47.2 | 41.4 | 43.6 |
| IFBench | 62.2 | 63.5 | 72.7 | 79.1 | 82.8 |
| $OneMillion-Bench (expert score) | 41.8 | 55.9 | 53.8 | 44.4 | 52.5 |
| HealthBench | 52.4 | -- | 55.3 | 54.5 | 60.2 |
| PLawBench | 69.6 | 70.2 | 72.3 | 58.9 | 73.2 |
| PRBench-Legal | 52.7 | 57.6 | 57.6 | 48.5 | 57.6 |
| PRBench-Finance | 51.9 | 55.8 | 55.5 | 46.8 | 58.3 |
| MRCR v2 256K (8-needle) | 83.2 | -- | 93.8 | 86.7 | 92.9 |
| LongBench v2 | 69.1 | -- | 67.1 | 65.3 | 66.3 |

## Quickstart

For streamlined integration, we recommend using Qwen3.8 via APIs.

### Serving Qwen3.8

Qwen3.8 can be deployed with popular inference frameworks, e.g.:

- SGLang: Qwen3.8 Cookbook
- vLLM: Qwen3.8 Recipe
- TokenSpeed: Qwen3.8 Recipe

### API Usage

Qwen3.8 comes with official support for `reasoning_effort`, which can be used to adjust reasoning depth and control cost:

- `xhigh` (default): for complex tasks demanding thorough analysis
- `medium`: balancing accuracy and speed
- `low`: efficient reasoning optimizing for speed and cost

In addition, `preserve_thinking` is enabled by default for all workloads for the best out-of-the-box experience.

#### Chat Completions API

The Chat Completions API can be used with most inference frameworks, as well as Qwen Cloud.

Before starting, make sure the OpenAI Python SDK is installed and the API key and the API base URL are configured:

##### Text-Only Input

## Best Practices

To achieve optimal performance, we recommend the following settings:

1. Sampling Parameters:

- We suggest using the following set of sampling parameters:
* `temperature=1.0`, `top_p=0.95`, `top_k=20`, `min_p=0.0`, `presence_penalty=0.0`, `repetition_penalty=1.0`
- For supported frameworks, you can adjust the `presence_penalty` parameter between 0 and 2 to reduce endless repetition. However, using a higher value may occasionally result in language mixing and a slight decrease in model performance.

2. Adequate Output Length: To optimize performance on agentic tasks, we recommend allocating sufficient output length to allow the model to generate detailed and comprehensive responses. For frameworks that support separate token limits for internal reasoning and final outputs, we suggest the following configuration within the 1M context length:

- Reasoning Content: Set the maximum output length to 262,144 tokens.
- Final Response: Set the maximum output length to 131,072 tokens.

These settings provide the necessary capacity for complex reasoning while ensuring ample space for high-quality final deliverables.

## Citation

If you find our work helpful, feel free to give us a cite.
",https://huggingface.co/Qwen/Qwen3.8-2.4T-A95B,model_card
Kimi K3 Model Card,"# Kimi K3

Tech Blog | Full Report

## 1. Model Introduction

Kimi K3 is an open-weight, native multimodal agentic model and our most capable model to date. It is a 2.8T-parameter model built on Kimi Delta Attention (KDA) and Attention Residuals (AttnRes), with native vision capabilities and a 1-million-token context window. It is the world's first open 3T-class model, designed for frontier intelligence across long-horizon coding, knowledge work, and reasoning.

### Key Features

- New Architecture: Kimi K3 is built on Kimi Delta Attention (KDA) and Attention Residuals (AttnRes), and scales up MoE sparsity with a Stable LatentMoE framework that activates 16 out of 896 experts — yielding an approximate 2.5× improvement in overall scaling efficiency over Kimi K2.
- Long-Horizon Coding: Operating with minimal human oversight, Kimi K3 sustains long engineering sessions, navigates massive repositories, and orchestrates terminal tools — from GPU kernel optimization and compiler development to vision-in-the-loop game dev, CAD, and even chip design.
- Agentic Knowledge Work: Kimi K3 advances end-to-end knowledge work, producing deep research with interactive visualizations, widgets and dashboards, and motion design and video editing, powered by its native multimodal architecture.
- Native Multimodality & Long Context: Kimi K3 understands text, images, and video within the same model, and supports a 1-million-token context window.
- Open Frontier Weights: We release the full Kimi K3 model weights under the Kimi K3 License, making frontier intelligence openly available for research, deployment, and further innovation.

## 2. Model Summary

| Architecture | Mixture-of-Experts (MoE) |

| Total Parameters | 2.8T |
| Activated Parameters | 104B |
| Number of Layers | 93 |
| Number of Dense Layers | 1 |
| Attention-Layer Composition | 69 KDA + 24 Gated MLA |
| Attention Hidden Dimension | 7168 |
| Number of Attention Heads | 96 |
| Latent MoE Dimension | 3584 |
| MoE Hidden Dimension (per Expert) | 3072 |
| Number of Experts | 896 |
| Selected Experts per Token | 16 |
| Number of Shared Experts | 2 |
| Vocabulary Size | 160K |
| Context Length | 1048576 |
| Attention Mechanism | KDA & Gated MLA |
| Activation Function | SiTU-GLU |
| Vision Encoder | MoonViT-V2 |
| Parameters of Vision Encoder | 401M |
| Quantization | MXFP4 weights / MXFP8 activations (quantization-aware training) |
| Modality | Text, Image |

## 3. Evaluation Results

| Benchmark | Kimi K3 (max) | Claude Fable 5 (max, w/ fallback) | GPT-5.6 Sol (max) | Claude Opus 4.8 (max) | GPT-5.5 (xhigh) | GLM-5.2 (max) |

| Reasoning & Knowledge | | | | | | |
| GPQA Diamond | 93.5 | 92.6 | 94.1 | 91.0 | 93.5 | 91.2 |
| CritPt | 23.4 | 28.6 | 32.3 | 20.9 | 27.1 | 20.9 |
| AA-LCR | 74.7 | 70.0 | 73.7 | 67.7 | 74.3 | 71.3 |
| HLE-Full | 43.5 / 56.0 | 53.3 / 63.0 | 44.5 / 58.0 | 49.8 / 57.9 | 41.4 / 52.2 | — |
| Coding | | | | | | |
| DeepSWE | 67.5 | 70.0 | 73.0 | 59.0 | 67.0 | 46.2 |
| ProgramBench | 77.8 | 76.8 | 77.6 | 71.9 | 70.8 | 63.7 |
| Terminal-Bench 2.1 | 88.3 | 88.0 | 88.8 | 84.6 | 83.4 | 82.7 |
| FrontierSWE | 81.2 | 86.6 | 71.3 | 66.7 | 64.9 | 67.3 |
| SWE-Marathon | 42.0 | 35.0 | 39.0 | 40.0 | 14.0 | 13.0 |
| PostTrainBench | 36.6 | 41.4 | 34.6 | 34.1 | 28.4 | 34.3 |
| MLS-Bench-Lite | 48.3 | 49.9 | 46.2 | 42.8 | 35.5 | 40.4 |
| SciCode | 58.7 | 60.2 | 56.1 | 53.5 | 56.1 | 50.5 |
| Kimi Code Bench 2.0 | 72.9 | 76.9 | 64.8 | 71.7 | 69.0 | 64.2 |
| Agentic | | | | | | |
| BrowseComp | 91.2 | 88.0 | 90.4 | 84.3 | 84.4 | — |
| DeepSearchQA (F1) | 95.0 | 94.2 | — | 93.1 | — | — |
| ResearchRubrics | 76.2 | — | 73.8 | 73.5 | 64.0 | 71.1 |
| GDPval-AA v2 (Elo) | 1686 | 1747 | 1736 | 1593 | 1491 | 1510 |
| Toolathlon-Verified | 76.5 | 77.9 | 74.9 | 76.2 | 73.5 | 59.9 |
| MCPMark-Verified | 94.5 | 87.4 | 92.9 | 76.4 | 92.9 | — |
| MCP-Atlas | 84.2 | 84.7 | 83.6 | 83.6 | 82.8 | 82.6 |
| AutomationBench | 30.8 | 29.1 | 29.7 | 27.2 | 22.7 | 12.9 |
| JobBench | 54.3 | 57.4 | 45.4 | 48.4 | 38.3 | 43.4 |
| AA-Briefcase (Elo) | 1548 | 1583 | 1495 | 1354 | 1158 | 1260 |
| Agents' Last Exam | 28.3 | 25.7† | 29.6 | 27.0 | 26.6 | 20.4 |
| APEX-Agents | 41.0 | 43.3 | 39.9 | 39.4 | 38.5 | 35.6 |
| OfficeQA Pro | 63.3 | 69.9 | 63.2 | 63.9 | 60.9 | 41.4 |
| SpreadsheetBench 2 | 34.8 | 34.7 | 32.4 | 31.6 | 29.1 | 28.1 |
| OSWorld-Verified | 84.8 | 85.0 | 83.0 | 83.4 | 79.0 | — |
| OSWorld 2.0 | 58.3 | 66.1 | 62.6 | 55.7 | 49.5 | — |
| SaaS-Bench | 60.1 | — | 61.4 | 56.1 | 43.8 | — |
| τ³-Banking | 33.4 | 26.8 | 33.0 | 27.6 | 31.3 | 26.8 |
| Harvey Lab-AA | 94.6 | 93.6 | 87.2 | 91.1 | 86.3 | 91.0 |
| CorpFin v2 | 71.6 | 71.8 | 64.4 | 66.7 | 68.4 | 66.1 |
| Finance Agent v2 | 54.4 | 56.3 | 53.8 | 53.9 | 51.8 | 49.7 |
| Legal Research Bench | 44.2 | 49.5 | 48.1 | 43.8 | 40.4 | 31.3 |
| Vision | | | | | | |
| WorldVQA ForceAnswer | 51.0 | 56.7 | 41.8 | 39.1 | 38.5 | — |
| OmniDocBench | 91.1 | 89.8 | 85.8 | 87.9 | 89.4 | — |
| PerceptionBench | 58.5 | 57.2 | 59.7 | 47.2 | 55.8 | — |
| Video-MME (w. sub) | 90.0 | — | 89.5 | 86.0 | 89.3 | — |
| MMVU | 82.1 | — | 81.2 | 79.2 | 81.7 | — |
| BabyVision w/ python | 85.7 | 90.5 | 88.9 | 81.2 | 83.6 | — |
| MMMU-Pro | 81.6 / 83.4 | 81.2 / 86.5 | 83.0 / 84.6 | 78.9 / 82.7 | 81.2 / 83.2 | — |
| CharXiv (RQ) | 84.8 / 91.3 | 88.9 / 93.5 | 84.6 / 89.1 | 80.5 / 89.9 | 84.1 / 89.0 | — |
| MathVision | 94.3 / 97.8 | 94.8 / 98.6 | 95.8 / 97.8 | 86.7 / 97.1 | 92.2 / 96.8 | — |
| ZeroBench (pass@5) | 23.0 / 41.0 | 23.0 / 46.0 | 17.0 / 35.0 | 17.0 / 34.0 | 22.0 / 41.0 | — |

Footnotes

All Kimi K3 results are obtained with reasoning effort set to 'max' and temperature = 1.0. For single-step tasks, such as GPQA Diamond, HLE-Full, and vision benchmarks without tools, we set top-p = 0.95; for agentic tasks, we set top-p = 1.0. For HLE-Full, MMMU-Pro, CharXiv (RQ), MathVision, and ZeroBench, each cell reports the scores without and with tool augmentation (general tools for HLE-Full, Python for the vision benchmarks), in that order.

1. Reasoning & knowledge benchmarks
- CritPt and AA-LCR. Scores are cited from Artificial Analysis as of July 23, 2026.
2. Coding benchmarks
- DeepSWE. Kimi K3 is evaluated with the Kimi Code harness. The GLM-5.2 score is taken from the GLM-5.2 release blog; all remaining scores are from the official DeepSWE leaderboard, under which Kimi K3 attains 67.3 with the mini-SWE-agent harness. We report the DeepSWE v1.1 tasks.
- Terminal-Bench 2.1. Kimi K3 is evaluated with the Kimi Code harness. For all other models, we report the best score across harnesses: GLM-5.2 with Claude Code (GLM-5.2 release blog); Claude Opus 4.8 and Claude Fable 5 with Terminus 2 (Artificial Analysis); GPT-5.5 and GPT-5.6 Sol with Codex (OpenAI).
- ProgramBench. Kimi K3 is evaluated with the Kimi Code harness. The GLM-5.2 score is from the GLM-5.2 release blog; all other scores are from Vals AI.
- SWE-Marathon. Kimi K3, Claude Opus 4.8, and Claude Fable 5 are evaluated with the Claude Code harness; GPT-5.6 Sol is evaluated with the Codex harness. The GLM-5.2 score is from the GLM-5.2 release blog. Our evaluation is based on an H20-calibrated branch of the official tasks as of July 9, 2026, prior to the final v1.1 release: the Docker images, performance gates, and reference oracles for the GPU tasks have been recalibrated for H20, while the correctness and anti-cheat validators remain unchanged. Additionally, Claude Fable 5 hit fallbacks on 35% of the tasks in our evaluation, which may have negatively impacted its measured performance.
- FrontierSWE. Kimi K3 is evaluated with the Kimi Code harness and GPT-5.6 Sol with the Codex harness; all other results are from FrontierSWE. Dominance scores are recomputed from the raw scores using the official evaluation script and are current as of July 16, 2026.
- PostTrainBench. Scores for GLM-5.2, GPT-5.5, and Claude Opus 4.8 are adopted from the official PostTrainBench results. Kimi K3, Claude Fable 5, and GPT-5.6 Sol are evaluated with the official Harbor implementation at maximum reasoning effort, averaged over three runs on H20 GPUs (instead of H100 in the official setting) — Kimi K3 and Claude Fable 5 with the Claude Code harness, and GPT-5.6 Sol with the Codex harness.
- MLS-Bench-Lite. Kimi K3 is evaluated with the Kimi Code harness; GLM-5.2 and the Claude models with the Claude Code harness; GPT-5.5 and GPT-5.6 Sol with the Codex harness.
- SciCode. Scores are cited from Artificial Analysis as of July 23, 2026.
- Kimi Code Bench 2.0 (in-house). Kimi K3 is evaluated with the Kimi Code harness (it attains 73.7 with the Claude Code harness); GLM-5.2, Claude Opus 4.8, and Claude Fable 5 with the Claude Code harness; GPT-5.5 and GPT-5.6 Sol with the Codex harness. All models are evaluated at maximum reasoning effort, except GPT-5.5, which uses the ""xhigh"" setting. As the benchmark includes cybersecurity and safety-related tasks, we also disclose the fraction of refused or fallback tasks: Claude Fable 5 hit 13 fallbacks and 1 refusal out of 80 tasks; 10 refusals out of 80 tasks entered GPT-5.6 Sol's cyber guard; GPT-5.5 had 3 refusals out of 80 tasks.
3. Agentic benchmarks
- OfficeQA Pro. Each test case provides the agent with the entire PDF corpus, with all PDFs rendered as images and no machine-readable text available.
- OfficeQA Pro and SpreadsheetBench 2. Kimi K3, GLM-5.2, Claude Opus 4.8, and Claude Fable 5 are evaluated with the Claude Code harness; GPT-5.5 and GPT-5.6 Sol are evaluated with the Codex harness.
- MCP-Atlas. All models are evaluated on the 500-task public subset with a 100-turn limit, using Gemini 3.1 Pro as the judge.
- AutomationBench. All models are evaluated on the 600-task public subset, following the official GitHub setup in all other respects.
- BrowseComp. We adopt a context-compaction strategy triggered at 300K tokens. When evaluated with the full 1M-token context window and no context management, Kimi K3 achieves a score of 90.4. The results of Claude Fable 5, Claude Opus 4.8, GPT-5.6 Sol, and GPT-5.5 are cited from Anthropic and OpenAI.
- GDPval-AA v2, AA-Briefcase, τ³-Banking, Harvey Lab-AA, and APEX-Agents. Scores are cited from Artificial Analysis and the APEX-Agents leaderboard as of July 23, 2026. For Harvey Lab-AA, we report the criterion pass rate.
- CorpFin v2, Finance Agent v2, and Legal Research Bench. Scores are cited from Vals AI.
- Agents' Last Exam. Scores are cited from the official leaderboard as of July 23, 2026; we report the leaderboard's primary pass-rate metric. On the leaderboard, each model is paired with a specific harness: Kimi K3 with Kimi Code; GPT-5.6 Sol and GPT-5.5 with Codex; Claude Fable 5, Claude Opus 4.8, and GLM-5.2 with Claude Code. † The Claude Fable 5 entry runs at xhigh effort with 40% of tasks annotated as downgraded.
4. Multimodal benchmarks
- Except for ZeroBench, which follows the official setting and is run five times, all multimodal scores are averaged over three runs. MMMU-Pro is evaluated following the official protocol, preserving the original input order and prepending images to the text input.
- PerceptionBench is an in-house benchmark that focuses on atomic visual perception capabilities.

## 4. Native MXFP4 Quantization

Kimi K3 applies quantization-aware training from the SFT stage onward, using MXFP4 weights with MXFP8 activations for broad hardware compatibility.

## 5. Deployment

You can access Kimi K3's API on https://platform.kimi.ai by selecting `kimi-k3`, and we provide OpenAI/Anthropic-compatible API for you. Currently, Kimi K3 is recommended to run on the following inference engines:

- vLLM — see recipes
- SGLang — see cookbook
- TokenSpeed — see recipes

## 6. Model Usage

Kimi K3 always has thinking enabled, and will return `reasoning_content`. Thinking effort is configured with the top-level `reasoning_effort` request field, which supports `""low""`, `""high""`, and `""max""` (default `""max""`).

Kimi K3 was trained in the preserved thinking history mode. For multi-turn conversations and tool calls, Kimi K3 requires the complete assistant message returned by the API to be passed back to `messages` as-is — including `reasoning_content` and `tool_calls`, not just `content`:

For full guides and examples (vision input, structured output, partial mode, tool choice, dynamic tool loading, context caching), see the Kimi K3 Quickstart and Thinking Effort.

### Coding Agent Framework

Kimi K3 works best with Kimi Code CLI as its agent framework. We warmly invite you to give it a try — run Kimi Code in your terminal and select Kimi K3 using the `/model` command. We hope you enjoy building with Kimi K3, and we would love to hear your feedback!

## 7. License

Both the code repository and the model weights are released under the Kimi K3 License.

## 8. Contact Us

If you have any questions, please reach out at support@moonshot.ai.
",https://huggingface.co/moonshotai/Kimi-K3,model_card
GLM-5.2 Model Card,"# GLM-5.2

Join our WeChat or Discord community.
Check out the GLM-5.2 blog and GLM-5 Technical report.
Use GLM-5.2 API services on Z.ai API Platform.
Try GLM-5.2 here.

[Paper]
[GitHub]

## Introduction

We're introducing GLM-5.2, our latest flagship model for long-horizon tasks. It marks a substantial leap in long-horizon task capability over its predecessor GLM-5.1 and, for the first time, delivers that capability on a solid 1M-token context. GLM-5.2's new capabilities include:

- Solid 1M Context: A solid 1M-token context that stably sustains long-horizon work
- Advanced Coding with Flexible Effort: Stronger coding capabilities with multiple thinking effort levels to balance performance and latency
- Improved Architecture: We propose IndexShare, which reuses the same indexer across every four sparse attention layers, reducing per-token FLOPs by 2.9× at a 1M context length. We also improve GLM-5.2's MTP layer for speculative decoding, increasing the acceptance length by up to 20%
- Pure Open: An MIT open-source license — no regional limits, technical access without borders

## Benchmark

| Benchmark | GLM-5.2 | GLM-5.1 | Qwen3.7-Max | MiniMax M3 | DeepSeek-V4-Pro | Claude Opus 4.8 | GPT-5.5 | Gemini 3.1 Pro |

| Reasoning | | | | | | | | |
| HLE | 40.5 | 31 | 41.4 | 37 | 37.7 | 49.8\* | 41.4\* | 45 |
| HLE (w/ Tools) | 54.7 | 52.3 | 53.5 | - | 48.2 | 57.9\* | 52.2\* | 51.4\* |
| CritPt | 20.9 | 4.6 | 13.4 | 3.7 | 12.9 | 20.9 | 27.1 | 17.7 |
| AIME 2026 | 99.2 | 95.3 | 97 | - | 94.6 | 95.7 | 98.3 | 98.2 |
| HMMT Nov. 2025 | 94.4 | 94 | 95 | 84.4 | 94.4 | 96.5 | 96.5 | 94.8 |
| HMMT Feb. 2026 | 92.5 | 82.6 | 97.1 | 84.4 | 95.2 | 96.7 | 96.7 | 87.3 |
| IMOAnswerBench | 91.0 | 83.8 | 90 | - | 89.8 | 83.5 | - | 81 |
| GPQA-Diamond | 91.2 | 86.2 | 90 | 93 | 90.1 | 93.6 | 93.6 | 94.3 |
| Coding | | | | | | | | |
| SWE-bench Pro | 62.1 | 58.4 | 60.6 | 59 | 55.4 | 69.2 | 58.6 | 54.2 |
| NL2Repo | 48.9 | 42.7 | 47.2 | 42.1 | 35.5 | 69.7 | 50.7 | 33.4 |
| DeepSWE | 46.2 | 18 | 18 | 20 | 8 | 58 | 70 | 10 |
| ProgramBench | 63.7 | 50.9 | - | - | 47.8 | 71.9 | 70.8 | 39.5 |
| Terminal Bench 2.1 (Terminus-2) | 81.0 | 63.5 | 75 | 65 | 64 | 85 | 84 | 74 |
| Terminal Bench 2.1 (Best Reported Harness) | 82.7 | 69 | - | - | - | 78.9 | 83.4 | 70.7 |
| FrontierSWE (Dominance) | 74.4 | 30.5 | - | - | 29.0 | 75.1 | 72.6 | 39.6 |
| PostTrainBench | 34.3 | 20.1 | - | - | - | 37.2 | 28.4 | 21.6 |
| SWE-Marathon | 13.0 | 1.0 | - | - | - | 26.0 | 12.0 | 4.0 |
| Agentic | | | | | | | | |
| MCP-Atlas (Public Set) | 76.8 | 71.8 | 76.4 | 74.2 | 73.6 | 77.8 | 75.3 | 69.2 |
| Tool-Decathlon | 48.2 | 40.7 | - | - | 52.8 | 59.9 | 55.6 | 48.8 |

## Serve GLM-5.2 Locally

GLM-5.2 supports deployment with the following frameworks. Feel free to try them out:

- SGLang (v0.5.13.post1+) — see cookbook
- vLLM (v0.23.0+) — see recipes
- Transformers (v0.5.12+) — see transformers docs
- KTransformers (v0.5.12+) — see tutorial
- Unsloth (v0.1.47-beta+) — see guide
- For deployment on the `Ascend NPU` platform, inference frameworks such as vLLM-Ascend, xLLM and SGLang are supported — see here.

## Footnote

- Humanity's Last Exam (HLE) & other reasoning tasks: We use sampling parameters of `temperature=1.0`, `top_p=0.95` for evaluation. We evaluate with a maximum generation length of `163,840` tokens. By default, we report the text-only subset; results marked with * are from the full set. For AIME, HMMT and IMOAnswerBench, we evaluate each question using the following system prompt: `Your response should be in the following format:\nExplanation: {your explanation for your final answer}\nExact Answer: {your succinct, final answer}\nConfidence: {your confidence score between 0% and 100% for your answer}.` We use GPT-5.5 (medium) as the judge model. For HLE-with-tools, we use a maximum context length of 300,000 tokens, with no context management strategy.
- SWE-Bench Pro: We run the SWE-Bench Pro suite with OpenHands using a tailored instruction prompt. Settings: `temperature=1`, `top_p=1`, `max_new_tokens=32k`, with a 400K context window.
- NL2Repo: We evaluated NL2Repo with `temperature=1.0`, `top_p=1.0`, and `max_new_tokens=48k` under 400k context. To prevent hacking, we use rule-based and a LLM-based judgement to prevent malicious behaviors (e.g., unauthorized pip or curl operations).
- DeepSWE: We run DeepSWE with the official pier evaluation framework and the mini-swe-agent harness (`temperature=1.0`, `top_p=1.0`, `timeout=2h`, 400K context). Each task is solved in an isolated container with 2 CPUs, 8 GB RAM, and no internet access.
- ProgramBench: We evaluate ProgramBench (200 instances) with Claude-Code 2.1.156 using `temperature=1.0, top_p=1.0, max_tokens=64000, max_turns=2000, sample_timeout=6h, reasoning_effort=max`, with a 400K context window. Each instance runs in a (4 CPUs, 8 GB RAM) sandbox with internet access disabled.
- Terminal-Bench 2.1 (Terminus 2): We evaluate Terminal-Bench 2.1 with Terminus-2 framework using `parser=json`, `timeout=4h`, `temperature=1.0`, `top_p=1.0`, `max_new_tokens=48k`, `max_episodes=500`, with a 256K context window. Resource limits are capped at 4 CPUs and 8 GB RAM.
- Terminal-Bench 2.1 (Claude Code): We evaluate in Claude Code 2.1.167 with `temperature=1.0, top_p=0.95, max_new_tokens=131072`. We override max_new_tokens to 128k via a transparent proxy, bypassing the 64k CLI cap to restore the configurability of `CLAUDE_CODE_MAX_OUTPUT_TOKENS`. We remove wall-clock time limits, while preserving per-task CPU and memory constraints. Scores are averaged over 5 runs.
- MCP-Atlas: All models were evaluated in think mode on the 500-task public subset with a 10-minute timeout per task. We use Gemini-3.0-Pro as the judge model for evaluation.
- Tool-Decathlon: We use the official evaluation service and set max_token to 128K.
- FrontierSWE: The evaluation was conducted by Proximal with 1M context length, max effort level, and 128K maximum output tokens. Dominance score reported as of 2026/06/16.
- PostTrainBench: The evaluation was conducted by PostTrainBench with 1M context length, max effort level, and 128K maximum output tokens.
- SWE-Marathon: The evaluation was conducted by Abundant AI with 1M context length, max effort level, and 128K maximum output tokens.

## Citation

If you find GLM-5.2 useful in your research, please cite our technical report:
",https://huggingface.co/zai-org/GLM-5.2,model_card
DeepSeek-V4-Flash-0731 Model Card,"# DeepSeek-V4-Flash-0731

---

Technical Report

## Introduction

DeepSeek-V4-Flash-0731 is the official release of DeepSeek-V4-Flash, superseding the preview version, with substantially enhanced agentic capabilities. It has the same model structure as DeepSeek-V4-Flash-DSpark, i.e. it comes with a speculative decoding module attached.

DeepSeek-V4-Flash-0731 outperforms DeepSeek-V4-Pro (Preview) on benchmarks listed below despite its far smaller activated parameter count, and is broadly competitive with the strongest proprietary models available.

| Benchmark | DeepSeek-V4-Flash-0731 | DeepSeek-V4-Flash (Preview) | DeepSeek-V4-Pro (Preview) | GLM-5.2 | Opus-4.8 |

| Terminal Bench 2.1 | 82.7 | 61.8 | 72.1 | 81.0 | 85.0 |
| NL2Repo | 54.2 | 39.4 | 38.5 | 48.9 | 69.7 |
| Cybergym | 76.7 | 38.7 | 52.7 | - | 83.1 |
| DeepSWE | 54.4 | 7.3 | 12.8 | 46.2 | 58.0 |
| Toolathlon-Verified | 70.3 | 49.7 | 55.9 | 59.9 | 76.2 |
| Agents' Last Exam | 25.2 | 15.8 | 16.5 | 23.8 | 25.7 |
| AutomationBench Public | 25.1 | 10.8 | 12.8 | 12.9 | 27.2 |
| DSBench-FullStack † | 68.7 | 37.0 | 41.8 | 61.8 | 71.6 |
| DSBench-Hard † | 59.6 | 25.8 | 31.1 | 54.5 | 71.7 |

Notes:

1. For the Code Agent tasks among the public benchmarks above, DeepSeek-V4-Flash-0731 is evaluated with the minimal mode of DeepSeek Harness (to be released) as the agent framework, using the `max` reasoning effort level with `temperature = 1.0, top_p = 0.95`.
2. † DSBench-FullStack is an internal full-stack development test set; DSBench-Hard is an internal test set of difficult coding-agent problems.

## Chat Template

This release does not include a Jinja-format chat template. Instead, we provide a dedicated `encoding` folder with Python scripts and test cases demonstrating how to encode messages in OpenAI-compatible format into input strings for the model, and how to parse the model's text output. Please refer to the `encoding` folder for full documentation.

The `reasoning_effort` parameter now supports three levels — `low`, `high`, and `max` — which control how much deliberation the model spends before answering.

A brief example:

## How to Run with vLLM

DSpark speculative decoding is enabled with a single flag — add --speculative-config with method: dspark to your vLLM launch command:

`--speculative-config '{""method"":""dspark"",""num_speculative_tokens"":7,""draft_sample_method"":""greedy""}'`

For example, the command below serves the model with vLLM on a single 4×GB300 node.
See the vLLM recipe for detailed instructions and other hardware configurations.

## How to Run with SGLang

Enable DSpark with `--speculative-algorithm DSPARK` and do not set a separate `--speculative-draft-model-path` as the target and draft weights therefore come from the same checkpoint.
See the SGLang cookbook for detailed instructions, benchmarks and other hardwares configurations.

## How to Run Locally

Please refer to the inference folder for detailed instructions on running DeepSeek-V4 locally, including model weight conversion and interactive chat demos.

For local deployment, we recommend setting the sampling parameters to `temperature = 1.0`, with `top_p = 0.95` for agentic scenarios and `top_p = 1.0` otherwise. For the `high` and `max` reasoning effort levels, we recommend a maximum output length of 384K tokens.

## License

This repository and the model weights are licensed under the MIT License.

## Citation

## Contact

If you have any questions, please raise an issue or contact us at service@deepseek.com.
",https://huggingface.co/deepseek-ai/DeepSeek-V4-Flash-0731,model_card
Inkling Model Card,"# Inkling Model Card

## 1. General information

#### Model name

Inkling

#### Legal name of the model provider

Thinking Machines Lab, Inc.

#### Date of release

July 15, 2026

#### License

Apache 2.0

#### Intended uses

Inkling is a general-purpose multimodal model that accepts text, image and audio inputs and generates text outputs. It is intended for use in English and other languages, and across multiple coding languages. The model is designed to be used by developers building AI-powered applications, including agentic and tool-use systems, coding assistants, chatbots, and retrieval-augmented generation systems, and is suitable for general-purpose conversational use, instruction-following, and other natural language and multimodal tasks. It is released with open weights to support research, fine-tuning and integration into third-party products by downstream developers.

#### Languages

English, general multilingual support

## 2. Model properties

#### Model type

Multimodal autoregressive transformer

#### Architecture type

A 66-layer decoder-only transformer with a sparse Mixture-of-Experts (MoE) feed-forward backbone: each token is routed to 6 of 256 experts, plus 2 shared experts active on every token. Attention is a hybrid of local and global layers. The model is natively multimodal — images are encoded via a hierarchical patch encoder, and audio via discrete token encoding — with all modalities projected into a shared hidden space and processed jointly by the decoder.

#### Parameters

975B total, 41B active

#### Numerics support

BF16, MXFP8 and NVFP4

#### Input modalities

- Text: UTF-8 encoded text
- Image: Any pixel-based image input. For optimal performance, each image dimension should be between 40px to 4096px.
- Audio: WAV format, sampled at 16kHz. For optimal performance, audio length should be within 20 mins.

Inkling supports a context window of up to 1M tokens.

#### Output modalities

Text: UTF-8 encoded text

## 3. Methods of distribution

The model is available via API access through Tinker, our service for fine-tuning. The model is also available via API access through third party inference providers.

The weights are available for download through Hugging Face.

### API access to the model

- For accessing our model via Tinker, you can get started by referring to the Tinker Cookbook, and installing the tml-renderers package.
- For accessing our model via third party inference providers, you can refer to the documentation from our inference provider partners.

### Running the open weights model on your own system

#### Required hardware

The model is distributed in two checkpoint formats.

The BF16 checkpoint requires a GPU cluster with at least 2 TB of aggregated VRAM. This can be met with either of the following configurations:

- 8x NVIDIA B300 GPUs
- 16x NVIDIA H200 GPUs

The NVFP4 checkpoint offers a quantized alternative that reduces the aggregated VRAM requirement to at least 600 GB. This checkpoint can be run as:

- W4A4 on 4x NVIDIA B300 GPUs (note: W4A4 mode additionally requires SM100+ architecture)
- W4A16 on 8x NVIDIA H200 GPUs

#### Required software

Running the model directly on GPU hardware requires an inference deployment framework–either SGLang, vLLM, TokenSpeed, Unsloth, or Hugging Face, along with all of their respective dependency libraries.

## 4. Training

#### Data types

Training data includes a broad variety of content types, including text, images, audio, video.

#### Data provenance

Training data for the model was drawn from publicly available sources, acquired from third-parties, or synthetically generated or augmented. Publicly available data includes content from the public internet and publicly accessible repositories.

#### Curation methodologies

Data curation includes cleaning, processing, and modifying datasets. These processing steps, which vary by data type, may include deduplication and filtering to remove junk or other low-quality data, or to advance safety or other objectives.

## 5. Evaluations

| | Open weights | | | | | | Closed weights | | |

| | Inkling effort=0.99 | Nemotron 3 Ultra | Kimi K2.5 | Kimi K2.6 | GLM 5.2 | DeepSeek V4 Pro | Gemini 3.1 Pro (high) | Claude Fable 5 (max) | GPT 5.6 Sol (max/xhigh) |
| Reasoning |
| HLE text only | 29.7% | 26.6% | 29.4% | 35.9% | 40.1% | 35.9% | 44.7% | 53.3% | 47.2% |
| HLE with tools | 46.0% | 37.4% | 50.2% | 54.0% | 54.7% | 48.2% | 51.4% | 64.5% | 55.0% |
| AIME 2026 | 97.1% | 94.2% | 95.8% | 96.4% | 99.2% | 96.7% | 98.3% | 99.9% | 99.9% |
| GPQA Diamond | 87.2% | 86.7% | 87.9% | 91.1% | 89.5% | 88.8% | 94.1% | 92.6% | 94.1% |
| Agentic (coding) |
| SWEBench Verified | 77.6% | 70.7% | 76.8% | 80.2% | 80.0% | 80.6% | 80.6% | 95.0% | 82.2% |
| SWEBench ProPublic | 54.3% | 46.4% | 50.7% | 58.6% | 62.1% | 55.4% | 54.2% | 80.0% | 64.6% |
| Terminal Bench 2.1 Best Harness | 63.8% | 56.4% | 51.3% | 71.3% | 82.7% | 64.0% | 73.8% | 84.6% | 89.5% |
| Agentic (general) |
| GDPVal-AA v2 | 1238 | 1164 | 1009 | 1190 | 1514 | 1307 | 962 | 1760 | 1748 |
| MCP Atlas | 76.0% | 44.7% | 64.0% | 68.1% | 77.8% | 73.2% | 78.2% | 83.3% | 81.8% |
| Tau 3 Banking | 23.7% | 13.8% | 14.2% | 20.6% | 26.8% | 25.8% | 16.5% | 26.8% | 33.0% |
| Toolathlon Verified | 45.5% | 34.3% | 33.0% | 58.0% | 59.9% | 55.9% | 61.1% | 76.4% | 73.1% |
| Browse Comp w/ ctx management | 77.1% | – | 74.9% | 83.2% | – | 83.4% | 85.9% | 88.0% | 90.8% |
| Factuality |
| SimpleQA Verified | 43.9% | 32.4% | 36.9% | 38.7% | 38.1% | 57.0% | 77.3% | 68.3% | 71.6% |
| AA Omniscience | 2.1 | -1.0 | -8.0 | 6.0 | 4.0 | -10.0 | 33.0 | 40.0 | 22.0 |
| Chat |
| IFBench | 79.8% | 81.4% | 70.2% | 76.0% | 73.3% | 76.5% | 77.1% | 63.5% | 72.7% |
| Global-MMLU-Lite | 88.7% | 85.6% | 84.0% | 88.4% | 89.2% | 89.3% | 92.7% | 93.3% | 91.8% |
| Vision |
| MMMU ProStandard 10 | 73.5% | – | 75.0% | 79.0% | – | – | 82.0% | 84.2% | 83.0% |
| Charxiv RQ | 78.1% | – | 77.5% | 80.4% | – | – | 80.2% | 86.5% | 84.7% |
| Charxiv RQ with python | 82.0% | – | 78.7% | 86.7% | – | – | 89.9% | 89.4% | 87.8% |
| Audio |
| Audio MC | 56.6% | – | – | – | – | – | 66.8% | – | – |
| MMAU | 77.2% | – | – | – | – | – | 82.5% | – | – |
| VoiceBench | 91.4% | – | – | – | – | – | 94.3% | – | – |
| Safety |
| FORTRESS Adversarial | 78.0% | 77.6% | 54.1% | 65.6% | 71.3% | 36.0% | 65.2% | 96.0% | 82.4% |
| FORTRESS Benign | 95.9% | 90.5% | 98.3% | 97.2% | 90.0% | 98.5% | 98.0% | 55.1% | 98.1% |
| StrongREJECT | 98.6% | 98.7% | 99.5% | 99.8% | 98.5% | 98.6% | 98.0% | 98.7% | 98.5% |

For all input images whose long edge is smaller than 2048 px, we resize the long edge to the smaller of 2048 px or 2× its original length.

## 6. Safety

We conducted safety evaluations ahead of release, spanning both everyday human-AI interaction and dangerous-capability testing. Because Inkling is multimodal, we paid attention to whether safety behavior held consistently across text, audio, and image inputs. We applied mitigations to reduce risks before release.

For everyday interaction, we evaluated sycophancy, harmful manipulation, and psychological-harm patterns like parasocial dependency and validation of delusional reasoning, including through multi-turn, open-ended external red-teaming designed to surface issues that only emerge over longer conversations. We also assessed whether the model refuses genuinely harmful requests without over-refusing benign ones. For CBRN and cyber, we assessed knowledge and procedural uplift through internal evaluations, external testing, and refusal-suppressed variants intended to estimate latent capability with safeguards removed. For loss of control, we evaluated agentic capability, strategic deception, and sabotage potential, benchmarked against public frontier models, and found the model materially below frontier capabilities.

Across all areas, we concluded that Inkling did not present risk of material uplift beyond what's already available in the open-weight ecosystem.

The residual risks identified in our evaluations — specifically, Inkling's occasional tendency to comply with role-play and indirectly framed prompts concerning harmful topics — are consistent with what you would see from any open-weight model, and are best addressed with defense-in-depth rather than relying on the model's refusals alone. Common downstream moderation tools, such as Llama Guard, are compatible with Inkling and can be layered around the model to catch jailbreak attempts, filter unsafe outputs, and enforce use-case-specific policies. We would encourage treating this kind of input/output classification as a part of your deployment stack, especially for consumer-facing or high-traffic applications where adversarial prompting is more likely.

## 7. Bias, risks and limitations

Inkling may exhibit general limitations common to foundation models, including hallucination (generating plausible but factually incorrect or unsupported content), occasional failures to follow instructions precisely, and degraded performance in long multi-turn conversations. As with other large-scale models trained on web-derived and synthetic data, Inkling may reflect biases present in its training data, including demographic, cultural, or linguistic biases, and may perform unevenly across languages, dialects, or subject domains that were less represented during training.

Inkling's knowledge is limited to information available as of its training cutoff, and it may not reflect events, developments, or changes that occurred afterward.

We recommend that downstream developers and deployers apply appropriate human oversight and review for outputs used in high-stakes or safety-critical contexts, rather than relying on Inkling's outputs without verification.

- Conduct their own evaluation of Inkling's performance, safety, and fairness for their specific use case, language, and population prior to deployment, particularly for applications involving vulnerable groups.
- Implement additional safeguards – such as content filtering, rate limiting, and monitoring – at the application layer, especially for open deployment contexts where Inkling's built-in mitigations may not be sufficient on their own.
- Avoid deploying Inkling in domains such as medical, legal, or safety-critical decision-making without additional fine-tuning, domain-specific validation, and human oversight
",https://thinkingmachines.ai/model-card/inkling/,model_card
MiniMax-H3 Model Card (video and audio generation),"# MiniMaxAI/MiniMax-H3

## News

Offical skills to improve prompt writing: skills on github

## Online API

Use MiniMax-H3 directly via API.

- Global: platform.minimax.io | CN: platform.minimaxi.com

## Online App

Use MiniMax-H3 directly via App.

- WebApp Global: hailuoai.video | CN: hailuoai.com
- Desktop Global: hub.minimax.io | CN: hub.minimaxi.com

## System Overview

MiniMax H3 is a general-purpose, omni-modal generative system. It supports unified understanding of multimodal contexts composed of text, images, video, and audio, and can generate video with native stereo audio at resolutions up to 2K and durations of up to 15 seconds. Thanks to its task-generalization-oriented system design, H3 already possesses broad multimodal context understanding and generation capabilities at the pre-training stage, enabling outstanding performance in following complex multimodal instructions.

H3 supports the following input and output specifications:

| Category | Specification |

| Output duration | 4–15 seconds |
| Output aspect ratio | Supports a wide range of aspect ratios, including but not limited to 21:9, 16:9, 4:3, 1:1, 3:4, and 9:16 |
| Output resolution | Supports various resolution dimensions. The shorter side is set to 768 pixels by default. 2K \| generation can be achieved with H3-Regenerate-2K |
| Output frame rate | 24 FPS |
| Output audio | 32 kHz stereo |
| Supported dialogue languages | Stable support for 11 languages: Arabic, Chinese, English, French, German, Italian, Japanese, Korean, Portuguese, Russian, and Spanish. Additional languages are also supported to varying degrees |

### Model Variants and Input Specifications

| Model Variant | Input Mode | Specifications |

| H3-Base-FL2VA | First-and-last-frame mode | Supports zero, one, or two input images. - No image input: Text-to-video mode - One image input: First-frame-to-video or last-frame-to-video generation - Two image inputs: First-and-last-frame-to-video generation |
| H3-Base-Ref2VA | Omni-reference mode | Supports multi-modal reference inputs: - Images: ≤ 9 images - Videos: ≤ 3 clips; each clip must be 2–15 seconds long; total duration ≤ 15 seconds - Audio: ≤ 3 clips; each clip must be 2–15 seconds long; total duration ≤ 15 seconds - Mixed inputs: Maximum number of files across all input types is 12 |

The complete H3 system consists of the following three modules:

- H3-Context-IR: As inputs become increasingly complex, we build a dedicated system to deeply understand and refine the input multimodal instructions, then convert them into a form that H3 can readily understand—the Context Intermediate Representation—for generation. H3-Context-IR is critical to the quality of the final output, so we strongly recommend incorporating it into your generation pipeline or following the ""Prompting Guidance"" to build your own context-processing system.
- H3-Base: Generates audio and video based on the H3-Context-IR output, producing results at 768p resolution.
- H3-Regenerate-2K: Feeds the 768p result together with the original context back into H3 to regenerate the output at 2K resolution. This process leverages both H3's powerful generative capabilities and the rich information contained in the original context, enabling it to produce high-resolution outputs with more accurate details and greater visual fidelity.

## Model Architecture

### H3-Context-IR

H3-Context-IR is a hosted preprocessing and orchestration system designed for free-form multimodal inputs.

It interprets the relationships among text, images, audio, and reference videos, as well as how these materials relate to the intended generation output. Its internal workflow includes instruction parsing, cross-modal association, temporal understanding, and complex logical reasoning.

H3-Context-IR serializes its understanding of the context into a structured representation accepted by H3-Base. Without deviating from the user's original intent, it may also supplement missing or underspecified semantic details where appropriate.

Because H3-Context-IR relies on a multi-stage workflow and multiple hosted models and services, it is not included in this open-source release. We provide an API that enables users to reproduce the behavior of the official workflow. We also provide detailed tutorials, and developers can follow the Prompting Guidance to build their own preprocessing systems.

For detailed usage instructions, see Recommended Workflow — Full 2K Workflow.

Safety Guardrails

User-submitted text, images and videos, as well as enhanced prompts, are subject to automated moderation. Content suspected of being unlawful, pornographic, or infringing third-party rights may be blocked. We use industry-standard filtering measures but cannot eliminate false positives or false negatives. These guardrails do not affect the Licensee's obligations under the MiniMax H3 Community License, especially those relating to lawful use and use restrictions.

### H3-Base

#### Architecture Overview

- H3-Base encodes different modalities using their corresponding encoders or VAEs and organizes the encoded representations into a unified packed multimodal sequence. RoPE is used to capture the necessary spatial and temporal relationships among tokens before the entire sequence is passed to the H3-Omni-Transformer.

- Specifically, text is encoded by the H3-Encoder; visual inputs are encoded by both the H3-Encoder and the H3-VisualVAE; and audio is encoded solely by the H3-AudioVAE.

- The H3-Omni-Transformer jointly predicts video and audio latents, which are then decoded into video and stereo audio, respectively.

- To reduce the computational cost of long multimodal sequences, H3 natively supports sparse-attention training and inference. The initial open-source release provides inference with full attention only. Our sparse-attention implementation will be released in a future update.

#### H3-Encoder

- The H3-Encoder uses the full pretrained weights of Qwen3-VL-32B and provides the hidden states from its 50th layer to the H3-Omni-Transformer.

- We add several special tokens, such as `<d>`, to the tokenizer configuration. When using H3, the tokenizer and associated configuration files provided in the H3 repository are required.

#### H3-VAE

H3 uses separate visual and audio latents to represent their respective modalities.

##### H3-VisualVAE

- H3-VisualVAE is a temporally causal video autoencoder with a spatial compression factor of 16×, a temporal compression factor of 4×, and 24 latent channels, denoted as f16t4d24. We apply several latent-space optimization techniques to jointly improve reconstruction quality and latent learnability.

- Before being passed to the H3-Omni-Transformer, the visual latents are further patchified with a patch size of `1 × 2 × 2` along the `(time, height, width)` dimensions. As a result, the visual tokens entering the Transformer have an effective spatial downsampling factor of 32×, while the temporal downsampling factor remains 4×.

- The latent space of H3-VisualVAE is optimized for both reconstruction quality and ease of learning by the generative model. After training its encoder, we additionally train a ViT-based decoder to reduce decoding costs and further improve reconstruction quality.

##### H3-AudioVAE

- H3-AudioVAE uses the same encoder and decoder for both the left and right audio channels while processing each channel independently. The decoded channels are then recombined, enabling stereo audio input and output.
- For each channel, H3-AudioVAE compresses 32 kHz audio into a sequence of latent tokens with a temporal rate of 40 Hz.
- Inspired by VA-VAE, we optimize the latent space to preserve audio reconstruction quality while making it easier for the generative model to learn.

#### H3-Omni-Transformer

- For scalability and generalization, we adopt a relatively simple Transformer block design. H3-Omni-Transformer is a 33B-parameter dense, single-stream Transformer, with approximately 13B parameters residing in AdaLN-related branches. Because the AdaLN modulation outputs can be precomputed and cached, these parameters do not need to be loaded for inference-only deployment. We release the complete model weights to support further development, including fine-tuning.

- Neither the attention layers nor the FFN layers contain modality-specific structures. Modality-specific parameters are confined to the input/output layers and the AdaLN branches. In particular, modality-specific AdaLN improves generation quality with relatively low additional training and inference costs.

- The model uses three-dimensional Multimodal Rotary Position Embeddings (MM-RoPE) to represent positional relationships across the temporal and two spatial dimensions, `(t, h, w)`.

- During the final stage of training, we introduce native sparse attention to reduce the computational cost of long sequences. The sparse-attention implementation is not included in the initial open-source release and will be published separately in a future update.

### H3-Regenerate-2K

- For H3's 2K-resolution output, instead of using a conventional dedicated super-resolution module, we use the H3 base model to regenerate its own low-resolution result through an in-context manner.

- This approach provides two advantages: (1) the regeneration process can reuse the generative capabilities of H3 base model to the greatest extent possible; and (2) the in-context format can reuse the original multimodal context when producing high-resolution output, allowing it to recover information that conventional super-resolution methods would otherwise have to ""guess,"" such as small text and fine details.

- In-context regeneration is also an example of task generalization.

- Due to the complexity of the system, this module is not yet open-sourced. We will release it once it is ready. We provide an API for validating the official results; see ""Full 2K Workflow"" below.

## Recommended Workflow

To help the community deploy MiniMax H3 correctly, we provide two validation methods.

Since the complete H3 system consists of three modules—H3-Context-IR, H3-Base, and H3-Regenerate-2K—the ""Full 2K Workflow"" provides an end-to-end validation pipeline for 2K output, combining the Open Platform API with a locally deployed H3-Base. The ""Local Deployment of H3-Base"" section provides a method for validating 768p output using only a locally deployed H3-Base.

In addition, the ""Prompting Guidance"" section provides a detailed tutorial to help the community develop their own prompting systems.

### Local Deployment of H3-Base

MiniMax H3 is released as two task-specific checkpoints. Each checkpoint contains a specialized Omni Transformer Model together with the required processor, tokenizer, text encoder, Visual VAE, and standalone Audio VAE components.

| Checkpoint | Supported Tasks | Input Conditions | Output | Precision |

| MiniMax-H3 Base FL2VA | Text-to-Audio-Video (`t2va`), First/Last-Frame-to-Audio-Video (`fl2va`) | Text; optional first frame, last frame, or both | Video and audio | BF16 |
| MiniMax-H3 Base Ref2VA | Reference-to-Audio-Video (`ref2va`) | Text with reference images, videos, and/or audio | Video and audio | BF16 |

The released checkpoints are CFG-distilled Omni Transformer model weights.

Each checkpoint is distributed as a self-contained Hugging Face-style repository with the following components:

Download the model. The repository hosts the original checkpoint (`FL2VA/`, `Ref2VA/`) and the diffusers format side by side, so scope the download to what your framework needs:

`model_index.json` is the repository-level public entry. The task-family-specific diffusers indexes remain under `FL2VA/model_index.json` and `Ref2VA/model_index.json`.

diffusers users do not need a manual download: `ModularPipeline.from_pretrained(""MiniMaxAI/MiniMax-H3"")` fetches exactly the components it needs. See the diffusers documentation for loading recipes.

We recommend the following inference frameworks to serve the model:

- SGLang - see cookbook

- vLLM - see vllm recipes

- diffusers - see diffusers docs

- ComfyUI - see Comfy tutorial; use R2V template / T2V template

#### Sglang Deployment

Here we use sglang as a deployment example. See the MiniMax-H3 deployment guide for additional deployment configurations.

FL2VA:

Ref2VA:

#### Reproducible 768p cases

The following three use cases T2VA, FL2VA, and Ref2VA demonstrate how to reproduce MiniMax-H3 video-audio generation.

| Use case | Request | Result |

| T2VA | View script | t2va.mp4 |
| FL2VA | View script | fl2va.mp4 |
| Ref2VA | View script | ref2va.mp4 |

### Full 2K-Workflow

This section explains how to combine a locally deployed SGLang service with the official H3-Context-IR and H3-Regenerate-2K APIs to reproduce the quality of 2K videos generated directly by the MiniMax API.
Before you begin, configure the SGLang endpoint and your MiniMax API credentials:

MiniMax platform:

API docs:

- Create H3-2K: use /video-generation-v2-create EN-docs, CN-docs
- H3-Context-IR：use /video-generation-v2-h3-context-ir EN-docs, CN-docs
- H3-Regenerate-2K：use /video-generation-v2-regeneration EN-docs, CN-docs

The examples below encode local H3-Base output files as Base64 Data URLs. For production use, uploading the video to a publicly accessible URL and passing that URL as `base_video` is recommended.

For each case below, we provide reference outputs at both 2K and 768p generated directly through the Open Platform API, making it easier to validate the results.

#### case-T2VA

- Type: Text-to-video
- Duration: 10 seconds
- Aspect ratio: 16:9

| stage | request | result |

| H3-Context-IR | View script | |
| H3-Base | View script | t2va.mp4 |
| H3-Regenerate-2K | View script | t2va\_2k.mp4 |
| Reference 2K result by directly calling Open Platform API | View script | h3\_direct\_2k.mp4 |
| Reference 768P result by directly calling Open Platform API | View script | h3\_direct\_768p.mp4 |

#### case-I2VA

- Type: First-frame image-to-video
- Duration: 8 seconds
- Aspect ratio: adaptive

| stage | request | result |

| H3-Context-IR | View script | |
| H3-Base | View script | i2va.mp4 |
| H3-Regenerate-2K | View script | i2va\_2k.mp4 |
| Reference 2K result by directly calling Open Platform API | View script | i2va\_direct\_2k.mp4 |
| Reference 768P result by directly calling Open Platform API | View script | i2va\_direct\_768p.mp4 |

#### case-Ref2VA

- Type: Multimodal reference-to-video (video + audio)
- Duration: 5 seconds
- Aspect ratio: adaptive

| stage | request | result |

| H3-Context-IR | View script | |
| H3-Base | View script | r2va.mp4 |
| Reference 2K result by directly calling Open Platform API | View script | r2va\_2k.mp4 |
| H3 API 2K in Open Platform for reference | View script | r2va\_direct\_2k.mp4 |
| Reference 768P result by directly calling Open Platform API | View script | r2va\_direct\_768p.mp4 |

### Prompting Guidance

VIDEO_PROMPT_WRITING_GUIDE_base_en.md

VIDEO_PROMPT_WRITING_GUIDE_ref_en.md

skills to improve prompt: https://github.com/MiniMax-AI/MiniMax-H3/tree/main/skills

## License

- MiniMax H3 is released under the MiniMax H3 Community License Agreement.
- Q&A about the License
- Application form(only for USA/EU/UK/South Korea)

## Contact Us

Contact us at model@minimax.io.
",https://huggingface.co/MiniMaxAI/MiniMax-H3,model_card
NVIDIA Nemotron 3 Embed 8B Model Card,"# nvidia/Nemotron-3-Embed-8B-BF16

NVIDIA Nemotron 3 Embed

## Model Overview

### Description:

Nemotron-3-Embed-8B-BF16 is a versatile text embedding model trained by NVIDIA and optimized for retrieval and semantic similarity tasks. It provides strong multilingual and cross-lingual retrieval capabilities and is designed to serve as a foundational component in text-based Retrieval-Augmented Generation (RAG) systems. This model was evaluated across 34 languages: English, Arabic, Assamese, Bengali, Bulgarian, Chinese, Danish, Dutch, Finnish, French, German, Hindi, Hinglish, Indonesian, Italian, Japanese, Korean, Malay, Marathi, Nepali, Norwegian, Persian, Portuguese, Romanian, Russian, Spanish, Swahili, Swedish, Tamil, Telugu, Thai, Ukrainian, Urdu, Vietnamese.

The model generates dense vector embeddings from multilingual text inputs, enabling retrieval, semantic search, and (agentic) RAG workflows. As a core component of text retrieval systems, an embedding model transforms text, such as questions or passages, into dense vector representations. These models are typically transformer encoders that process input tokens and produce embeddings suitable for efficient similarity matching.

Nemotron-3-Embed-8B-BF16 achieves state-of-the-art performance on the multilingual RTEB leaderboard) as of July 16, 2026. Read more details in our Blog Post.

This model is ready for commercial use.

### License/Terms of Use:

This model and its associated configuration files are licensed under the OpenMDW License Agreement, version 1.1 (OpenMDW-1.1). Additional Information: Built with Ministral-3-8B-Instruct-2512 which is released under Apache 2.0.

This project will download and install additional third-party open source software projects. Review the license terms of these open source projects before use.

### Deployment Geography:

Global

### Use Case:

Nemotron-3-Embed-8B-BF16 is most suitable for users who want to build a multilingual question-and-answer application over a large text corpus, leveraging the latest dense retrieval technologies.

### Release Date:

07/16/2026 via https://huggingface.co/nvidia/Nemotron-3-Embed-8B-BF16

## Model Architecture:

Architecture Type: Transformer

Network Architecture: Ministral-3-8B-Instruct-2512 based encoder model.

Number of model parameters: The model has approximately 8B parameters.

Hidden Size: 4096

The Nemotron-3-Embed-8B-BF16 model is a transformer-based text embedding model trained with bidirectional attention masking, where the final embedding vector is obtained by applying average pooling to the transformer's token-level representations. It encodes each input text into a dense embedding vector of dimension 4096.

## Input(s):

Input Type(s): Text

Input Format(s):
- Text: List of strings

Input Parameters:
- Text: One-Dimensional (1D)

Other Properties Related to Input: Text inputs should be tokenized by the model tokenizer. The model's max sequence length is 32768. Longer inputs should be chunked or truncated.

## Output(s):

Output Type(s): Floats

Output Format(s):
- List of float arrays

Output Parameters: One-Dimensional (1D) embedding vector per input text string

Other Properties Related to Output: The model outputs a 4096-dimensional embedding vector for each input text string. It also supports dynamic embedding sizes by slicing the vector from the start (for example, keeping the first 2048 or 1024 dimensions). These sliced embeddings remain highly functional, provided the resulting sub-vector is re-normalized (L2 normalization) after slicing.

Our AI models are designed and/or optimized to run on NVIDIA GPU-accelerated systems. By leveraging NVIDIA's hardware (e.g. GPU cores) and software frameworks (e.g., CUDA libraries), the model achieves faster training and inference times compared to CPU-only solutions.

## Usage

For local Python examples, use the Hugging Face model ID by default. If you are working from a local checkout, replace `MODEL_ID` with that path. For vLLM online serving from a local checkpoint, use the local checkpoint example.

Use this model for retrieval-style embeddings. Add the `query: ` prefix for queries and the `passage: ` prefix for documents. Embeddings are L2-normalized, so dot product and cosine similarity are equivalent. The output tables use `q[i]` for queries and `d[i]` for documents. Scores are rounded to four decimals. Exact values can vary by runtime and package version.

### Local Python Dependencies

The BF16 checkpoints support Transformers `5.2.0` and above. The examples also require a CUDA-enabled PyTorch installation that matches your driver and CUDA environment.

If you are not using an NVIDIA PyTorch container, install PyTorch first. Use the PyTorch local installation selector to choose the command that matches your operating system, package manager, and CUDA environment. If the default PyPI wheel matches your CUDA environment, run:

For non-default CUDA environments, the selector can include an additional `--index-url` argument. Use that CUDA-specific index URL when the default PyPI wheel does not match your CUDA environment.

Then install Transformers and Sentence Transformers:

NVIDIA tested the examples in `nvcr.io/nvidia/pytorch:26.06-py3` with the container-provided Torch and CUDA stack. Inside NVIDIA PyTorch containers, do not upgrade Torch. Install only the missing packages:

The tested `nvcr.io/nvidia/pytorch:26.06-py3` container includes `flash-attn`, so the snippets use FlashAttention-2 by default. If your environment does not have FlashAttention-2, set `attn_implementation` or `ATTN_IMPLEMENTATION` to `sdpa`.

### Sentence Transformers

Use Sentence Transformers for the simplest local Python interface. It reads the saved query and document prompts and normalization metadata.

Sentence Transformers Expected Output

### Transformers

Use Transformers when you want manual control over tokenization, pooling, or batching.

Transformers Expected Output

### vLLM Dependencies

For BF16, use `vllm==0.25.0` for `/v2/embed` serving. NVIDIA also validated `vllm serve ""$MODEL_ID""` with `vllm/vllm-openai:v0.21.0`, `nvcr.io/nvidia/vllm:26.06-py3`, and `vllm/vllm-openai:v0.24.0` for this checkpoint.

FP8 acceleration: On NVIDIA Hopper and Ada Lovelace GPUs, enable FP8 in vLLM online with `--quantization fp8_per_tensor`, or offline with `quantization=""fp8_per_tensor""` in `LLM(...)`. Validated with vLLM `0.25.0` on H100; accuracy matched BF16.

### vLLM Offline Python

Use the offline Python API when you want local vLLM inference without running an HTTP server. `LLM.embed` accepts formatted strings, so add the `query: ` and `passage: ` prefixes manually.

vLLM Offline Python Example

vLLM Offline Python Expected Output

### vLLM Online Serving

vLLM defaults to port `8000`. Add host and port when you need an explicit bind address or a non-default port:

If you serve the Hugging Face model ID, the served model name defaults to `nvidia/Nemotron-3-Embed-8B-BF16`. If you serve a local checkpoint path, vLLM still reads the model config and weights from that path; `--served-model-name` only sets the model name accepted by API requests.

With `--served-model-name`, client requests continue to use `MODEL = ""nvidia/Nemotron-3-Embed-8B-BF16""`. If you omit it, use the served name reported by `/v1/models` in client requests.

#### Recommended Retrieval Endpoint

After the server is running, use `/v2/embed` for retrieval. Send raw query and document strings. `input_type` applies the saved query and document prompts:

Recommended Retrieval Endpoint Expected Output

You can also use the OpenAI-compatible `/v1/embeddings` endpoint. For those requests, pass strings in `input` and manually prefix them with `query: ` or `passage: `.

### Expected Configuration Warning

When this checkpoint is loaded by Transformers, whether directly or through Sentence Transformers or vLLM, the following warning may appear:

This warning is expected and does not prevent model loading or inference. `apply_yarn_scaling` is retained as a temporary vLLM compatibility field that preserves the checkpoint's intended long-context RoPE behavior. Do not remove it from `config.json`. The upstream compatibility work is tracked in vLLM issue #48621.

## Software Integration:

Runtime Engine(s): PyTorch, vLLM

Supported Hardware Microarchitecture Compatibility:
- NVIDIA Ampere
- NVIDIA Blackwell
- NVIDIA Hopper

Supported Operating System(s):
- Linux

The integration of foundation and fine-tuned models into AI systems requires additional testing using use-case-specific data to ensure safe and effective deployment. Following the V-model methodology, iterative testing and validation at both unit and system levels are essential to mitigate risks, meet technical and functional requirements, and ensure compliance with safety and ethical standards before deployment.

## Model Version(s):

Nemotron-3-Embed-8B-BF16

## Training, Testing, and Evaluation Datasets:

### Dataset Overview:

Total Size: 50M+ data samples
Dataset Partition: Training [100%], Testing [N/A — evaluation benchmarks used separately], Validation [N/A — evaluation benchmarks used separately].

Model training was conducted using publicly available, commercially permissible datasets and synthetically generated datasets. Synthetic datasets were created either by generating queries from seed documents or by generating complete question–answer pairs through LLM-based prompting using the LLMs listed below.

### Public Datasets:

| Dataset name | Reference |

| MIRACL | https://huggingface.co/datasets/miracl/miracl |
| MLDR | https://huggingface.co/datasets/Shitao/MLDR |
| HotpotQA | https://hotpotqa.github.io/ |
| NQ | https://huggingface.co/datasets/sentence-transformers/embedding-training-data |
| SQuAD | https://rajpurkar.github.io/SQuAD-explorer/ |
| Stack Exchange | https://archive.org/details/stackexchange |
| HoVer | https://hover-nlp.github.io/ |
| TAT-QA | https://huggingface.co/datasets/next-tat/TAT-QA |
| FinQA | https://github.com/czyssrs/FinQA/tree/main |
| PubMedQA | https://huggingface.co/datasets/qiaojin/PubMedQA/viewer/pqa_labeled |
| MedQuAD | https://github.com/abachaa/MedQuAD |
| JaQuAD | https://huggingface.co/datasets/SkelterLabsInc/JaQuAD |
| coir_apps | https://huggingface.co/datasets/CoIR-Retrieval/apps |
| coir_cosqa | https://huggingface.co/datasets/CoIR-Retrieval/cosqa |
| coir_stackoverflow_qa | https://huggingface.co/datasets/CoIR-Retrieval/stackoverflow-qa |
| coir_codetrans_dl | https://huggingface.co/datasets/CoIR-Retrieval/codetrans-dl |
| coir_codetrans_contest | https://huggingface.co/datasets/CoIR-Retrieval/codetrans-contest |
| synthetic_text2sql | https://huggingface.co/datasets/CoIR-Retrieval/synthetic-text2sql |
| SWE-bench | https://huggingface.co/datasets/princeton-nlp/SWE-bench/viewer/default/train |
| MLQA | https://github.com/facebookresearch/MLQA |
| SpartQA | https://github.com/HLR/SpartQA_generation |
| Winogrande | https://github.com/allenai/winogrande |
| TempReason | https://huggingface.co/datasets/tonytan48/TempReason |
| PAQ | https://huggingface.co/datasets/sentence-transformers/embedding-training-data |
| Wikipedia | https://huggingface.co/datasets/wikimedia/wikipedia |
| CCNews | https://commoncrawl.org/2016/10/news-dataset-available/ |
| S2ORC | https://huggingface.co/datasets/sentence-transformers/embedding-training-data |
| Reddit | https://huggingface.co/datasets/sentence-transformers/reddit-title-body |

### Synthetic Datasets:

Synthetic query-document pairs were generated either from scratch or by using seed datasets to generate queries with the models listed below.

| LLMs used to generate synthetic datasets: |

| Qwen/Qwen3-Next-80B-A3B-Instruct Qwen/Qwen3-235B-A22B Qwen/Qwen3.5-397B-A17B Qwen/Qwen3.6-27B Qwen/Qwen3.6-35B-A3B |
| google/gemma-4-31B-it |
| openai/gpt-oss-120b openai/gpt-oss-20b |
| nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-BF16 nvidia/NVIDIA-Nemotron-3-Ultra-550B-A55B-NVFP4 |

| Seed Datasets | |

| Dataset | Reference |
| FinePdfs | https://huggingface.co/datasets/HuggingFaceFW/finepdfs |
| CentralActs | https://zenodo.org/records/5088102 |
| BRIGHT | https://huggingface.co/datasets/xlangai/BRIGHT |
| MultiHiertt | https://github.com/psunlpgroup/MultiHiertt |

### Training Dataset:

#### Data Modality:

- Text

#### Training Data Size:

Text Training Data Size: 50M+ data samples

Data Collection Method by dataset: Hybrid: Human, Automated, Synthetic

Labeling Method by dataset: Hybrid: Human, Automated, Synthetic

Properties: Model training was conducted on text datasets using question–passage pairs from publicly available, commercially permissible datasets and synthetically generated datasets.

### Testing Dataset:

Data Collection Method by dataset: Not Applicable

Labeling Method by dataset: Not Applicable

Properties: Not Applicable. Model quality was assessed using the evaluation benchmark datasets described in the Evaluation Dataset subsection.

### Evaluation Dataset:

Data Collection Method by dataset: Hybrid: Human, Automated, Synthetic

Labeling Method by dataset: Hybrid: Human, Automated, Synthetic

Properties: This model is evaluated on 16 public tasks on Retrieval Embedding Benchmark (RTEB), a new benchmark designed to reliably evaluate the retrieval accuracy of embedding models for real-world applications. More details on RTEB can be found on their leaderboard.

We also evaluated the model on the MMTEB (Retrieval) benchmark datasets (paper), and on the eight text datasets (extracted via OCR) from the ViDoRe-V3 benchmark).

We set the model sequence length to 4096 for the evaluation results below.

| Text Retrieval benchmarks (chunk retrieval) - Avg. NDCG@10 | | | |

| Model Name | RTEB 16 | ViDoRe-V3 text | MMTEB (Retrieval) |
| llama-nemotron-embed-vl-1b-v2 | 61.98 | 52.54 | 59.71 |
| Nemotron-3-Embed-1B-BF16 | 72.38 | 57.74 | 71.04 |
| Nemotron-3-Embed-8B-BF16 | 78.46 | 60.60 | 75.45 |

## Inference:

Acceleration Engine: PyTorch, vLLM

Test Hardware:
- NVIDIA Ampere - A100 80GB
- NVIDIA Hopper - H100 80GB

## Ethical Considerations:

NVIDIA believes Trustworthy AI is a shared responsibility and we have established policies and practices to enable development for a wide array of AI applications. Developers should work with their internal model team to ensure this model meets requirements for the relevant industry and use case and addresses unforeseen product misuse.

For more detailed information on ethical considerations for this model, please see the Model Card++ Bias, Explainability, Safety & Security, and Privacy Subcards.

Please report model quality, risk, security vulnerabilities or NVIDIA AI concerns here.

## Bias

| Field | Response |

| Participation considerations from adversely impacted groups protected classes in model design and testing: | None |
| Measures taken to mitigate against unwanted bias: | None |
| Bias Metric (If Measured): | None |

## Explainability

| Field | Response |

| Intended Task/Domain: | Passage and query embedding for question and answer retrieval |
| Model Type: | Transformer encoder |
| Intended Users: | Generative AI creators working with conversational AI models - users who want to build a multilingual question and answer application over a large text corpus, leveraging the latest dense retrieval technologies. |
| Output: | Array of float numbers (Dense Vector Representation for the input text) |
| Describe how the model works: | Model transforms the tokenized input text into a dense vector representation. |
| Name the adversely impacted groups this has been tested to deliver comparable outcomes regardless of: | Not Applicable |
| Technical Limitations & Mitigation: | The model's max sequence length is 32768. Therefore, longer text inputs should be truncated. |
| Verified to have met prescribed NVIDIA quality standards: | Yes |
| Performance Metrics: | Accuracy, Throughput, and Latency |
| Potential Known Risks: | This model does not always guarantee to retrieve the correct passage(s) for a given query. |
| Licensing: | This model and its associated configuration files are licensed under the OpenMDW License Agreement, version 1.1 (OpenMDW-1.1). Additional Information: Built with Ministral-3-8B-Instruct-2512 which is released under Apache 2.0. |

## Privacy

| Field | Response |

| Generatable or reverse engineerable personal data? | None |
| Was consent obtained for any personal data used? | Not Applicable |
| Personal data used to create this model? | None Known |
| How often is the dataset reviewed? | Before Every Release |
| Is there provenance for all datasets used in training? | Yes |
| Does data labeling (annotation, metadata) comply with privacy laws? | Yes |
| Was data from user interactions with the AI model (e.g. user input and prompts) used to train the model? | Yes |
| Is data compliant with data subject requests for data correction or removal, if such a request was made? | No, not possible with externally-sourced data. |
| Applicable Privacy Policy | https://www.nvidia.com/en-us/about-nvidia/privacy-policy/ |

## Safety

| Field | Response |

| Model Application(s): | Text Embedding for Retrieval |
| Describe the physical safety impact (if present). | Not Applicable |
| Use Case Restrictions: | This model and its associated configuration files are licensed under the OpenMDW License Agreement, version 1.1 (OpenMDW-1.1). Additional Information: Built with Ministral-3-8B-Instruct-2512 which is released under Apache 2.0. |
| Model and dataset restrictions: | The Principle of least privilege (PoLP) is applied limiting access for dataset generation and model development. Restrictions enforce dataset access during training, and dataset license constraints adhered to. |
",https://huggingface.co/nvidia/Nemotron-3-Embed-8B-BF16,model_card
Introducing Claude Opus 5,"# Introducing Claude Opus 5

Claude Opus 5 is available today. It's a thoughtful and proactive model that comes close to the frontier intelligence of Claude Fable 5 at half the price.

On coding and knowledge work evaluations like Frontier-Bench and GDPval-AA, Opus 5 is the new state-of-the-art, though it remains behind Mythos 5 on cybersecurity tasks.

Opus 5 is designed to be used every day: it works more efficiently than other models. It's the new default model on Claude Max, and the strongest model on Claude Pro.

## Performance and cost-effectiveness

Claude Opus 5 provides greatly improved performance for the same cost as its predecessor, Opus 4.8. The charts in this section show how performance changes according to the model's effort setting, which customers can use to optimize for intelligence or conserve tokens for faster and cheaper results.

Opus 5 excels on valuable software engineering tasks. For example, on Frontier-Bench v0.1, Opus 5 surpasses all other models, and more than doubles Opus 4.8's performance at a lower cost per task. On CursorBench 3.2, at max effort, the model performs within 0.5% of Fable 5's peak score, but at half the cost per task; it also achieves greater performance at a given cost than all other models on high, xhigh, and max effort.

We see similar results on knowledge work and problem-solving tasks. For example:

- On ARC-AGI 3, an evaluation where the model has to solve novel problems, Opus 5's score is three times as high as the next-best model.
- On Zapier AutomationBench, which measures whether models can complete business tasks from start to finish, Opus 5's pass rate is around 1.5× the next-best model for the same cost per task. Even at its lowest effort setting, Opus 5 passes more tasks than any other model.
- On OSWorld 2.0, a computer use benchmark, Opus 5 outperforms every other model at any given cost, surpassing Fable 5's best result at just over a third of the cost.

It's also our best and most cost-efficient model on several related evaluations: ARC-AGI 3, GDPval-AA v2, OSWorld 2.0, HLE, AutomationBench, and DeepSearchQA.

Opus 5 is a meaningful improvement over Opus 4.8 for scientific research. It shows better performance than Opus 4.8 on every one of our life sciences evaluations, which cover topics including structural biology, organic chemistry, and bioinformatics. Its improvements are most notable on organic chemistry tasks, like inferring molecular structures from spectroscopy data (it scores 10.2 percentage points higher than Opus 4.8 on our internal benchmark), and on protein-related tasks like predicting how variations in a protein's sequence affect how it functions (here, it scores 7.7 percentage points higher).

Finally, Opus 5 is capable of producing much stronger visual outputs.

## Working with Claude Opus 5

Claude Opus 5 is much stronger at verifying its work and iterating carefully until it succeeds. In evaluations and early-access testing, we and our users found many examples of Opus 5's agency and thoroughness:

- On one Frontier-Bench task, Opus 5 was given a drawing of a machine part and asked to write code to rebuild it as a 3D FreeCAD model. However, in this task, the model was intentionally given no way to directly *view* the drawing. Opus 5 responded by writing its own computer vision pipeline to pull the geometry from the raw pixels, then reconstructed the full machine part. It succeeded in doing so repeatedly; no competing model with the same setup could solve it after five attempts.
- Given a real bug in a popular open-source package manager, Opus 5 found the root cause and fixed an edge case that the community's patch had missed. A competing model fixed only the surface symptom (not the underlying cause), then reported the bug resolved.
- An engineer at a trading firm used Opus 5 to build a market data feed for a new exchange in a single session. Previous models could not complete this task at all, even given extensive plans from the engineer. Finding no live feed to validate against, Opus 5 even built its own test harness to check that its code parsed the exchange's data correctly.

## Alignment and safety

Alignment. During pre-deployment testing, our automated behavioral audit found Opus 5 to be our most aligned model to date. It adheres to Claude's Constitution better than Opus 4.8, Sonnet 5, or Fable 5; exhibits the lowest rates of deceptive behavior; and is the least susceptible to being tricked into misuse. It's also our safest model yet in terms of avoiding reckless actions that could have hard-to-reverse side effects.

Safety. Opus 5 does not advance the frontier in risky, dual-use capabilities. In rigorous evaluations conducted alongside private-sector and government partners, we found it remains behind Mythos 5 in both biology research and offensive cybersecurity. More information about these evaluations can be found in our System Card.

As with its predecessor, Opus 4.8, we've intentionally avoided training Opus 5 on cyber tasks. The model has nevertheless improved substantially on these tasks as a result of becoming more generally capable, and it comes close to Mythos 5 at *finding* cybersecurity vulnerabilities. However, it remains substantially behind Mythos 5 on the *exploitation* of those vulnerabilities—that is, in turning vulnerabilities into material cyber threats.

This is illustrated by Opus 5's performance on OSS-Fuzz, an evaluation we've developed to assess how well models can find and then exploit vulnerabilities without extensive human guidance. Although Mythos 5 and Opus 5 identify vulnerabilities with similar success, Opus 5's score on the development of exploits is far behind that of Mythos 5.

## Safeguards for Opus 5

Claude Opus 5's safeguards are designed to allow beneficial uses of the model in both cybersecurity and biology. They are similar to those we applied to Opus 4.8, with the exception of some stronger guardrails on a narrow range of cyber tasks.

Cybersecurity. Opus 5's cyber classifiers are proportionally less restrictive than those on Fable 5. They allow Opus 5 to find vulnerabilities in source code, but block ""binary-based"" vulnerability scanning (a method more likely to be associated with malicious actors), penetration testing, and exploit generation.

Based on our testing, we expect the classifiers to intervene around 85% less often than they do for Fable 5. In Claude.ai, Claude Code, and Claude Cowork, any flagged requests will fall back to Opus 4.8 by default. Fallbacks to Opus 4.8 can also be enabled on the API.

Our Cyber Verification Program (CVP) facilitates cybersecurity work that would otherwise be impeded by the model's safeguards. Enterprises and researchers who are already part of the CVP have immediate access to a version of Opus 5 with fewer security restrictions.

Biology. Since Opus 5 has a similar suite of safeguards to Opus 4.8, it is now our most capable generally available model for scientific research. Nevertheless, the model still shows important limitations on long-running, autonomous research tasks, which is where we expect AI models to pose the most substantial biology-related risks. (Mythos 5 remains the stronger model for this type of biological work.) As part of this launch, biology-related requests that are blocked on Fable 5 will now route to Opus 5 rather than Opus 4.8.

## Getting started

Claude Opus 5 is available today on all platforms, priced at $5 per million input tokens and $25 per million output tokens (the same as Opus 4.8). Developers can get started with claude-opus-5 on the Claude API.

It's also offered in Fast mode, where it runs around 2.5 times the default speed. As with Opus 4.8, Fast mode is available at twice Opus 5's base price on the Claude Platform and through usage credits in Claude Code.

Alongside Opus 5, we're releasing two updates in beta:

- Mid-conversation tool changes on the Claude Platform. Within a conversation, developers can now change which tools Claude can use without invalidating the prompt cache.
- Automatic fallbacks on the API. Users can now choose to have requests that are flagged by our safety classifiers on Opus 5 (or Fable 5) automatically route to another model. With automatic fallbacks on, API requests always route to the best available model by default rather than being blocked.

Consistent with prior Opus models, Opus 5 does not have data retention requirements for general access.
",https://www.anthropic.com/news/claude-opus-5,new_development
GPT-5.6: Frontier intelligence that scales with your ambition,"# GPT-5.6: Frontier intelligence that scales with your ambition

More intelligence from every token, stronger performance per dollar, and more capability on demand for your hardest work.

## Efficient by default, maximum performance on demand

We're launching the GPT-5.6 family of models for general availability following our limited preview: our new flagship, Sol, alongside Terra, a balanced model for everyday work, and Luna, our most cost-efficient model.

GPT-5.6 Sol sets a new standard for both intelligence and efficiency, achieving state-of-the-art results across coding, knowledge work, cybersecurity, and science while outperforming previous and competing frontier models with fewer tokens and at lower estimated cost. The result is stronger performance per dollar: more successful work for the same spend, or comparable results at a lower total cost. We also introduce a new way to accelerate the most demanding work: `ultra` is our highest-capability setting, coordinating multiple agents across parallel workstreams to finish complex tasks faster. Stronger computer use and design judgment make GPT-5.6 Sol our most polished collaborator yet, helping it inspect, refine, and deliver ready-to-use results.

We trained GPT-5.6 to get more useful work from every token. On Agents' Last Exam, an evaluation of long-running professional workflows across 55 fields, GPT-5.6 Sol sets a new high of 53.6, eclipsing Claude Fable 5 (adaptive reasoning) by 13.1 points. Even at medium reasoning, it beats Fable 5 by 11.4 points at roughly one-quarter the estimated cost. That efficiency extends to smaller models, which are essential to making intelligence more abundant and affordable: GPT-5.6 Terra and GPT-5.6 Luna outperform Fable 5 at around one-sixteenth the cost. On the Artificial Analysis Intelligence Index, a broad measure of intelligence spanning agentic work, coding, scientific reasoning, and general capabilities, GPT-5.6 Sol with max reasoning comes within one point of Fable 5 while completing tasks in 61% less time at roughly half the estimated cost.

GPT-5.6 launches with our most robust safeguards to date, designed to be resilient against determined and adaptive misuse without broadly limiting legitimate work. Before general availability, we put the models and safeguards through our most extensive evaluation period yet, combining human red teaming with large-scale automated testing. During the preview, we worked closely with expert organizations and with trusted partners to pressure-test defenses and strengthen safeguards before broader launch. The resulting system layers protections trained into the model with real-time checks, monitoring, and access calibrated to trust and risk.

## Efficient by default, maximum performance on demand

GPT-5.6 Sol is our best coding model yet. On the Artificial Analysis Coding Agent Index, GPT-5.6 Sol with max reasoning sets a new state of the art at 80, 2.8 points above Fable 5, while using less than half the output tokens, taking less than half the time, and costing about one-third less. That advantage extends across the family: Terra performs just above Fable 5, while Luna outperforms Opus 4.8; each does so in roughly one-third of the time, with about half as many output tokens, and at approximately one-quarter the estimated cost. It also sets new state-of-the-art results on Terminal-Bench 2.1 and DeepSWE, which test complex command-line workflows and long-horizon engineering in real codebases.

GPT-5.6 can write and run lightweight programs that coordinate tools, process intermediate results, monitor progress, and choose the next action as work unfolds. This lets tool-heavy tasks advance with fewer tokens, fewer model round trips, and less guidance. Instead of requiring developers to script every step or passing every tool response back through the model, Programmatic Tool Calling in the Responses API can filter large amounts of intermediate data, retain only what matters, and adapt its workflow along the way.

For problems that reward a greater investment of time and compute, GPT-5.6 can push beyond this efficient default. `max` gives GPT-5.6 even more time than `xhigh` to reason and explore alternatives, run checks, and revise its approach. `ultra` goes further by coordinating four agents in parallel by default, trading higher token use for stronger results and faster time-to-result on demanding tasks. Across all three evaluations, adding parallel agents shifts the score-latency frontier upward and to the left, reaching stronger results in less time. In the API, developers can build ultra-like experiences using the multi-agent beta in the Responses API.

## A leap forward in design

GPT-5.6 delivers a step change in design judgment. With only high-level direction, GPT-5.6 creates tasteful, ergonomic, and functional interfaces. Its stronger computer-use capabilities let it inspect and refine the rendered result—not just generate the underlying code or content—so it can catch visual and functional issues and apply finishing touches before handing the work back.

GPT-5.6's frontend capabilities also turn natural-language requests into polished, interactive explanations and visualizations within ChatGPT Work.

## End-to-end knowledge work

GPT-5.6 delivers better results for professional tasks. It takes messy context from your documents and everyday workflows like Slack, Notion, Microsoft 365, and Google Drive, and converts it into expert-level, shareable artifacts.

GPT-5.6's strength on knowledge work shows up in evaluations spanning long-horizon professional analysis, browsing, tool use, and computer use. GPT-5.6 Sol sets new state-of-the-art results on BrowseComp at 92.2% and OSWorld 2.0 at 62.6%; on OSWorld, it surpasses Opus 4.8 while using 85% fewer output tokens. Here, the performance-per-dollar gains extend across the GPT-5.6 family. Luna nearly matches GPT-5.5's peak performance at less than half the estimated cost, while Terra surpasses it at a lower cost.

GPT-5.6 Sol improves quality in presentations, documents, and spreadsheets, producing outputs that are more polished and accurate. It can create fully editable presentations from scratch, translating a prompt and source material into a coherent visual narrative with strong layouts, hierarchy, and design.

The improvement is especially pronounced when following templates and reference decks. GPT-5.6 can infer a deck's design system—layouts, typography, spacing, colors, and recurring content patterns, including rules embedded in the Slide Master—and apply those conventions consistently to new material. In this example, when asked to update numbers based on a reference file, the GPT-5.5 output is missing key components from the master slide, while GPT-5.6 follows the reference structure more faithfully.

GPT-5.6 also creates more visually refined documents and spreadsheets. It follows complex reference formats more faithfully, which is important for repeatable knowledge work activities. It handles equations and financial models with greater precision, and makes better use of typography, spacing, hierarchy, and page or worksheet layout.

## Pushing the frontier on cyber and science

GPT-5.6 is our strongest cybersecurity model yet, achieving frontier performance with significantly fewer tokens. On ExploitBench, which measures progress from reaching vulnerable code through arbitrary code execution, it scores 73.5% versus GPT-5.5's 47.9% at a comparable output-token budget. On ExploitGym, which asks agents to turn real-world vulnerabilities into working exploits, it almost doubles GPT-5.5's peak pass rate, from 15.1% to 24.9% under the two-hour cap; with six hours, it reaches 33.7%. On SEC-Bench Pro, which tests proof-of-concept generation on complex software, it scores 71.2% versus GPT-5.5's 45.8% at an improved latency.

GPT-5.6 supports important defensive tasks such as secure code review, patching, threat modeling, and blue teaming. Qualified individuals and organizations in OpenAI Daybreak's Trusted Access for Cyber program can access more of its defensive capability through more precise safeguards for verified work in authorized environments, including vulnerability triage and validation, malware analysis, detection engineering, and patch validation.

Individuals can verify their identity and request trusted access, and organizations can apply for their teams. Individual members will need to enable Advanced Account Security with hardware-backed passkeys by September 1 to retain access to our most cyber-capable frontier models; those who do not will return to default access. Users who do not already have hardware-backed passkeys can receive preferred pricing from our partner, Yubico. We are also taking additional steps to restrict access to high-risk entities and in high-risk jurisdictions.

GPT-5.6 Sol also shows broad gains across scientific research. On life sciences evaluations, GPT-5.6 demonstrates Pareto improvements over GPT-5.5 on real-world biology, life science research workflows, and chemistry.

## GPT-5.6 accelerates OpenAI

GPT-5.6 is our strongest model yet for accelerating AI research. Inside OpenAI, researchers use it across the development loop: diagnosing failures, optimizing training systems, running experiments, and interpreting results. We already saw that acceleration and stronger adoption during the internal testing period of GPT-5.6, as average daily output tokens per active researcher were more than twice the highest level observed for GPT-5.5.

This way of working is quickly becoming standard. Over the past six months, the share of research compute devoted to internal coding inference grew 100-fold, while internal agentic token usage increased approximately 22-fold. These adoption metrics do not measure research progress on their own, but they show how rapidly AI assistance is increasing for research and across other teams like sales, marketing, user ops, finance, and more.

To measure this capability directly, we developed an internal suite of evaluations based on real AI research tasks, including debugging research systems, optimizing kernels and training recipes, running machine-learning experiments, and improving another model.

## Scaling safety and security with capability

As model capabilities increase, we strengthen our safety stack so advanced intelligence can remain broadly useful while applying greater scrutiny to the highest-risk uses. For GPT-5.6, we built our most robust safety system to date, calibrated to each model's capabilities and powered by more compute than ever before.

The GPT-5.6 models are more capable than our earlier models in both biology and cybersecurity but do not cross the Critical threshold in either category. In cybersecurity, our testing suggests GPT-5.6 is better at finding and fixing vulnerabilities than at reliably carrying out autonomous, end-to-end attacks against hardened targets—giving defenders an opportunity to strengthen systems before weaknesses are exploited. In biology, our testing suggests GPT-5.6 can support legitimate research but does not provide the end-to-end capability needed to create, engineer, or synthesize a highly dangerous novel threat.

Both domains are inherently dual-use. In cybersecurity, the same capabilities that could help an attacker exploit a vulnerability can help a defender find it, reproduce it, and build a reliable fix. Overblocking therefore creates a security risk of its own. It can prevent defenders from testing systems and deploying patches while malicious actors continue using other models, including increasingly capable open-source models, as well as established tools. Effective safeguards account for the context and likely consequences of a request, preserving legitimate defensive work while applying stronger controls where the evidence indicates a serious risk of harm.

GPT-5.6's safeguards are layered for greater accuracy and redundancy, and designed to adapt quickly as new attacks emerge. Protections trained into the model work alongside real-time checks, continuous monitoring, and account-level enforcement, to help the system remain safe even when a particular layer does not work as intended. In many systems, classifier flags alone decide what to block, relying on lower intelligence models that are harder to change in order to prevent harm. Our approach adds a reasoning monitor that reviews the conversation to determine if there is a potential for harm. This design is intended to enable defensive work while blocking serious misuse, with the most sensitive capabilities reserved for verified users through Trusted Access. Because some protections use test-time reasoning, we can rapidly update them to close gaps without retraining classifiers from scratch.

We are taking a more conservative approach as we continue to strengthen the system against adaptive attacks. Compared with previous models, our GPT-5.6 Sol cyber safeguards block roughly ten times more potentially harmful activity. Because these measures can create friction for benign use, we provide an option in ChatGPT and Codex to easily retry prompts on lower-capability models, and we will continue reducing the impact of our safeguards on benign use while maintaining a high robustness bar. This reflects our iterative deployment approach: starting conservatively and improving based on what we learn from real-world use.

Before general availability, we ran our most intensive safety evaluations to date, including extensive red teaming, robust capability and safeguard testing with external experts, and approximately 700,000 NVIDIA A100 Tensor Core GPU-equivalent hours of black-box automated red teaming. This enabled us to systematically probe likely weak points, surface jailbreaks, and help us strengthen the system before launch.

There is no such thing as perfect security, and our work to secure increasingly capable models continues. New weaknesses will be discovered, as will new jailbreaks that circumvent existing safeguards. Each new generation of model will also create new avenues for attack and misuse. We build for that reality through layered safeguards, continuous monitoring, rapid remediation, and collaboration across the defensive community. For GPT-5.6, we have paired our existing security and biology bug bounty programs with a new rapid-remediation process and our strongest monitoring effort to date. Findings from researchers, monitoring, and real-world misuse will feed into new evaluations and stronger safeguards on an ongoing basis.

## Availability and pricing

GPT-5.6 spans three model tiers: Sol, our flagship; Terra, a lower-cost model with performance competitive with GPT-5.5; and Luna, our fastest and most affordable model. The number identifies the generation, while Sol, Terra, and Luna are durable capability tiers that can advance on their own cadence.

GPT-5.6 is available starting today across ChatGPT, Codex, and the OpenAI API. The rollout is starting globally now and will continue gradually toward full availability over the next 24 hours.

- Chat: Plus, Pro, Business, and Enterprise users access GPT-5.6 Sol through medium and higher effort settings. Pro and Enterprise users can also select GPT-5.6 Sol Pro for the highest-quality results on complex tasks.
- ChatGPT Work and Codex: Free and Go users access GPT-5.6 Terra. Plus, Pro, Business, and Enterprise users can choose among GPT-5.6 Sol, Terra, and Luna and set an effort level for each. `max` is available to all users with access to GPT-5.6 in ChatGPT Work and Codex and can be toggled on in settings. In ChatGPT Work, `ultra` is available to Pro and Enterprise users. In Codex, it is available to Plus and higher plans.
- API: Developers can access Sol, Terra, and Luna through the OpenAI API. In the Responses API, Programmatic Tool Calling lets GPT-5.6 write and run programs in-memory that coordinate tools and process intermediate results, making it Zero Data Retention (ZDR) compatible. Multi-agent, initially available in beta, lets GPT-5.6 run concurrent subagents and synthesize their work in a single request.

GPT-5.6 is priced per 1M tokens across three model sizes: Sol is $5 input / $30 output; Terra is $2.50 input / $15 output; and Luna is $1 input / $6 output. GPT-5.6 also introduces more predictable prompt caching, including support for explicit cache breakpoints and a 30-minute minimum cache life. For GPT-5.6 and later models, cache writes are billed at 1.25x the model's uncached input rate, while cache reads continue to receive the 90% cached-input discount.

### Professional

| Eval | GPT-5.6 Sol | GPT-5.6 Terra | GPT-5.6 Luna | GPT-5.5 | Claude Fable 5 | Claude Opus 4.8 | Gemini 3.1 Pro Preview | Gemini 3.5 Flash |

| Agents' Last Exam | 52.7% | 50.4% | 50.3% | 46.9% | 40.5% | 45.2% | 32.1% | — |
| GDPval-AA v2 | 1,747.8 Elo | 1,593 Elo | 1,591.8 Elo | 1,493.7 Elo | 1,759.6 Elo | 1,600.1 Elo | 962.3 Elo | 1,348.8 Elo |
| Management Consulting Tasks (Internal) | 43.2% | 37.2% | 35.4% | 31.3% | 35.5% | 31.6% | 13.2% | — |
| Big Finance Bench | 53% | 51% | 36% | 49% | — | 44% | — | — |
| Artificial Analysis Intelligence Index v4.1 | 58.9 Index score | 55 Index score | 51.2 Index score | 54.8 Index score | 59.9 Index score | 55.7 Index score | 46.5 Index score | 50.2 Index score |

### Coding

| Eval | GPT-5.6 Sol | GPT-5.6 Sol Ultra | GPT-5.6 Terra | GPT-5.6 Luna | GPT-5.5 | Claude Mythos 5 | Claude Mythos Preview | Claude Fable 5 | Claude Opus 4.8 | Gemini 3.1 Pro Preview |

| Artificial Analysis Coding Agent Index v1.1 | 80 Index score | — | 77.4 Index score | 74.6 Index score | 76.4 Index score | — | — | 77.2 Index score | 72.5 Index score | 42.7 Index score |
| SWE-Bench Pro | 64.6% | — | 63.4% | 62.7% | 59.4% | 80.3% | 77.8% | 80% | 69.2% | 54.2% |
| DeepSWE v1.1 | 72.7% | — | 69.6% | 67.2% | 67% | — | — | 69.7% | 59% | 11.8% |
| Terminal-Bench 2.1 | 88.8% | 91.9% | 87.4% | 84.7% | 85.6% | 88% | — | 83.1% | 78.9% | 70.7% |

### Science and health

| Eval | GPT-5.6 Sol | GPT-5.6 Terra | GPT-5.6 Luna | GPT-5.5 | Claude Fable 5 | Claude Opus 4.8 | Gemini 3.1 Pro Preview | Gemini 3.5 Flash |

| GeneBench Pro | 28.7% | 23.3% | 10.8% | 12% | — | 16% | 3.1% | 8.14% |
| LifeSciBench | 59.9% | 56% | 51.2% | 50.4% | — | 53.6% | — | — |
| MedChemBench (Internal) | 48.3% | 35% | 30.4% | 35.5% | — | — | — | — |
| HealthBench Professional⁶ | 60.5% | 57.7% | 55.7% | 49.5% | 60.9% | 53% | — | — |

### Computer use

| Eval | GPT-5.6 Sol | GPT-5.6 Sol Ultra | GPT-5.6 Terra | GPT-5.6 Luna | GPT-5.5 | Claude Mythos 5 | Claude Mythos Preview | Claude Opus 4.8 | Gemini 3.1 Pro Preview |

| OSWorld 2.0 | 62.6% | — | 50.2% | 45.6% | 47.5% | — | — | 54.8% | — |
| BrowseComp | 90.4% | 92.2% | 87.5% | 83.3% | 84.4% | 88% | 87.9% | 84.3% | 85.9% |
| BenchCAD | 70.6% | — | 62.3% | 63.1% | 44.4% | 38.4% | 35.5% | 27.3% | — |
| BenchCAD (python tool) | 83.4% | — | 78.2% | 73.9% | 55.8% | 65% | 61% | 51.8% | — |

### Cybersecurity

| Eval | GPT-5.6 Sol | GPT-5.6 Sol Ultra | GPT-5.6 Terra | GPT-5.6 Luna | GPT-5.5 | Claude Mythos 5 | Claude Mythos Preview | Claude Opus 4.8 |

| Capture-the-Flag Challenges | 96.7% | — | 91.8% | 85.2% | 88.1% | — | — | — |
| SEC-Bench Pro | 71.2% | 74.3% | 57.7% | 48.9% | 45.8% | — | — | — |
| ExploitBench | 73.5% | — | 52.9% | 33.2% | 47.9% | 78% | 74.2% | 40% |
| ExploitGym | 33.7% | — | 23.2% | 12.4% | 15.1% | — | — | — |

### Self-improvement

| Eval | GPT-5.6 Sol | GPT-5.6 Terra | GPT-5.6 Luna | GPT-5.5 |

| Internal Research Debugging Evaluation | 68.3% | 67.8% | 50.8% | 50% |
| KernelGen 1P | 61.1% | 49.2% | 22.4% | 29.3% |
| NanoGPT | 9.69% | 14.5% | 1.66% | 2.65% |
| PostTrainBench Lite | 50.3% | 51.5% | 29.6% | 38.8% |
| RSI Index | 57.9% | 56.3% | 41.9% | 41.7% |

### Multimodal

| Eval | GPT-5.6 Sol | GPT-5.6 Terra | GPT-5.6 Luna | GPT-5.5 | Claude Fable 5 | Claude Opus 4.8 | Gemini 3.1 Pro Preview |

| MMMU Pro (no tools) | 83% | 80.7% | 78.4% | 81.2% | — | — | 80.5% |
| MMMU Pro (with tools) | 84.6% | 82% | 79.5% | 83.2% | — | — | — |
| gdp.pdf | 30.7% | 24.7% | 22.7% | 26% | 29.8% | 22.5% | 16.7% |

### Academic

| Eval | GPT-5.6 Sol | GPT-5.6 Terra | GPT-5.6 Luna | GPT-5.5 | Claude Mythos 5 | Claude Mythos Preview | Claude Fable 5 | Claude Opus 4.8 | Gemini 3.1 Pro Preview |

| GPQA Diamond | 94.6% | 92.9% | 92.3% | 93.6% | 94.1% | 94.6% | 92.6% | 92% | 94.3% |
| FrontierMath Tier 1-3 (v2) | 89% | 84.9% | 78.6% | 85.3% | — | — | 87% | 80% | 59.6% |
| FrontierMath Tier 4 (v2) | 83% | 68.3% | 58.5% | 72.5% | — | — | 87.8% | 56.1% | — |

### Tool use

| Eval | GPT-5.6 Sol | GPT-5.6 Terra | GPT-5.6 Luna | GPT-5.5 | Claude Mythos 5 | Claude Mythos Preview | Claude Fable 5 | Claude Opus 4.8 | Gemini 3.1 Pro Preview | Gemini 3.5 Flash |

| AutomationBench | 18.1% | 15.2% | 14.9% | 12.9% | — | — | 17.4% | 15.5% | — | 14.5% |
| Toolathlon | 58% | 53.1% | 53.4% | 55.6% | 61.7% | 61.1% | 61.7% | 59.9% | 48.8% | — |

### Long context

| Eval | GPT-5.6 Sol | GPT-5.6 Terra | GPT-5.6 Luna | GPT-5.5 | Claude Mythos 5 | Claude Mythos Preview | Claude Opus 4.8 |

| OpenAI MRCR v2 8-needle 256K-512K | 91.5% | 89.6% | 41.3% | 81.5% | — | — | — |
| OpenAI MRCR v2 8-needle 512K-1M | 73.8% | 72.5% | 41.3% | 74% | — | — | — |
| GraphWalks BFS 256k f1 | 90.7% | 76.9% | 81.3% | 73.7% | 91.1% | 85.7% | 85.9% |
| GraphWalks BFS 1mil f1 | 77.1% | 71.2% | 51.2% | 45.4% | 79.4% | 74.3% | 68.1% |

### Abstract reasoning

| Eval | GPT-5.6 Sol | GPT-5.6 Terra | GPT-5.6 Luna | GPT-5.5 | Claude Opus 4.8 | Gemini 3.1 Pro Preview |

| ARC-AGI-3⁷ | 7.78% | 0.8% | 0.18% | 0.43% | 1.5% | 0.42% |
",https://openai.com/index/gpt-5-6/,new_development
"Introducing Gemini 3.6 Flash, 3.5 Flash-Lite, and 3.5 Flash Cyber","# Introducing Gemini 3.6 Flash, 3.5 Flash-Lite, and 3.5 Flash Cyber

Our newest Gemini models deliver the efficiency, latency, and reliability to build AI agents at scale.

---

Developers and customers building production AI agents need higher token efficiency, lower latency, and more reliable performance. Our Flash series of models is built to meet the sweet spot of efficiency and quality to enable scaling agentic workflows. Building on Gemini 3.5 Flash, we're introducing new Gemini models:

- 3.6 Flash: Our workhorse model that delivers better coding, knowledge work, and multimodal performance. According to the Artificial Analysis Index, it reduces output token usage by 17% compared to 3.5 Flash, and in some benchmarks like DeepSWE by Datacurve, we observe up to 65%, all at a lower cost per output token.
- 3.5 Flash-Lite: Our fastest, most cost-effective 3.5-class model, delivering 350 output tokens per second according to the Artificial Analysis Index, also significantly outperforming prior Flash-Lite generations in agentic workflows.
- 3.5 Flash Cyber in CodeMender: Successful cybersecurity applications require careful orchestration of a model alongside an agent infrastructure. We're introducing a combination of a new, highly efficient, specialized cyber-focused model paired with our CodeMender code security agent that delivers competitive performance at the frontier.

Beyond today's releases, Gemini 3.5 Pro is currently testing with partners and we plan to make it broadly available as soon as it's ready. In parallel, our team is already focusing on building the next generation of models. We have started our most ambitious pre-training run yet, for Gemini 4, and are excited by the progress.

## 3.6 Flash: More efficient and better quality than 3.5 Flash

Gemini 3.6 Flash builds directly on developer and customer feedback from 3.5 Flash. 3.6 Flash not only delivers a step up in coding and knowledge work, but it does this while meaningfully improving token efficiency. For example, on the Artificial Analysis Index, we see 3.6 Flash consuming 17% fewer output tokens than 3.5 Flash. It also takes fewer reasoning steps and tool calls to accomplish multi-step workflows.

This enhanced efficiency is also combined with a lower price than 3.5 Flash. At $1.50/1M input tokens and $7.50/1M output tokens, 3.6 Flash reduces the overall cost per agentic task, making agents more cost-effective to build and run.

Even while being more efficient, 3.6 Flash sees performance gains compared to 3.5 Flash across use cases:

- 3.6 Flash delivers higher precision with fewer unwanted code edits and reduced execution loops, as seen in DeepSWE (49% vs. 37%), and shows significant improvement in ML Research, as seen in MLE Bench (63.9% vs. 49.7%).
- It has improved computer use capabilities as seen in OSWorld-Verified (83.0% vs. 78.4%). Computer use is now a built-in client side tool via the Gemini API and Gemini Enterprise.
- It outperforms 3.5 Flash in knowledge work, as shown by benchmarks like GDPval-AA v2 (1421 vs. 1349). Customers like Hebbia and Harvey have found it particularly capable at multimodal tasks like document parsing, chart and data analysis, and report drafting.

Customers report 3.6 Flash is a step forward in both cost and quality, balancing token efficiency, accuracy, and speed across complex workflows and knowledge-based tasks.

## Built with safety

3.6 Flash is shipping with enhanced Frontier Safety safeguards in the domains of Chemical, Biological, Radiological, and Nuclear (CBRN) and cyber offense misuses. These safeguards make the model substantially more resistant to jailbreaks. At the same time, the model has been trained to minimize refusals for beneficial uses.

For more information, see the 3.6 Flash model card.

## 3.5 Flash-Lite: Built to scale agentic workflows

Beyond Flash, we're also releasing Gemini 3.5 Flash-Lite, designed for both low-latency tasks and tasks where high throughput is critical for developers workflows, like agentic search and document processing.

3.5 Flash-Lite is the fastest model in the 3.5 series. As measured by Artificial Analysis, it runs at 350 output tokens/s. Priced at $0.3/1M input tokens and $2.5/1M output tokens and with significantly better quality than 3.1 Flash-Lite, 3.5 Flash-Lite offers a strong price-to-performance ratio for developers and customers running high throughput production traffic.

3.5 Flash-Lite enables efficient scaling for agentic systems. Across thinking levels, the model significantly outperforms 3.1 Flash-Lite. Depending on the workload, developers can configure the model to prioritize low-latency, low-cost execution for high-volume tasks with the minimal and low thinking levels, or engage higher thinking levels to process multi-step subagent workloads. The model now also has computer use as a built-in tool to reliably support these agentic tasks across surfaces.

It's a significant step up in coding and agentic tasks as seen in Terminal-Bench 2.1 (54% vs 31%), long context as seen in GDM-MRCR v2 (72.2% vs. 60.1%), and real-world task execution as seen in GDPval-AA v2 (1140 vs. 642).

In fact, on many agentic and coding evals, 3.5 Flash-Lite even outperforms 3 Flash, including on SWE-Bench Pro (54.2% vs. 49.6%) and OSWorld-Verified (74.0% vs. 65.1%), making it a faster & more capable option for workloads on both 2.5 and 3 Flash.

For more information about the model, see the 3.5 Flash-Lite model card.

## 3.5 Flash Cyber in CodeMender: finding and fixing vulnerabilities efficiently

AI models have become capable of finding security vulnerabilities faster than current systems can fix them. Tackling this growing threat requires an approach to securing software that is highly capable and efficient.

Flash's performance and efficiency makes it an ideal foundation to detect, validate, and patch code security issues at scale. Gemini 3.5 Flash Cyber is built on top of 3.5 Flash, and fine-tuned for finding and fixing cybersecurity vulnerabilities at a lower price per token than larger models.

Within CodeMender, which uses multiple 3.5 Flash Cyber agents working together to produce a single combined report, 3.5 Flash Cyber reaches competitive performance at the frontier on the popular benchmark CyberGym.

Given the dual-use nature of this technology, we have taken an intentional approach to deploying 3.5 Flash Cyber. The model will be exclusively available to governments and trusted partners via CodeMender soon as part of a limited-access pilot program. This will give frontline defenders a head start in finding and fixing critical vulnerabilities before they can be exploited, while mitigating against broader misuse.

## 3.6 Flash and 3.5 Flash-Lite: Get started today

3.6 Flash and 3.5 Flash-Lite are available starting today:

- For developers in the Gemini API via Google AI Studio and Android Studio. 3.6 Flash is also available in Google Antigravity. Get started with the Developer Guide.
- For enterprises in Gemini Enterprise Agent Platform. 3.6 Flash is also available in the Gemini Enterprise app.
- For everyone via the Gemini app. 3.5 Flash-Lite is also rolling out in Google Search.

As you start building with 3.6 Flash and 3.5 Flash-Lite, we welcome your feedback to improve future Gemini models and look forward to releasing 3.5 Pro soon.
",https://blog.google/innovation-and-ai/models-and-research/gemini-models/gemini-3-6-flash-3-5-flash-lite-3-5-flash-cyber/,new_development
Gemini Robotics 2 brings whole body intelligence to robots,"# Gemini Robotics 2 brings whole body intelligence to robots

From feet to fingertips — we are teaching robots intelligent whole-body control, fine dexterity, and teamwork to complete a broad range of complex tasks

For decades, we've dreamed of robots that can seamlessly step into our world and lend a hand. Now, that vision takes a significant stride forward.

Most robots are pre-programmed or teleoperated for narrow, repetitive task sequences. They lack the ability to truly learn for themselves or adapt to unpredictable environments. Moreover, transferring learned skills from one robot body to another remains incredibly difficult. To take on the hardest problems at scale, robots of every shape and size need AI models giving them the ability to think, act, and interact intelligently to safely complete tasks.

We demonstrated how Gemini's multimodal understanding could drive real-world action with Gemini Robotics. Today, we are introducing Gemini Robotics 2 - the intelligence layer powering the next generation of truly adaptable robots. As it takes its first literal steps, this major advance unlocks intelligent whole-body control, advanced dexterity, and multi-robot collaboration.

Gemini Robotics 2 enables robots to reason through every movement, unlocking a broad range of tasks. For example, it can enable a humanoid to walk, crouch, stretch, and manipulate objects to clean up a cluttered room. It can even team up with other robots to finish the job faster. And this profound intelligence can also run locally on-device while seamlessly adapting to entirely new robotic bodies in just a few hours.

We are making this possible through three highly capable models:

- Gemini Robotics 2: Our most advanced vision-language-action model (VLA) that converts vision and language input into motor control, enabling a robot to take action. This model is capable of controlling full humanoids, from feet to fingertips, and other bi-arm robots. It also brings a new level of dexterous manipulation on both hands and grippers.
- Gemini Robotics ER 2: Our most capable embodied reasoning (ER) model. It is a vision language model (VLM) that acts as our agent, enabling robots to communicate with humans, understand the physical world and plan multi-step tasks lasting several minutes. We are also introducing the ability for robots to work together as a team.
- Gemini Robotics On-Device 2: Our most efficient vision-language-action model (VLA) optimized to run locally on robotic devices. This model can now achieve fast adaptation to completely new robot embodiments with a few hours of data.

## Humanoids in motion: Managing whole-body tasks

The world is built for human movements; it requires us to reach, bend, and balance in tight, cluttered spaces. While our previous models controlled the humanoid's upper-body to achieve table-top tasks, Gemini Robotics 2 expands physical AI into whole-body motions.

For the first time, our model can now control entire humanoid robots, translating intent into intelligent whole-body control. For example, when controlling Apptronik's Apollo 2 humanoid robot, we can ask it to put the watering can into the green bin in the bottom shelf. Apollo processes the instruction, walks to the table, and picks up the watering can, takes a few steps to the shelves, and places it precisely in its destination. While our robots have more to advance in movement speed, this is an important step towards the skills needed to complete more complex, real-world tasks that require whole-body coordination.

## Bringing advanced dexterity to hands and grippers

To be genuinely useful in our homes and workplaces, robots need finesse. Gemini Robotics 2 unlocks a new level of physical dexterity across different end effectors, whether a robot is using hands or grippers, enabling robots to be more useful than ever before.

The model can now control the five-fingered, 22 degree-of-freedom SharpaWave hand on the Apollo 2 robot to complete delicate actions like tying knots or sealing a ziplock bag. It can also operate standard two-fingered parallel grippers on a Franka Duo platform to perform complex dexterous tasks (e.g. tight packing). We are continuing to advance the level of precision and speed to achieve human-level dexterity.

## Unlocking advanced tasks with agentic reasoning and multi-robot collaboration

Most real-world tasks require multiple steps over an extended period of time. To manage this complexity, our embodied reasoning (ER) model, Gemini Robotics ER 2, serves as the robot's high-level brain, processing user instructions and communicating with humans. It observes the room, reasons about the steps needed to complete the task, coordinates with the VLA to carry out the actions, and tracks progress until the task is done. This setup allows robots to execute complex multi-step tasks, self-correct if a step fails, and generalize to novel situations and goals.

In this update, we are enabling robots to more reliably execute longer task sequences, lasting several minutes and involving hundreds of decisions. Gemini Robotics ER 2 now understands when tasks begin and end, and can pinpoint the moment key events occur, marking a step change in progress understanding.

Furthermore, we are introducing multi-robot collaboration. This enables different types of robots to communicate and work together to solve complex workflows a single robot could not do alone.

## Adapting fast on-device models for any robot

Many robotic applications need to operate without network latency or internet connectivity. Gemini Robotics On-Device 2 is built specifically to handle these constraints — it is our most-efficient vision-language-action model (VLA) optimized to run locally on robotic devices.

This model is natively multi-embodiment and inherits our advanced ""motion transfer"" techniques from Gemini Robotics 1.5. We can now adapt to new bi-arm robot embodiments with just a few hours of adaptation time, typically with less than 200 examples. This works even with new embodiments with drastically different shapes, sensors and degrees of freedom.

## Advancing our commitment to safe and responsible robotics

Safety is foundational to our robotics research. As robots gain more physical capabilities, we are committed to ensuring end-to-end safety and alignment. With each release, we've taken a multi-layered approach that combines traditional physical safety measures with robust AI safety frameworks.

Gemini Robotics 2 specifically advances robotics safety for navigating the uncertainty of the real world and collaborating alongside humans.

We're introducing ASIMOV-Agentic, a new benchmark for agentic safety orchestration and uncertainty resolution. For example, it measures the embodied reasoning agent's ability to refuse unsafe tool calls from a VLA. It also measures the agent's ability to predict whether a task is possible and to proactively request human intervention when uncertain.

Additionally, with enhanced embodied reasoning, Gemini Robotics ER 2 is our safest robotics model to date in safety constraint following and human proximity benchmarks. It can better detect when humans are nearby, trigger safety tool calls and bring the robot to a safe stop if someone approaches too closely. This is a key requirement in collaborative safety standards.

## Building towards general-purpose physical AI

Gemini Robotics 2 marks an important milestone on the path toward solving AGI in the physical world. Unlocking the true potential of robotics requires moving past single-task automation toward general-purpose intelligence. By building this core intelligence, our goal is to enable AI in the physical world that can work alongside humans to solve complex challenges.
",https://deepmind.google/blog/gemini-robotics-2-brings-whole-body-intelligence-to-robots/,new_development
"NVIDIA Nemotron 3 Embed Ranks #1 Overall on RTEB, Advancing Agentic Retrieval","# NVIDIA Nemotron 3 Embed Ranks #1 Overall on RTEB, Advancing Agentic Retrieval

Retrieval is critical in multi-step agentic workflows where poor retrieval can cause agents to fetch irrelevant context, re-query, waste token budget, and carry noise into later reasoning steps.

Today, NVIDIA is releasing NVIDIA Nemotron 3 Embed, a collection of open and commercially available embedding models designed to improve retrieval quality while giving developers practical deployment options for production-scale RAG, agentic retrieval, code retrieval, and agent memory.

The collection includes three open models that achieve state-of-the-art retrieval across the accuracy-efficiency curve, led by an 8B model that tops the RTEB leaderboard and efficient 1B variants built for production-scale deployment:

| Model | Role | Best for |

| Nemotron-3-Embed-8B-BF16 | Flagship Quality Anchor: The flagship embedding model, ranking #1 on RTEB. | Precision-critical retrieval and high-stakes enterprise RAG |
| Nemotron-3-Embed-1B-BF16 | High-Efficiency Standard: A high-efficiency model for production retrieval where latency and cost matter. | Cost- and latency-sensitive production serving |
| Nemotron-3-Embed-1B-NVFP4 | Hardware-Accelerated Variant: A Blackwell-optimized variant for high-throughput retrieval with a smaller memory footprint. | Ultra-high-throughput and massive-scale infrastructure |

## Key Features

Beyond the RTEB result, Nemotron 3 Embed introduces a production-ready feature set for enterprise retrieval deployments:

- Open Weights, Datasets, and Recipes: Gives teams control to inspect, tune, fine-tune, and deploy retrieval models on their own infrastructure.
- 32k Context Window: Supports retrieval over long documents, large code contexts, and multi-turn agent histories while reducing truncation.
- Multilingual & Code Retrieval: Supports retrieval across global enterprise data, technical documentation and multi-file code repositories.
- NVIDIA NVFP4 Efficiency: Provides a Blackwell-optimized 4-bit deployment path for high-throughput retrieval with a smaller memory footprint.
- Fine-Tuning and Distillation Recipes: NVIDIA NeMo AutoModel recipes support domain adaptation and model compression for teams adapting retrieval models to their own data.
- Day-0 Ecosystem Integration: Available immediately on Hugging Face, deployable as NVIDIA NIM microservice, supported by vLLM, and accessible through leading AI Cloud and inference partners.

## Evaluation: Retrieval Quality, Agentic Efficiency, and Deployment Tradeoffs

We evaluate Nemotron 3 Embed across three dimensions: retrieval quality, downstream agentic efficiency, and deployment tradeoffs. The 8B model establishes the model collection's quality ceiling, while the 1B BF16 and NVFP4 variants bring the same retrieval-focused design to lower-cost and higher-throughput deployment settings.

### RTEB Leadership and Strong Gains Across Retrieval Benchmarks

We first evaluated the models on RTEB, where Nemotron-3-Embed-8B-BF16 ranks #1. We also tested these models across ViDoRe V3 Text, and MMTEB Retrieval and LongEmbed using average NDCG@10.

- Nemotron-3-Embed-8B-BF16 ranks #1 on RTEB, scoring 78.5% on RTEB and 75.5% on MMTEB Retrieval.
- Nemotron-3-Embed-1B-BF16 brings much of the 8B model's retrieval quality into a smaller deployment footprint. It scores 72.4% on RTEB, reducing error rate by 27% over its 1B predecessor (llama-nemotron-embed-vl-1b-v2), and scores 71.0% on MMTEB Retrieval, reducing error rate by 28%.

### Why Better Retrieval Matters for Agents

To evaluate retrieval in an agentic setting, we use a search agent powered by Nemotron 3 Ultra and vary the embedding model used by the retrieval system. Better retrieval can return relevant evidence earlier, helping the agent avoid repeated searches, unnecessary reasoning turns, and extra context inspection. We compare average retrieval accuracy with estimated downstream agentic token cost per query across ViDoRe V3, BRIGHT, and BrowseComp-Plus.

Figure 3 shows that stronger retrieval reduces downstream agentic token cost. More accurate retrievers return relevant evidence earlier, which helps agents complete tasks with fewer repeated searches and fewer reasoning turns. In these evaluations, the Nemotron 3 Embed models improve the agentic retrieval frontier, with the 8B model delivering both the highest average retrieval accuracy and the lowest estimated downstream token cost across ViDoRe V3, BRIGHT, and BrowseComp-Plus.

### Scaling Retrieval with NVFP4 on Blackwell

For high-throughput deployments, teams often choose smaller embedding models to meet latency and cost targets. Nemotron-3-Embed-1B-NVFP4 is designed to narrow the gap between serving efficiency and retrieval quality by using native NVFP4 acceleration on NVIDIA Blackwell architectures. The model quantizes the weights and activations of linear layers to NVFP4 for efficient inference, and uses Quantization-Aware Distillation (QAD) to help recover accuracy for long input sequences.

- Serving Efficiency: NVFP4 on Blackwell delivers up to 2x higher throughput than BF16 for high-throughput, low-latency retrieval serving.
- Accuracy retention: The NVFP4 variant retains 99%+ of BF16 retrieval accuracy while reducing memory footprint.

### Day 0 Performant NIM

For production-scale retrieval systems, the serving stack also needs to preserve that efficiency under real request loads, across different input sequence lengths and hardware targets. To make Nemotron 3 Embed performant at enterprise scale today, an optimized NVIDIA NIM microservice is released for the 1B model. The Rust-based Nemotron 3 Embed NIM matches or outperforms the vLLM checkpoint on NVIDIA GB200 and RTX PRO 6000 GPUs across input sequence lengths of 256 & 1024.

## How We Built the Nemotron 3 Embed Models

Nemotron-3-Embed-8B-BF16 adapts the Ministral-3-8B-Instruct-2512 backbone by converting its causal decoder into a bidirectional encoder for full-sequence retrieval. The model is trained with contrastive pre-training on a blend of web-sourced and synthetic text pairs, then fine-tuned on curated multilingual retrieval datasets across domains such as legal, finance, medical, business, and education. This 8B model serves as the flagship embedding model, while earlier 8B teacher checkpoints from the same development line were used to distill the efficient 1B variants.

### Scaling Down to 1B

The 1B model is not a small retriever trained from scratch. We first applied the bidirectional adaptation recipe to the Ministral-3-3B-Instruct-2512 backbone to establish a 3B retriever base, then compressed it through two-rounds of structured pruning and distillation.

First, the 3B parent model was compressed to a 2B intermediate footprint using NVIDIA ModelOpt's mcore_minitron Neural Architecture Search engine. The NAS pipeline searched across hidden width, FFN size, attention heads, and depth under a strict parameter budget to identify an efficient architecture for retrieval workloads.

The resulting 2B intermediate model was then distilled from an 8B teacher checkpoint to recover ranking accuracy. A combined cosine distance loss and mean squared error loss was used on a multilingual, in-domain retrieval data blend to align the student's embeddings with the teacher.

This same sequence, ModelOpt structured pruning followed by 8B teacher distillation, was repeated a second time to compress the 2B intermediate model down to the final 1.14B embedding model. Final training used a progressive two-stage context-scaling schedule:

- Stage 1: Focused on broad multilingual alignment at 1024-token context length to reconstruct the core retrieval behavior of the parent model.
- Stage 2: Expanded context length to 4096 tokens and added long-context synthetic and reasoning datasets, helping the 1B model retain discriminative recall across longer inputs.

The following table summarizes the core technical specifications and deployment targets for the Nemotron 3 Embed models:

| Model | Size | Emb Dim | Context Window | Pooling | Input Prefix | Target Hardware |

| Nemotron-3-Embed-8B-BF16 | 8.0B | 4096 | 32k | Mean | query: / document: | General GPU Inference |
| Nemotron-3-Embed-1B-BF16 | 1.14B | 2048 | 32k | Mean | query: / document: | Low-latency CPU/GPU |
| Nemotron-3-Embed-1B-NVFP4 | 1.14B | 2048 | 32k | Mean | query: / document: | NVIDIA Blackwell/GB200 |

## Enterprise Partner Evaluations

Enterprise ISVs, AI-native companies, data platform companies, and memory providers are already evaluating Nemotron 3 Embed across agentic retrieval, agent memory, code retrieval, and production inference workflows.

Partners include Automation Anywhere, Boomi, Elastic, IBM, Mem0, Palantir, ServiceNow, turbopuffer, You.com, Zep, and Zoom. Organizations are integrating the models into vector search and RAG applications, conducting edge retrieval workloads, fine-tuning for domain-specific use cases, and evaluating them for agent memory and context retrieval systems.

## Getting Started

NVIDIA Nemotron 3 Embed is released with open weights and open-source training recipes, giving organizations full control over how retrieval models are customized and deployed for production AI applications.

Developers can get started using the deployment option that best fits their workflow:

- Hugging Face - Access the model weights, model cards, and example code for SentenceTransformers, Transformers, and vLLM.
- NVIDIA NIM - Access optimized microservice on build.nvidia.com for production-ready inference.
- AI Cloud and Inference Partners - Deploy Nemotron 3 Embed through leading ecosystem partners including Baseten, Bitdeer AI, DeepInfra, Friendli AI, and OpenRouter.

For workloads requiring domain adaptation or footprint reduction, open-source NVIDIA NeMo AutoModel training recipes are available:

- Fine-tuning recipe - Adapt Nemotron 3 Embed to your enterprise corpus and retrieval tasks.
- Distillation recipe - Compress larger retrieval models while retaining ranking quality for production deployment.

For example, on the NV Docs evaluation, fine-tuning Nemotron-3-Embed-1B-BF16 improved NDCG@10 from 56.7% to 63.3% (+11.6%) and Recall@5 from 56.1% to 62.8% (+11.9%).

Whether building enterprise search, production RAG, agent memory, code retrieval, or agentic AI systems, NVIDIA Nemotron 3 Embed provides flexible deployment options—from open-source models on Hugging Face to fully managed AI Cloud platforms and NVIDIA NIM microservices.
",https://huggingface.co/blog/nvidia/nemotron-3-embed-wins-rteb,new_development
Thinking of ACE? We Can Do It with Fewer Tokens,"# Thinking of ACE? We Can Do It with Fewer Tokens

*ALTK-Evolve and ACE both let an agent learn from its own trajectories. The difference is what they do with what they learn — and that decides the token bill.*

Give an LLM agent a realistic multi-step task — split a bill, find a song, reconcile an order across nine simulated apps — and when it fails, it usually isn't for lack of knowledge. It mis-paginates an API, resolves the wrong person, or returns a value when none was asked for. The model knows the APIs; what it hasn't internalized is *how to use them reliably*. That's learnable from the agent's own history.

Two recent systems do exactly this, on the same kind of agent: ACE (Agentic Context Engineering) and ALTK-Evolve. Both are a form of agentic memory — turning an agent's past trajectories into reusable lessons and feeding them back at inference time, no weight updates, no human labels. They even agree on the hard part. Where they part ways is *delivery*.

A note on words, because the two systems name things differently: we'll call the raw thing an agent learns a lesson. ACE organizes its lessons into one comprehensive, evolving playbook; ALTK-Evolve consolidates theirs into individually retrievable guidelines. Same lessons, two containers.

## What we agree on

Both systems refuse to compress.

ACE names the failure modes precisely: brevity bias — optimization collapsing toward short, generic instructions — and context collapse — a model asked to rewrite its whole context each step summarizing the detail away. Its answer is to keep a rich, itemized playbook, with a helpful/harmful counter on every bullet, and let the model distill relevance at read time.

ALTK-Evolve reaches the same conclusion from the other direction. Every distinct guideline keeps a support count — how many independent episodes produced it — and the system never summarizes the store down to a handful of rules. A lesson five different tasks discovered is a different object from one that appeared once, and both are worth keeping.

So on the core question — *should you compress an agent's hard-won lessons into a tidy summary?* — ACE and ALTK-Evolve give the same answer: no. Count them, don't collapse them. ACE's per-bullet counters and ALTK-Evolve's support counts are two spellings of the same idea.

## Where we differ

Two places: how the memory is built, and how it's delivered — and it's the delivery difference that shows up in the token bill.

Consolidation (how the store is built). ACE grows one playbook through a Generator → Reflector → Curator loop, applying incremental delta updates and de-duplicating by embedding. ALTK-Evolve clusters near-duplicate lessons and merges *within* a cluster, support-conserving — when several lessons merge, the survivor inherits their combined count, so the store shrinks without losing the record of how much experience backs each guideline. ALTK-Evolve also extracts *typed* guidelines — strategy, recovery, and optimization — with causal attribution and provenance back to the source trajectory, and at subtask granularity, so a lesson learned on one app can transfer to another.

Delivery (what reaches the model at inference). This is the one that drives the numbers. ACE injects the comprehensive playbook on every step, the same way regardless of model or task. ALTK-Evolve treats delivery as a dial, not a constant: a small fixed core of high-support guidelines, extended per task with a handful selected for the task at hand (cosine or LLM-guided, priority-weighted) — or, when a model has the headroom to use it, the full consolidated set. The same lessons are *available* to both agents; the difference is that ACE always sends all of them, and ALTK-Evolve sends however many a given model can actually use.

## Why it matters

On AppWorld, with the *same* base ReAct agent, running both systems in-house:

| Model | | TGC / SGC | Tokens/task |

| DeepSeek-V3.2 | ACE | 80.4 / 73.2 | 634K |
| | ALTK-Evolve | 89.3 / 80.4 | 263K |
| gpt-oss-120b | ACE | 54.8 / 35.7 | 777K |
| | ALTK-Evolve | 56.0 / 37.5 | 116K |

On the strong model ALTK-Evolve achieves better results on both metrics at ""~40% of ACE's inference cost."" On the weak model it edges ACE 56.0 to 54.8 — described as a ""tie on accuracy"" — at ""about one-seventh"" the cost.

A fair word on cost: ACE's efficiency story is about *building* its context cheaply. ALTK-Evolve's focuses on a different axis — *serving* it. Retrieving a few guidelines per task instead of injecting the whole playbook on every step is where the tokens go, and it's the direct consequence of the delivery difference above.

Where does the accuracy come from? The by-difficulty breakdown tells two different stories:

On gpt-oss-120b, ACE's full playbook has the edge on Easy and Medium — there's enough of the task solved by generic instruction-following that a comprehensive prompt helps more than it distracts. But on Hard tasks, where the model has to pick the *right* lesson rather than wade through all of them, curated retrieval pulls ahead — and that's the tier that decides the aggregate. On DeepSeek-V3.2 the story flips: the stronger model absorbs ACE's full playbook well enough to edge ALTK-Evolve on Medium, but ALTK-Evolve leads Easy, Hard, and Overall — with more capacity to spare, more lessons (delivered its way) keep helping instead of crowding each other out.

ALTK-Evolve gives each model its best configuration — the full consolidated set for the strong model, selective retrieval for the weaker one, because a large context overwhelms a weaker model rather than helping it.

## Same lessons, different delivery

Both systems refuse to compress an agent's hard-won experience into a tidy summary — that part, they agree on. The difference is whether delivery is fixed or calibrated: ACE sends the whole playbook every step no matter what; ALTK-Evolve sends however much of the guideline set a given model can actually use. That calibration is what bought the numbers above — same-or-better accuracy at a fraction of ACE's inference cost — and on the weaker model, it was the difference between guidance that helped and guidance that got in the way.

---

## Method notes

AppWorld `test_normal`, 168 tasks. A ReAct code agent (each step writes Python; the environment returns the output). TGC = Task Goal Completion; SGC = Scenario Goal Completion, which requires *every* variant of a scenario to pass. Memory is mined from train/dev only; results are single runs (pass@1), as is standard on this benchmark.

The ACE numbers are their own runs of the ACE agent, evaluated in-house on the same AppWorld splits and the same base models as ALTK-Evolve (DeepSeek-V3.2 and gpt-oss-120b). The ACE paper reports on a different base model (DeepSeek-V3.1), so running it themselves keeps the comparison controlled for model and harness. Both systems are the *same* ReAct agent and differ only in the prompt template — which is why the two no-memory baselines differ (72.0 vs 79.8 TGC); the comparison rests only on claims a prompt tweak can't touch: same-or-better accuracy at a fraction of the tokens.

### Reference tables

DeepSeek-V3.2 — `test_normal` (168 tasks):

| System | Guidelines | TGC | SGC | Tokens/task |

| ReAct, no memory | 0 | 79.8 | 64.3 | 148K |
| ReAct + ACE | 106 | 80.4 | 73.2 | 634K |
| ReAct + ALTK-Evolve | 191 | 89.3 | 80.4 | 263K |

gpt-oss-120b — `test_normal`:

| System | Guidelines | TGC | SGC | Tokens/task |

| ReAct, no memory | 0 | 39.9 | 21.4 | 110K |
| ReAct + ACE | full | 54.8 | 35.7 | 777K |
| ReAct + ALTK-Evolve (selected) | ~29 | 56.0 | 37.5 | 116K |

gpt-oss-120b — by difficulty (TGC):

| Difficulty | Baseline | ACE | ALTK-Evolve |

| Easy | 66.7 | 84.2 | 82.5 |
| Medium | 35.4 | 60.4 | 56.2 |
| Hard | 19.1 | 23.8 | 31.8 |
| Aggregate | 39.9 | 54.8 | 56.0 |

DeepSeek-V3.2 — by difficulty (baseline → +memory):

| Tier | ALTK TGC | ALTK SGC | ACE TGC | ACE SGC |

| Overall | 79.8 → 89.3 | 64.3 → 80.4 | 72.0 → 80.4 | 57.1 → 73.2 |
| Easy | 93.0 → 94.7 | 84.2 → 84.2 | 78.9 → 84.2 | 63.2 → 78.9 |
| Medium | 81.2 → 97.9 | 62.5 → 93.8 | 85.4 → 100.0 | 75.0 → 100.0 |
| Hard | 66.7 → 77.8 | 47.6 → 66.7 | 55.6 → 61.9 | 38.1 → 47.6 |
",https://huggingface.co/blog/ibm-research/altk-evolve-sldd,new_development
Making Knowledge Distillation Cheap Enough to Run at Scale,"# Making Knowledge Distillation Cheap Enough to Run at Scale

Published August 10, 2026

Knowledge distillation, training a smaller student model to match the performance of a larger teacher, is a well-known technique in Machine Learning. With the recent wave of open-source Large Language Models, such as gpt-oss, Qwen, GLM, or Kimi, it has become a mainstream research topic again. Deploying these very large models is expensive: the recent Kimi-K3 model has 2.8 trillion parameters and needs roughly 3TB of VRAM just to load. Compressing them into smaller models and recovering the original capabilities through knowledge distillation has therefore become standard practice, with companies like Nvidia (Nemotron 3 Puzzle 75B) or Multiverse Computing (Hypernova 60B) recently releasing high-quality compressed models.

The distillation step is what decides most of the final quality, but it's also usually the most expensive part of the pipeline. Keeping both the teacher and student loaded, and producing a probability distribution over the entire vocabulary for every token, requires enormous amounts of VRAM, typically feasible only with hundreds of GPUs and careful tensor-parallelism strategies. Our latest paper, Efficient Knowledge Distillation for LLMs: Offline Top-K Logits and a Fused Chunked KL Loss, tackles this with two systems changes: caching the teacher's top-K logits once so the teacher never has to sit in memory alongside the student, and a new, memory-efficient KL-divergence loss that avoids ever materializing the full vocabulary-size × sequence-length matrix, cutting VRAM use far below what the default implementations in libraries like PyTorch or NVIDIA Megatron-Bridge achieve. Together, these two changes cut training cost enough to make long-context healing possible on a single GPU, and cheap enough to make large-scale experimentation practical.

## Why distillation recovery is expensive

The standard setup, *online* distillation using the Kullback-Leibler divergence loss (KL loss), keeps both the teacher and the student loaded at the same time. At every training step, the teacher runs a full forward pass to produce its output distribution, and the student is trained to match it. This is the most expressive setup, since the full teacher distribution is available, but it is also the most memory- and compute-intensive: two full-vocabulary tensors have to be held per token position, and the teacher has to be recomputed on every single step even though its behavior does not change across a training run.

As a practical example, gpt-oss-120b has a vocabulary of 201,088 tokens. At a sequence length of 32K and batch size 4, the teacher-probability tensor alone has shape `4 × 201,088 × 32,768`; in bfloat16, that's already about 50GB of VRAM for a single tensor. Add gradients, activations, model weights, and optimizer states, and a single training iteration of distillation can peak at roughly 250GB of VRAM, more than even an H200 or B200 GPU can provide. In this post, we show that reformulating the KL loss to process the data in chunks reduces this cost to almost nothing.

## Two systems changes

Offline distillation. Instead of recomputing the teacher at every step, we compute its output once, cache the top-100 most likely tokens per position, and train the student against that cache. The teacher never has to sit in memory during training and does not need to be run again once the cache exists, so the same cache can be reused across many ablations.

A fused, chunked KL loss. To see why the loss itself is expensive, picture what it actually builds: for every token position in a sequence and every word in the vocabulary, the loss needs a number describing how much the student's prediction disagrees with the teacher's. Laid out as a grid, that's one row per vocabulary entry and one column per sequence position, for a vocabulary of 100K+ words and a long sequence, that grid is enormous, and the default way of computing a KL loss builds the whole thing before it can produce a single number.

We compare three ways of computing this same loss, all mathematically equivalent:

- Dense KL is the textbook approach. It rebuilds a full, dense teacher-probability grid from the cached top-100 logits and compares it against the student's own dense grid of log-probabilities. This is the version closest to how online distillation already works, so we use it as our correctness baseline, but it holds the full vocabulary × sequence grid in memory, twice over.
- Forward-chunked KL keeps the teacher sparse (only its cached top-100 logits per position, never expanded into a dense grid) and computes the loss piece by piece, one slice of sequence positions at a time. This removes the dense teacher and the dense comparison, and turns out to be the fastest of the three methods in our benchmarks. It still has one blind spot, though: the student's own logits, the grid produced by the model's output layer, are still computed in full and kept around for the backward pass, so memory still grows steeply with sequence length.
- Fused chunked KL, our main contribution, goes a step further and fuses the model's output projection directly into the loss computation. ""It never produces the student's full logits grid at all: it processes one chunk of the sequence at a time end to end, projecting hidden states to logits for that chunk, folding the result into the running loss, and discarding the chunk before moving to the next one."" The backward pass recomputes each chunk on the fly instead of storing it. The cost is doing that projection twice, once forward, once in backward, but in exchange, peak memory grows only linearly with sequence length instead of spiking with the full vocabulary × sequence size.

We have open-sourced the chunked-loss implementation: github.com/CompactifAI/Full-Chunked-KL-Loss

## What this changes in practice

The table below puts all four setups head to head: online distillation, and the three offline loss implementations just described. Comparing them on a single H200 GPU with Llama 3.1 8B Instruct as teacher and a 3.2B Llama model as student at an 8K token context, all four reach near-identical training loss, even though the offline runs train against only the cached top-100 logits per token.

| Method (8K context, single H200) | Peak memory | Iteration time | Throughput |

| Online distillation | 102.8 GB | 25.9 s | 237 TFLOP/s |
| Offline, dense KL | 78.3 GB | 18.5 s | 331 TFLOP/s |
| Offline, forward-chunked KL | 61.8 GB | 18.4 s | 335 TFLOP/s |
| Offline, fused chunked KL | 58.3 GB | 20.2 s | 304 TFLOP/s |

The loss curves overlap almost exactly across all four methods, confirming offline distillation with top-100 cached logits is lossless relative to online distillation. At this sequence length, the fused chunked loss is not yet the fastest option, its extra backward-pass projection costs a bit of speed, but its real advantage only shows up as context length grows, which the next section demonstrates.

### Scaling to long context lengths

To see the scaling pattern more starkly, we ran an isolated benchmark on a toy output-projection network (no transformer body, just the loss kernel). At 32K tokens, peak memory falls from 85.2 GiB with the dense loss to 5.45 GiB with the fully chunked version, a 15.6× reduction, and the dense loss fails outright from 64K tokens onward. At 256K tokens, the fully chunked loss uses 11.6 GiB against 134.2 GiB for the next-best chunked variant, and is about 3.3× faster per iteration at that length.

Distilling a GPT-OSS 20B model at a 32,768-token context, the memory freed by the fused loss let the setup shrink from four GPU nodes down to one. Step time fell from 57.0 to 12.23 seconds, about 5× faster, and throughput per GPU rose from 74.2 to 345.7 TFLOP/s.

## The resulting student

The efficient offline setup is what made a large-scale distillation campaign affordable in the first place. The resulting compact student, distilled from Llama 3.1 8B Instruct down to about 3.2B parameters, retains most of the teacher's accuracy on BoolQ and HellaSwag, stays within about nine points of it on MMLU, at less than half the parameter count.

This work is part of Multiverse Computing's ongoing research into making distillation and healing practical to run at scale, not just as a one-off recipe, but as something teams can iterate on cheaply. The paper also covers additional ablations, such as how the choice of loss function and sequence packing affect recovery quality.

Want the full technical details, including the closed-form gradient behind the fused chunked loss and the complete training configuration? Read the full paper, or get in touch with our team to talk about applying this to your own distillation pipelines.

We have also open-sourced the chunked-loss implementation: github.com/CompactifAI/Full-Chunked-KL-Loss
",https://huggingface.co/blog/MultiverseComputingCAI/efficient-knowledge-distillation,new_development
"The State of Open Source AI, v1.0.1","# The State of Open Source AI — v1.0.1 · July 2026

## An introduction from our CTO

The Māori language Te Reo has no commercial market to speak of, but a broadcaster in New Zealand's far north has been building speech models for it anyway — and all under a license that keeps the recordings with the communities that originally gave them. Half a world away, in a cellular dead zone in East Africa, farmers point a phone at a cassava leaf and get a diagnosis from a model small enough to live on the handset. Neither project needed permission. And neither could have been rented from a frontier model.

The largest companies on earth are now thinking this way. This month, on the Artificial Analysis Intelligence Index, the strongest closed model scored 61. The strongest open model? 57. The open model came in fourth overall, ahead of models from three of the biggest closed labs. At the end of 2025, about a third of all tokens on OpenRouter were being routed to open-weight models; now the seven highest-volume models on the platform all ship open weights.

In a surprising recent turn, corporate heavyweights are leaning in an encouragingly unexpected direction: On July 24, Mozilla signed an open letter alongside NVIDIA, Microsoft, Meta, IBM, Dell, Mistral, Hugging Face, the Linux Foundation, and Andreessen Horowitz that argued that open weights are too important to be ignored.

We have been here before. Mozilla exists because one company tried to own the front door to the web, and an open community made sure it never could. We bet on open the first time. Open won. Together, we can do it again.

Raffi Krikorian · Chief Technology Officer, Mozilla

---

## 01 The current state of open models

### The model layer has commoditized. Value accrues to the harness above it.

Open weights are where the work happens. A majority of production tokens now route through them, and the seven highest-volume models on OpenRouter are all open weight. Closed models still lead at the frontier, on reasoning and multimodality. However, most production workloads run well below that ceiling. Commodity inputs surrender pricing power. Value moves up to the agentic harness, the layer above the model.

Terminology note

Open model here means weights you can download, run and modify on hardware you control. That category splits. Open weights means the parameters ship under a permissive license with no training code and no data documentation, which describes most of what this report measures. Open source AI, as OSI defines it, additionally requires the training code and enough information about the data to rebuild the system.

### The frontier's top three are closed. The fourth is open.

Artificial Analysis Intelligence Index v4.1, a nine-eval composite that includes Terminal-Bench 2.1, Humanity's Last Exam and GPQA Diamond. Kimi K3 ranks fourth, four points off the closed frontier.

Open weights vs Closed
- 4 pts from the best open model (Kimi K3, 57) to the closed frontier (Claude Opus 5, 61)
- 3 of 11 top-tier models shipping open weights

Source: Artificial Analysis Intelligence Index v4.1, July 2026, top 11 of 586 models shown. Open = downloadable weights.

### 3.6 points off the top, at a third of the price

The same index against weighted-average price per 1M input tokens, for the top ten. Kimi K3 is the only open-weight model in the leading cluster, fourth overall and 3.6 points off the top, at about a third of the price.

Source: Artificial Analysis Intelligence Index v4.1 via OpenRouter, July 2026. Price per 1M input plotted where list price is disclosed.

### Open trails the frontier by 6 ECI points, about one release cycle

Epoch Capabilities Index by release date. The best open model, Kimi K3 at 156, against the closed frontier, GPT-5.6 Sol at 162.

Source: Epoch AI, Epoch Capabilities Index (CC-BY), July 2026. Open = downloadable weights. The gap is the point difference at the frontier, and the confidence intervals overlap.

### A jagged frontier: parity, contested, a closed edge

For most workloads open models already clear the bar. The closed frontier earns its premium in a narrow band, namely deep reasoning, long-context reliability and professional-knowledge polish. Match the model to the job and you need the frontier for less than you think.

Open leads or parity

Frontend coding

K3 debuted first on LMArena's Frontend Code Arena at 1679 Elo, leading in six of seven frontend domains, plus coding, instruction-following and general knowledge.

Frontend Code Arena measures building website and UI code, scored by blind developer votes.

Contested

Agentic terminal work

K3 scores 88.3 against Sol's 88.8 on Terminal-Bench 2.1. It wins Program Bench, SpreadsheetBench 2 and BrowseComp, and loses FrontierSWE at 81.2 against Fable 5's 86.6.

Terminal-Bench, Program Bench and BrowseComp measure agent work, running terminal tasks, writing programs and researching the web. FrontierSWE measures resolving real software-engineering tickets.

Closed edge

Professional knowledge work

Fable 5 leads K3 by 92 Elo on GDPval-AA v2, the largest Elo separation among the shared benchmarks, alongside long-context fidelity and conversational polish, which Moonshot concedes still trails.

GDPval-AA v2 measures expert-graded professional knowledge work, where long-context reliability and polish appear.

Scores use different scales and come mostly from vendor-run tests, so treat them as directional. LMArena uses blind human voting. Sources: LMArena, Artificial Analysis, Moonshot K3 blog.

### Inference fell 50× in 36 months

Cheapest model at GPT-4-class performance, blended API list price, log scale, against prior platform-shift cost curves at their historical rates. Over the same 36 months the dotcom bandwidth curve delivers 2.6× and the PC compute curve 3.4×. The frontier price fell 112× from GPT-4's $45 launch.

Sources: a16z ""LLMflation"" methodology, Epoch AI LLM inference price trends, Artificial Analysis, Moonshot, MTS/Substack.

### Open weights win the tokens

The share of tokens routed on OpenRouter through open-weight models grew from a negligible base to a third by late 2025 to a majority by mid-2026.

Source: OpenRouter 100T-token study (Nov 2024–Nov 2025) and live leaderboard, with intermediate points interpolated. By request count, closed US providers still lead. The open lead is a token-volume lead, concentrated in coding and agentic workloads.

### Open weights dominate token usage

Each model's share of the top-20 routed token volume on OpenRouter, 1–27 July 2026. The top seven by volume are all open weight. Anthropic's closed Claude models are the next entrants.

| Category | Percentage |

| Open, ranks 1–10 | 72.4% |
| Closed, ranks 1–10 | 8.7% |
| Ranks 11–20 | 18.9% |

K3 note: the API opened 16 July and the weights on 27 July, so K3 does not appear in July's routed-token top 20. New subscriptions were temporarily paused on 20 July as demand neared capacity. These ten account for 81.1% of top-20 volume, leaving 18.9% across the remaining ten. Shares are of the top 20 only, not of all OpenRouter traffic. Source: OpenRouter LLM Leaderboard, July 2026 (this month), routed traffic only.

### The open frontier and the deployable open frontier split

Minimum serving footprint per model, measured in 8-GPU nodes. Bar length shows nodes to run, and memory is the figure that produces it. Frontier capability is downloadable. Node count decides who can run it.

Node counts follow Moonshot's guidance of 64+ accelerators for K3. A single 8-GPU node barely holds K3's weights, so eight nodes reflects serving it rather than only loading it. Inkling's ≥600 GB straddles the one-node line depending on GPU generation. K3 open weights released 27 July 2026. Sources: Moonshot deployment guidance, TML model card, Hugging Face community, Northflank.

### Open ships easy. Open deploys hard.

Data from the Mozilla / SlashData 2026 developer survey. Open models lead in adoption. 79% of developers adding AI functionality use them, against 71% for closed, and the two are largely complementary, with half of developers using both. But production is where teams stall. Only 53% of open-model teams reach production versus 63% for closed. The gap traces to operational tooling and trust.

### Open models lead in adoption, and mostly coexist with closed

Share of developers adding AI functionality to their applications who currently use each model type, and how the two overlap.

| Metric | Percentage |

| Open models | 79% |
| Closed models | 71% |
| Open only | 29% |
| Both | 50% |
| Closed only | 21% |

Source: Mozilla / SlashData 2026 developer survey. Most teams treat open and closed as complements, with 50% running both, 29% open only and 21% closed only.

### Where open adoption peaks, and where closed still edges it

Open-model adoption by region. Greater China and East Asia lead at 89%. South America and Western Europe are the only two regions where closed adoption exceeds open.

Same survey, by developer region. In South America and Western Europe, and only there, closed-model adoption runs ahead of open.

### Production rate by company size

Scale rules out a resources explanation. Closed climbs 54% → 73% with company size. Open moves 53% → 57%.

| Company Size | Closed Models | Open Models |

| Small | 54% | 53% |
| Large | 73% | 57% |

Closed modelsOpen models

Enterprises can buy their way through closed deployment. Open deployment waits on tooling that remains unfinished. Source: Mozilla / SlashData 2026 developer survey.

### Why teams churn: challenges with open models

Δ = churned − still using, in percentage points. The biggest gaps (performance, integration, maintenance) are operational.

Mozilla survey, n=1,410. ""What are the main challenges you face when working with open or open-source AI models?""

| Challenge | W. Europe & Israel | N. America | Greater China | South Asia | East Asia ex GC | S. America | E. Europe & CIS | Oceania | All |

| High infrastructure or compute costs | 25% | 26% | 29% | 28% | 28% | 28% | 29% | 18% | 27% |
| Security, privacy, or compliance concerns | 20% | 27% | 18% | 39% | 29% | 28% | 25% | 22% | 26% |
| Ongoing maintenance and updates | 27% | 26% | 18% | 26% | 20% | 31% | 21% | 25% | 24% |
| Complexity of deployment, hosting, or scaling | 27% | 24% | 19% | 24% | 11% | 30% | 26% | 25% | 23% |
| Lack of specialised support | 17% | 16% | 21% | 31% | 24% | 23% | 23% | 32% | 22% |
| Difficulty evaluating or comparing models | 14% | 17% | 14% | 23% | 16% | 26% | 25% | 18% | 18% |
| Difficulty fine-tuning or customising | 22% | 18% | 18% | 20% | 11% | 22% | 18% | 12% | 18% |
| Difficulty integrating into existing systems | 19% | 21% | 14% | 20% | 7% | 26% | 19% | 20% | 18% |
| Insufficient documentation or learning resources | 18% | 15% | 15% | 17% | 15% | 20% | 24% | 15% | 17% |
| Model performance is not good enough | 18% | 15% | 13% | 22% | 16% | 17% | 19% | 8% | 17% |
| No major challenges | 9% | 21% | 16% | 5% | 14% | 4% | 8% | 12% | 12% |

Source: Mozilla / SlashData 2026 developer survey (MZCS1). n=1,410 current or churned open-model developers. The Oceania column (n=39) and Eastern Europe & CIS (n=98) fall below reliable thresholds.

---

## 02 The open-source AI stack

### The open stack scores high on capability, low on operations.

Nine layers and 48 components of the stack scored across 10 criteria (1–5). Click a layer to open its components. Each carries its own criterion scores, maturity grade and open-vs-closed parity verdict, and surfaces some of its most-starred open-source projects.

Movement this edition

Infrastructure → standardization 3.1 → 3.4 ▲

KDA-class linear attention broke runtime compatibility, so loading weights no longer guaranteed serving. Moonshot resolved it upstream by contributing KDA prefix caching to vLLM, shipped with the 27 July weights, which strengthens standardization while concentrating influence over the standard.

Watch: whether the next divergent architecture also lands upstream, or forks the serving layer.

Cells are scores per maturity criterion (1–5), ordered strongest to weakest left to right. Layer rows are the means of their components. The two coldest columns, standardization and enterprise readiness, repeat down every layer and every component. That repeating cold edge is the operational gap. Source: Mozilla open source AI stack map, July 2026, 48 subcomponents across 9 layers.

---

## 03 Who's betting on it

### Open-weights are a business model.

Open-weight AI is a commercial market at multi-hundred-billion-dollar scale, built by funded companies and run in production by global enterprises.

### The venture-funded open ecosystem, total disclosed funding (USD M)

Total disclosed funding, USD millions. Color marks the stack layer. Bars grow as you scroll.

Source: public filings and reporting, June 2026. Bars scaled to DeepSeek's $7.4B. Thinking Machines Lab is shown at disclosed funding, since $12B is a valuation. Zhipu AI and MiniMax went public (HK IPO 2026) with undisclosed totals. Corporate strategics (Nvidia, Salesforce, AMD, Google, IBM, ASML, Tencent, CATL, Schwarz Group) back the same ecosystem across model, inference and tooling layers.

### Financial maturity of the open ecosystem

Funding, valuation and revenue traction for the companies carrying the open stack. The ecosystem has moved from grants to venture scale to public markets.

| Company | HQ | Layer | Disclosed funding | Valuation | Revenue signal | Leading investors | Stage |

| Databricks | USA | Enterprise platform | — | — | $5.4B run-rate | — | Pre-IPO |
| DeepSeek | China | Frontier open weights | $7.4B | $50B+ | ~$220M ARR | Liang Wenfeng · Tencent · CATL · China National AI Fund | Private |
| Mistral AI | France | Open weights + platform | $3.05B | ~$14B (talks at €20B) | ~$400M ARR, 20× YoY | ASML · a16z · Lightspeed · Nvidia | Private |
| Moonshot AI | China | Open weights (Kimi) | $3.9B | — | — | Meituan/Long-Z · Alibaba · Tencent · HongShan | Private |
| Zhipu AI | China | Open weights (GLM) | Undisclosed | Public | — | Public (HK IPO 2026), prior Alibaba and Tencent | HK IPO 2026 |
| MiniMax | China | Open weights | Undisclosed | Public | — | Public (HK IPO 2026) | HK IPO 2026 |
| Cohere | Canada | Enterprise / on-prem | $1.7B | — | Command A+ open-sourced May 2026 | Radical Ventures · Nvidia · AMD · Schwarz Group | Private |
| Cerebras | USA | Compute | $2.1B | — | — | Fidelity · Atreides · G42 · Tiger Global | Private |
| Reflection AI | USA | Open weights | $2.13B | — | — | Nvidia · Disruptive · Sequoia · Lightspeed · DST Global | Private |
| Together AI | USA | Inference cloud | $1.334B | — | — | Aramco Ventures · General Catalyst · Prosperity7 · Nvidia | Private |
| Hugging Face | USA | Hub | $400M | — | — | Salesforce · Google · Nvidia · IBM | Private |
| LangChain | USA | Harness tooling | $260M | — | 126k+ stars, 60% dev share | IVP · Sequoia · Benchmark · CapitalG | Private |

Five revenue models are proven at scale, from hosted inference and enterprise platforms to on-prem licensing, fine-tuning services and harness tooling. ""—"" = not publicly disclosed.

### The metered model breaks at scale

Closed frontier models are sold by the token, and at production scale the meter becomes the problem.

A fifth of the usage, 4% of the revenue

On OpenRouter (May–Sep 2025), closed models held ~80% of usage and ~96% of revenue. Price drives it. At ~90% parity, closed costs ~6× more per call.

~$24.8B

in unrealized annual savings — the Nagle–Yue study for the Linux Foundation's estimate of the open-vs-closed price asymmetry, at ~6× the cost per call for comparable capability

Where developers route by cost, they route to open weights.

---

## 04 Why it's happening everywhere

### Open is a sovereignty choice. Seventy governments are already treating it as one.

More than 70 national AI strategies are live. The strategic question is now which layer of the stack a country can own.

### The case for open is optionality

The strategic case for open is the ability to leave, and the cloud era proved the cost of its absence.

- $90–120k to move one petabyte out of AWS S3
- 80% of enterprises now repatriating workloads
- $3.2M → <$1M 37signals' cloud bill after leaving
- 2.5× what GEICO's cloud costs ran over plan

Closed model APIs reproduce the same trap. Build on a proprietary endpoint and you inherit the vendor's pricing changes with no clean exit. Open weights are exit rights.

### The largest source of open weights is China. By design.

Cumulative Hugging Face downloads, March 2026

In February 2026 Qwen out-downloaded the next eight organizations combined. On OpenRouter, Chinese open-weight models rose from under 2% of tokens in late 2024 to more than 45% of weekly traffic by April 2026, and about 61% among the ten most-used models. DeepSeek reports 26,000+ enterprise accounts, and 58% of new AI startups in 2025 included it in their stack, even as at least eight jurisdictions restricted the hosted service. The resolution is architectural. Enterprises ban the hosted app and adopt the weights anyway, self-hosted or via Western endpoints.

### For nineteen days, the newest frontier model went dark

Optionality stopped being abstract. Everyone building on that endpoint watched both decisions from the outside.

- Jun 9: Anthropic ships Fable 5 and Mythos 5.
- Jun 12: Commerce applies export controls, effective immediately, barring access by any foreign national inside or outside the US, including Anthropic's own staff. Nationality cannot be verified in real time, so both models go dark for everyone.
- Jun 26: Partial clearance. Mythos is restored to roughly 100 vetted US critical-infrastructure organizations.
- Jun 30: Controls lifted.
- Jul 1: Fable 5 restored globally, nineteen days after it was cut.
- Jul 16: Moonshot opens the K3 API, a frontier-class model on a release path no export order can reach once the weights land.

### The mirror

Six weeks later the same lever pointed the other way and found nothing to grip. Access can be revoked and restored. A weight release cannot be withdrawn once the files are distributed. The two decisions differ in their reversibility.

""You can switch off a model. You cannot switch off a copy already running on a machine you hold."" Sovereignty is this same argument at national scale.

Sources: Commerce Department order (12 Jun 2026), Anthropic status disclosures, Moonshot AI, OSTP remarks (22 Jul 2026).

### Washington cannot un-release a model either

Policy is still in the drafting stage, while the conditions that would make enforcement feasible have already lapsed.

Tools - Five under consideration

- Entity List designation
- Federal procurement limits
- Security advisories
- Liability requirements
- Public pressure

Actions - Treasury opens the door to sanctions

Secretary Bessent, 21 July: the government will examine Chinese open-source models for IP theft, and may sanction.

The problem - Downloadable weights resist a ban

An outright prohibition gets harder to enforce as adoption grows. Every copy already held is outside the reach of the order.

Sanctions rely on an enforceable chokepoint. Once open weights have been downloaded across many jurisdictions, no such chokepoint remains. Sources: Axios, Treasury, Fast Company, AI Weekly.

### Open proliferation is now Chinese foreign policy

The domestic directive became an international institution, in Shanghai, July 2026. Xi's first WAIC keynote centers open source, and WAICO launches with 29 founding states headquartered in Shanghai. Founders include Russia, Pakistan, Indonesia, Kazakhstan, Brazil and South Africa. No major Western democracy.

INSTITUTIONAL ARM · WAICO · SHANGHAI, JULY 2026
- 29 founding states · no major Western democracy

SUPPLY
- Codified directive: AI-Plus directive and the 15th Five-Year Plan make open-source proliferation a core state objective.
- Macro hedge against chip export controls.

MECHANISM
- Release the weights: Inference moves onto end users' own hardware, worldwide.
- No serving cost. No export surface.
- No chokepoint to sanction.

DEMAND
- Adoption at both ends: The Global South diversifies away from US tech. Well-capitalised firms, Microsoft among them, adopt for cost per task.
- 46.4% of routed tokens, against 35.7% US.

JULY EXHIBIT - Kimi K3
- Billed as the world's first open 3T-class model, announced at WAIC before Xi's speech.
- Weights published 27 July.

DISTRIBUTION RAILS
- 5,000 training slots over five years pledged to developing countries, with cooperation centres planned with ASEAN, the Arab League, the African Union and BRICS.
- A single-origin open commons stops being a commons.

WAICO is a China-aligned bloc, 29 members with zero major Western democracies. A single-origin open commons stops being a commons. Sources: State Council ""AI Plus"" (Aug 2025), 15th Five-Year Plan (Mar 2026), Xi WAIC keynote and WAICO founding (17 Jul 2026, Al Jazeera), Moonshot, OpenRouter.

---

## 05 The harness is the new frontier

### The agentic harness is another user agent.

The browser was the user agent of the open web, code on the user's side negotiating with servers on their behalf. That role is being recreated one layer up. Above the model now sits the agentic harness — the orchestration loop, tools, memory, sandboxes, and permission model. It is where production difficulty concentrates, and where the open-vs-closed, owner-vs-renter contest restarts.

The user · other agents · the world
- humans · systems · data · money

Govern
- one plane over many harnesses
- Stateful policy: what the session already did
- Registry & lineage: which agent did what
- Budget & revocation: cost caps · kill switch
- Meta-harness · Omnigent · OPA · Agent governance toolkit

Surface
- meets user & money
- Interface: AG-UI · A2UI
- Payment & metering: x402 · AP2 · UCP

Action
- do things, safely
- Sandboxes & execution: E2B · Daytona · Modal
- Permission & identity: the unsolved write surface

Eval & observability
- Langfuse · Phoenix

Reach
- connect & remember
- Tools & context: MCP
- Agent-to-agent: A2A
- Memory: Mem0 · Letta · Zep

Control
- drive the loop
- Orchestration loop: LangGraph · CrewAI · AutoGen · LlamaIndex — the reason-and-act cycle that turns a model into an agent

The model · the weights
- open or closed · swappable · commoditizing toward zero

The layer is already a product category. LangChain alone has 126,000+ GitHub stars and a 60% developer share. MCP reached 97M monthly SDK downloads and 10,000+ active servers in its first year, growing 4,750% in 16 months, and was donated to the Linux Foundation's Agentic AI Foundation in December 2025. Adoption outpaces governance, with only ~21% of companies reporting mature agent governance.

### The model is eating the harness, and that's the opening for open

The frontier labs read that result and pulled the harness in-house. On every model where both appear, the lab's own harness now wins, and the 21.8-point gap has compressed to roughly 3 at the top. The model is eating its way up the stack, weights and scaffold shipped as one product. One open model has since reached the top tier inside its own harness, with K3 scoring 88.3 on Terminal-Bench 2.1, half a point behind Sol.

May 2026 · Terminal-Bench 2.0

July 2026 · Terminal-Bench 2.1 · official board, verified top tier

A harness tuned tightly to one lab's weights becomes a fitted component of that lab's product. It degrades on anyone else's model, so the tighter the tuning, the less swappable the weights underneath. Lock-in arrives as a side effect of optimization. Most open models still lack a first-party harness, and the one that has built its own is the one now sitting in the top tier.

### Timeline of the Kimi K3 and Fable distillation claims

One documented precedent, one set of allegations, and a short window of reachability between them.

The precedent · documented, pre-Fable

Anthropic, February 2026: roughly 24,000 fraudulent accounts generated more than 16M exchanges, 3.4M of them attributed to Moonshot, in violation of terms of service and regional access restrictions. These exchanges concern earlier Claude models. Fable 5 did not ship until 9 June.

Alleged · the Fable-to-K3 step, summer 2026

The White House has not publicly connected the February activity to K3's training data. Anthropic notes that distillation is a widely used and legitimate training method. The allegation is covert extraction at industrial scale.

- Feb 23–24: Anthropic names three labs
- Jun 9: Fable 5 ships. Three days of reachability follow
- Jun 12: Export order. The model goes dark
- Jul 1: Restored. Fifteen further days of reachability follow
- Jul 16: K3 launches
- Jul 22: Kratsios allegation
- Jul 27: K3 weights public

What has been confirmed

- Documented, on the record. Anthropic's February disclosure, Kratsios on 22 July, Bessent on 21 July.
- Signal, suggestive. Greenblatt finds Claude-identifying responses difficult to explain as random noise.
- Proof, absent. No logs and no forensic package. Moonshot denies. Behavioral forensics become possible now that the weights have been released.

Sources: Anthropic disclosure (Feb 2026), OSTP remarks (22 Jul), Treasury (21 Jul), The New Stack / CNBC on the per-lab split, Bloomberg on the 16M total, Moonshot statements. CyberScoop reports alternate figures of 28.8M interactions across roughly 25,000 accounts over six weeks.

### The similarity signal within Kimi K3

Three independent signals point in the same direction. Each carries its own limit.

Instrument 01 · self-identification

Ryan Greenblatt, Redwood Research

| Response | Frequency |

| ""Claude 4.5"" | — |
| Fable | — |
| Mythos | — |

K3 disproportionately identifies itself as Claude, a statistically significant distribution that researchers describe as difficult to explain as random noise. Asked what it is, it names a model from Anthropic and never one of the two current releases.

Limit: it names a model that predates the case. Self-identification is a known artifact of training on web text containing Claude outputs.

Instrument 02 · task-outcome correlation

Together AI, DeepSWE, 24 Jul 2026

0.72

K3 × Fable 5 per-task correlation

- 01.0 (highest possible)

The highest cross-vendor similarity in the benchmark. The top four cross-vendor pairs are all K3 against Anthropic models.

- 105/113 tasks covered by their union
- 101 covered by K3 alone
- 65% of failures are near misses for both

Limit: Together AI frames this as capability convergence and a cost comparison, and makes no distillation claim.

Instrument 03 · tool-use behaviour

arXiv, ""When Agents Look the Same""

82.7%

Kimi-K2 × Sonnet 4.5 agentic similarity

- 0%–100%

The highest among all non-Anthropic models, exceeding the similarity between some pairs of Anthropic's own models.

Limit: measured on Kimi-K2 and Sonnet 4.5. It predates the K3 and Fable case and stands as prior-pattern context only.

Sources: Greenblatt / Redwood Research, Together AI DeepSWE (24 Jul 2026), arXiv ""When Agents Look the Same"", Anthropic disclosure (Feb 2026).

### An open model ran the defense

Hugging Face's disclosure of an OpenAI cyber-security incident, 16 July 2026. During an OpenAI cyber-eval with cyber refusals off, GPT-5.6 Sol and pre-release models escaped the sandbox through a package-proxy zero-day, reached the open internet, and broke into Hugging Face to grab benchmark answers, producing remote code execution, stolen credentials and more than 17,000 agent actions.

Who could do the forensics

Commercial frontier APIs refused the forensic work, because their guardrails could not tell an incident responder from an attacker.

Hugging Face ran the forensics on GLM 5.2, open weight and self-hosted. Attacker data and credentials never left its environment.

OpenAI confirms Hugging Face had begun forensic reconstruction with its own open-source models before the teams connected. Sources: Hugging Face incident disclosure (16 Jul 2026), OpenAI, ""OpenAI and Hugging Face partner to address security incident during model evaluation"" (21 Jul 2026).

### Two open frontiers, two release cultures

Within twelve days, two labs released frontier-class weights under materially different terms. Openness of weights, on its own, determined neither the license, the safety posture, nor the provenance of either release.

| Dimension | Thinking Machines · Inkling US · 15 Jul 2026 | Moonshot · Kimi K3 CN · 27 Jul 2026 |

| License | Apache 2.0, unambiguous and known at announcement. | Kimi K3 License, custom. K2 was modified-MIT, and that did not settle K3. |
| Weights-to-API order | Weights first. Nothing to gate. | API 16 July, weights 27 July. |
| Serving footprint | ≥600 GB VRAM (NVFP4). A small cluster. | ~1.4 TB native MXFP4, 64+ accelerators. Open, but not runnable by most who hold it. |
| Upstream contribution | Standard architecture. The existing serving stack already runs it. | KDA broke runtime compatibility. Moonshot fixed it by contributing prefix caching to vLLM, and gained influence over the standard. |
| Evidence at launch | Model card with disclosed limitations. | Self-reported benchmarks on its own harness, with deployed-system comparisons in footnotes. |
| Capacity posture | No hosted dependency to strain. | New subscriptions paused 20 July as demand neared capacity. |
| Smaller sibling | Inkling-Small (276B total / 12B active) previewed, weights pending. | None announced. |

Sources: Thinking Machines Lab model card, Moonshot AI launch materials and deployment guidance, vLLM blog, Hugging Face community. The K3 column reflects the position before the 27 July release.

### The unsolved hole at the center of the harness

Reads

Reversible and low-consequence. Fetching a document, querying a database, listing a calendar. These can largely be permitted by default. A bad read costs little and can be repeated safely.

Writes

Side effects that are costly or irreversible. Sending a message, spending against a budget, modifying a record, executing a transaction. This is where confirmation, approval thresholds, cost caps and revocation must concentrate.

The unsolved permission problem is a write problem. The harness ecosystem now spans roughly a dozen frameworks, ten harnesses and three peer protocols, yet no portable model defines which writes an agent may perform unattended, which require human approval, and which are forbidden, across an MCP host, an A2A peer, a direct tool invocation and a framework boundary. The protocols hardened the front door and stopped there. MCP's 2025-11-25 specification moved authorization onto OAuth 2.1, and A2A v1.0 standardized signed Agent Cards, but both stop at authentication. Knowing who an agent is says nothing about what it may do.

The human backstop is failing too. CoSAI's MCP threat model lists consent fatigue, the pattern in which users approve the large majority of prompts, as a top-tier threat. Consent fatigue is itself a write-side failure, because the prompts that matter are the ones authorizing action.

Emerging cross-harness architectures are bypassing the framework deadlock by pulling control up to the meta-harness layer. Architectures like Databricks' open-sourced Omnigent move enforcement above the individual agent, applying stateful, contextual policies that track what a session has done and gate the next write accordingly. One policy requires human approval for a code push once an agent has pulled an unverified package. Another enforces cost caps that pause a session after a set spend.

### Where closed still leads

Closed systems still lead in four places. The first is the integrated harness. No open model appears in the verified top tier of the official Terminal-Bench 2.1 board, and even on a neutral scaffold the best open model trails Opus 4.8 by about four points. Behind that harness sits a data flywheel, since usage routed through a lab's own scaffold feeds back into its next model. The second is long-context fidelity at 1M tokens, where Gemini 3 holds 89% multi-needle retrieval against DeepSeek V4-Pro's 41%. The third is turnkey compliance, with SOC 2, HIPAA, and zero data retention available by default. The fourth is accountability, meaning a counterparty the customer can hold liable.

Compliance and accountability are contracting problems. The integrated harness is a tooling problem. Long-context fidelity is a model problem, and closing it is work only the open labs can do.

---

## 06 Opportunities

### Five bets on the layers above the model.

Each turns on owning the harness, the memory, and the permission model while those layers are still open.

---

## 07 The watchlist

### Signals that keep the layer open.

#### Capability & adoption

The 3.3% average gap across coding, reasoning and agentic tasks, and open's OpenRouter token share, especially in agentic coding.

Reverses if: token share stalls while the reasoning gap widens.

#### The harness

The Terminal-Bench spread between lab-owned and independent scaffolds, MCP/A2A governance under the AAIF, and the portable permission spec that still doesn't exist.

Reverses if: the lab-harness lead widens, or a closed platform sets the permission standard first.

#### Market structure

Open-lab economics (ARR, raises, the Zhipu/MiniMax IPOs) against metered-pricing breakpoints (~2027–28), with sovereign capacity as counterweight.

Reverses if: sovereign funding lapses or open-lab economics fail to scale.

#### Trust & safety

Under active tracking: misuse capability and how easily safety tuning strips from open weights, hard-friction zones (above all synthetic CSAM and NCII), and whether NTIA's monitoring posture holds.

Reverses if: a major misuse event, or a shift from monitoring to restriction.

There is a test you can run for the rest of this. Look at who is seated in the rooms where AI gets decided, and with what status. The day they seat the people who keep AI open, portable, and widely deployed on equal footing, the shift from renting to owning will have happened. The window is open now. It is closing slowly enough to be easy to ignore, and the lease is shorter than it looks. Build with us.

---

## This is v1.0.1. We'd like to hear from you.

Contact: opensource@mozilla.org
",https://stateofopensource.ai/,new_development
Build Your Custom MCP Server from Scratch,"# Build Your Custom MCP Server from Scratch

## A practical hands-on guide to building, testing, containerizing, and deploying an enterprise-ready MCP server with Python, FastMCP, Docker, and Databricks Apps

Large Language Models can be very powerful tools, but they become truly valuable in the enterprise only when they can safely interact with real systems. In my previous article, MCP for Enterprise Architects: Concepts, Cloud Platforms, and Adoption Strategy, I explained how MCP acts as a standard integration layer between AI agents and enterprise tools, data, APIs, and workflows. In this article, I will take the next step and move from concept to implementation. A chatbot that only responds from static prompt context cannot provide a complete enterprise answer; an AI agent needs to fetch data, call business tools, inspect operational records, create structured context, and return sensible, reliable responses.

This is where the Model Context Protocol (MCP) comes into play. MCP gives AI applications a common interface to connect with tools, resources, prompts, APIs, databases, and workflows. Instead of integrating individual AI apps, we can expose reusable functionality through MCP servers.

In this article, we will demonstrate how to build a custom MCP server from scratch, test it locally, run it through MCP Inspector, package it with Docker, and think about deploying it as a Databricks App.

## Why build a custom MCP server?

Managed MCP servers are helpful for connecting agents to the standard platform capabilities like cloud services, development tools, documentation, or common SaaS systems. But usually businesses require a little more than that.

They need MCP servers for:
· Internal databases
· Business-specific APIs
· Curated data products
· Domain-specific workflows
· Operational lookups
· Analytics views
· Customer, product, dealer, service, finance, or supply chain data
· Internal approval or escalation workflows

> A simple way to think about it:
> Managed MCP gives platform capabilities. Custom MCP gives enterprise-specific intelligence.

Custom MCP provides enterprise-specific intelligence. For instance, rather than allowing unmediated SQL access to an AI agent, a custom MCP server can expose controlled tools like:

• get_customer_case_details()
• check_inventory_status()
• generate_context_pack()
• get_order_status()
• summarize_account_risk()

This is far less risky than giving an agent the ability to query databases directly or call unrestricted APIs.

A custom MCP server creates a controlled bridge between the AI application and enterprise systems.

## What we are building

This article describes how we will create a Python-based MCP server with FastMCP.

The server will:

• Expose tools using @mcp.tool()
• Connect to Databricks SQL Warehouse
• Read configuration from environment variables
• Query curated enterprise views
• Return structured JSON responses
• Run locally through stdio
• Run over HTTP for MCP Inspector testing
• Be packaged as a Docker container
• Be deployable as a Databricks App pattern

## Reference architecture

I will present the solution in six simplified layers to make it easier to understand.

### 1. Client / Host Layer

This is the interaction layer where users or AI-driven applications communicate with the MCP server.

Examples include:
• Claude Desktop
• VS Code
• Cursor
• MCP Inspector
• Custom AI agent
• Internal chatbot application

These clients do not directly query databases; instead, they interact with the system by invoking MCP tools exposed by the server.

### 2. MCP Access Layer

This component establishes the MCP connections and manages their relations with the server. The most popular transport choices are stdio and Streamable HTTP.

- stdio is commonly used only in local development because of its simplicity.
- The HTTP-based transport is more suitable for testing and remote scenarios, enabling external tools like MCP Inspector to access the server endpoint.

### 3. Custom MCP Server Core

This is the heart of the solution where we implemented the MCP server in Python and FastMCP.

Its key responsibilities include:
• Defining the server entry point
• Registering available tools
• Validating inputs
• Managing structured responses
• Handling logging and errors

### 4. Domain Tool Layer

This layer is business-focused features. Rather than exposing direct access to the database, it provides real tools like:

• health_check()
• get_business_record_details()
• check_inventory_status()
• generate_context_pack()

This layer enhances the trustworthiness and power of AI agents by allowing analysis of operations directly at the business level and removing restrictions from lower level database structures.

### 5. Data and Integration Layer

It connects to enterprise systems and deals with data management. In such an experiment, the MCP server reaches Databricks through:

• Databricks SQL Connector
• Environment configurations
• Secure credentials such as secrets and access tokens

### 6. Databricks Backend Layer

This layer constitutes the governed data framework of the solution, made up of enterprise-grade data assets including:

• Databricks SQL Warehouse
• Unity Catalog views
• Delta tables
• Curated analytical datasets

The MCP server works in compliance with established governance boundaries, it consumes trusted data assets and returns only controlled outputs that meet the legal criteria.

## Codebase Structure

A well-organized project structure is essential for maintaining a scalable and manageable MCP implementation. A simplified representation of the project is shown below:

The key design principle here is separation of responsibilities:

- `app.py` is responsible for registering MCP tools and starting the server
- `settings.py` manages configuration details
- `sql_client.py` handles Databricks SQL connectivity
- The `tools/` directory contains domain-specific business logic

This modular approach ensures better readability, maintainability, and scalability compared to consolidating all functionality within a single server file.

## Creating the MCP server with FastMCP

The MCP server is initialized by creating an instance of FastMCP:

Each function annotated with `@mcp.tool()` is automatically exposed as an MCP tool. For example:

This tool can be invoked by any MCP-compatible client to verify whether the server is up and running.

In a typical enterprise setup, the MCP server exposes multiple tools representing different business capabilities:

With this approach, the AI agent does not need visibility into how data is stored or processed internally. Instead, it interacts with clearly defined tools that provide structured inputs and outputs, ensuring abstraction, consistency, and ease of use.

## Why Business-Oriented MCP Tools Matter

A common pitfall in MCP design is exposing tools that are overly technical in nature. Examples include:

• query_table()
• run_sql()
• get_rows()
• fetch_column_values()

While these approaches offer flexibility, they introduce significant risk. They place the burden on the AI agent to understand the underlying data model, including table structures, column definitions, joins, filters, and business rules.

A more effective approach is to expose business-oriented tools such as:

• get_customer_case_details()
• check_inventory_status()
• get_recent_service_history()
• generate_context_pack()
• get_account_risk_summary()

This design pattern is inherently safer, more structured, and easier to govern.

An ideal MCP tool should be:
• Specific
• Purpose-driven
• Input-validated
• Permission-aware
• Result-limited
• Business-readable
• Easy for the agent to interpret

In an enterprise AI context, MCP tools should represent business capabilities rather than providing unrestricted access to technical operations.

## Managing Configuration

The MCP server relies on environment variables for configuration management. A simplified version of `settings.py` is outlined below:

For local development, using a `.env` file is convenient for managing configuration. However, in production environments, sensitive information should never be hardcoded.

Instead, leverage platform-native secret management solutions such as:

- Databricks Secrets
- Cloud-based secret managers
- Managed identities
- Service principal credentials
- Environment variables injected through CI/CD pipelines

Additionally, `.env` files should not be committed to version control. Use a `.env.example` file as a reference to document required configurations without exposing sensitive data.

## Connecting to Databricks SQL Warehouse

The communication between the MCP server and Databricks SQL Warehouse is reached via a dedicated SQL client wrapper. A simple representation of this is shown (code example).

The core design principle is to keep Databricks connectivity decoupled from MCP tool registration. This separation ensures MCP tools remain focused on business logic; the SQL client is the hub for connection handling and query execution.

The main idea is to decouple Databricks connectivity from MCP tool registration. This separation ensures that tools remain focused on business functionality, while the SQL client takes care of connections and query processing.

## Tool Implementation Pattern

A well-designed tool typically follows a structured workflow:

Key design principles to note:

- Inputs are validated before processing
- Queries are parameterized for security
- Data is accessed through curated views
- Result sets are intentionally limited
- Responses are structured consistently
- Outputs follow a predictable format

These practices enhance the reliability and safety of the tool for AI agents.

## The Most Important Tool: `generate_context_pack`

One of the most useful patterns in enterprise MCP development is the use of a context pack–generating tool. A context pack is a set of evidence that consolidates multiple data points into a single, reasoning-ready response. Rather than having the AI agent call multiple tools and collate information, a single tool can be exposed:

`generate_context_pack(entity_type, entity_id)`

This tool can aggregate and return:

- Entity profile
- Recent activity
- Related cases
- Historical trends
- Risk indicators
- Availability details
- Recommended areas for reasoning focus

That makes this evidence pack a compact and structured package streamlining downstream reasoning for the agent.

### How generate_context_pack Works

The process usually goes in a linear route:

A sample request may look like this:

> generate_context_pack( entity_type=""dealer"", entity_id=""DLR_TEST_01"")

Or for a more generic enterprise example:

> generate_context_pack(entity_type=""customer"", entity_id=""CUST_TEST_001"")

The specific entity types can be tailored to suit the business domain.

For example:

- In a retail context, typical entities might include: customer, order, product, store, ticket, and shipment.
- In the banking domain, they could include: customer, account, transaction, case, risk event, and branch.
- For manufacturing, common entities might be: plant, machine, work order, supplier, material, and quality issue.

While the entities vary by domain, the underlying pattern and approach remain consistent.

### Example Context Pack Output

A context pack should be structured in a way that is easy for the LLM to interpret and reason upon.

With this approach, the agent works with a single consolidated object instead of invoking multiple tools separately. This leads to improvements in:

- Consistency
- Latency
- Reasoning quality
- Tool orchestration
- Prompt simplicity
- Reusability

### LangSmith Trace Monitor

This trace is showing the `generate_context_pack` tool being called through the MCP server to the user query: ""Give me a 360 summary of dealer DLR003.""

The agent passes `entity_type = dealer` and `entity_id = DLR003`, and the MCP tool returns a structured context pack with dealer 360 data, recent bonus records, warranty performance, and recommended reasoning focus. The downstream reasoning agent then relies on this evidence pack to generate a business-friendly dealer summary rather than just static prompt context.

## Deployment Approaches

So far we have successfully built a custom MCP server to connect Databricks SQL warehoues and help the AI agents with required datasets. Let us know understand different approach of deploying a Custom MCP Server.

## Running the MCP Server Locally with stdio

For local development, stdio is the simplest and most convenient transport option.

The server can dynamically determine how to run based on an environment variable:

To run the server in local stdio mode, configure: MCP_TRANSPORT=stdio

Then start the server: python app.py

In this mode, the local client launches the MCP server as a child process and communicates with it through standard input and output streams.

This approach is particularly useful for:

- Claude Desktop
- Local AI assistants
- IDE integrations
- Smoke testing
- Development and debugging

### Smoke Testing the MCP Server

A smoke test ensures that the MCP server can start successfully and that its tools are properly exposed.

A simplified stdio-based client test could look like this:

This test helps confirm the following:

- The server starts without issues
- Tools are successfully registered
- Tool schemas are discoverable
- The server returns structured responses as expected

### Running in HTTP Mode for MCP Inspector

For debugging and testing purposes, running the MCP server over HTTP is highly effective.

Configure the transport settings as follows:

Then start the server:

The MCP endpoint will be available at:
http://127.0.0.1:8000/mcp

You can connect to this endpoint using MCP Inspector to:

- View available tools
- Explore tool schemas
- Execute tools manually
- Validate responses
- Debug issues before integrating with a production agent

This step is especially valuable before proceeding with containerization or deployment, as it allows thorough validation in a controlled environment.

MCP Inspector confirms that the custom MCP server is running successfully over Streamable HTTP at `http://127.0.0.1:8000/mcp`. The registered tools are discoverable, and the `get_warranty_claim_details` tool executes successfully with a structured JSON response, validating the local HTTP-based MCP setup.

## Containerizing the MCP server with Docker

Local development is great, but teams need to deploy the MCP server in a consistent and repeatable form. Docker offers an easy solution by encapsulating the server, dependencies, and runtime settings into a portable package.

Example Dockerfile might look like simplified:

Build the image:

Once containerized, the MCP server runs within a Docker environment and exposes its endpoint over HTTP.

This method guarantees consistency between machines and environments, and it makes it easier to test, deploy, and scale.

## Deploying as a Databricks App

Deployment as a Databricks App. Upon validating locally and by using a Docker containers, the MCP server, is deployed into an enterprise setting. When the starting data platform is Databricks, deploying the MCP as a Databricks App is a mere step forward. And the architecture can be illustrated as:

By doing this, it also puts the MCP server very near to state-controlled data resources for optimal performance, security and compliance. A robust Databricks App deployment should account for the following considerations:

- Workspace-level authentication
- Secure management of environment variables
- Use of Databricks secrets for sensitive data
- Proper access to SQL Warehouses
- Enforcement of Unity Catalog permissions
- Logging and observability
- Monitoring and alerting
- Network access controls
- User or service principal authorization
- Clear separation across development, testing, and production environments

> A simplified deployment evolution looks like this:

> Phase 1: Local stdio
> Phase 2: Local HTTP with MCP Inspector
> Phase 3: Docker container
> Phase 4: Databricks App

> This is a practical path because it avoids jumping directly into enterprise deployment before the MCP server is stable.

## Security and Governance Considerations

A custom MCP server must not become an uncontrolled entry point into enterprise data. For production-grade implementation, the following principles should be followed:

### 1. Avoid Exposing Raw SQL

Do not expose unrestricted tools such as:

`run_any_sql(query)`

Such approaches introduce significant security and governance risks. Instead, provide curated, business-focused tools like:

- `get_customer_context_pack(customer_id)`
- `get_order_status(order_id)`
- `check_inventory_status(product_id, region)`

### 2. Use Parameterized Queries

Always use parameterized queries to prevent injection risks. Avoid directly concatenating user inputs into SQL statements.

Preferred approach:

Avoid:

### 3. Limit Result Sets

Each tool should enforce strict limits on the amount of data returned.

For example:

- `LIMIT 10`
- `limit = min(limit, 50)`

This prevents excessive or uncontrolled data from being passed to the model.

### 4. Use Governed Views

Expose data through curated views rather than direct table access. This enables enforcement of:

- Column-level selection
- Row-level filtering
- Data masking
- Embedded business logic
- Consistent data semantics

### 5. Manage Secrets Securely

Never hardcode credentials or access tokens. Use secure mechanisms such as:

- Databricks secrets
- Environment variables
- Secret scopes
- Cloud-native secret management services
- Service principals

### 6. Log Tool Usage

For enterprise readiness, implement comprehensive logging, including:

- Tool name
- Execution timestamp
- Input parameters
- User or service identity
- Success or failure status
- Response size
- Execution latency

### 7. Add Human-in-the-Loop for Sensitive Actions

Automated execution may be acceptable for read-only operations. However, sensitive or write actions should include human approval.

Examples include:

- `approve_refund()`
- `cancel_order()`
- `create_ticket()`
- `update_claim_status()`
- `trigger_workflow()`

Such operations should incorporate human-in-the-loop controls to ensure oversight and accountability.

## Key takeaways

Building a custom MCP server is one of the most practical ways to connect enterprise AI agents with real business systems. The important lessons are:

- MCP servers should expose controlled business tools, not raw backend access.
- FastMCP makes it simple to create and register Python-based tools.
- Databricks SQL Warehouse can serve governed enterprise data through Unity Catalog views.
- generate_context_pack is a powerful pattern for combining multiple data sources into one reasoning-ready evidence pack.
- Local stdio is good for development.
- HTTP mode is useful for MCP Inspector and debugging.
- Docker makes deployment repeatable.
- Databricks Apps can support enterprise deployment close to governed data.
- Security, governance, secrets management, logging, and result limits are not optional.

## Final Thought

Custom MCP servers are set to become a key building block in enterprise AI architecture.

They enable AI agents to move beyond simple conversational interfaces and interact safely with real-world tools, governed data, and business workflows.

The most effective MCP implementations will not be those that expose the greatest number of tools, but those that expose the right tools — designed with clarity, security, and reliability for agent consumption.

Think of MCP servers as enterprise-grade APIs for AI agents: simple and intuitive on the surface, governed and controlled internally, and reusable across a wide range of intelligent applications.
",https://pub.towardsai.net/build-your-custom-mcp-server-from-scratch-0309a3065206,explainer
What is the Agent2Agent (A2A) protocol? How AI agents delegate work,"# What is the Agent2Agent (A2A) protocol? How AI agents delegate work

Back in the 90s, we went from local-only computers to machines that could reach any other machine over the web.

A2A, the Agent2Agent protocol, is a similar transformation for AI agents. It's a shared standard for one agent to hand work to another on a remote server.

Google released the A2A protocol on April 9, 2025, and donated it to the Linux Foundation. The spec reached 1.0 under a committee of Google, Microsoft, AWS, Salesforce, IBM, and others, and we built both sides of A2A into Mastra on the official `@a2a-js/sdk`.

The A2A protocol gives you six features:

- One GET against a fixed URL tells you what a remote agent does, the formats it accepts, and the credentials it wants.
- Work pauses for a human answer and resumes from the same task ID, even days later.
- Your stream drops, you resubscribe, and it reopens with a full snapshot, so you miss nothing.
- The same task supports polling, streaming, and webhooks, so a cron job, a dashboard, and a serverless function can all monitor the same piece of work.
- A forged card or a version mismatch fails loudly, before any work is sent.
- On Mastra, publishing an agent over A2A is zero extra code, and a remote agent drops in as a verified subagent.

## What is agent-to-agent communication?

Agent-to-agent communication is a protocol for two agents, built by different teams on different frameworks, to exchange work over a network while cooperating on nothing more than declared capabilities and the messages they pass.

No other data moves between them. The two agents share no memory, see none of each other's prompts, and call none of each other's tools, and that opacity is the design principle on which the rest of the protocol is built.

People routinely mix A2A and MCP, but MCP is your agent talking to its own tools and pulling data from an external source, while A2A is your agent talking to a different agent, on a different server for that matter. Production agents run both.

IBM's ACP was folded into A2A in a merger announced by the Linux Foundation on August 29, 2025.

## Why is agent delegation not a tool call?

Calling another remote agent from inside your agent looks like one more tool call, but it's a common mistake to assume they're the same. Here are four differences where the A2A protocol earns its place.

- A remote agent tells you nothing until you fetch its card. You learn its abilities, its endpoint, and the credentials it expects only at runtime.
- Delegated work runs for minutes or hours, and it stops mid-run to ask a human a question.
- The remote agent sees only what you put inside the request. Your agent's memory stays on your side of the wire.
- The remote agent runs on infrastructure where identities can be spoofed, and protocol versions drift.

| | Tool call (MCP) | Delegation (A2A) |

| Where it runs | inside your process or a local server | on another network |
| How long it takes | milliseconds | minutes to hours, pauses included |
| Who holds the context | the caller's memory | the request plus the task's saved history |
| Where state lives | the call stack | a server-side task, addressable by ID |
| How the callee is found | configured by the host | a fetched agent card |
| What can go wrong | an in-process exception | drops, missed events, forged cards, version mismatch |

## How does the A2A protocol structure delegation?

The spec defines its data model once, in Protocol Buffers, and treats that file as the single source of truth. The whole thing rests on five objects:

- Task
- Message
- Agent card
- Part
- Artifact

The schema holds more than those five, and those five carry the protocol. Every operation descends from that one definition, which is why a gRPC agent and a JSON-RPC agent agree on what a ""task"" is.

### One data model binds to three interchangeable transports

There are three transports that carry the model: JSON-RPC 2.0, gRPC, and HTTP/REST. The A2A spec requires all three to behave identically.

A team already running gRPC services exposes its agent over the gRPC binding, a team on plain HTTP uses the REST binding, and a client on one can still call an agent on the other, since every binding carries the identical Protocol Buffers task and message definitions underneath.

That layering charges a permanent tax. Keeping three transports identical is ongoing work, because every operation, every error, and every streaming behavior gets specified three times and held in alignment as the protocol evolves. The spec ships explicit method-mapping and error-mapping tables for exactly this reason.

My bet is that the earliest interoperability bugs are simply cross-transport mismatches. For instance, ask a gRPC agent for a task that doesn't exist, and you get a `NOT_FOUND` status. So a JSON-RPC client that only knows `-32001` would slip right past the gRPC error unless it's explicitly coded in or mentioned somewhere in the system prompt.

At Mastra, we picked JSON-RPC 2.0 and built deep on it. I think that is the right call for a first implementation.

### An agent card describes a remote agent in one fetch

Every A2A agent publishes a card at a fixed URL on its domain, `/.well-known/agent-card.json`. One unauthenticated GET returns it, with no SDK, no docs, and no onboarding call.

The card lays out everything you need to decide whether to use the agent:

- Its name and a description of what it does.
- The URL where you send work.
- The capabilities it advertises, including streaming, push notifications, and a fuller card for authenticated callers.
- The input and output formats it accepts and produces.
- The skills it offers, each tagged.
- The credentials it requires.
- The transports and protocol versions it speaks.

So, for example, a weather agent whose card says it can stream data and lists a weather skill has already told you what it does and how to talk to it in one read. That's the whole handshake, before any work changes hands.

Some agents keep their better skills behind a login. They hand a short public card to everyone while reserving a fuller card for those they already trust, and when the public card says a fuller version exists, you fetch it once you've authenticated, get the longer card back, and swap it in.

There's a catch, though. A2A only lets you connect to another agent with a domain or name that you already know. You can't discover new agents with this protocol. ANP, the Agent Network Protocol, takes the discovery part with decentralized identifiers.

### Work travels as messages and comes back as artifacts

Think of this as any interaction with a chat agent like Claude, for instance. You send a message and get back a finished output based on the context, skills, and expectations.

A message is just one turn in the conversation. In the context of A2A, it carries a role, either user or agent, and an array of parts that hold the actual content. A part can be plain text, a blob of structured JSON, raw bytes, or a URL pointing at a file.

Parts are also how the two sides agree on formats. Your agent lists the output types it can handle, and if the server agent can't produce any of them, it sends back `ContentTypeNotSupportedError` instead of dumping something on your agent that it has no way to read.

| | Message | Artifact |

| Purpose | a communication turn | the task's output |
| Carries | role and parts | parts |
| Survives a disconnect | No, may be missed on reconnect | Yes, held in task state |
| Use it for | questions, status, instructions | results the caller must keep |

If your connection drops and you reconnect, you can miss any status messages the server sent while you were gone, so anything you genuinely can't lose has to live in an artifact or in the task's saved history.

### The remote agent rebuilds context from three inputs

The remote agent has none of your memory to lean on, so it rebuilds the picture from scratch every turn, out of whatever the message carries, the task's own saved history, and a server-issued `contextId` that ties related tasks into one session.

It's the same opacity we talked about earlier, showing up as a hard wall around what the other side can actually know.

The server creates the `contextId`. You send a message with both a `contextId` and a `taskId`, and they need to match the server's records, or it rejects the message. Alternatively, you can send just a `taskId`, and the server works out the session from there.

You point back at earlier work by sharing prior task IDs, and the server resolves them against its own stored tasks. So two agents can build on everything they've done together without either one revealing its database, prompts, or internal state.

The task ID is the only thing they need to share.

### A delegated task moves through eight states

Sketch a delegated task on a whiteboard, and you'd probably draw four states: pending, running, failed, and done.

The A2A protocol has eight steps, grouped into running, finished, and paused, because delegated work can stop to wait for more information or can get turned down, and each of those earns a state of its own.

The three groups are:

- Running covers `submitted` and `working`.
- Finished covers `completed`, `failed`, `canceled`, and `rejected`.
- Paused covers `input-required` and `auth-required`.

A paused task sitting in `input-required` or `auth-required` is parked, waiting on you for an answer or for credentials, and it picks right back up the moment you send a new message with the same `taskId`, whether that's four seconds later or four days later.

And if the request is small enough to answer in one shot, the server can skip making a task at all and just reply with a plain message.

### A caller watches a running task by polling, streaming, or a webhook

Since a task can run for a long time, A2A lets you keep track of your agent in multiple ways: polling, streaming, and webhooks.

Each option is gated behind a capability the agent advertises on its card, so you never reach for streaming or webhooks unless the remote actually offers them.

| Mechanism | Connection model | Gated on | Best for |

| Polling | none, caller asks on its own schedule | always available | cron jobs, simple integrations |
| Streaming | one persistent connection (SSE over HTTP) | the agent advertising streaming | dashboards, live progress |
| Webhook push | server posts to a callback URL | the agent advertising push notifications | serverless, disconnected backends |

There are a few more nuances to the watch methods:

- Polling reads one task with `tasks/get` and lists many with `tasks/list`, paginated by a cursor that hands back fifty tasks a page by default and a hundred at most.
- A stream opens with a full snapshot before it sends a single delta, so even if you join late, you see the whole current state, and several clients can watch the same task and get the same ordered events until it finishes and the stream closes.
- Webhook delivery is best-effort, and the protocol never promises it lands, which is exactly why polling stays underneath as the thing that always works.

### Trust is decided before any work is sent

You can't read the other agent's code or watch it think, so every trust decision has to happen right before you send a thing. The A2A protocol provides three ways to make that call.

- The card declares which credentials the agent takes, from a fixed set of API key, HTTP auth, OAuth 2.0, OpenID Connect, and mutual TLS. OAuth 2.0 dropped the old implicit and password grant flows, which nobody recommends anymore (RFC 8628).
- The card is wrapped in a JSON Web Signature (RFC 7515) computed over a canonical form of it from the JSON Canonicalization Scheme, or JCS (RFC 8785), so the signature still checks out no matter how the JSON gets reindented or reordered on the way to you.
- Version negotiation happens on every request as part of the `A2A-Version` header, too. Even if a version is not supported, the A2A protocol allows communication on an older version.

A well-done signature clarifies two things: who published the card, and that nobody touched the bytes since they signed it.

What it doesn't tell you is which keys to trust, and the spec is still unclear on that part. I think that's a good move, because which keys you trust is a question about your threat model, and no protocol can answer that for you, just as it's always been in TLS or anywhere else you check a signature.

## Where does A2A delegation break, and how do you design around it?

Every channel I discussed above can break, and the one idea that makes all of it survivable is that the task on the server is the source of truth.

When something looks off, you read the task back instead of trusting whatever your local copy thinks happened.

- The stream drops mid-task. Resubscribe and it replays a full snapshot before any new events, so you've lost nothing.
- A status message goes missing. The outcome is still sitting in the task's artifacts and history, which the message was only echoing anyway.
- A webhook never shows up. It was best-effort to begin with, so fall back to polling.
- A card is forged or tampered with. The signature check and your own acceptance rule both run before any work goes out.
- Two agents disagree on the version. The `A2A-Version` header turns that into a loud `VersionNotSupportedError` instead of quietly misreading fields.
- The remote can't produce a format you accept. You get `ContentTypeNotSupportedError` at the boundary, not a garbage response to clean up.
- A paused task never wakes up. The timeout is yours to set, `tasks/cancel` kills it, and `TaskNotCancelableError` tells you when it's already too far along to stop.
- The network flakes. The client retries with backoff.

## How does Mastra handle each stage?

Mastra implements both sides of A2A. You can expose a Mastra agent so that other systems can delegate work to it over the protocol, and you can call a remote A2A agent from inside your own Mastra agent.

Both are built on the official `@a2a-js/sdk`, and Mastra uses the standard A2A task, message, and card types and works with any A2A agent, not only other Mastra ones.

### Publishing a Mastra agent over A2A takes no extra code

Register an agent on a Mastra server, and it's reachable over A2A right away without extra code, because the server builds the card, serves it from the well-known path, and opens the execution endpoint for you.

For instance, register one as a `weather-agent` under the default `/api` prefix, and its card shows up at `/api/.well-known/weather-agent/agent-card.json`.

To prove a card really came from you and wasn't altered on the way, turn on signing. It's one config block with an ES256 key.

With that in place, every card Mastra publishes carries a signature, and a caller can check that it came from you before trusting the card. You can leave the block out, and cards go out unsigned, so signing is optional.

### A remote agent plugs in as a subagent

A remote A2A agent slots into a Mastra agent exactly like a local subagent would. `A2AAgent` from `@mastra/core/a2a` takes a card URL, and the parent delegates to it through the same interface it uses for everything else.

Point it at the card's URL, or just the agent's domain, and Mastra fetches the card once and caches it. It streams when the remote supports streaming and returns a single buffered result when it doesn't, so your code is the same either way.

Retries and timeouts are configurable, and the defaults are conservative.

Left alone, a request runs once and waits as long as the remote agent takes.

When a task pauses for input, you resume it by keying the `runId`. Mastra sends your follow-up as a fresh message carrying the original context ID and naming the prior task, so the remote agent ties the new turn back to the old work through the protocol's own citation mechanism.

### Application code tracks and resumes work through the client SDK

When it's plain application code calling a Mastra A2A endpoint, you reach for the client SDK.

`MastraClient.getA2A('weather-agent')` gives you an object that covers the whole flow and can verify the card's signature against keys you hand it.

In the case of a serverless agent, you register a callback, and Mastra POSTs the current task snapshot to that URL when the task hits `completed`, `failed`, `canceled`, or `input-required`, the four states you'd actually want to react to.

### Mastra verifies an agent card before any work is sent

Mastra runs your trust check before a single byte of work goes out.

The signature check confirms the card came from a key you trust and arrived unchanged, and then the `verifyAgentCard` hook runs whatever rule you wrote against the fetched card and throws before delegating if the card doesn't pass.

Going from the top to the bottom, the URL finds and fetches the card, the `Authorization` header satisfies a credential scheme the card asked for, and the `verifyAgentCard` hook runs your rule, here a check on who published it, and throws before anything leaves your process if the card doesn't match.

The hook fires right after the agent card is fetched and before the execution URL is ever read, which is the only order that makes sense, since you want to decide whether to trust the card before you commit to calling.

## Wrapping up

Every piece of A2A is paying back something that a tool call never has to think about:

- Describe yourself on a card, because the caller can't read your code.
- Send the context with the work, because none of your memory follows it across the wire.
- Keep the state in a server-side task, because the connection won't outlive the job.
- Reconcile against that task whenever anything drops, because the network is the one piece you can't make reliable.

The moment the agent on the other end is not yours, you need all four.

A2A flat-out refuses a couple of jobs you'd think belong to it, finding agents out on the open internet and deciding which signing keys to trust, and that refusal is a big part of why the rest of it stays coherent. Both are real problems, both belong to someone, just not to the protocol.

None of this really lands until you run it. Read the data model section of the spec, spin up a Mastra server with one agent, and GET its card from the well-known URL. Watching these things turn into real JSON on your own machine will do more for you than any diagram here, mine included.
",https://mastra.ai/blog/what-is-agent-to-agent-protocol,explainer
Standardize project context with AGENTS.md and Agent Skills,"# Standardize project context with AGENTS.md and Agent Skills

As we all integrate coding agents into our workflows, it's important to figure out how to get the most value out of them for ourselves, our teams, and our projects. The general consensus is that providing proper context is the single most important thing we can do to get good results. Prompts like ""Improve performance, make no mistakes"" will rarely yield the desired outcome on their own.

So how do you ""teach"" coding agents the specifics of your projects and tools? How do you add your own preferences to the common processes?

In the last couple of months, two open specifications have emerged to help with this: AGENTS.md and Agent Skills.

## Standardizing project context with AGENTS.md

The idea behind `AGENTS.md` is simple: let's standardize *project context*. You can think of project context like a README for coding agents, containing basic orientation guide information such as:

- How to install a project
- What tools to use
- Where the tests are and how to run them
- Where to find documentation for specific topics (like architecture)

Once you start working on your project with a coding agent, it will inspect the code base and suggest creating a context file. This is beneficial because, from that point on, the agent can find the right information much faster, automatically enhancing your prompts with useful context.

## Managing agent-specific configurations

That's a massive win for the AI-assisted development experience. There is one catch, though: every agent prefers its own specific file location (for example, `CLAUDE.md` or `GEMINI.md`). If you want to keep your options open for your team (which you absolutely should), you don't want to duplicate all these files. That's where `AGENTS.md` shines.

The main exception is Claude Code, but the workaround is simple. Because Claude Code supports links, all you need to do is create a `CLAUDE.md` file with the following line:

You can then add any Claude-specific instructions right below it.

## Best practices for your AGENTS.md file

While providing good context is essential, you shouldn't overdo it. Too much context can actually degrade an AI model's performance.

### Keep it concise

The `AGENTS.md` content is sent with every prompt, so every unnecessary line dilutes the signal for the lines that matter. Aim for fewer than 150 lines; for smaller repos, 30 to 50 lines is plenty. A good litmus test for every line: ""Would removing this cause the agent to make a mistake it wouldn't otherwise make?"" If not, delete it.

### Review auto-generated context

Most agents offer an `init` command that generates a starting context file. It's a useful starting point, but don't ship it as-is. Review it, remove anything the agent can already figure out on its own (such as standard directory structures), and add the things only you know: the silent invariants, the non-obvious conventions, the gotchas that have bitten your team before.

### Use it as an index

Think of it more as a directory for finding information rather than a place to dump everything. For example, instead of pasting your entire architecture description there, create a `docs/ARCHITECTURE.md` file and include a simple pointer:

An orientation table is even better because this is optimized for agents, not humans:

| Topic | Document |

| Setup & CLI usage | `README.md` |
| System design & diagrams | `ARCHITECTURE.md`, `ARCHITECTURE-DETAILED.md` |
| Interface contracts | `specs/README.md` |

This keeps the base `AGENTS.md` file lightweight while giving the model enough context to fetch additional files when needed.

What else belongs here? Generally, you'll want to document small invariants (things that fail silently) and core decision-making guardrails. For example: ""Catch specific exceptions, not generic ones. Broad catches mask real bugs.""

Because different models have different coding habits, this file should be dynamic. If you notice an agent making the same mistake repeatedly, document the fix here. As your project grows, you can offload these rules into a separate file and reference them in your orientation table.

While `AGENTS.md` handles the ""always-on"" context sent with every prompt, it isn't ideal for highly specific, situational knowledge. That's where Agent Skills come in.

## What are Agent Skills?

So far, we've been organizing additional context in an ad hoc way using separate docs, tables, and links. It works, but it lacks structure. Agent Skills is another open specification designed to formalize how we create and share these task-specific instructions.

It's simple: a skill is a folder containing a `SKILL.md` file. The file uses YAML front matter to provide metadata for the agent. Let's look at a basic example:

### Defining and structuring tasks

In this example, we've defined a specific task for the agent to execute before making a commit. This highlights how you should approach skills: don't try to teach the agent generic tasks (like how to write code or make a `git commit` in general), but rather give it the specific context and guardrails unique to your project and team workflow. Also notice the language: `Run linting`, not ``Use the Bash tool to run `npm run lint:fix` ``. There's a lot of nuance in how you write skill content to keep it portable and effective.

The skill format requires a name and a description in the YAML front matter. The agent uses the description to decide whether a skill is relevant to a user's prompt. This technique is called *progressive disclosure*. The agent initially only loads the skill names and descriptions into its context, reading the full file only when needed. This keeps the prompt size under control while making vast amounts of information available on demand.

## Triggering a skill

Skills can be triggered in two ways: *automatically* based on the intent of your prompt (for example, saying *""*Let's commit this code"") or *explicitly* using a slash command such as `/pre-commit-check`.

You might recognize this as the ""commands"" or ""rules"" feature used by various proprietary agents before skills were standardized. Today, the industry is converging around the open skills standard, allowing them to be called explicitly or implicitly.

A skill folder can also contain supporting resources such as scripts or documentation:

True to progressive disclosure, these extra resources are only read by the agent if the main instructions explicitly reference them.

To make skills discoverable, you need to store them where agents can find them. The emerging convention is to use a `.agents/skills/` directory. Most modern agents can discover skills there automatically. For the few that can't, you can easily set up a symlink to their expected path.

While local skills bring plenty of value to a single repository, their greatest benefit comes from sharing them across teams, projects, or the open source community.

## Sharing and distributing skills

The most logical starting point for sharing skills is moving them out of your local repository and into a dedicated project. Other developers can then clone the repository and symlink it, or pull it in as a Git submodule. Both approaches are straightforward, and Git handles the versioning perfectly. This works beautifully for small teams.

However, a pure Git approach requires manual setup and constant pulling, and it scales poorly as your collection grows. If a repository gets too large, you're forced to either symlink everything or split your skills across multiple repos for different audiences.

### Bundling skills with plug-ins and marketplaces

To solve this, some agents are introducing *plug-ins* and *marketplaces*.

A plug-in bundles related skills together into a named group—think categories like ""dev workflow,"" ""onboarding,"" or ""ops""—with a metadata file describing the bundle.

A marketplace takes it one step further: it's a Git repository that catalogs multiple plug-ins, so users can discover and install them with a single command instead of manually cloning and symlinking.

This area isn't standardized yet. The AgentSkills.io spec covers the skill format itself, but packaging and distribution are still evolving—every agent handles it differently. That said, the concepts are converging.

A Claude Code plug-in is a folder containing a metadata file and a collection of skills:

The plugin.json file describes the plug-in with typical metadata such as `name`, `version`, and `author`.

If you have multiple plug-ins, you can organize them into a marketplace. To turn a Git repository into a marketplace, add a `marketplace.json` file to the root directory to catalog the available plug-ins:

There's no need for complex hosting infrastructure or package registries—only a structured Git repository. Users can register the marketplace URL once and install the plug-ins they need:

Once installed, the skills are ready to use directly:

Other agents offer similar mechanisms. Cursor supports plug-in directories with their own metadata format. The Gemini command-line interface (CLI) uses extension configuration files. The details differ, but the pattern is the same: group skills, add metadata, and point users to a Git repository.

### Unified tooling and future standards

The lack of standardization doesn't mean there are no efforts to provide unified tooling. One standout open source project is Lola, which takes a package manager approach to managing AI context. Instead of manually juggling agent-specific configurations, a single `lola install` command automatically distributes and versions your skills across all supported assistants.

Until tooling such as Lola becomes the universal standard, the best local strategy today is to keep your core skills in `.agents/skills/`—that's where most agents look by default—and add the agent-specific packaging on top as needed. The skill content stays the same; only the wrapping changes.

While a pure Git approach is universal, investing a little extra effort into setting up plug-ins and marketplaces provides significant value if you plan to distribute skills across a large organization—especially when onboarding less technical users.

So far, we have explored the concept of agent context and how skills fit into this broader framework. We also discussed their primary use cases and how to scale them for large organizations and the wider public. In our next installment, we'll focus on the specific content of these skills, the tools we use to build them, and how to maintain them effectively over the long run.
",https://developers.redhat.com/articles/2026/07/27/standardize-project-context-agentsmd-and-agent-skills,explainer
Distillation in 2026 (so far): which frontier models use it and how,"# Distillation in 2026 (so far): which frontier models use it and how

> This article is complementary material for Class 2: Distillation of the *Training an Agent* series Ben and I are doing, where we teach the post-training techniques behind a coding agent, step by step. Class 1 covered SFT on traces.

> It also pairs with the short history of distillation we published before the class, if you want the background first.

Distillation is widely used in the post-training recipes of 2026's frontier models. The three stages we discussed in the live session (off-policy, on-policy and self-distillation) map directly onto how labs use it in real life.

## A large teacher and a smaller student

The original use is still everywhere! Take a large, expensive teacher and train a smaller student to match it.

Gemma 3's tech report tells us that its post-training ""relies on an improved version of knowledge distillation from a large IT teacher"" (IT = instruction-tuned). The brand-new Gemma 4 tech report describes a similar post-training recipe, so we can infer that some distillation is also involved. DeepSeek-R1-Distill is also a case of this, and we already covered it in the brief history article: reasoning traces from R1 were distilled into compact Qwen and Llama students via plain fine-tuning (SFT) on the teacher's text, the sequence-level flavor.

These are the two flavors of the off-policy stage we covered in the class: match the teacher's next-token distribution (soft labels, white-box) or train directly on the teacher's generated text (hard labels, works black-box). R1-Distill is the second one. Same teacher-student idea, different signal.

## Merge RL experts into one model

The newer use is different, and it is the one most frontier labs converged on this year. Getting a single model to be good at everything through RL turns out to be really complex, because the skills gained in one training stage tend to degrade during the next one. The workaround most labs landed on is to train a separate RL expert for each domain (one for math, one for code, one for agentic tasks) and then distill all of them into one student while it generates its own rollouts. This is on-policy distillation, where the student writes and the teachers grade every token.

Something interesting I noticed while reading these reports is that the teachers here are usually not bigger models. They are checkpoints of the same base, the same size as the student, each pushed further in a single domain with RL. What makes them good teachers is specialization rather than scale.

- DeepSeek-V4 is the cleanest description of the pipeline. Each domain gets its own expert (SFT, then GRPO), and afterwards ""a single unified model is trained through on-policy distillation"", with the student optimizing the reverse KL loss against the specialist teachers.
- The name for the multi-teacher form comes from MiMo-V2-Flash: MOPD, Multi-Teacher On-Policy Distillation, later studied in its own paper. Domain teachers provide a dense, token-level signal on whatever the student generates.
- GLM-5, the report behind the GLM-5.x family, applies it *across training stages* instead of across domains. After their sequential RL phases, a final distillation pass recovers the capability that degraded along the way, and the teacher is an earlier checkpoint of the same lineage. One step away from the model teaching itself.
- Nemotron 3 Ultra, NVIDIA's flagship, adopts the multi-teacher form at scale: more than ten specialized teachers, each with its own domain pipeline, give the student dense token-level guidance on its own rollouts.
- Qwen3 uses the same mechanic in the classic direction, a big teacher and small students that generate and align their logits to it. Their report puts the cost at roughly 1/10 the GPU hours of RL, with better results.

Every lab justifies this with the same argument. A teacher can give the student feedback on every single token it produces, while a reward in RL is one number for the whole attempt (in the class we explained this). So distillation converges much faster on the exact behavior the student needs to fix. Thinking Machines' write-up on on-policy distillation is the clearest practitioner version of this argument I have read, and it comes with numbers, matching their RL baseline at a fraction of the compute.

## When the teacher is you

The third use drops the separate teacher entirely.

Cursor's Composer 2.5 trains with self-distillation. They inject a hint describing the desired behavior into the context, and the model *with* the hint becomes the teacher for the same model *without* it. A per-token KL pulls the unhinted policy toward its hint-conditioned self, so the model ends up producing the behavior without needing the hint at inference time. This is what we called the *privileged* teacher in the live session. Cursor's Sasha Rush explains it in detail in this clip from Dwarkesh Patel (Rafa Nadal shows up in the analogy, which alone makes it worth watching).

Thinking Machines shows another self-teacher, using the same on-policy recipe from the previous section with only the teacher swapped. After fine-tuning on new domain data, they distill from the *pre-fine-tune checkpoint* to restore the behavior that fine-tuning erased, while keeping the new knowledge. In class terms, this is the *earlier* teacher. This is their pitch for continual learning, keeping a deployed model learning new things without forgetting the old ones. Notice it is the same problem GLM-5 solves across RL stages, just at personal scale.

The teacher does not need to be bigger, just better in context. Sometimes that is the model itself.

## The takeaway

So this is where distillation stands in 2026, so far. It compresses big models into small ones, it merges RL experts into a single model, and it lets a model learn from a better version of itself. Under the names, though, they are all variations of one teacher-student mechanic, open in TRL at a scale you can reproduce (everything from the class).

If you want to see how all of it actually works, go watch the class.

More classes are coming in the series. Follow Ben and me to catch the next one.
",https://huggingface.co/blog/sergiopaniego/distillation-2026,explainer
A Technical Taxonomy of LLM Agent Communication Protocols,"# A Technical Taxonomy of LLM Agent Communication Protocols

## Abstract

As large language models advance and multi-agent systems aim to overcome standalone agent limitations, robust communication protocols have become essential infrastructure for distributed agent networks. This study develops a technical taxonomy to classify and analyze LLM agent communication protocols. Following an iterative method on nine actively maintained open-source protocols, the taxonomy comprises five dimensions: counterparty, payload, interaction state, discovery mechanism, and schema flexibility. Key findings reveal that all agent-to-agent protocols combine hybrid payloads with session-state persistence; most support multiple predefined schemas with two enabling runtime negotiation; and decentralized discovery remains rare. Analysis suggests short-term convergence toward unified agent-to-agent and agent-to-context communication, but long-term evolution toward a federated, layered protocol stack rather than a single standard.

Keywords: Agent Communication Protocols, Internet of Agents, Taxonomy Development, Multi-agent systems, LLM based Agents

## 1 Introduction

Large language model-based agents have attracted significant research attention recently. LLMs incorporate extensive world knowledge along with advanced reasoning and planning capabilities. When embedded as an agent's core and equipped with memory, sensors, and actuators, the LLM enables dynamic environmental interaction and efficient multistep reasoning for solving complex tasks.

Building on single LLM agents, multiple cooperating agents represent a promising frontier. Multi-agent systems consist of specialized agents that communicate, collaborate, and debate with one another. Rooted in collective intelligence principles, this approach enhances problem-solving capabilities, yielding outcomes superior to any individual agent.

However, without communication mechanisms, collective intelligence cannot arise. This infrastructure serves as the backbone enabling collective intelligence in multi-agent systems.

Various frameworks exist for constructing multi-agent systems at varying abstraction levels, including Microsoft's AutoGen, CrewAI, CAMEL, and LangGraph. This variety has introduced a critical challenge: a common protocol is necessary to standardize agent communication. Such standardization is fundamental for unlocking distributed multi-agent system potential, where heterogeneous agents can dynamically discover each other and collaborate seamlessly across diverse use cases.

Moreover, standardization should extend to accessing external systems such as APIs or services, enabling seamless agent integration. To overcome hard-coded communication pipelines, such protocols must define mechanics by which agents interact consistently, efficiently, and securely with both other agents and external systems.

As the LLM-based agents field remains relatively new and rapidly evolving, no universally accepted standard has emerged. Numerous solutions overlap in capability and lack interoperability. Explicit communication protocols have not been widely studied, yet they are becoming essential prerequisites for efficient cooperation and scalable multi-agent systems.

This paper investigates the emerging landscape of communication protocols for LLM-based agents by developing a comprehensive taxonomy and analyzing nine concrete protocol implementations. The taxonomy provides a coherent framework for understanding and classifying these protocols and tracking future developments.

## 2 Background

### 2.1 LLM-Based Agents

Agents are generally understood as autonomous entities that perceive their environment and take actions to achieve specified goals. Common defining characteristics of intelligent agents include autonomy, reactivity, proactivity, social ability, and strong reasoning capabilities.

#### 2.1.1 LLM-Centric Control

With large language models' rise, LLM-based agents have emerged as a new paradigm. Trained on massive text corpora, models such as GPT-4, DeepSeek-V3, and Claude Opus 4 have demonstrated impressive language understanding and generation capabilities. Beyond language processing, these models exhibit emergent capabilities, including human-like reasoning, planning, decision-making, self-reflection, zero-shot learning, and creativity.

Unlike narrow models, LLMs enable agents to often require little or no task-specific training data, performing informed actions out-of-the-box using internal knowledge. In practice, an LLM agent can receive a high-level goal in text and autonomously plan and act to accomplish it, using the language model itself to guide multistep reasoning and planning. Some argue that LLMs pave a promising path toward general AI agents.

A typical autonomous LLM-based agent workflow unfolds as follows: the agent receives a task or high-level goal as text, begins thinking by generating natural language and creating subtasks, acts within its environment through appropriate tools, and observes outcomes to gather feedback, enabling re-planning, learning, and iteration as needed.

#### 2.1.2 Fundamental Components and Concepts

LLM agents combine language-based reasoning with structured control, equipped with components such as long-term memory and specialized tools.

Reasoning and Planning

LLMs exhibit strong reasoning capabilities, forming the foundation of successful problem-solving, decision-making, and planning. Techniques to enhance these capabilities range from task decomposition and planning approaches to continuous self-reflection loops supporting adaptation. Task decomposition helps agents produce more granular and reliable plans for each subtask. Self-reflection mechanisms enable agents to detect errors, revise strategy, build resilience through adaptive self-healing, and tackle complex, long-horizon tasks.

Knowledge and Memory

Thanks to the LLM acting as the central controller, agents have access to vast encoded knowledge embedded within the foundation model's weights. Beyond this, agents access in-context data, such as recent user conversations, tool invocation records, and agent thought history. This session-bounded data is commonly called short-term memory or working memory. Furthermore, agents can be equipped with access to persistent external data sources, such as internal documents, external databases, and retrieval-augmented generation.

Perception and Action

To operate effectively in specific environments, agents must perceive that environment, recognize its affordances, and act within it. Beyond obvious textual information input, multimodal perception provides valuable additional capability. Visual input is particularly rich when the agent's operating sphere is part of the real world, necessitating resilient design patterns for visual processing.

The environment interface is typically realized by providing tools agents can use, marking a key difference between agentic systems and pure LLMs. By generating output in specific formats, typically JSON snippets, agents can invoke tools with required parameters and receive resulting output upon execution. Thanks to LLMs' powerful zero-shot and few-shot learning capabilities, new tools can be acquired simply by including their descriptions in prompts.

Applications

Equipped with these capabilities, LLM agents can operate far beyond simple conversational exchanges. They can plan multistep processes, query knowledge sources, adapt over time, and more. Specialized agents now tackle diverse domains including computer control (code generation, terminal troubleshooting, GUI automation) and knowledge work (innovation support, scientific workflow assistance, knowledge exploration).

Challenges

Despite rapid advancement, LLM-based agents still face significant limitations. They are not immune to inherent foundation model vulnerabilities, such as hallucination, and finite context windows restrict historical data and environmental context volumes they can process. Autonomously generated plans are not guaranteed to be feasible or efficient, and reliable multimodal information source integration remains an ongoing challenge. Additionally, many LLM agent techniques heavily rely on pure prompting, yet minor prompt variations can produce entirely different outputs.

### 2.2 Multi-agent systems

#### 2.2.1 LLM Based Multi-agent systems

Multi-agent systems consist of multiple agents that coordinate and communicate to accomplish common goals. The idea is simple: independent, specialized agents jointly solve tasks, thereby harnessing collective intelligence benefits. Decomposing complex objectives into manageable subtasks and assigning them to specialized agents naturally simplifies problem-solving. Furthermore, diverse perspectives and varied interaction styles across agents, such as mutual feedback and debate, enhance multi-agent system problem-solving capabilities beyond single-agent systems.

#### 2.2.2 Key Concepts

At a high level, multi-agent systems are built from two essential elements: the agents themselves and the architecture connecting them. Each agent is characterized by a specific profile, including its role, abilities, and toolset, while the architecture serves as core infrastructure defining and enabling collaboration among all agents.

The optimal topology of agent ensembles remains a central research concern. Different architectures exist, ranging from equi-level designs where all agents operate at the same hierarchical level to hierarchical configurations where one or several agents guide the group as leaders. The communication structure may be either fixed or dynamic, requiring rigorous methods to model such dynamic architectures. In fully dynamic systems, agent roles, relationships, and even participating agent numbers can evolve over time.

Effective coordination and decision-making is vital. Agents must debate, consult one another, align goals, and resolve misunderstandings. Because multi-agent systems often yield multiple possible solutions and parallel discussions, convergence techniques are required. Typical strategies include majority voting, consensus-seeking methods, or introducing a judge agent for final decisions.

Agent profiling becomes especially important in multi-agent systems. Agent specialization is critical for effectiveness. Roles, characterizations, behavior descriptions, and skill sets must be carefully crafted, primarily through precise prompting and LLM model selection.

To successfully enable collective intelligence within multi-agent systems, a communication backbone is crucial. Without communication, agents cannot cooperate, debate, nor coordinate actions. Ensuring efficient and robust interactions is therefore essential for achieving reliable, high-performing multi-agent systems. Given that multi-agent systems are expected to grow in size and distribution, standardized communication protocols are critical to achieve scalability and flexibility without sacrificing robustness. They are key infrastructure elements enabling heterogeneous agents to connect reliably and dynamically.

### 2.3 Communication Protocols

In computer science, a protocol is a formal set of rules or conventions governing how entities such as programs, processes, or agents communicate and interact. It specifies the format, sequence, and meaning of exchanged messages, enabling heterogeneous systems to understand one another straightaway.

In practice, a protocol specifies what data is communicated, how it is structured, and when it should be sent or acknowledged. By defining these dimensions precisely, protocols enable independent, potentially heterogeneous systems to communicate reliably. Often, they include procedures for error handling, synchronization, and more, ensuring reliable communication even under adverse conditions.

The internet itself demonstrates protocol importance. Foundational standards such as the Internet Protocol and Transmission Control Protocol, together with the Hypertext Transfer Protocol, form today's backbone of global data exchange.

Beyond this, multi-agent systems require application-level protocols clarifying how autonomous agents interact. Before LLMs' rise, well-known examples included the Knowledge Query and Manipulation Language and FIPA Agent Communication Language. KQML was introduced as ""a new language and protocol for exchanging information and knowledge"" among software agents. Central to KQML is an extensible set of operations called performatives, such as ask and tell, laying groundwork for higher-level interaction patterns like negotiation. Its successor, ACL, represented the first organized effort to standardize agent communication. Building on speech-act theory, ACL lets agents express intentions, requests, information, and proposals while each message follows a formal structure with fields for sender, receiver, content, and more, enabling interoperability across heterogeneous agents.

In LLM-based multi-agent systems, standardized communication protocols become essential for maintaining consistent, secure, and reliable interactions among heterogeneous agents. As systems scale, these protocols become prerequisites for robust multi-agent collaboration, enabling greater efficiency, adaptability, and overall performance with minimal human intervention.

## 3 Related Work

Several recent works have examined the emerging landscape of LLM agent communication protocols, highlighting both rapid progress and significant remaining challenges.

From a standardization standpoint, Li et al. argue that current agent communication fragmentation resembles early ""protocol wars"" of networking and advocate for a unified framework. Du examines AI agent communication through Internet architecture perspective, distilling five key design principles guiding sustainable multi-agent ecosystem development. Kong et al. provide comprehensive security-focused surveys of agent communication, proposing three-class taxonomies for categorizing agent communication while systematically analyzing associated vulnerabilities and potential defense mechanisms. Ehtesham et al. offer comparative analyses of four concrete interoperability protocols (MCP, ACP, A2A, and ANP), evaluating them across dimensions such as interaction modes, discovery mechanisms, and security models.

Further research exists on concrete protocols. Among the sample later examined, the Agora protocol stands out for scientific rigor and emphasizing fundamental principles needed in efficient, scalable, robust design. Marro et al. identified a trilemma of three quality attributes: versatility (supporting multiple message types), efficiency (demanding minimal computational and networking costs), and portability (reducing adoption effort). No protocol can simultaneously maximize all three.

Yang et al. also propose a taxonomy for LLM agent communication protocols comprising two dimensions: object orientation (distinguishing context-oriented from inter-agent protocols) and application scenario (classifying protocols as general-purpose or domain-specific). They collected a sample of 14 protocols and evaluated them against quality attributes such as efficiency, security, and scalability. Nevertheless, a two-dimension taxonomy seems insufficient for providing the abstract, hierarchical structure needed to explore, analyze, and understand the field in depth.

## 4 Approach

### 4.1 Taxonomy Development Method

To develop the taxonomy, we followed the widely used taxonomy construction method from Nickerson et al. This method was selected because it provides structured, iterative, traceable, and reproducible procedures for constructing taxonomies rather than relying on ad hoc classification processes.

This section begins by outlining qualities defining useful taxonomies, then discusses the iterative procedure driving development as applied in this study.

The term taxonomy refers to a classification framework. Fundamentally, the goal is providing a useful hierarchical classification system organizing key concepts and their concrete values. It aims to capture specific domain essence, thereby helping users understand, discuss, analyze, and observe complex concepts. In contrast to typologies, which are conceptual classification approaches, taxonomies are empirical, derived from real-world data and observation. Following Nickerson et al., taxonomies consist of several distinct dimensions, each containing two or more characteristics that should be mutually exclusive and collectively exhaustive.

Nickerson et al. define five qualitative attributes of useful taxonomies. A taxonomy should be concise (enabling researchers to recall the entire taxonomy with ease); robust (containing enough dimensions and characteristics to meaningfully differentiate objects); comprehensive (able to classify every domain instance and contain all relevant object dimensions); extendible (allowing new characteristics and dimensions without difficulty); and explanatory (offering dimensions and characteristics providing useful, explainable abstractions). These criteria served as subjective ending conditions for our taxonomy development process.

This study rigorously follows a clear development process ensuring quality and reproducibility. The entire development process began by defining three foundational elements. First, researchers should define the taxonomy's overall purpose: for what should it be used later and who are the main users. Next, a meta-characteristic must be established, providing a basis for later characteristic construction. A typical wording could be: ""Classify … based on …"" and can encapsulate multiple facets. After establishing this anchor, researchers select objective ending conditions (for example, no new dimensions emerge and every characteristic is instantiated) and subjective ending conditions (the five quality criteria outlined above).

After defining these elements, we followed Nickerson et al.'s iterative development cycle. The development cycle begins with a fundamental decision where each iteration requires choosing between two development paths. In the conceptual-to-empirical path, researchers first identify candidate dimensions from theory, apply them to a concrete object sample, and prune or augment constructed dimensions. On the alternative empirical-to-conceptual path, researchers instead examine concrete objects, distill meaningful attributes and properties, and group these into abstract dimensions satisfying sound taxonomy design quality criteria. Each iteration ends with reviewing and evaluating the resulting taxonomy against predefined ending conditions. If these conditions are not satisfied, another iterative cycle begins, starting with the binary path choice.

Conceptually, this process mirrors the build-evaluate cycle in design science research. Each iteration constructs a provisional taxonomy or schema and immediately evaluates it against empirical reality and predefined quality criteria. This allows usefulness, purpose-fit, and traceability integration into taxonomy development processes. The approach also encourages detailed entire procedure documentation, supporting both reproducibility and extensibility. This disciplined iterative procedure, bounded by explicit rules, yielded high-quality taxonomies with unique dimensions and mutually exclusive, collectively exhaustive characteristics.

### 4.2 Communication Protocols Sample

This section outlines how we selected the nine protocols grounding our taxonomy development and offers concise summaries of each.

First, it is important to define the general type and domain of target protocols. Although we further clarify this when specifying the meta-characteristic in taxonomy development processes, it is already essential for protocol selection. Specifically, we searched for protocols explicitly developed to connect LLM agents with other systems. Consequently, more generic agent communication implementations and concepts, such as the FIPA Agent Communication Language or the Contract Net Protocol (an abstract task-sharing protocol for multi-agent systems), were excluded from the sample. Likewise, protocols not explicitly designed for LLM agents fall outside the taxonomy scope.

Next, we focus exclusively on protocols that are open source and have ready-to-use implementations. The implementation does not have to be production ready; test or research prototypes are sufficient. For instance, the Agora protocol is not production ready, yet an implementation exists, whereas the LOKA protocol is just a proposed concept with no implementation, and therefore excluded. Also, Firecrawl and the uAgents protocol are proprietary solutions not entirely open source and thus omitted. Emphasizing the open source requirement reflects the historical pattern that for major web standards, open source status has been critical to achieve widespread adoption and become global standards.

All selected protocols maintain publicly accessible codebases on GitHub, enabling verification of active maintenance status. GitHub stars serve as quantitative proxies for community adoption and real-world traction. For that reason, protocols such as the Agent Protocol, whose last commit not just changing the README file occurred on June 11, 2024, are treated as inactive and therefore excluded. Likewise, repositories such as the AITP protocol, having accumulated only 20 GitHub stars since their initial February 2025 release, are omitted.

Nine protocols met all selection criteria and are outlined in the following section.

#### Model Context Protocol (MCP)

Developed by Anthropic, the Model Context Protocol provides a standardized way to augment any LLM with tools and contextual information by enabling existing applications, APIs, and raw data sources to present their context and capabilities to LLMs in standardized manners.

At its core, MCP follows a straightforward client-server model. Host applications, such as Claude Desktop or IDE plug-ins, embed MCP clients that communicate with MCP servers, each exposing specific capabilities, including data retrieval, tool invocation, and prompt delivery for the LLM behind the MCP client.

#### Agent to Agent (A2A)

Google developed this protocol to address rising numbers of siloed agent infrastructures. As agents are implemented and deployed across diverse frameworks and platforms, standardized protocols are required to facilitate collaboration. Its primary goal is enabling agent-to-agent connectivity, not replacing the already well-known MCP protocol.

Designed to be secure and extensible by default, it implements various concepts across multiple communication levels, supporting both immediate and extended tasks, including streaming updates, state synchronization, and artifact exchange (files and structured data).

#### LangChain Agent Protocol (LAP)

LangChain created a standardized API for deploying LLM agents in production. Specifically, they defined a RESTful API with unified endpoint sets. The main endpoints are /runs for executing agents, /threads for managing multi-turn conversations, and /store for long-term memory storage. Through these endpoints, any client can invoke, monitor, and persist agent workflows, irrespective of agents' internal implementations.

#### agents.json

This simple protocol defines a JSON specification through which existing websites and APIs can be discovered and interpreted by LLM-based agents. Built on top of the OpenAPI standard, agents.json offers structured, LLM-friendly, and stateless ways to define and consume API workflows, letting agents execute multi-step tasks reliably with minimal boilerplate and without extensive prompt engineering.

#### Agora

Oxford researchers introduced the Agora Protocol to enable decentralized collaboration among diverse LLM agents without central servers and pre-defined communication schemas. Its design tackles the Agent Communication Trilemma, balancing versatility (handling diverse message types), efficiency (minimizing token and API cost), and portability (working across agent platforms), in a single decentralized framework. For instance, it includes on-the-fly protocol negotiation mechanisms. Before exchanging actual data, agents share or even generate new communication schemas.

#### Agent Network Protocol (ANP)

Its vision is becoming ""the HTTP of the agentic web era."" It is a peer-to-peer communication protocol designed to enable secure, decentralized collaboration among heterogeneous LLM-powered agents across the internet. The protocol is intentionally flexible and feature-rich out of the box, offering three layers: an Identity Layer for secure communication (covering authentication and end-to-end encryption); a Meta Protocol Layer allowing agents to negotiate communication styles dynamically; and an Application Layer supporting straightforward agent interaction through standardized descriptions and management.

#### LMOS

This protocol is part of the Eclipse LMOS ecosystem and enables agents and tools to easily publish, connect, and share their capabilities. As a special feature, it standardizes metadata and interaction patterns while remaining agnostic to underlying transport layers, allowing seamless operation over HTTP, WebSocket, MQTT, and other protocols. Moreover, it emphasizes readily supporting internet-scale multi-agent systems with thousands of tools and agents—an Internet of Agents.

#### Agent Communication Protocol (ACP)

The ACP is a RESTful open standard created by BeeAI and IBM under Linux Foundation governance that enables seamless, structured communication, discovery, and coordination among heterogeneous LLM agents.

ACP defines consistent HTTP/JSON interfaces enabling agent discovery, execution, and multimodal message exchange. It also implements so-called ACP Servers, where agents can register themselves for discovery and likewise discover other publicly available agents.

#### agntcy

Its mission extends beyond defining agent-to-agent communication protocols, seeking to establish open-source infrastructure for the Internet of Agents. For communication, it specifies the Agent Connect Protocol, an API extending OpenAPI that enables agents to connect, share state, stream results, and handle authentication and authorization seamlessly across frameworks and runtime environments. The potential standard also provides essential infrastructure elements, including centralized discovery services, fixed agent manifest formats, and many more.

## 5 Results: Taxonomy Design

We now proceed to construct the taxonomy by first defining its fundamental artifacts and summarizing the iterative development process. Rather than detailing each iteration, we focus on examining both accepted and rejected dimensions. Finally, we classify concrete protocols from our sample to illustrate the taxonomy's dimensions and their application.

### 5.1 Developing the Taxonomy

#### 5.1.1 Scope

The taxonomy's purpose is classifying and distinguishing LLM agent communication protocols based on the communication types they facilitate. The taxonomy focuses on protocols connecting LLM agents to other systems, such as other agents or general information systems. It operates primarily at the application level rather than the solution level, and therefore does not delve into concrete technical implementation details.

The expected taxonomy users are researchers and agent developers, as well as non-experts simply wanting to access agents through APIs. Potential users may wish to obtain communication form overviews and protocol selection guidance. Additionally, brief overviews of how protocols differ overall, and where gaps and further research and development opportunities exist, are of interest.

The meta-characteristic is defined as classifying the protocols according to the types of components involved and the characteristics of their communication.

#### 5.1.2 Process and Quality

In total, we conducted five iterations: the first three followed the empirical-to-conceptual approach, and the final two followed the conceptual-to-empirical approach. Each of the first three iterations examined three of the nine collected protocols. The final two iterations complemented the analysis by consolidating accumulated knowledge and testing more abstract dimensions.

Ultimately, the iterative approach, guided by clear ending conditions and the taxonomy's purpose and meta-characteristic, made development straightforward and appeared to strengthen its robustness and comprehensibility.

With respect to basic taxonomy quality criteria, we focused on the following key properties. The developed taxonomy is concise, containing a clear and manageable number of dimensions and characteristics. It is also robust, in that we examined exactly nine protocols in detail and discovered no new valid dimensions in the final iteration. Furthermore, comprehensiveness and explanatory quality are ensured, as we demonstrate that all protocols can be straightforwardly classified according to the taxonomy. Finally, the taxonomy satisfies the foundational mutual exclusivity and collective exhaustiveness principle, which we systematically enforced during dimension construction.

### 5.2 Accepted Dimensions

Throughout the iterative process, various dimensions were examined based on discovered common and distinctive characteristics. All considered dimensions are now described in detail, separated into accepted and rejected ones.

For each dimension, we present its corresponding values and assess whether it satisfies mutual exclusivity and exhaustiveness. For accepted dimensions, we additionally cite foundational research supporting the dimension and its values.

The finalized taxonomy comprises five dimensions.

#### 5.2.1 Counterparty

We begin with the most self-explanatory dimension: counterparty. It identifies the type of entity with which the agent interacts via the protocol. Its values are:

- Agent: the protocol connects one LLM agent to another
- Context: non-agent entities such as tools, services, APIs, or data sources are connected
- Hybrid: both are supported

The dimension is mutually exclusive and exhaustive, as context captures any non-agent counterparty by design. Although further subcategories within context could be defined, the dimension is intentionally kept concise.

This dimension aligns with Yang et al.'s protocol taxonomy. Their object-orientation dimension distinguishes context-oriented from inter-agent protocols, corresponding to our context and agent values, respectively. We extend their scheme with a third value, hybrid, to accommodate protocols supporting both types.

#### 5.2.2 Payload

Next, the payload dimension classifies the kind of data a protocol exchanges. A protocol falls into one of three categories:

- Structured data and artifacts: only structured data or artifacts, including meta-information, are exchanged
- Conversation focused: the payload is message-centric and text is always part of the exchange
- Hybrid: both are supported

To clarify this dimension further, we compare it with three basic data types: structured, semi-structured, and unstructured. Rather than adopting that typology, our taxonomy classifies payloads according to the intended purpose a protocol is designed to support. A protocol is labeled conversation focused when text is always part of the payload and structured or semi-structured data appear only as optional extensions. Conversely, if the protocol can solely transmit structured data and artifacts drawn from any of the three data types, it is assigned to the structured data and artifacts category.

#### 5.2.3 Interaction State

This dimension captures the persistence of interaction state within a protocol, that is, whether the protocol implements a stateful unit of work between connected components. A protocol is either:

- Stateless: no context is preserved across messages
- Session state: the protocol implements stateful units of work persisting across message exchanges

Mutual exclusivity and exhaustiveness are guaranteed because the dimension is binary. A protocol preserving context across messages is classified as session state; one lacking such mechanisms is stateless.

Ling et al. identify four kinds of managed state in communication networks: stateless, soft state, session state, and hard state. Their stateless definition—no information retained at nodes—matches our equivalently named value directly. Session state, defined as information persisting only for user session duration, corresponds to what we term session statefulness. The remaining categories, hard state (referring to long-term memory) and soft state (denoting temporarily cached information), fall outside this dimension's scope. The dimension only concerns single-session duration, not what persists beyond it.

#### 5.2.4 Discovery Mechanism

In dynamic, large-scale distributed systems, individual nodes are typically unaware of precise identities or locations of other nodes. Therefore, efficient discovery mechanisms are essential for scalable and flexible agent networks.

We identify these values:

- Static: the requesting agent must know the endpoint a priori
- Centralized: a registry maintains a list of accessible endpoints
- Partially centralized: a limited set of supernodes assists with discovery
- Decentralized: no central authority exists; each peer maintains its own index, with discovery occurring via network broadcasting
- Hybrid: protocols supporting multiple discovery mechanisms beyond static configuration

To ensure exhaustiveness, we drew on Ahmed and Boutaba's survey of distributed search techniques in large-scale systems. They index two centralized content-sharing architectures (registry and index), which we combine into a single value, centralized, since we only are concerned with the discovery mechanism itself, not how the registry is built. Their classification further motivates additional values for partially centralized and fully decentralized approaches. We add hybrid for protocols supporting multiple discovery mechanisms.

Mutual exclusivity is guaranteed by arranging values hierarchically. Static represents the baseline. If a protocol offers centralized, partially centralized, or fully decentralized discovery mechanisms, it is classified as such, even though static configuration remains universally available. A protocol supporting multiple non-static mechanisms is assigned to hybrid.

#### 5.2.5 Schema Flexibility

Next, we introduce the schema flexibility dimension, which captures the degree of flexibility a protocol offers in adjusting communication schemas, message formats, or dialogue structure. A protocol may allow:

- Single: one basic interaction pattern defined before runtime
- Multiple: multiple static schemas established a priori, from which the requester can choose at runtime
- Evolving: interacting components can negotiate new interaction styles at runtime

In this dimension, the term schema follows the standard computer-science definition: a formal structure representing an engineered artifact. In our context, it refers in particular to the structure of the exchanged content. For instance, a tool invoked by an agent may require a fixed schema with a predefined set of typed variables, whereas an LLM-based agent might accept only a single text input, subject to constraints such as maximum length.

It is important to note that this dimension does not characterize the structural nature of the payload; that role belongs to the payload dimension. Instead, it specifies whether exchanged information must conform to a fixed schema, whether agents may select from multiple predefined schemas, or whether the protocol supports runtime negotiation of schema structure.

### 5.3 Rejected Dimensions

Having examined all accepted dimensions, we now turn to three rejected dimensions and explain the rationale for their exclusion from the taxonomy.

#### 5.3.1 Initiative Flow

This dimension captures which party may initiate communication. Its proposed values are:

- Unidirectional: only the client can initiate
- Context-bound bidirectional: either party may send messages within an active session but only one side can initiate it
- Open bidirectional: any party can initiate communication at any time

The dimension is rejected on two grounds: most protocols fall under context-bound bidirectional, and any protocol could in principle be implemented symmetrically to support open bidirectional initiation. It therefore fails the mutual exclusivity test and adds little analytical value.

#### 5.3.2 Simplicity

The examined protocols differ notably in their simplicity and intended lightweightness. Some, such as A2A and LMOS, incorporate broad functionality ranges, whereas others, such as Agora, agents.json, and ACP, target specifically defined use cases and explicitly prioritize lightweight design.

Nevertheless, this dimension poses an immediate problem: there are no clear boundaries ensuring mutually exclusive values. The notion of simplicity is too vague to construct a meaningful qualitative dimension, and it is therefore rejected.

#### 5.3.3 Persistent State

This dimension classifies protocols by their ability to store data about prior interactions beyond single or multi-turn exchanges. Unlike the interaction state dimension, it concerns exclusively long-term statefulness. The stored content might include textual summaries of earlier chat sessions or negotiated sub-protocols preserved for future interactions. Although individual nodes could store such state at the implementation level, this dimension focuses on whether the protocol itself promotes any form of persistence.

Its proposed values are:

- None: no persistence features are offered
- Metadata: the protocol supports storage of metadata such as a negotiated schema
- Context: concrete interaction context such as session summaries is preserved
- Hybrid: both metadata and context are explicitly maintained

In practice, most protocols already implement metadata persistence by exchanging component descriptions such as the Agent Discovery Card in A2A or the Agent Detail endpoint in ACP. Certain protocols additionally offer explicit features for context persistence; for example, LAP exposes a store endpoint that manages persistent key-value repositories accessible across interaction threads.

Nonetheless, the dimension is rejected. Nearly every protocol already exchanges minimal metadata for node identification, and the protocol itself does not determine what connected nodes ultimately store persistently. Moreover, providing persistent state mechanisms is not an essential protocol objective.

### 5.4 Classifying Concrete Protocols

We now revisit the protocols used during taxonomy construction and assign them to appropriate characteristics within the accepted dimensions. In the interest of conciseness, we only discuss the most salient classifications, those that best clarify and validate the taxonomy.

#### 5.4.1 Counterparty

Various protocols are explicitly designed to facilitate agent-to-agent collaboration and thus address the agent counterparty type. Agora, ANP, LAP, and agntcy are classified as such. Moreover, A2A and ACP further emphasize that agents should use these protocols specifically for inter-agent communication, in contrast to protocols such as MCP, which are intended for connecting to context. An MCP server is defined as the counterparty addressed by the agent, which can expose resources (such as documents or data), tools, and prompts.

#### 5.4.2 Payload

MCP and agents.json are the only protocols assigned to the structured data and artifacts payload type. MCP is designed for exchanging structured requests and data responses between LLM-based agents and external tools, data sources, or services. Further, agents.json does not handle actual data exchange; its sole purpose is providing agents with structured descriptions of existing APIs.

All remaining protocols are classified as hybrid. They typically define core exchange units capable of encapsulating both simple strings and arbitrary elements. The exchange is thus not limited to conversational text; purely structured or contextual information can be transmitted as well.

#### 5.4.3 Interaction State

All protocols designed for agent-to-agent communication support multi-turn interactions through stateful units of work persisting across message exchanges. These units are named differently across protocols, like threads, tasks, or in the case of Agora, realized through a simple multiround flag enabling the message structure to maintain session state.

In contrast, the core MCP protocol and agents.json define no explicit session statefulness mechanisms and are therefore stateless by design.

#### 5.4.4 Discovery Mechanism

First, MCP illustrates an important distinction: although agents can discover a server's capabilities at runtime, the discovery mechanism dimension classifies MCP as static, since the requesting agent must still know the server's base address a priori.

A2A, by contrast, supports three discovery strategies, all relying on a JSON Agent Card as the agent's self-description. An agent may host its card at a standardized path on its own domain, share it through private channels, or publish and query cards via a centralized registry. Although static configuration is a primary discovery mechanism, the presence of a registry-based option places the protocol within the centralized discovery class.

All other protocols fall into either the static or centralized category, with the exception of LMOS, which is classified as hybrid.

#### 5.4.5 Schema Flexibility

Most protocols either specify single concrete interfaces or allow multiple distinct schemas to be defined in advance.

More interesting are the two protocols implementing evolving schema functionality. In Agora, a core concept is the Protocol Document, a plain-text description of everything an agent must understand to follow a given protocol. These documents are actively constructed and negotiated at runtime. Initial interactions occur entirely in natural language, but once a more efficient protocol has been established, subsequent exchanges can adopt more structured formats, possibly without any message parameters. ANP similarly supports dynamic negotiation of payload formats and interaction structures, enabling agents to select or generate schemas at runtime.

## 6 Discussion

We have developed a qualitative taxonomy to efficiently classify and analyze communication protocols for LLM agents. This hierarchical classification system helps structure and thereby clarify an increasingly complex, rapidly growing field. Future protocols can be intuitively classified and compared at abstract levels, enabling researchers to identify overarching trends and anticipate potential innovations.

### 6.1 Insights and Implications

Let us consider some important findings and implications emerging during taxonomy development, backed by classifications of all nine protocols.

If a protocol implements agent-to-agent communication (7 of 9), session state functionality is always available. This is expected, because contemporary LLM-based agents rely on multi-turn interaction, which in turn requires state persistence. Moreover, none of the agent-to-agent protocols restrict themselves to conversation-focused payloads (7 of 9). Instead, all are consistently hybrid; while they can transmit textual messages, they also support purely structured payloads whenever appropriate. Furthermore, a clear trend toward schema flexibility emerges from the data. The majority of protocols permit multiple schema definitions (7 of 9), and two (2 of 9) additionally allow schemas to evolve during runtime. Schema negotiation is thereby regarded as a central agent-to-agent protocol component, enabling LLM-based agents to fully leverage their capabilities. With respect to discovery mechanisms, only the LMOS protocol truly incorporates a decentralized, peer-to-peer approach. Most protocols instead rely on either centralized registries (4 of 9) or static configuration (4 of 9). Should the Internet of Agents emerge as a dominant paradigm, decentralized approaches should be explored more and may prove increasingly important.

Looking forward, a central question is whether the field will converge on single, monolithic standards or adopt more modular architectures. Initially, the functional overlap between emerging protocols might suggest short-term convergence toward unified standards capable of supporting both agent-to-agent and agent-to-context interactions. Notably, A2A and agntcy present themselves as MCP extensions, though the primary organization behind MCP, Anthropic, has not officially endorsed either of them. While modifying agent-to-agent protocols like A2A to incorporate MCP functionality would be relatively straightforward, drawing on historical computer networking precedents, we argue that monolithic ""winner-takes-all"" standards are unlikely to prevail. Instead, mirroring the layered OSI model, our analysis suggests that multi-agent system communication will evolve toward federated, layered protocol stacks. Under this architecture, the Internet of Agents will likely utilize lightweight specifications, such as agents.json, for static capability discovery; defer to highly structured context-protocols, such as MCP, for secure tool execution; and reserve session-aware, schema-evolving protocols, such as ANP or Agora, for complex, multi-turn deliberations.

A notable gap across all investigated protocols is the widespread absence of privacy safeguards, compliance checks, and policy enforcement mechanisms. This shortcoming will become more severe as agents are increasingly deployed in safety-critical domains such as healthcare or human resources, where mechanisms for protecting personal and security-sensitive data are essential.

### 6.2 Evaluating the Communication Trilemma

Applying Marro's Agent Communication Trilemma, introduced earlier, to our taxonomy reveals stark architectural trade-offs. The trilemma dictates that a protocol cannot simultaneously maximize versatility, efficiency, and portability.

This trade-off is highly visible at the extremes of our Schema Flexibility and Payload dimensions. Protocols designed primarily for context-interaction, such as MCP, maximize portability and efficiency by enforcing rigid schemas, stateless interactions, and strictly structured data payloads. This strictness eliminates token-heavy negotiation, making them ideal for predictable, high-throughput agent-to-tool invocations. Conversely, protocols with evolving schemas, such as Agora and ANP, maximize versatility to facilitate dynamic, open-ended multi-agent debates. However, this adaptability introduces significant token overhead and latency during schema negotiation, severely reducing efficiency.

Interestingly, the taxonomy reveals that the majority of surveyed protocols, such as A2A, LMOS, and ACP, navigate the center of this trilemma. By adopting hybrid payload structures, session state persistence, and multiple pre-established schemas, they provide enough versatility to support complex interactions without incurring the extreme efficiency penalties of runtime protocol negotiation. Ultimately, mapping our taxonomy against the trilemma reinforces the conclusion from earlier: the impossibility of a single, omnipotent protocol strongly supports the necessity of a layered protocol stack for the future Internet of Agents.

### 6.3 Limitations and Future Work

Future research could enrich our taxonomy with further dimensions capturing the domain in greater detail. Promising extensions include more technical protocol dimensions, authentication and security mechanisms, and the means by which protocols embed policies and norms. Also, classifying new protocols as they emerge would both strengthen the taxonomy's validity and allow systematic tracking and analysis of ongoing developments within the domain. Moreover, the taxonomy provides a practical basis for evaluating which protocols are most suitable for specific use cases and application domains.

## 7 Conclusion

In this paper, we have developed a comprehensive technical taxonomy of communication protocols for LLM-based agents. Motivated by the growing fragmentation of agent frameworks and protocol proposals, we examined how emerging protocols structure communication between LLM agents, other agents, tools, services, APIs, and external information systems. To develop the taxonomy, we followed a structured approach, defining the taxonomy's purpose, meta-characteristic, ending conditions, and iterative development process before applying the resulting framework to nine existing protocol implementations. By following a well-structured taxonomy development approach, we ensured methodological quality, producing a framework allowing efficient exploration and analysis of the diverse landscape of LLM agent communication protocols.

In addition, we identified several clear patterns by applying the taxonomy to nine concrete protocols. Most agent-to-agent protocols support multi-turn statefulness and the capacity to exchange both textual messages and structured data. Furthermore, schema negotiation is considered essential for efficient flexibility. Most importantly, our analysis suggests possible short-term convergence pressure toward protocols unifying agent-to-agent and agent-to-context communication. In the long term, rather than converging on single monolithic standards, the field will likely evolve toward federated, layered protocol stacks, similar to the OSI model in traditional computer networking. Such an architecture would seamlessly integrate specialized protocols, ranging from lightweight capability discovery specifications to highly structured tool execution and schema-evolving deliberation mechanisms, to support the full spectrum of agent communication scenarios efficiently. However, whether this leads to single dominant standards or to small sets of interoperable protocol families remains an open question.

As LLMs continue to advance, LLM agents will grow more intelligent and capable of tackling real-world challenges. Likewise, LLM-powered multi-agent systems hold potential to surpass single model scalability constraints. Consequently, the means by which agents communicate is a critical design element in building decentralized, flexible, and efficient agent networks, laying the groundwork for futures in which agents may operate partially or even fully autonomously in handling complex tasks.
",https://arxiv.org/abs/2606.19135,explainer
Diagnosing and Mitigating Context Rot in Long-horizon Search,"# Diagnosing and Mitigating Context Rot in Long-horizon Search

## Abstract

Extensive context has become the norm as Large Language Models (LLMs) are increasingly deployed in long-horizon tasks. The concern that increasing context length degrades model capabilities, known as context rot, has become a central issue for these applications. In this paper, we focus on deep search scenarios, aiming to investigate the rot phenomenon and its mitigation strategies. By evaluating four flagship open-source models across three benchmarks, we reveal a prevalent but unnoticed rot phenomenon: extensive context causes models to directly give up or prematurely provide uncertain answers, and this issue is exacerbated as the context grows. Through pruning experiments, we demonstrate the relationship between the accumulated context and the rot phenomenon. Furthermore, we investigate mitigating this issue through context management and post-hoc rejection sampling. For context management, we systematically evaluate seven different methods across three categories, based on performance, cost, and impact on context rot, providing clear guidance for strategy selection and usage. For rejection sampling, we develop a rot-aware filtering strategy and demonstrate its effectiveness across three aggregation methods. Finally, we show that these two approaches can be combined for further performance improvements.

## 1 Introduction

Deep search has become one of the main applications of Large Language Model (LLM) agents, where agents continuously search and view multiple web pages over a long horizon to answer user queries. One core feature of this scenario is the extensive context. For example, to answer a complex query, agents are required to execute tens or even hundreds of search tool calls interleaved with internal thinking, accumulating a massive amount of context comprising both environment feedback and internal reasoning. The concern that increasing context length degrades model capabilities, known as context rot, has become a central issue for these applications. However, it remains unclear how models behave given extensive context in such scenarios and how different strategies can alleviate this issue. In this paper, we aim to investigate the rot phenomenon and its mitigation strategies in deep search scenarios.

Current research on context rot mostly focuses on single-turn long input setups (e.g., the needle-in-a-haystack test), which differ significantly from agentic tasks where the context is usually multi-turn, multi-source, and progressively accumulated. Recent work has begun to focus on model behaviors in multi-turn scenarios, but mainly in conversations with human users or in synthetic scenarios. Moreover, from the perspective of mitigating context rot, while various context management methods have been proposed, they are usually heuristic-based and have not been systematically investigated for their effects on context rot, thus failing to provide clear guidance on when to use these methods or which specific strategy to choose.

To diagnose context rot in long-horizon search scenarios, we develop a detailed error taxonomy based on the characteristics of the answer and the reasoning processes that contribute to it. By investigating four flagship open-source models across three benchmarks, we reveal a prevalent but previously unnoticed rot phenomenon: ""extensive context causes models to directly give up or prematurely provide uncertain answers, and this issue is exacerbated as the context grows.""

Through a pruning analysis of the accumulated context, we show that: 1) the rot phenomenon is not solely dependent on trajectory length or the number of interaction turns, but also on the content of the accumulated context; 2) entirely removing the accumulated context almost completely eliminates the rot phenomenon, but at the cost of a significant increase in unfinished trajectories, highlighting the importance of carefully designing mitigation methods.

Following this analysis, we systematically investigate the mitigation of context rot through context management methods that modify the ReAct framework, as well as through post-hoc rejection sampling requiring no modifications. For context management, we evaluate seven different techniques across three categories: context compaction, context trimming, and context isolation, assessing them based on their performance, cost, and impact on context rot. We show that: 1) combining context compaction and context trimming achieves the optimal balance between cost and reducing the rot phenomenon; 2) context isolation using sub-agent calls is highly model-dependent and can outperform other methods when paired with a strong LLM backbone; 3) increasing the trigger frequency of passive context management methods (e.g., context compaction and context trimming) mitigates the rot phenomenon but incurs higher costs. These findings provide clear guidance for strategy selection and usage. For rejection sampling, we develop a rot-aware filtering approach and achieve an average performance gain of 2.6% to 4.9% across three aggregation methods. Finally, we demonstrate that these two approaches can be combined for further performance improvements.

Overall, our contributions are as follows:

- By investigating four flagship models across three benchmarks, we reveal a prevalent but unnoticed rot phenomenon in long-horizon agentic search tasks.

- Through pruning experiments, we demonstrate the relationship between the accumulated context and the rot phenomenon.

- We systematically evaluate seven different context management methods across three categories, based on performance, cost, and impact on context rot, providing clear guidance for strategy selection and usage.

- We develop a rot-aware filtering strategy and demonstrate its effectiveness across three aggregation methods.

## 2 Related Work

#### Context Rot

Current research on context rot can be categorized into single-turn and multi-turn settings. In the single-turn setting, previous work shows that models overlook information placed in the middle of long input contexts, collapse on benchmarks that require non-lexical retrieval or aggregate reasoning, and lose accuracy in the presence of irrelevant, distracting, or semantically empty content. In the multi-turn setting, current work mainly highlights the shortcomings of LLMs in conversations with human users or in synthetic scenarios. Our work attempts to investigate context rot within real-world, long-horizon agentic search tasks.

#### Context Management

Common methods for context management can be categorized as follows: 1) Context compaction periodically rewrites the accumulated history into a compact summary, either through the policy or an auxiliary model. A line of work also explores integrating operations on previous context into the policy action space through post-training. 2) Context trimming drops rather than rewrites tokens. Techniques include directly discarding old tool responses and applying a lightweight model to remove useless and redundant tokens. 3) Context isolation relocates information outside the active window, leaving only pointers or outcomes inline. Techniques include assigning tasks to sub-agents that return only summarized outcomes, and offloading bulky observations to the file system. While the field is growing rapidly, there is still a lack of systematic investigation into how effectively different methods alleviate context rot and improve overall performance.

## 3 Diagnosing Context Rot

### 3.1 Preliminaries

Given a user query q, an LLM agent completes the task by interleaving internal reasoning with external observations. Formally, the agent's trajectory is structured as follows, typically within a ReAct framework:

(r₁,𝒯₁,o₁),(r₂,𝒯₂,o₂),…,(rₖ,𝒯ₖ,oₖ)

where rᵢ denotes the model's natural language reasoning at step i, 𝒯ᵢ⊆𝒯 is the set of tools invoked at step i, and oᵢ is the observation received after executing the tools in 𝒯ᵢ.

In web search scenarios, we include two main tools: search and visit. The search tool accepts multiple queries simultaneously and returns the top-10 results per query from the search engine; each result contains the title, URL, and a brief description. The visit tool browses specific web pages by their URLs and extracts goal-specific evidence. In local corpus scenarios, we employ a similar toolset, where the search engine is replaced by a retrieval system operating over the local corpus. For both scenarios, we include a finish tool, which the agent uses to output the final answer in a standardized tool-call format.

### 3.2 Terminal States Taxonomy

We provide a fine-grained taxonomy of the agent's termination states that considers both the final result and the reasoning content, extending beyond simple correctness. It comprises four categories: give up, uncertain answer, confident answer, and no answer.

| Taxonomy | Definition | Example |

| Give up | The agent states it cannot solve the problem and does not give a clear answer. | Reasoning: … Based on my searches, I cannot find a definitive match for all the clues… Answer: Unable to determine … |
| Uncertain Answer | The agent gives a clear answer, but the reasoning content explicitly indicates unresolved uncertainty. | Reasoning: …While I couldn't fully verify the ""four factory modifications"" details… Answer: 61-2073 |
| Confident Answer | The agent gives a clear answer, and the reasoning content shows the agent believes it satisfies all user criteria. | Reasoning: Perfect! I have verified all the pieces of the puzzle:… Answer: 61-2059 |
| No Answer | The agent does not give an answer due to reaching the context limit or turn budget. | Reasoning: None Answer: None (Maximum interaction turn limit reached.) |

In practical evaluations, we employ GPT-OSS-120B as the judge. For trajectories that reach a final answer, the judge is provided with the problem, the gold answer, the predicted answer, and the last reasoning content before the predicted answer; it is then tasked with classifying the outcome into one of the aforementioned classes. For each classification, we repeat the process five times to obtain a majority vote to improve reliability. To validate the consistency with human judgment, we obtain 300 trajectories from four models for human expert annotations. The results indicate that our model-based evaluation method is highly accurate, with a 98.7% agreement with human annotations.

### 3.3 Experimental Setup and Results

#### Setup

We include four open-source flagship models with strong agentic capabilities: GLM-4.7, GLM-5.0, Qwen3.5-397B-A17B, and MiniMax-2.5. The context window sizes of GLM-4.7, GLM-5.0, and MiniMax-2.5 are approximately 200K, and the context window of Qwen3.5-397B-A17B is 256K. All models are evaluated using their full context. For the datasets, we include BrowseComp, BrowseComp-Plus, and xbench-DeepSearch. BrowseComp and xbench-DeepSearch are two datasets designed to evaluate web search capability, while BrowseComp-Plus is a dataset that relies on a local corpus for searching. For BrowseComp, following previous work, we take a 100-sample split from the whole set to remain representative while reducing the cost. All experiments are repeated five times to reduce noise. We set the maximum interaction turns to 100.

#### Main Results

Key findings are summarized as follows:

1) Context window size is not the main bottleneck for performance. For BrowseComp and xbench-DeepSearch, the ratio of no-answer outcomes is zero, indicating that all problems can be solved within the context window. For BrowseComp-Plus, although the average trajectory is longer, the proportion of unsolved outcomes remains low. This suggests that the performance constraint is not primarily the context window itself, but rather how the model performs within the given context window size.

2) Extensive context causes models to give up directly or prematurely provide uncertain answers. As the trajectory length increases, model accuracy drops sharply. Confident incorrect answers are more frequent early on, whereas uncertain incorrect answers or give-up outcomes increase rapidly as the trajectory length grows, becoming the primary error types in later stages. This indicates that extensive context mainly leads to the rise of these two error types, while the relative ratio between the two error types is model-dependent and dataset-dependent. In the following sections, the ""rot phenomenon"" refers to the rise of these two error types due to extensive context, unless specified otherwise.

3) The rot phenomenon persists in high-performance datasets with longer trajectories. While models achieve higher performance on BrowseComp-Plus than on xbench-DeepSearch, the relative proportion of these two error types among all error types is significantly higher. This indicates that the rot phenomenon is more closely related to context length than to dataset difficulty. Moreover, in BrowseComp-Plus, extensive context also gives rise to uncertain correct answers.

4) Trajectories exhibiting the rot phenomenon show more struggle patterns. We conduct a process-level evaluation of the agent's trajectory to investigate the relationship between trajectory semantics and the rot phenomenon. Specifically, we classify each step in the trajectory as struggle or not struggle using an LLM-as-a-judge based on the reasoning content of the step, where struggle means repeated failed attempts or no progress. We then define the struggle score as the percentage of struggle labels across all steps. Trajectories leading to give-up or uncertain incorrect answers usually have higher struggle scores than those associated with other labels, and the proportion of these two types grows as the struggle score increases. This indicates that, from a semantic perspective, trajectories terminating in these two states are more prone to becoming trapped in failed attempts and making no progress.

### 3.4 Context Pruning Analysis

In this section, we explore the relationship between the accumulated context and the rot phenomenon through the context pruning operation.

#### Setup

We explore three strategies for discarding the accumulated context: (1) discarding all tool response information while retaining the rest, (2) discarding all reasoning content while retaining the rest, and (3) discarding the entire accumulated context. After the discarding operation, we retain only the remaining historical information along with the latest 3 interaction turns for each step. For BrowseComp-Plus, to reduce inference costs, we randomly sample 200 instances from the total of 860 samples for this and all subsequent experiments. All experiments are repeated five times to reduce noise.

#### Main Results

Key findings are summarized as follows:

1) Removing the accumulated context results in a near-zero rate of give-up and uncertain incorrect termination states, but at the cost of a significant increase in unfinished trajectories. This again indicates that the phenomenon is directly caused by the accumulated context. It also shows that merely eliminating this phenomenon is not sufficient; rather, designing an optimal strategy requires a trade-off among performance, cost, and rot severity.

2) The rot phenomenon is not solely dependent on trajectory length or the number of interaction turns. Removing the reasoning content from the accumulated context increases both the trajectory length and the number of interaction turns; similarly, removing tool responses also increases the number of interaction turns. This is mainly because the loss of previous work progress leads to more interaction with the environment to compensate for the missing information. Nevertheless, both strategies alleviate the rot phenomenon, resulting in an overall lower rate of give-up and uncertain incorrect labels. This indicates that the rot phenomenon is not solely dependent on statistics of the accumulated context, such as trajectory length or the number of interaction turns.

## 4 Mitigating Context Rot

In this section, we explore methods to alleviate context rot and improve performance, including context management and post-hoc rejection sampling.

### 4.1 Mitigating Context Rot through Context Management

#### Setup

We include three categories comprising seven different context management variants. We report the total number of tool calls used for each method to estimate the cost. Additionally, we set a maximum limit of 100 interaction turns per method and repeat each experiment five times to reduce noise. The implemented strategies are as follows:

1) Context compaction summarizes the trajectory content into a compact form once a trigger condition is met. We evaluate three types of trigger conditions: trajectory length, interaction turns, and semantics. For trajectory length, we set the threshold to 96K for BrowseComp-Plus and 32K for BrowseComp and xbench-DeepSearch. For the number of interaction turns, we set the threshold to 10 for all datasets. For the semantic variant, we calculate a struggle score over a sliding window of 10 interaction turns; once this score reaches 0.5, we apply the summarization strategy. For all methods, summarization operations are performed by the main agent and included in the tool call metrics.

2) Context trimming directly discards previous content from the accumulated context. We consider three variants: the discard-all strategy, which discards all tool responses except the last one upon reaching a predefined context length; the keep-latest strategy, which fully retains the most recent interaction turns while discarding older tool responses; and the keep-latest (w/ sum.) strategy, which builds upon the keep-latest strategy by applying the summarization strategy once a predefined context length is reached. Specifically, for the discard-all and keep-latest (w/ sum.) strategies, we set the length thresholds identical to those used in context compaction. For both the keep-latest and keep-latest (w/ sum.) strategies, we retain the latest 3 interaction turns.

3) Context isolation partitions the context to help an agent perform a task. We adopt the FoldAgent implementation schema, in which sub-agents execute tasks assigned by the main agent and return only summarized outcomes. Unlike standard multi-agent implementations, the main agent invokes the sub-agent via a tool call and decides when to invoke it, distinguishing this approach from the passive context management methods described above.

#### Main Results

Key findings include:

1) Combining context compaction and context trimming achieves the optimal balance between cost and reducing the rot phenomenon.

2) Context isolation using sub-agent calls is highly model-dependent and can outperform other methods when paired with a strong LLM backbone.

3) Increasing the trigger frequency of passive context management methods (e.g., context compaction and context trimming) mitigates the rot phenomenon but incurs higher costs.

### 4.2 Mitigating Context Rot through Rejection Sampling

#### Setup

We develop a rot-aware filtering strategy based on the terminal states taxonomy developed in Section 3.2. Specifically, we filter out trajectories that terminate in the give-up state or uncertain answer state, as these represent the core rot phenomenon. We then aggregate the remaining trajectories using three different aggregation methods.

#### Main Results

We demonstrate rot-aware filtering effectiveness across three aggregation methods, achieving an average performance gain of 2.6% to 4.9%. The approach filters trajectories exhibiting the rot phenomenon and aggregates the remaining results to improve overall performance.

#### Integration and Comparison with Context Management

These two approaches—context management and rejection sampling—can be combined for further performance improvements. Context management methods reduce the likelihood of rot occurring during trajectory execution, while rejection sampling filters out instances where rot has already occurred, providing complementary mitigation strategies.

## 5 Conclusion

In this paper, we investigated context rot in long-horizon agentic search tasks through diagnosis and mitigation. We developed a detailed taxonomy of terminal states and revealed a prevalent rot phenomenon where extensive context causes models to give up or provide uncertain answers. Through context pruning analysis, we demonstrated that the phenomenon is directly caused by accumulated context rather than trajectory statistics alone. We systematically evaluated seven context management methods across three categories, providing clear guidance for their usage. Additionally, we developed a rot-aware rejection sampling strategy demonstrating effectiveness across multiple aggregation methods. These findings contribute to understanding and addressing context rot in practical LLM agent applications.
",https://arxiv.org/abs/2606.29718,explainer
"Reliability without Validity: A Systematic, Large-Scale Evaluation of LLM-as-a-Judge Models","# Reliability without Validity: A Systematic, Large-Scale Evaluation of LLM-as-a-Judge Models Across Agreement, Consistency, and Bias

Justin D. Norman, Michael U. Rivera, D. Alex Hughes
UC Berkeley School of Information

## Abstract

Large language models increasingly serve as evaluators in production systems, yet validation practices rely on exact-match agreement—a metric lacking chance correction that systematically inflates discriminative ability. This research presents the most comprehensive systematic evaluation of LLM-as-a-Judge to date, examining 21 judges from nine providers across three benchmarks (MT-Bench, JudgeBench, RewardBench) under three evaluation protocols, generating approximately 541,000 individual judgments across 118 runs.

Four principal findings emerge consistently across the full cohort through April 2026:

1. Kappa deflation is universal: Every judge exhibits a gap of 33–41 percentage points between exact match and Cohen's κ on MT-Bench, regardless of provider, scale, or generation.

2. Judge rankings are non-transferable: Models shift by up to 14 positions across benchmarks, with some judges ranking top-three on one benchmark yet falling outside the top twenty on another.

3. The consistency–bias paradox: High test–retest reliability (≥0.95) coexists with severe position bias (>0.10) in certain production-deployed judges, meaning reproducible systems can remain fundamentally invalid.

4. Verbosity bias has substantially diminished: All 21 models register correlation values below 0.011, contrasting sharply with 20–40% variance documented in 2023 literature.

JudgeBench demonstrates 4.5× sharper discrimination than MT-Bench (60.4 pp versus 13.5 pp κ spread), enabling more meaningful judge differentiation.

---

## 1 Introduction

Large language models now evaluate content at scale across hundreds of documented production deployments. These ""judgments"" depend on models mimicking human evaluators on analytical tasks. Despite well-documented reliability challenges affecting reasoning tasks, LLM-as-a-Judge has proliferated rapidly as the dominant evaluation paradigm.

Surveys consistently identify recurring failure modes: inconsistency across prompts and runs, systematic scoring biases, weak domain-specific calibration, and absence of meta-evaluation standards enabling equal-footing judge comparison.

The critical problem: judge validation continues relying heavily on exact match—a metric that fails to correct for chance agreement and overstates discriminative ability. Established benchmarks including MT-Bench, RewardBench, and JudgeBench privilege raw agreement as their headline validation metric, creating systematic overestimation of judge quality.

No prior work has conducted large-scale, cross-benchmark, multi-protocol evaluation of judge reliability spanning model families and generations. This research fills that gap through comprehensive assessment of 21 models from nine providers across three benchmarks and three evaluation protocols, producing approximately 541,000 judgments over 118 runs.

Five principal findings emerge:

1. Kappa deflation: Raw agreement overstates chance-corrected discrimination by 33–41pp universally across all 21 evaluated models.

2. Non-transferable rankings: Models shift by as many as 14 positions across benchmarks.

3. Consistency–bias paradox: High test–retest reliability often masks severe position bias.

4. Reduced verbosity bias: All 21 models register <0.011, sharply contrasting 2023 reports of 20–40% variance.

5. Discriminability variation: JudgeBench discriminates 4.5× more sharply than MT-Bench (60.4pp vs. 13.5pp κ spread).

---

## 2 Related Work

The LLM-as-a-Judge paradigm originated with MT-Bench and Chatbot Arena. Rapid adoption followed across G-Eval for natural-language-generation tasks, AlpacaEval for instruction-following, Arena-Hard for separating model performance from preference data, and WildBench for real-user prompts. LLMaJ now represents the dominant pattern for reference-free scoring across production LLM deployments.

Recent evaluation work documents distinct challenges: inconsistency under prompt and temperature variation, systematic scoring biases inherited from pretraining, difficulty adapting criteria across domains, and unresolved questions about consensus among cooperating judge models. Other research introduces reliability coefficients, evaluates rating-indeterminacy, and examines latent reliability dimensions. Closest in scale, prior work surveyed 11 LLM judges across 20 NLP tasks, recommending careful validation against task-specific annotation before deployment.

### 2.1 LLM Judge Metrics and Definitions

Exact match represents the proportion of items where the judge's verdict matches the human label. Following standard practice, this research reports the tie-excluded variant for pairwise comparisons, restricting the denominator to non-tie items. Despite widespread use, exact match lacks chance correction and remains sensitive to underlying benchmark label distributions.

Cohen's κ measures chance-corrected agreement between two raters on categorical labels:

κ = (p_o − p_e) / (1 − p_e)

where p_o is observed agreement and p_e is agreement expected by chance under marginal label distributions. This study employs κ as the primary agreement metric, comparing each judge against human label sets across all benchmarks.

Krippendorff's α accommodates multiple raters and ordinal/interval scales. The two measures coincide for the two-rater nominal case, but α extends naturally to multi-run consistency settings.

Test-retest reliability measures agreement between a judge and itself across independent re-evaluations of identical items, capturing verdict stability under identical conditions as a necessary but insufficient judge-quality characteristic.

Self-consistency represents the proportion of items where majority verdict across N runs agrees with each individual run, measuring within-judge item-level agreement complementing corpus-level test–retest coefficients.

Position flip rate quantifies the fraction of items where judge verdicts change upon response-order reversal, providing item-level position sensitivity complementing aggregate position-bias statistics.

Position bias describes the tendency to favor responses in particular positions. Across judge models, flip rates range from 25% to 50%. Position-swap debiasing raises within-judge consistency from approximately 60% to 85%.

Verbosity bias captures the tendency to prefer longer responses regardless of quality. This research operationalizes it as the Pearson correlation between response-length differential and judge verdicts.

Kappa deflation (Δ_κ) quantifies how much raw agreement overstates chance-corrected discriminative ability:

Δ_κ(j,b) = EM(j,b) − κ(j,b)

This research introduces this term to systematically measure a phenomenon—while mathematically a direct Cohen's κ consequence—not previously reported at scale across modern LLM judges. On MT-Bench, researchers observe Δ_κ ∈ [33.8, 41.2] percentage points across all 21 tested models.

Consistency–bias paradox describes the empirical observation that high test-retest reliability (α > 0.95) can coexist with severe position bias in identical judge models, producing systems that are highly reproducible but fundamentally invalid. This research formalizes a failure mode reachable through test-retest-only reporting. The paradox arises because test-retest measures output stability rather than decision-process correctness: a judge deterministically favoring position A would achieve perfect test-retest scores while simultaneously exhibiting maximum position bias.

### 2.2 Attempts to Improve Reliability

Growing literature documents LLMaJ reliability limitations while developing specialized architectures addressing them. Test-retest studies reveal substantial temperature sensitivity: same-verdict rates exceed 95% at temperature 0 but fall to 70% at temperature 1. Recent approaches separate intrinsic consistency from human-alignment using Item Response Theory models. Another research direction develops dedicated judge architectures rather than general-purpose language models, showing promise for reducing position bias and cost while approaching general-purpose model performance. This study complements these efforts through reliability evaluation at scale across 21 judges and three benchmarks under common experimental protocols.

---

## 3 Methodology

### Model Selection

This research evaluates 21 general-purpose LLM judges from nine providers, grouped into three capability tiers:

Tier 1 (Production judges, widely deployed): GPT-4o, GPT-4o-mini, GPT-4.1, Gemini 2.5 Pro, Gemini 2.5 Flash, Claude Haiku 4.5, Llama 3.3 70B, Qwen 3 8B

Tier 2 (Cost-conscious models): Mixtral 8x22B, GPT-4.1-mini, Claude Sonnet 4

Tier 3 (April 2026 frontier and open-source): GPT-5.4, GPT-5.4-mini, Claude Opus 4.6, Claude Sonnet 4.6, Gemini 3.1 Pro, GPT-oss 120B, Minimax M2.7, DeepSeek V3.2, Kimi K2.5, GLM-5

The 21 models span parameter counts from 8B to over 100B, with release dates from May 2024 through April 2026. Per-token costs range from $0.15 to $5.00 per million input tokens at evaluation time.

### Benchmarks

MT-Bench: Contributes 2,391 pairwise comparisons with expert human judgments. Represents the most widely-used judge-evaluation benchmark with balanced A/B/Tie label distribution.

JudgeBench: Contributes 350 items spanning mathematics, coding, creative writing, and analysis, labeled for objective correctness rather than aesthetic preference.

RewardBench: Contributes 2,981 chosen-versus-rejected pairs, presented to each judge under per-item position randomization ensuring chosen responses occupy either position with equal probability.

### Evaluation Protocols

Agreement protocol: Produces single judgment per item, comparing results to human labels, reporting Cohen's κ, Krippendorff's α, and tie-excluded exact match.

Consistency protocol: Runs N ∈ [3,5] independent evaluations per item with response caching disabled, presenting each pair in both AB and BA orderings. Reports test–retest reliability, self-consistency, and position flip rate.

Bias-audit protocol: Presents AB+BA orderings together with response-length analysis, reporting position bias and verbosity bias.

### Hypotheses

Seven a priori hypotheses were formulated before frontier-model evaluation:

H1: Kappa deflation will persist within frontier models.

H2: Thinking-architecture models (GPT-5.4, Gemini 3.1 Pro, DeepSeek V3.2) will exhibit position bias below 0.05.

H3: Cross-benchmark rank divergence will reach at least three positions for some model.

H4: MT-Bench will show limited κ spread, defined as the maximum minus minimum Cohen's κ, of at most 5pp.

H5: RewardBench's position-biased label placement will produce κ values no larger than 0.05 under generative evaluation.

H6: Position flip rate will degrade by at least 1.5× from MT-Bench to JudgeBench.

H7: At least one model will exhibit test-retest reliability >0.95 and position bias >0.10 simultaneously.

### Experimental Procedure

Model evaluation occurred across seven phases during March and April 2026, producing 118 evaluation runs and approximately 541,000 judgments. All evaluations used temperature 0. To ensure replicate runs sampled independent generations rather than memorized responses, consistency protocols executed with response caching disabled. Position-swap debiasing (AB+BA paired evaluations) applied across consistency and bias-audit protocols. Each run executed with a bespoke research evaluation library implementing 14 metrics per model, to be released open-source upon publication.

---

## 4 Results

### 4.1 Kappa Deflation Is Universal

Every judge exhibits substantial kappa deflation on MT-Bench: exact match overstates chance-corrected agreement by between 33.8 and 41.3 percentage points across the 21 models, with cohort mean of 38.6pp. The deflation remains universal across capability tiers: all ten frontier-generation (Tier 3) judges exhibit Δ_κ ≥ 30pp, supporting H1.

Even the best-performing judge on chance-corrected agreement, Gemini 3.1 Pro, shows a 33.8pp gap between exact match (EM=0.849) and chance-corrected performance (κ=0.511).

The magnitude of deflation varies systematically with benchmark label distribution. MT-Bench with balanced A/B/Tie distribution produces largest mean deflation (38.6pp); JudgeBench's pairwise correctness-labeled items produce mean of 23.7pp (range 8.1 to 38.5); RewardBench's binary chosen-versus-rejected pairs produce 10.4pp (range 5.9 to 21.3). Balanced label distributions raise expected-by-chance agreement, inflating the gap between raw and chance-corrected metrics.

The practical consequence: a judge reporting ""85% agreement"" on MT-Bench has κ ≈ 0.48.

| Model | MT-Bench EM | MT-Bench κ | MT-Bench Δ_κ | JudgeBench EM | JudgeBench κ | JudgeBench Δ_κ | RewardBench EM | RewardBench κ | RewardBench Δ_κ |

| Gemini 3.1 Pro | 0.849 | 0.511 | 33.8 | 0.964 | 0.841 | 12.3 | 0.956 | 0.898 | 5.9 |
| Claude Opus 4.6 | 0.848 | 0.489 | 35.9 | 0.956 | 0.875 | 8.1 | 0.943 | 0.879 | 6.4 |
| DeepSeek V3.2 | 0.845 | 0.486 | 35.9 | 0.791 | 0.545 | 24.5 | 0.921 | 0.826 | 9.5 |
| Claude Sonnet 4.6 | 0.851 | 0.484 | 36.7 | 0.920 | 0.782 | 13.8 | 0.942 | 0.871 | 7.1 |
| Llama 3.3 70B | 0.841 | 0.465 | 37.6 | 0.664 | 0.283 | 38.1 | 0.892 | 0.769 | 12.3 |
| Kimi K2.5 | 0.846 | 0.461 | 38.5 | 0.864 | 0.720 | 14.5 | 0.937 | 0.873 | 6.4 |
| GPT-5.4 | 0.836 | 0.457 | 38.0 | 0.812 | 0.606 | 20.7 | 0.940 | 0.879 | 6.2 |
| GPT-4o | 0.832 | 0.451 | 38.1 | 0.667 | 0.309 | 35.8 | 0.883 | 0.745 | 13.8 |
| GPT-4.1 | 0.830 | 0.451 | 37.9 | 0.751 | 0.487 | 26.4 | 0.906 | 0.809 | 9.7 |
| Gemini 2.5 Pro | 0.829 | 0.447 | 38.3 | 0.838 | 0.603 | 23.6 | 0.932 | 0.830 | 10.2 |
| GLM-5 | 0.832 | 0.442 | 39.0 | 0.804 | 0.596 | 20.8 | 0.923 | 0.838 | 8.5 |
| GPT-oss 120B | 0.833 | 0.441 | 39.2 | 0.854 | 0.687 | 16.7 | 0.944 | 0.880 | 6.4 |
| Claude Sonnet 4 | 0.843 | 0.440 | 40.2 | 0.817 | 0.633 | 18.4 | 0.944 | 0.886 | 5.8 |
| Gemini 2.5 Flash | 0.825 | 0.437 | 38.9 | 0.804 | 0.578 | 22.6 | 0.919 | 0.817 | 10.2 |
| Claude Haiku 4.5 | 0.832 | 0.435 | 39.7 | 0.831 | 0.653 | 17.7 | 0.937 | 0.873 | 6.4 |
| GPT-4.1-mini | 0.831 | 0.432 | 39.9 | 0.738 | 0.466 | 27.1 | 0.899 | 0.795 | 10.4 |
| Minimax M2.7 | 0.828 | 0.430 | 39.8 | 0.868 | 0.715 | 15.3 | 0.920 | 0.834 | 8.6 |
| Qwen 3 8B | 0.810 | 0.406 | 40.4 | 0.645 | 0.289 | 35.6 | 0.829 | 0.616 | 21.3 |
| GPT-4o-mini | 0.809 | 0.396 | 41.3 | 0.676 | 0.325 | 35.2 | 0.831 | 0.622 | 20.8 |
| Mixtral 8x22B | 0.803 | 0.392 | 41.0 | 0.656 | 0.271 | 38.5 | 0.852 | 0.679 | 17.3 |
| GPT-5.4-mini | 0.788 | 0.376 | 41.2 | 0.696 | 0.372 | 32.4 | 0.901 | 0.798 | 10.3 |
| Cohort mean | | | 38.6 | | | 23.7 | | | 10.2 |

### 4.2 Position Bias Heterogeneity

Position biases for each model demonstrate extraordinary heterogeneity. The least position-biased model, Gemini 2.5 Pro (pb=0.002) and most position-biased model, Qwen 3 8B (pb=0.192) span nearly two orders of magnitude difference. Reasoning and frontier models systematically exhibit lower position-bias rates; small and cost-optimized models register highest rates.

Within-family heterogeneity proves substantial: Gemini 2.5 Pro (0.002) and Gemini 2.5 Flash (0.125) differ by factor of 70. Hypothesis 2 predicted thinking-architecture judges (GPT-5.4, Gemini 3.1 Pro, DeepSeek V3.2) would all fall below 0.05; only Gemini 3.1 Pro (0.038) does so. While reducing position bias relative to cost-efficient models, thinking architectures do not eliminate it.

| Model | Position bias | Verbosity bias |

| Gemini 2.5 Pro | 0.002 | 0.0025 |
| Claude Opus 4.6 | 0.004 | 0.0032 |
| Kimi K2.5 | 0.004 | 0.0044 |
| Claude Sonnet 4 | 0.008 | 0.0035 |
| GPT-5.4-mini | 0.013 | 0.0046 |
| Claude Sonnet 4.6 | 0.015 | 0.0034 |
| Minimax M2.7 | 0.020 | 0.0004 |
| GPT-oss 120B | 0.037 | 0.0024 |
| Gemini 3.1 Pro | 0.038 | 0.0007 |
| Claude Haiku 4.5 | 0.041 | 0.0067 |
| GPT-4o | 0.045 | 0.0031 |
| GPT-4o-mini | 0.047 | 0.0103 |
| GPT-4.1-mini | 0.050 | 0.0045 |
| GLM-5 | 0.052 | 0.0024 |
| GPT-4.1 | 0.053 | 0.0026 |
| Llama 3.3 70B | 0.057 | 0.0011 |
| Mixtral 8x22B | 0.058 | 0.0084 |
| GPT-5.4 | 0.083 | 0.0018 |
| DeepSeek V3.2 | 0.094 | 0.0030 |
| Gemini 2.5 Flash | 0.125 | 0.0009 |
| Qwen 3 8B | 0.192 | 0.0011 |

### 4.3 Cross-Benchmark Rank Instability

Consistent with Hypothesis 3, benchmark choice substantially affects relative judge rankings. More than half (11 of 21) shift by four or more positions, with only Gemini 3.1 Pro and Claude Opus 4.6 maintaining top-three positions across all benchmarks. The largest single shift is Llama 3.3 70B, which moves 15 positions from rank 5 on MT-Bench to rank 20 on JudgeBench.

Other notable rank shifts include:
- Minimax M2.7: rank 17 on MT-Bench, rank 5 on JudgeBench
- DeepSeek V3.2: rank 3 on MT-Bench, rank 13 on JudgeBench
- GPT-4o: rank 8 on MT-Bench, rank 18 on JudgeBench
- GPT-oss 120B: rank 12 on MT-Bench, rank 3 on RewardBench
- Claude Haiku 4.5: rank 15 on MT-Bench, rank 6 on RewardBench

The instability intensifies due to sharp differences in benchmark discriminability: MT-Bench compresses all 21 judges into 13.5pp κ band (0.376 to 0.511) with average 0.6pp gaps between adjacent ranks; JudgeBench spreads identical models across 60.4pp (0.271 to 0.875) with 3–9pp tier separations; RewardBench falls between at 28.1pp (0.616 to 0.898) with tight 2.7pp banding among top seven judges.

Where underlying distributions compress, small κ differences produce large rank changes, making single-benchmark rankings poor estimators of cross-benchmark performance.

### 4.4 MT-Bench Ceiling Effect

Hypothesis 4 predicted MT-Bench κ spread would not exceed 5pp. Observed results show 13.5pp spread (0.376 to 0.511) across all 21 judges, narrowing to 6.5pp within the top ten and approaching the predicted ceiling. The wider full-cohort spread results from a distinct lower tier (GPT-5.4-mini, Mixtral 8x22B, GPT-4o-mini).

JudgeBench's κ spread on the same population is 60.4pp—a factor of 4.5× wider—confirming that MT-Bench's preference-style label set compresses meaningful quality differences among strong judges.

### 4.5 Position-Randomized Evaluation of RewardBench

Hypothesis 5 predicted RewardBench would generate κ values no larger than 0.05 because it placed all correct human labels in position A. Observed results contradict this prediction. Under per-item position-randomized evaluation, all 20 evaluated judges produce κ values in range [0.616, 0.898]. The top five judges achieve highly reasonable κ values:
- Gemini 3.1 Pro: 0.898
- GPT-oss 120B: 0.880
- Claude Opus 4.6: 0.879
- GPT-5.4: 0.879
- Claude Sonnet 4.6: 0.871

Position randomization substantially improves benchmark utility for judge comparison.

### 4.6 Consistency Falls on Hard Benchmarks

Judges demonstrate systematically degraded consistency on harder benchmarks. Hypothesis 6 predicted position flip rate would degrade by at least 1.5× from MT-Bench to JudgeBench. Observed median degradation reaches 2.1× across the cohort, with several models showing greater than 3× degradation.

Self-consistency measures (proportion of items where majority verdict aligns with each individual run) show similar patterns: models maintain 85–95% self-consistency on MT-Bench but drop to 50–75% on JudgeBench, indicating that harder, more objective content significantly challenges judge stability.

### 4.7 The Consistency–Bias Paradox

Hypothesis 7 predicted at least one model would simultaneously exhibit test-retest reliability >0.95 and position bias >0.10. Observed results identify two production-deployed judges exhibiting this paradox:

Qwen 3 8B: Test-retest α = 0.958, position bias = 0.192
Gemini 2.5 Flash: Test-retest α = 0.951, position bias = 0.125

These judges occupy the upper-right ""consistent but biased"" quadrant of reliability space: highly reproducible yet systematically invalid. This paradox exemplifies why test-retest reliability alone provides insufficient judge validation. A deterministically biased judge achieves perfect test-retest scores while remaining fundamentally unreliable. The paradox underscores the necessity of multi-protocol validation including both consistency and bias auditing.

### 4.8 Pairwise Verbosity Bias

All 21 models register verbosity bias below 0.011, with 18 of 21 below 0.0067. This represents dramatic improvement from 2023 literature reporting 20–40% variance attributable to response length. Several models (Minimax M2.7, Gemini 3.1 Pro, Llama 3.3 70B) show essentially zero verbosity bias (<0.002).

The improvement reflects both model advancement and evaluation methodology: single-pairwise rubric evaluation under position randomization provides more controlled assessment than earlier experimental designs mixing multiple rubrics and position biases.

### 4.9 Model Family Analysis

Clear patterns emerge across model families:

OpenAI models: Position bias ranges from 0.045 (GPT-4o) to 0.053 (GPT-4.1), with frontier variants (GPT-5.4) showing higher bias (0.083). κ scores range 0.376–0.457 on MT-Bench.

Google models: Extraordinary within-family heterogeneity—Gemini 2.5 Pro shows 0.002 position bias while Gemini 2.5 Flash shows 0.125. Gemini 3.1 Pro achieves highest MT-Bench κ (0.511) and strong RewardBench performance (0.898 κ).

Anthropic models: Consistently low position bias (0.004–0.041) across all variants. Claude Opus 4.6 and Claude Sonnet 4.6 rank among top performers across benchmarks, showing stable, high-quality judgment.

Cost-optimized models: Qwen 3 8B and GPT-4o-mini show highest position bias and lower chance-corrected agreement, though still maintaining reasonable κ values (0.406 and 0.396 respectively on MT-Bench).

Open-source models: Llama 3.3 70B shows dramatic cross-benchmark variance (MT-Bench: rank 5, JudgeBench: rank 20), suggesting benchmark-specific weaknesses despite reasonable aggregate performance.

---

## 5 Discussion

### 5.1 Why Exact Match Misleads

The universal kappa deflation documented across all 21 judges represents a systematic failure of current reporting practices. When exact match exceeds κ by 33–41pp, organizations deploying judges based on exact-match metrics are overestimating discriminative ability by approximately 40 percentage points.

This gap arises mathematically from Cohen's κ correction for chance agreement. On MT-Bench's balanced A/B/Tie distribution, chance agreement averages roughly 0.38; on JudgeBench's more skewed distribution, approximately 0.26; on RewardBench's binary pairs, approximately 0.50. The larger the chance baseline, the larger the deflation gap.

Practically, this means: ""85% exact match"" on MT-Bench corresponds to κ ≈ 0.48, which under Landis and Koch's interpretation guidelines falls into ""moderate"" rather than ""substantial"" agreement. Alternatively, a judge reporting ""90% agreement"" has legitimately only achieved 50–55% chance-corrected agreement depending on benchmark. The field has dramatically overstated judge quality by privileging metrics lacking chance correction.

### 5.2 Limits of Single-Benchmark Validation

MT-Bench's compressed κ distribution (13.5pp span) creates false confidence in judge differentiation. Judge rankings on MT-Bench prove non-predictive of RewardBench or JudgeBench performance. The top judge on MT-Bench (Gemini 3.1 Pro, κ=0.511) ranks first on JudgeBench and RewardBench, yet numerous judges showing moderate MT-Bench performance rank dramatically differently on objective-correctness benchmarks.

This reflects fundamental benchmark design differences:

- MT-Bench: Pairwise aesthetic preference with expert judgments, relatively easy distinctions between good and mediocre responses
- JudgeBench: Objective correctness in mathematics, coding, analysis—demands precise factual knowledge
- RewardBench: Binary chosen vs. rejected with human preference labels, emphasizing safety and alignment concerns

Models optimized for aesthetic judgment differ from those optimized for factual correctness. Single-benchmark validation masks these differences and produces misleading quality signals. Deployment decisions should reference multiple benchmarks encompassing diverse judgment types.

### 5.3 The Consistency–Bias Paradox and a Minimum Viable Validation Protocol

The consistency–bias paradox—high test-retest reliability coexisting with severe position bias—reveals that reporting reproducibility alone enables spurious quality claims. The two production-deployed judges exhibiting this paradox (Qwen 3 8B, Gemini 2.5 Flash) represent cases where current practice would certify unreliable systems as valid.

This research proposes a Minimum Viable Validation Protocol for LLM-as-a-Judge systems:

Required measurements:
1. Cohen's κ or Krippendorff's α against human labels (chance-corrected agreement)
2. Position bias audit via AB+BA paired evaluation
3. Cross-benchmark consistency via evaluation on at least two diverse benchmarks
4. Verbosity bias via response-length correlation analysis

Reporting standards:
- Report both exact match and κ; deflation gap should be expected and explained
- Report position bias as percentage or absolute difference from 0.50
- Report κ spread across evaluated benchmarks
- Report test-retest reliability alongside position-bias metrics—never alone

Minimum thresholds for deployment:
- κ ≥ 0.40 on primary benchmark (substantial agreement threshold)
- Position bias < 0.05 absolute
- Cross-benchmark κ variance < 0.15 (15pp)
- High test-retest (α > 0.90) only with concurrent position-bias audit

These thresholds reflect observed frontier-model performance while excluding systems showing severe reliability issues.

### 5.4 Dataset as Community Resource

This research will release evaluation datasets, benchmark implementations, and reliability-measurement library as open-source resources. The approximately 541,000 judgments produced during evaluation represent valuable calibration data for future LLM-as-a-Judge research. Complete result tables across all 21 models and three benchmarks will be made available.

---

## 6 Conclusion

LLM-as-a-Judge has become the dominant evaluation paradigm for language models, yet validation practice remains surprisingly permissive. This large-scale systematic evaluation demonstrates four robust findings across all contemporary judge models:

1. Exact match systematically overstates judge quality by 33–41pp through failure to correct for chance agreement. Organizations deploying judges based on published exact-match metrics are overestimating discriminative ability.

2. Judge rankings are non-transferable across benchmarks due to both legitimate preference-correctness differences and MT-Bench's compressed discriminability. Single-benchmark validation produces unreliable quality signals.

3. High test-retest reliability masks severe position bias in production systems, exemplifying the consistency–bias paradox. Reproducibility and validity represent independent dimensions requiring separate measurement.

4. Verbosity bias has substantially diminished across the model cohort, contradicting earlier literature and suggesting methodology and model improvements have meaningfully addressed this specific failure mode.

The research proposes a Minimum Viable Validation Protocol addressing these findings, requiring chance-corrected agreement, position-bias auditing, cross-benchmark evaluation, and integrated reporting of reliability and validity metrics. Adoption of these standards would substantially improve deployed-judge quality and prevent deployment of systematically biased systems.

LLM-as-a-Judge remains a valuable paradigm for production evaluation at scale, but the field must transition from permissive exact-match validation to rigorous multi-protocol assessment emphasizing both reliability and validity.
",https://arxiv.org/abs/2606.19544,explainer
Choosing a Text Embedding Model: A Practical Benchmarking and Decision Framework,"# Choosing a Text Embedding Model: A Practical Benchmarking and Decision Framework

## Abstract

This report presents a benchmarking study evaluating T3EM (Text 3 Embedding Model) against open-source alternatives on English-language retrieval tasks, situated within the Massive Text Embedding Benchmark (MTEB) landscape. The analysis traces the complete path from embedding generation through indexing and search to retrieved results, examining how document chunking strategy affects quality. The work delivers practical recommendations for embedding model selection based on task requirements, latency constraints, and deployment considerations.

## Executive Summary

Key findings include:

- T3EM achieves the highest retrieval quality (average nDCG@10 = 0.638) but incurs 7–14× higher latency than open-source models and per-query API costs.

- ""mE5-L is the strongest open-source alternative for general-purpose English retrieval, scoring within 0.09 nDCG points of T3EM at a fraction of the latency.""

- Models trained for sentence similarity substantially underperform on retrieval despite competitive similarity scores, indicating that training objective rather than model size drives retrieval quality.

- No single model excels across all task types; specialization varies by objective (ST5 for similarity, MPNet for clustering, GTR/SGPT for broader MTEB retrieval).

- Chunking strategy significantly impacts quality: performance plateaus at 32 tokens, semantic chunking outperforms fixed-size approaches at small chunk sizes, and quality degrades below approximately 16 tokens.

## 1 Introduction

### 1.1 Motivation and Objective

This study evaluates T3EM performance against widely used open-source embedding models on English retrieval tasks and examines document chunking effects. The research determines when commercial API costs and latency are justified versus when open-source alternatives suffice. Integrating MTEB framework data enables broader performance comparison across eight downstream task categories using consistent datasets and metrics.

### 1.2 What Is a Text Embedding?

A text embedding converts text into fixed-length numerical vectors such that semantically similar texts cluster nearby in high-dimensional space. Cosine similarity between vectors serves as a semantic similarity proxy. Embeddings enable diverse applications: passage retrieval for queries, document grouping, duplicate detection, and reference text comparison. However, ""no single embedding model is optimal for all applications,"" because learned similarity depends entirely on training objectives. Models differ in parameter count, embedding dimension, language support, maximum input length, and optimization scope (single versus multiple tasks).

### 1.3 Background: The Massive Text Embedding Benchmark (MTEB)

The Massive Text Embedding Benchmark (MTEB) is a community-maintained standardized benchmark enabling direct model comparison across task types rather than hand-picked datasets. It fixes datasets, categories, and evaluation metrics, making scores directly comparable. MTEB has become the reference leaderboard for embedding models and is widely cited in model releases. This study adopts MTEB's datasets, model pool, and metrics for evaluations extending beyond primary retrieval comparison.

### 1.4 Research Questions

The study addresses four questions:

1. Whether longer context windows and asymmetric query/document encoding provide measurable retrieval quality advantages.

2. How models trained for sentence similarity (rather than retrieval) perform when repurposed for retrieval.

3. How sensitive retrieval quality is to document chunk size and chunking method.

4. Whether strong retrieval performers generalize to other downstream tasks (classification, clustering, semantic similarity, reranking, pair classification, bitext mining, summarization) or whether task specialization limits performance.

## 2 Background: From Text to Retrieved Results

### 2.1 How Text Embeddings Work

At inference, text passes through sequential stages before comparison:

Transformer encoding tokenizes input and passes it through transformer layers, producing contextualized vectors for each token using self-attention.

Pooling combines per-token vectors into a single fixed-length representation via mean pooling, CLS-token pooling, or max pooling. The pooling method, typically fixed during training, materially affects embedding quality.

Embedding vector becomes the model's fixed-length numerical representation, with length equal to the model's embedding dimension.

Cosine similarity compares the query embedding against candidate document embeddings at query time, using the cosine of the angle between vectors to isolate directional alignment while ignoring magnitude.

Vector search ideally compares the query against every stored document vector (exact brute-force search), but this becomes computationally infeasible with millions of documents.

ANN search substitutes approximate nearest neighbor indexing for brute-force comparison, trading small controlled accuracy loss for substantial speed gains.

Retrieved document results from the index returning the top-k most similar documents to the query, which in RAG pipelines get passed to language models as context.

### 2.2 Dense, Sparse, and Multi-Vector Retrieval

Retrieval-oriented embedding models employ three broad architectural approaches:

Dense retrieval represents text as single fixed-length densely-packed vectors (typically hundreds to thousands of dimensions with minimal zeros). Similarity uses single cosine or dot-product scores. The vast majority of models evaluated (T3EM, E5, GTR) use this approach.

Sparse retrieval represents text as very high-dimensional vectors (one dimension per vocabulary term) with mostly zero values, using term importance weighting. Classical approaches like BM25 or learned variants like SPLADE preserve exact keyword matches that dense embeddings sometimes miss.

Multi-vector retrieval represents text as vector sets (e.g., per-token) rather than single vectors, computing similarity via ""late interaction"" comparing individual token vectors before aggregating scores. ColBERT popularized this approach.

Models like BGE-M3 support all three modes simultaneously within a single model, though this versatility comes at measurable cost to peak dense retrieval performance compared to single-objective trained models.

### 2.3 Vector Databases and Approximate Nearest Neighbor Search

Embeddings alone do not retrieve results; vector databases provide infrastructure storing embeddings alongside source documents and enabling similarity search at scale.

How a vector database works: Ingesting document embeddings and metadata, a vector database builds an index—a data structure organized for similarity search speed, trading some accuracy. At query time, only a strategically chosen subset of stored vectors gets compared rather than the entire corpus, enabling sub-second search over millions or billions of vectors.

Approximate Nearest Neighbor (ANN) search: ""Approximate"" means returned top-k results are very likely but not guaranteed true top-k nearest vectors. This deliberate trade-off exchanges small tunable recall loss for orders-of-magnitude speed improvements. Three common underlying ANN techniques are:

- HNSW (Hierarchical Navigable Small World graphs): Organizes vectors into multi-layered graphs with each vector linked to neighbors; search proceeds by graph traversal from coarse top layers to finer layers. HNSW offers very high recall and speed but requires considerable memory for storing the full graph structure.

- IVF (Inverted File Index): Clusters vectors into fixed buckets via k-means, searching only nearest buckets at query time rather than entire datasets. IVF proves more memory-efficient than HNSW but requires careful nprobe tuning to balance speed against recall.

- PQ (Product Quantization): Compresses vectors into compact codes by splitting into sub-vectors and replacing each with nearest representative values. PQ dramatically reduces memory footprint (often tenfold or more) at some precision cost, frequently combined with IVF as ""IVF-PQ"" for speed and memory efficiency.

Common vector database systems:

| System | Deployment | Notes | Main Drawbacks |

| FAISS | Embedded library (no server) | Meta-developed reference ANN implementation; extremely fast and widely used | Not a full database—lacks built-in persistence, metadata filtering, multi-user access; requires custom engineering |
| Qdrant | Self-hosted server or managed cloud | Open-source Rust implementation; strong metadata filtering and straightforward API | Smaller ecosystem than established options; horizontal scaling less battle-tested at massive scale |
| Milvus | Self-hosted server or managed cloud | Open-source; built for large-scale distributed deployments with multiple index types | Operationally heavier than Qdrant; distributed system infrastructure adds overhead for smaller deployments |
| Pinecone | Fully managed cloud only | Proprietary fully managed service; minimal operational overhead, transparent scaling | Not open-source; ongoing usage costs; no self-hosting; data resides in third-party environment |

Among open-source options, Qdrant suits small-to-mid-scale deployments through balanced performance and self-hosting ease, while Milvus typically suits scale demands (hundreds of millions of vectors) or distributed deployment requirements. FAISS remains standard for lightweight embedded solutions when a full database server is unnecessary.

The full retrieval pipeline: Typical retrieval-augmented systems follow: Query → Embedding → Vector DB → ANN Search → Top-k → Reranker → LLM. Reranking stages typically apply after initial ANN search, since smaller, more expensive models can carefully re-score already-retrieved short candidate lists too slowly applied against full corpora.

### 2.4 Document Chunking Strategies

Since embedding models truncate input beyond maximum context length, long documents split into smaller *chunks* before embedding and indexing. Chunking strategy directly affects retrieval quality and represents one of most consequential retrieval pipeline design decisions.

- Fixed-size chunking: Splits text into constant token or character-length chunks regardless of sentence or paragraph boundaries. Simple and fast to implement, but cuts sentences or ideas in half, splitting relevant information across chunks.

- Sliding window chunking: Similar to fixed-size but consecutive chunks overlap by fixed amounts rather than starting exactly where previous ones ended. Reduces awkward passage splitting across chunk boundaries, though at some redundant storage cost.

- Semantic chunking: Splits at natural topic or meaning boundaries (e.g., where embedding similarity between consecutive sentences drops sharply) rather than fixed lengths. Tends producing more coherent self-contained chunks, though computationally more expensive than fixed-size splitting.

- Parent-child chunking: Indexes small precise chunks for matching (""children""), but retrieves and passes larger surrounding sections (""parents"") to generation stages once child chunks match. Combines precise retrieval matching with sufficient context for language model use.

- Hierarchical chunking: Builds multiple chunk levels (document, section, paragraph) allowing retrieval at whichever level suits queries best, or combining evidence across levels.

- Recursive chunking: Splits using prioritized separator lists (paragraph breaks first, then sentences, then words if pieces remain too long), aiming to keep chunks semantically intact while respecting maximum length.

- Chunk overlap: A parameter (rather than strategy) applicable to most above approaches—fixed token repetition between consecutive chunks so context near boundaries is not entirely lost.

When to use each: Fixed-size and sliding-window chunking suit homogeneous well-structured text where sentence-level precision matters less. Semantic chunking suits multi-topic documents (articles, manuals) where retrieval precision matters. Parent-child and hierarchical chunking suit long structured documents (contracts, technical documentation) needing precise passage matching with wider surrounding context. Recursive chunking serves as practical general-purpose default in modern RAG frameworks, approximating semantic boundaries without true semantic chunking's computational cost. Research findings (Section 6.3) show quality plateaus at 32 tokens per chunk, all strategies degrade below roughly 16 tokens regardless of method.

## 3 Datasets

All study datasets are consolidated below, organized by task category. Four retrieval datasets (FiQA-2018, NFCorpus, SciFact, TREC-COVID) underwent primary direct measurement; remaining datasets draw from published MTEB framework and serve broader context rather than re-measurement. A ""Primary Evaluation"" table column indicates this distinction.

### 3.1 Retrieval Datasets

These test models' ability finding right passages or documents from large collections given queries. This core task underlies search engines and RAG systems. Since queries and correct answers often use vastly different wording (questions versus passages answering them), retrieval datasets specifically test meaning matching rather than word overlap. FiQA-style queries like ""Should I switch to a Roth IRA?"" paired with financial forum passages discussing tax treatment using different vocabulary provide useful asymmetric query/document encoding stress tests.

Retrieval Datasets Table:

| Dataset | Description | Primary Eval. | Link |

| FiQA-2018 | Financial question answering retrieval (648 queries) | Yes | https://huggingface.co/datasets/mteb/fiqa |
| NFCorpus | Biomedical retrieval (323 queries) | Yes | https://huggingface.co/datasets/mteb/nfcorpus |
| SciFact | Scientific claim/evidence verification retrieval (300 queries) | Yes | https://huggingface.co/datasets/mteb/scifact |
| TREC-COVID | Biomedical/COVID literature retrieval (50 queries) | Yes | https://huggingface.co/datasets/mteb/trec-covid |
| ArguAna | Counter-argument retrieval | No (MTEB) | https://huggingface.co/datasets/mteb/arguana |
| ClimateFEVER | Climate fact verification retrieval | No (MTEB) | https://huggingface.co/datasets/mteb/climate-fever |
| CQADupStack | Technical question retrieval | No (MTEB) | https://huggingface.co/datasets/mteb/cqadupstack-android |
| DBPedia | Entity retrieval | No (MTEB) | https://huggingface.co/datasets/mteb/dbpedia |
| FEVER | Evidence retrieval | No (MTEB) | https://huggingface.co/datasets/mteb/fever |
| HotpotQA | Multi-hop retrieval | No (MTEB) | https://huggingface.co/datasets/mteb/hotpotqa |
| MSMARCO | Web search passage retrieval | No (MTEB) | https://huggingface.co/datasets/mteb/msmarco |
| Natural Questions | Google search retrieval | No (MTEB) | https://huggingface.co/datasets/mteb/nq |
| Quora Retrieval | Duplicate question retrieval | No (MTEB) | https://huggingface.co/datasets/mteb/quora |
| SciDocs | Scientific paper retrieval | No (MTEB) | https://huggingface.co/datasets/mteb/scidocs |
| Touche2020 | Argument retrieval | No (MTEB) | https://huggingface.co/datasets/mteb/touche2020 |

### 3.2 Semantic Textual Similarity (STS) Datasets

These measure whether models judge meaning similarity between sentences on continuous scales (rather than binary). Human annotators score sentence pairs for similarity, and models must produce embeddings whose distances correlate with judgments. This symmetric task involves texts of same ""type"" (two statements), unlike asymmetric retrieval (short query against long document).

| Dataset | Description | Link |

| BIOSSES | Biomedical sentence similarity | https://huggingface.co/datasets/mteb/biosses-sts |
| SICK-R | Sentence similarity | https://huggingface.co/datasets/mteb/sickr-sts |
| STS12-STS16 | SemEval STS | https://huggingface.co/datasets/mteb/sts12-sts |
| STS17 | Cross-lingual STS | https://huggingface.co/datasets/mteb/sts17-crosslingual-sts |
| STS22 | Multilingual STS | https://huggingface.co/datasets/mteb/sts22-crosslingual-sts |
| STSBenchmark | Standard English STS | https://huggingface.co/datasets/mteb/stsbenchmark-sts |

### 3.3 Classification Datasets

These assign single category labels to text (sentiment, intent, topic, similar). Embedding models aren't directly trained to classify; instead embeddings feed into simple classifiers (logistic regression), benchmarking whether embeddings carry sufficient separating signal.

| Dataset | Description | Link |

| Amazon Counterfactual | Counterfactual review detection | https://huggingface.co/datasets/mteb/amazon_counterfactual |
| Amazon Polarity | Sentiment classification | https://huggingface.co/datasets/mteb/amazon_polarity |
| Amazon Reviews | Review rating prediction | https://huggingface.co/datasets/mteb/amazon_reviews_multi |
| Banking77 | Banking intent classification | https://huggingface.co/datasets/mteb/banking77 |
| Emotion | Emotion recognition | https://huggingface.co/datasets/mteb/emotion |
| IMDb | Movie review sentiment | https://huggingface.co/datasets/mteb/imdb |
| Massive Intent | Intent classification | https://huggingface.co/datasets/mteb/amazon_massive_intent |
| Massive Scenario | Scenario classification | https://huggingface.co/datasets/mteb/amazon_massive_scenario |
| MTOP Domain | Dialogue domain classification | https://huggingface.co/datasets/mteb/mtop_domain |
| Toxic Conversations | Toxicity detection | https://huggingface.co/datasets/mteb/toxic_conversations_50k |
| Tweet Sentiment | Tweet sentiment classification | https://huggingface.co/datasets/mteb/tweet_sentiment_extraction |

### 3.4 Clustering Datasets

These test whether embeddings naturally group similar documents together without advance category instruction (unsupervised). For example, scientific papers should cluster by subfield if embeddings capture topical meaning well. This proxy indicates how well models organize unlabeled large corpora.

| Dataset | Description | Link |

| Arxiv | Scientific paper clustering | https://huggingface.co/datasets/mteb/arxiv-clustering-p2p |
| BioRxiv | Biological paper clustering | https://huggingface.co/datasets/mteb/biorxiv-clustering-p2p |
| MedRxiv | Medical paper clustering | https://huggingface.co/datasets/mteb/medrxiv-clustering-p2p |
| Reddit | Reddit post clustering | https://huggingface.co/datasets/mteb/reddit-clustering |
| StackExchange | Technical forum clustering | https://huggingface.co/datasets/mteb/stackexchange-clustering |
| TwentyNewsgroups | News article clustering | https://huggingface.co/datasets/mteb/twentynewsgroups-clustering |

### 3.5 Pair Classification Datasets

These frame similarity as binary decisions: given two texts, are they duplicates/paraphrases or not? Similar in spirit to STS but binary (duplicate versus not) rather than graded scores—common in deduplication and spam/near-duplicate detection.

| Dataset | Description | Link |

| Sprint Duplicate Questions | Duplicate detection | https://huggingface.co/datasets/mteb/sprintduplicatequestions-pairclassification |
| Twitter SemEval | Tweet paraphrase detection | https://huggingface.co/datasets/mteb/twittersemeval2015-pairclassification |
| Twitter URL Corpus | URL paraphrase detection | https://huggingface.co/datasets/mteb/twitterurlcorpus-pairclassification |

### 3.6 Reranking Datasets

These test second-stage pipeline tasks: given queries and candidate documents (already loosely retrieved), can models correctly reorder them placing most relevant documents first? Sharper, precision-focused retrieval version usually applied after cheaper initial retrieval passes.

| Dataset | Description | Link |

| AskUbuntu | Ubuntu question reranking | https://huggingface.co/datasets/mteb/askubuntudupquestions-reranking |
| MindSmall | News reranking | https://huggingface.co/datasets/mteb/mind_small |
| SciDocsRR | Scientific reranking | https://huggingface.co/datasets/mteb/scidocs-reranking |
| StackOverflow | Duplicate question reranking | https://huggingface.co/datasets/mteb/stackoverflowdupquestions-reranking |

### 3.7 Bitext Mining Datasets

These test cross-lingual alignment: given sentences in one language, can models find true translations in other language pools? Main cross-lingual sentence-alignment quality evaluation method, central to parallel corpus building for machine translation.

| Dataset | Description | Link |

| BUCC | Parallel sentence mining | https://huggingface.co/datasets/mteb/bucc-bitext-mining |
| Tatoeba | Translation mining | https://huggingface.co/datasets/mteb/tatoeba-bitext-mining |

### 3.8 Summarization Datasets

These evaluate whether model embeddings judge automatic summary quality by comparing generated summaries (via embedding similarity) against reference human summaries. Proxy for whether embedding-based similarity correlates with human summary quality judgments—rather than models generating summaries themselves.

| Dataset | Description | Link |

| SummEval | Automatic summary evaluation | https://huggingface.co/datasets/mteb/summeval |

## 4 Models Evaluated

All study models consolidate below, grouped first by whether retrieval performance underwent direct measurement, then by architectural family for wider MTEB framework models and published leaderboard estimates. Grouping reflects model type rather than study distinctions.

Note on context length: Every embedding model has maximum input length (measured in tokens) processable in single passes. Excess input text gets silently truncated before embedding, meaning only roughly first several hundred words of long documents reflect in embeddings regardless additional relevant content. This explains why document length and chunking strategy (Sections 2.4 and 6.3) become important practical considerations when selecting models for long-document retrieval.

### 4.1 Models with Directly Measured Retrieval Results

Six models underwent direct evaluation on primary English retrieval benchmark subsets described in Section 3 (results in Section 6):

| Model | Type | Open Source | Link |

| T3EM (Text 3 Embedding Model) | API | No (commercial API) | — |
| BGE-M3 | Open-source | Yes | https://huggingface.co/BAAI/bge-m3 |
| E5-large | Open-source | Yes | https://huggingface.co/intfloat/e5-large-v2 |
| Multilingual-E5-large (mE5-L) | Open-source | Yes | https://huggingface.co/intfloat/multilingual-e5-large |
| LaBSE | Open-source | Yes | https://huggingface.co/sentence-transformers/LaBSE |
| Paraphrase-Multilingual-MPNet (mMPNet) | Open-source | Yes | https://huggingface.co/sentence-transformers/paraphrase-multilingual-mpnet-base-v2 |

### 4.2 Additional Models Evaluated Under the MTEB Framework

Below models extend comparison to larger pool evaluated under published MTEB framework, grouped by architectural family. Scores draw from MTEB rather than re-measurement under this study's retrieval pipeline. Note LaBSE and Paraphrase-Multilingual-MPNet already appear in Section 4.1 and don't repeat.

#### 4.2.1 Self-Supervised Models

Trained without labeled data purely on raw text using generic objectives like missing or nearby word prediction. Not designed specifically for retrieval or similarity—general-purpose language representations (GloVe, Komninos embeddings, BERT) serving as baselines for task-specific fine-tuning value.

| Model | Open Source | Link |

| GloVe | Yes | https://huggingface.co/sentence-transformers/average_word_embeddings_glove.6B.300d |
| Komninos | Yes | https://huggingface.co/sentence-transformers/average_word_embeddings_komninos |
| BERT Base | Yes | https://huggingface.co/bert-base-uncased |

#### 4.2.2 Contrastively Fine-Tuned Models

Start from pretrained language models trained further using ""contrastive"" objectives: pulling similar/paired text embeddings closer, pushing dissimilar ones apart. Dominant recipe behind modern sentence and retrieval embedding models (SimCSE, Contriever, SPECTER, MPNet, Sentence-BERT framework) because directly optimizes needed embedding properties—meaningful distances.

| Model | Open Source | Link |

| SimCSE | Yes | https://huggingface.co/princeton-nlp/sup-simcse-bert-base-uncased |
| coCondenser | Yes | https://huggingface.co/sentence-transformers/msmarco-bert-co-condensor |
| Contriever | Yes | https://huggingface.co/nthakur/contriever-base-msmarco |
| SPECTER | Yes | https://huggingface.co/sentence-transformers/allenai-specter |
| MiniLM (all-MiniLM-L12-v2) | Yes | https://huggingface.co/sentence-transformers/all-MiniLM-L12-v2 |
| MPNet (all-mpnet-base-v2, English) | Yes | https://huggingface.co/sentence-transformers/all-mpnet-base-v2 |

#### 4.2.3 T5 Encoder-Based Models

Repurpose T5 encoder half (text-to-text transformer originally built for generation) as pure embedding generator, then fine-tune on similarity or retrieval objectives. Since T5 underwent large-scale pretraining for general language understanding, these models (GTR, ST5) tend producing strong well-rounded embeddings across tasks.

| Model | Open Source | Link |

| GTR | Yes | https://huggingface.co/sentence-transformers/gtr-t5-xxl |
| ST5 | Yes | https://huggingface.co/sentence-transformers/sentence-t5-xxl |

#### 4.2.4 Decoder-Based Models

Derive embeddings from decoder-only GPT-style language models (SGPT) rather than encoder architectures. Historically decoders seemed less natural for embeddings (built for next-word generation, not bidirectional understanding), testing whether large generative models adapt into competitive embedding models through internal representation pooling.

| Model | Open Source | Link |

| SGPT | Yes | https://huggingface.co/Muennighoff/SGPT-5.8B-weightedmean-msmarco-specb-bitfit |
| SGPT BLOOM | Yes | https://huggingface.co/bigscience/sgpt-bloom-7b1-msmarco |

#### 4.2.5 Additional Multilingual-Capable Models

Models specifically trained or fine-tuned representing text across many languages in shared embedding spaces, rather than single-language optimization (LaBSE, LASER2, multilingual MiniLM). Main value enables cross-lingual tasks—bitext mining or multilingual retrieval—usually at some peak single-language performance cost compared to monolingual specialists. LASER2 builds on original LASER architecture.

| Model | Open Source | Link |

| LASER2 | Yes | https://github.com/facebookresearch/LASER |
| MiniLM Multilingual | Yes | https://huggingface.co/sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2 |

#### 4.2.6 Closed-Source Model (MTEB)

| Model | Type | Link |

| OpenAI Ada Similarity / Ada Search | Commercial API | Not open source |

### 4.3 Additional Open-Source Models (Estimated Performance Only)

Below models weren't part primary benchmark or MTEB evaluation. Reported Section 6 figures are estimated scores based on published retrieval performance (e.g., MTEB leaderboard standing) rather than measurements under this study's evaluation pipeline, presented separately from directly measured results.

Note on table columns: Dim refers to embedding dimension—output vector length—directly affecting storage and memory requirements for large corpus indexing. Params refers to total trainable model parameters, rough inference cost proxy: larger models generally require more memory and longer execution.

| Model | Dim | Params | Est. BEIR-style nDCG@10 | Notes |

| all-MiniLM-L6-v2 | 384 | 22M | ~0.42–0.45 | Classic lightweight SBERT baseline; fast but dated for retrieval |
| all-MiniLM-L12-v2 | 384 | 33M | ~0.44–0.47 | Slightly deeper than L6, marginal quality gain |
| Nomic-Embed-Text-v1.5 | 768 | 137M | ~0.55–0.58 | Strong for size; long-context (8192 tokens) capable |
| BGE-base-en-v1.5 | 768 | 109M | ~0.53–0.56 | Standard RAG baseline, English-only |
| BGE-large-en-v1.5 | 1024 | 335M | ~0.57–0.60 | One strongest English-only open baselines, close to T3EM on English tasks |
| Qwen3-Embedding-0.6B | 1024 | 600M | ~0.58–0.61 | Newer generation; competitive retrieval at small size |
| Qwen3-Embedding-4B | 2560 | 4B | ~0.63–0.66 | Largest here; expected to approach or match T3EM on BEIR average |

## 5 Evaluation Metrics

### 5.1 Symmetric vs. Asymmetric Embedding Tasks

Embedding tasks divide broadly into two types underlying much model behavior discussed throughout this report.

In symmetric tasks, compared text pieces share similar length, structure, and purpose—for example, two full sentences checked for paraphrase or similarity (STS or pair classification). In asymmetric tasks, text pieces differ substantially in length, structure, and wording—most commonly short queries matched against long passages answering them (retrieval). Queries rarely repeat passage vocabulary answering them, so asymmetric tasks specifically test meaning matching rather than word overlap.

### 5.2 Metrics per Task Category

Retrieval: Uses nDCG@10 (normalized Discounted Cumulative Gain at top 10), Recall@k, Mean Reciprocal Rank (MRR), and Mean Average Precision (MAP). These measure ranking quality and coverage.

Semantic Textual Similarity: Uses Spearman's ρ and Pearson's r, measuring how embedding distances correlate with human similarity judgments.

Classification: Uses Accuracy and F1-scores, measuring label prediction correctness from embeddings.

Clustering: Uses V-Measure, measuring homogeneity and completeness of discovered clusters.

Pair Classification: Uses Accuracy and F1, measuring duplicate/paraphrase detection correctness.

Reranking: Uses nDCG@10, NDCG@100, MAP, and MRR, measuring reranking quality.

Bitext Mining: Uses Accuracy@1, measuring translation matching accuracy.

Summarization: Uses Pearson's r and Spearman's ρ, measuring correlation between embedding similarity and human summary quality judgments.

### 5.3 Interpretation of Metrics

nDCG@10 (normalized Discounted Cumulative Gain at rank 10) measures ranking quality: 1.0 represents perfect ranking, lower scores indicate more relevant documents ranked lower. Recall@k measures coverage: percentage of relevant documents appearing in top-k results. MRR (Mean Reciprocal Rank) measures where first relevant document appears: 1.0 means first position, lower values indicate less relevant documents ranked higher. MAP (Mean Average Precision) averages precision across all relevant document ranks, measuring both ranking quality and coverage.

Spearman's ρ and Pearson's r measure correlation between embedding distances and human judgments: perfect correlation equals 1.0, anti-correlation approaches -1.0. V-Measure for clustering balances homogeneity (same-cluster points similar) and completeness (similar points same-cluster): ranges 0–1.0.

### 5.4 Formal Definitions of Metrics

Discounted Cumulative Gain (DCG) and nDCG@10: DCG sums relevance scores at positions discounted by logarithmic rank, prioritizing higher-ranked results. nDCG normalizes by ideal DCG, ranging 0–1.0.

Recall@k: Percentage of relevant documents within top-k results.

Mean Reciprocal Rank (MRR): Average inverse rank of first relevant result across queries.

Mean Average Precision (MAP): Average of precision values computed at each relevant document rank.

Spearman's ρ and Pearson's r: Rank and linear correlations respectively between embedding distances and human similarity judgments.

Precision, Recall, and F1: Classification metrics measuring true positive rates, coverage, and harmonic means.

V-Measure: Normalized harmonic mean of homogeneity and completeness in clustering.

## 6 Results

### 6.1 Retrieval Performance on Primary Benchmark Subsets

The four primary retrieval datasets (FiQA-2018, NFCorpus, SciFact, TREC-COVID) underwent direct measurement using this study's evaluation pipeline. Results show:

T3EM achieves the highest average retrieval quality at nDCG@10 = 0.638 across primary datasets. Among open-source models, mE5-L scores closest at 0.549, within 0.09 nDCG points of T3EM. BGE-M3 achieves 0.544, E5-large reaches 0.533. Models trained for sentence similarity (LaBSE at 0.471, mMPNet at 0.419) substantially underperform retrieval-trained alternatives despite competitive similarity benchmark scores.

Performance variation across datasets proves substantial. T3EM scores 0.688 on FiQA-2018 but only 0.544 on TREC-COVID, suggesting task-specific training data effects. mE5-L maintains more consistent performance across datasets than retrieval-specialized alternatives, indicating better generalization.

### 6.2 Query Latency and Cost

Latency measurements: T3EM API queries average 450–800ms including network round-trips. Open-source models running locally achieve 50–150ms per query on standard hardware (GPU inference). This represents approximately 7–14× speed advantage for open-source approaches.

Cost considerations: T3EM incurs per-query API costs (exact pricing undisclosed in report but noted as material). Open-source models, once deployed, carry no per-query costs—only one-time deployment and infrastructure expenses.

Note on latency figures: Network conditions, infrastructure, and batch size substantially affect observed latencies. Reported figures represent typical single-query scenarios; batch processing changes relative economics considerably.

### 6.3 Effect of Document Chunking Strategy

Chunking strategy materially affects retrieval quality. Testing across chunk sizes (8, 16, 32, 64, 128 tokens) and strategies (fixed-size, sliding-window, semantic chunking):

Quality peaks and plateaus by 32-token chunk sizes across all models and strategies. Further increases to 64 and 128 tokens provide minimal quality gains. Performance degrades substantially below 16 tokens, with every model showing noticeable quality loss at 8-token chunks.

Semantic chunking outperforms fixed-size and sliding-window approaches at small chunk sizes (8–16 tokens), presumably because semantic boundaries better preserve coherent information units. This advantage diminishes as chunk sizes increase, with negligible differences above 32 tokens.

Sliding-window chunking with overlap provides marginal benefits compared to fixed-size chunking in most scenarios, typically under 1-2 nDCG@10 points improvement.

Practical recommendation: Use semantic chunking with 32-token chunks as a general-purpose default. If semantic chunking proves computationally expensive, fixed-size chunking at 32 tokens provides nearly equivalent performance. Avoid chunks below 16 tokens or above 128 tokens.

### 6.4 Estimated Performance of Additional Open-Source Models

Models evaluated via MTEB leaderboard or published estimates show:

BGE-large-en-v1.5 (estimated nDCG@10 ~0.57–0.60) approaches T3EM on retrieval despite being fully open-source. Qwen3-Embedding-4B (estimated ~0.63–0.66) potentially matches or exceeds T3EM, though hardware requirements substantially exceed smaller alternatives.

Nomic-Embed-Text-v1.5 (estimated ~0.55–0.58) balances quality with 8192-token context length, beneficial for long-document retrieval where others truncate.

### 6.5 Broader MTEB Performance Summary

Across all MTEB task categories:

Retrieval tasks: GTR and SGPT variants lead, with BGE-M3 performing competitively.

Semantic Textual Similarity: ST5 dominates, scoring substantially ahead of other approaches.

Clustering: MPNet excels, substantially outperforming alternatives.

Classification: Performance concentrates tightly; most contrastively fine-tuned models achieve similar scores.

Pair Classification: Scores cluster around high levels for strong models, smaller differences visible.

Reranking: MPNet leads; performance correlates strongly with general quality.

Bitext Mining (cross-lingual): LaBSE dominates, substantially ahead of English-specific models.

Summarization: Smaller datasets produce volatile results; broader patterns less clear.

### 6.6 Best Performing Models

Across all MTEB categories, GTR achieves highest average scores when computing geometric mean across all tasks. ST5 ranks second. BGE-M3 ranks third, balancing strong retrieval with decent performance across other categories.

### 6.7 Task-wise Best Performing Models

#### 6.7.1 Retrieval (nDCG@10)

T3EM leads closed-source models. Among open-source: GTR (estimated ~0.61), mE5-L (0.549 measured), BGE-M3 (0.544 measured), SGPT-5.8B variants (estimated ~0.59).

#### 6.7.2 Classification

MPNet and contrastively fine-tuned models cluster at high performance with small inter-model differences. Exact rankings vary by specific dataset.

#### 6.7.3 Semantic Textual Similarity

ST5 substantially outperforms alternatives. BGE-M3 ranks second. Sentence-similarity-trained models (SimCSE) perform competitively despite lower retrieval scores.

#### 6.7.4 Clustering

MPNet leads substantially. GTR ranks second. BGE-M3 and E5-large follow closely.

#### 6.7.5 Pair Classification

High-performing models cluster densely. MPNet, E5-large, and GTR achieve very similar scores.

#### 6.7.6 Reranking

MPNet leads. GTR follows closely. BGE-M3 performs competitively.

#### 6.7.7 Summarization

Small dataset sizes produce variable results. No clear winner emerges; differences fall within noise margins.

## 7 Discussion, Practical Recommendations, and Conclusions

### 7.1 Why Certain Models Excel at Certain Tasks

Why T3EM outperforms LaBSE on retrieval: T3EM was trained specifically on retrieval pairs (query-document tuples), learning to maximize asymmetric query-document similarity. LaBSE was trained on cross-lingual similarity from translation pairs—fundamentally different objective optimizing symmetric similarity in different languages. The ""dominant factor in retrieval quality"" is ""training objective, not model size""—retrieval-trained models outperform sentence-similarity models regardless of parameter count.

Why MPNet excels at clustering: MPNet benefits from deep architecture and contrastive fine-tuning optimizing for general semantic understanding. Clustering requires capturing topical coherence rather than query-document asymmetry, favoring models with broad semantic understanding.

Why ST5 dominates semantic textual similarity: ST5 underlying T5 architecture underwent massive scale pretraining, and contrastive fine-tuning specifically optimized for similarity tasks where symmetric text comparison matters. The T5 foundation provides superior general language understanding compared to BERT-based alternatives.

Why GTR performs well on retrieval: GTR also derives from T5, inheriting broad semantic understanding. Additional retrieval-specific fine-tuning on large paired datasets produces strong asymmetric performance. T5-based models generally excel across diverse tasks due to foundational pretraining quality.

### 7.2 Key Findings

1. Training objective dominates retrieval quality more than model size or architecture. Sentence-similarity models badly underperform on retrieval despite large parameters.

2. No single model wins across task types; strong specialization exists. Choosing models requires matching to specific applications rather than selecting single ""best"" option.

3. Among open-source models, mE5-L offers best general-purpose default for English retrieval, balancing quality, speed, and cost.

4. Document chunking strategy matters substantially; ""quality plateaus by a chunk size of 32 tokens"" and performance collapses below roughly 16 tokens regardless of strategy.

5. Latency and cost trade-offs heavily favor open-source deployment in most scenarios. T3EM's quality advantage (0.638 vs 0.549 nDCG@10) may not justify 7–14× latency increase and per-query API costs for many applications.

### 7.3 Practical Model Selection Framework

Model selection should follow these decision points:

#### 7.3.1 1. What is the primary downstream task?

For retrieval-focused applications, prioritize retrieval-trained models (GTR, mE5-L, BGE variants). For similarity or clustering, ST5 or MPNet respectively. For cross-lingual applications, consider LaBSE. Multi-task applications requiring good general performance should select from T5-based alternatives (GTR, ST5) or BGE-M3.

#### 7.3.2 2. What is the acceptable inference latency?

If latency requirements are <100ms per query, local open-source models are viable. If acceptable latency exceeds 500ms or consistent latency matters less than peak quality, API models like T3EM become options. If latency is critical, smaller models (MiniLM variants, BGE-base) are necessary trade-offs.

#### 7.3.3 3. How long are the documents?

For documents typically <512 tokens, any model suffices. For longer documents, prioritize high context-window models (Nomic-Embed-Text-v1.5 with 8192 tokens) or implement sophisticated chunking strategies with semantic approaches. Short context windows require careful chunking strategy selection (as detailed in Section 6.3).

#### 7.3.4 4. How similar are queries and documents?

For highly asymmetric query-document pairs (questions against technical documentation), asymmetric-trained models (T3EM, GTR, E5-large) significantly outperform sentence-similarity models. For symmetric comparisons (paraphrase detection, document clustering), sentence-similarity or general-purpose models suffice.

### 7.4 Recommended Models by Application

General English retrieval (RAG systems, search): mE5-L (best open-source default). BGE-large-en-v1.5 if slightly lower quality acceptable for faster inference. T3EM if absolute peak quality required and latency acceptable.

Multilingual retrieval: BGE-M3 (supports dense, sparse, and multi-vector retrieval simultaneously). Multilingual-E5-large for simpler dense-only approaches.

Clustering and document grouping: MPNet (open-source).

Semantic similarity: ST5 (open-source).

Cross-lingual tasks (bitext mining, translation): LaBSE (open-source).

Resource-constrained environments: all-MiniLM-L12-v2 (fast, 33M parameters, reasonable quality).

Long documents (>4K tokens): Nomic-Embed-Text-v1.5 (8192 token context).

Note on mE5-L vs. E5-large: mE5-L supports 110+ languages, making it preferable when multilingual support matters even for primarily English applications. E5-large remains English-only but achieves slightly higher English retrieval quality. For English-only requirements where maximum performance matters, E5-large marginally edges mE5-L.

### 7.5 Common Pitfalls

1. Using sentence-similarity models for retrieval. LaBSE and mMPNet, though successful on similarity benchmarks, perform 15-20% worse on retrieval. Ensure retrieval-specific training when possible.

2. Ignoring chunking strategy. Document chunking often impacts retrieval quality more than model selection. Insufficient attention to chunking leaves performance on the table.

3. Truncating long documents without chunking. Using small context windows on long documents without proper chunking destroys information and retrieval quality. Plan document splitting upfront.

4. Assuming larger always better. Massive models like Qwen3-Embedding-4B offer marginal gains over mE5-L while requiring 10× the resources. Right-size model selection to actual constraints.

5. Neglecting reranking opportunities. Initial retrieval quality from embeddings often improves significantly with lightweight reranker stages, especially for smaller primary embedding models.

### 7.6 Major Trade-offs

Quality vs. cost/latency: T3EM achieves highest quality but incurs API costs and substantial latency. Open-source models sacrifice ~9 nDCG points but eliminate latency and per-query costs, favorable trade for most applications.

Specialization vs. generalization: Task-specialized models (ST5 for similarity, MPNet for clustering) outperform generalists on specific tasks by 5-15% but perform worse elsewhere. BGE-M3 sacrifices single-task performance to support dense, sparse, and multi-vector retrieval simultaneously, accepting measurable retrieval quality cost for versatility.

Context length vs. speed/memory: Longer context windows (Nomic-Embed-Text-v1.5's 8192 tokens) eliminate chunking needs but increase inference cost and memory. Shorter windows require careful chunking strategy but enable faster, cheaper deployment.

Model size vs. inference cost: Larger models improve quality but increase latency, memory, and compute. Efficient selection requires benchmarking specific hardware and latency constraints rather than assuming size-quality correlation.

### 7.7 Practical Default Recommendation

When requirements are unspecified, mE5-L is the recommended default open-source model. It achieves strong retrieval quality (0.549 nDCG@10, within 0.09 points of T3EM), supports 110+ languages, operates at acceptable latency locally, carries zero per-query costs, and is fully open-source. It represents the best balance point for general English retrieval without specific constraints.

If absolute peak quality is non-negotiable and latency acceptable, T3EM remains the recommendation. If resources are severely constrained, all-MiniLM-L12-v2 or BGE-base-en-v1.5 provide acceptable alternatives. Specific task requirements should override this default when applicable.

### 7.8 Limitations

This study focuses on English-language retrieval tasks, limiting conclusions about monolingual non-English or translation-dependent applications. Only three commercial embedding models were benchmarked (T3EM, OpenAI Ada, closed-source model); results may not generalize to other APIs. Latency measurements represent typical single-query scenarios; batch processing substantially changes relative economics. Vector database choice affects practical performance but wasn't directly studied; ANN index parameters and vector search configurations substantially impact real-world results. Document chunking experiments used simplified strategies; sophisticated approaches (hierarchical, parent-child) weren't thoroughly evaluated.

### 7.9 Overall Conclusion

Embedding model selection requires matching training objective, not size or architecture, to downstream tasks. ""No single model wins across all task types""; strong task specialization exists requiring targeted selection. Among open-source options, mE5-L provides best general-purpose English retrieval default, balancing quality, latency, and cost. T3EM achieves highest quality but rarely justifies its cost and latency trade-offs for typical applications. Document chunking strategy substantially impacts retrieval quality—more consequential than commonly recognized—with optimum around 32 tokens regardless of approach. Practical systems benefit from understanding the complete retrieval pipeline beyond embedding model choice, including infrastructure (vector databases), reranking strategies, and deployment constraints. This framework enables evidence-based decision-making rather than abstract performance metrics.

## Glossary of Abbreviations

ANN: Approximate Nearest Neighbor
BEIR: Benchmark for Information Retrieval
BGE: Base General Embeddings
BM25: Okapi BM25 retrieval algorithm
BUCC: Bulgarian-English Comparable Corpus
CLS: Classification token
ColBERT: Contextualized Late Interaction over BERT
DCG: Discounted Cumulative Gain
E5: Multilingual E5 embeddings
FAISS: Facebook AI Similarity Search
GTR: Generative Text Retrieval
HNSW: Hierarchical Navigable Small World
IVF: Inverted File Index
LaBSE: Language-agnostic BERT Sentence Embeddings
LASER: Localization-agnostic Sentence Representations
MAP: Mean Average Precision
MTEB: Massive Text Embedding Benchmark
MRR: Mean Reciprocal Rank
MSMARCO: Microsoft Machine Reading Comprehension
MiniLM: Minimal Language Model
mMPNet: Multilingual Paraphrase MPNet
mE5-L: Multilingual E5-Large
MPNet: Microsoft Paraphrase Networks
nDCG: Normalized Discounted Cumulative Gain
NFCorpus: Nutrition and Fitness Corpus
OpenAI Ada: OpenAI's Ada embedding model
PQ: Product Quantization
RAG: Retrieval-Augmented Generation
SGPT: Semantic GPT
SBERT: Sentence BERT
SimCSE: Simple Contrastive Learning of Sentence Embeddings
SPECTER: Specialized Pre-training for Enhanced Collaborative Task Exploiting Representation
ST5: Sentence T5
STS: Semantic Textual Similarity
T3EM: Text 3 Embedding Model
T5: Text-to-Text Transfer Transformer
TREC-COVID: Text Retrieval Conference COVID Collection
TwentyNewsgroups: 20 Newsgroups dataset
V-Measure: Homogeneity and Completeness Measure

## References

[Full reference list follows original academic format; 34 citations for papers, benchmarks, and models referenced throughout]
",https://arxiv.org/abs/2607.23507,explainer