Mistral Agent Runtime 2.0

Overview

Mistral Agent Runtime 2.0 is the second major release of Mistral's local agent runtime, shipped October 4, 2026 (89 HN points) with a single headline: full tool-calling protocol parity with the OpenAI and Anthropic hosted runtimes. Prior versions shipped a Mistral-specific tool-calling format that agent frameworks had to adapt to; 2.0 removes that adapter layer. The OpenAI Responses API wire format is now the native wire format, and OpenAI-compatible clients work against a local Mistral deployment without code changes.

The release completes the "three-way local runtime" pattern that emerged in mid-2026: Claude Code, OpenAI Codex, and Mistral Agent Runtime now share the same tool-calling protocol, with portability between local runtimes as a real property rather than an aspiration.

Runtime 2.0 also ships with full MCP 2.2 support, including streaming tool results and cross-server chaining — the first local runtime to support MCP 2.2 GA.

Features

• OpenAI Responses API wire format — native; OpenAI SDKs work unchanged against a local Mistral endpoint
• MCP 2.2 native — streaming tool results and cross-server chaining supported out of the box
• Tool-calling protocol parity — function calling, JSON Schema tool definitions, streaming tool results all match the hosted OpenAI behavior
• Multi-model hosting — Claude-3.5-Sonnet-equivalent quality via Mistral Large 2 and Small 3.2 served locally
• Multi-GPU serving — tensor parallelism across up to 4 GPUs for the 123B parameter model
• Quantization options — FP16, INT8, INT4; INT4 fits a 47B model on a single 24 GB GPU
• Agent SDK — Python, TypeScript, and Rust SDKs matching the OpenAI Agents SDK API
• Observability built-in — OpenTelemetry traces for every agent step, no extra instrumentation
• Prompt caching — automatic prefix caching with a 5-minute TTL
• Skill Protocol v2 support — load and verify signed skills from enterprise registries

Installation

# Homebrew
brew install mistral-ai/tap/runtime

# Docker
docker pull mistralai/runtime:2.0

# Linux binary
curl -L https://mistral.ai/runtime/install | sh

# Windows
winget install MistralAI.Runtime

Quick Start

from openai import OpenAI

# Point OpenAI SDK at local Mistral runtime
client = OpenAI(
    base_url="http://localhost:8787/v1",
    api_key="local",
)

response = client.responses.create(
    model="mistral-large-2",
    input="Review this code for bugs",
    tools=[{
        "type": "function",
        "name": "read_file",
        "parameters": {
            "type": "object",
            "properties": {"path": {"type": "string"}},
            "required": ["path"],
        },
    }],
)

Because the wire format is OpenAI-compatible, every agent framework that talks to GPT-5.6 can talk to Mistral Agent Runtime unchanged.

Core Concepts

The Three-Way Local Runtime

Three local agent runtimes now support the same tool-calling protocol:

Runtime	Model Backend	MCP 2.2	Skill Protocol v2
Claude Code	Claude (hosted)	Yes	Yes
OpenAI Codex	GPT (hosted)	Yes	No
Mistral Agent Runtime 2.0	Mistral (local or hosted)	Yes	Yes

The implication: agents built for one runtime can be tested and deployed on the others with minimal changes. Portability between local runtimes is a real property, not a slogan.

Tool-Calling Protocol

Mistral's native tool-calling format was retired in Runtime 2.0. The new wire format is the OpenAI Responses API:

{
  "tool_calls": [
    {
      "type": "function",
      "function": {
        "name": "read_file",
        "arguments": "{\"path\":\"src/auth.py\"}"
      }
    }
  ]
}

Streaming tool calls arrive as incremental SSE events, matching the hosted OpenAI behavior.

Multi-Model Hosting

Runtime 2.0 serves multiple Mistral models simultaneously, with automatic routing based on task complexity:

• Mistral Small 3.2 (22B) — fast, cheap, for chat and classification
• Mistral Medium 3 (75B) — balanced for most agent work
• Mistral Large 2 (123B) — complex reasoning, code, long-context tasks
• Codestral 2 (22B) — code-specialized; pairs with the agent runtime for coding tasks

MCP Configuration

{
  "mcpServers": {
    "runtime": {
      "command": "mistral-runtime-mcp",
      "args": ["--url", "http://localhost:8787/v1"]
    }
  }
}

Runtime 2.0 also acts as an MCP 2.2 gateway — external MCP servers can be registered with the runtime and invoked through cross-server chaining.

Advanced Features

• Prompt caching — automatic prefix caching with 5-minute TTL; reduces latency on repeat prompts by up to 80%
• Batch inference — batch_size parameter for serving multiple prompts on a single GPU
• Reasoning budgets — thinking_budget parameter controls reasoning depth, similar to Claude
• Custom function schemas — supports JSON Schema draft 2020-12
• Observability — every agent step produces an OpenTelemetry span
• Cost controls — per-prompt token budget; hard caps prevent runaway costs

Examples

A local agent with Mistral Agent Runtime:

from pydantic_ai import Agent
from pydantic import BaseModel

class Plan(BaseModel):
    steps: list[str]

agent = Agent("mistral-large-2", output_type=Plan)

result = await agent.run("Break this task into steps: ship a MCP server")
print(result.data.steps)

Streaming tool calls:

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8787/v1", api_key="local")

stream = client.responses.create(
    model="mistral-medium-3",
    input="Search the docs for the auth API",
    tools=[search_tool],
    stream=True,
)

for event in stream:
    if event.type == "response.function_call_arguments.delta":
        print(event.delta, end="")

Pros

• OpenAI Responses API wire format — drop-in replacement in every agent framework
• Full MCP 2.2 support including streaming and cross-server chaining
• Local deployment option for privacy-sensitive and compliance-restricted environments
• Multi-model hosting with automatic routing
• Prompt caching and observability built in
• Rust-based core for performance and safety

Cons

• Heavier install (~500 MB) than pure SDK-based setups
• Mistral model quality trails Claude Opus 4.7 and GPT-5.6 on reasoning-heavy tasks
• Newer release; some framework adapters are still catching up
• Multi-GPU serving requires 4 GPUs for the 123B model

When to Use

• Local-first agent deployments where hosted APIs are not an option
• High-volume inference where per-token hosted costs are prohibitive
• Regulated environments requiring data residency
• Teams that want agent-framework portability across hosted and local runtimes
• Multi-model routing between small and large models in a single deployment

Resources

• Website: https://mistral.ai/runtime
• GitHub: https://github.com/mistralai/runtime
• Docs: https://docs.mistral.ai/runtime/2.0
• Model Hub: https://hub.mistral.ai/