• en
• fr
• de
• es
• pt
• it
• ja
• ko
• ru
• zh
• ar
• fa
• id
• ms
• ne
• pl
• ro
• sr
• sv
• tr
• uk
• vi
• hi
• bn

• mistralai/Devstral-Small-2507
• mistralai/Mistral-Small-3.1-24B-Instruct-2503

[!NOTE]

You should use --jinja to enable the system prompt in llama.cpp.

Devstral 1.1, with tool-calling and optional vision support.

Learn to run Devstral correctly - Read our Guide.

Unsloth Dynamic 2.0 achieves superior accuracy & outperforms other leading quants.

✨ Run & Fine-tune Devstral 1.1 with Unsloth!

• Fine-tune Mistral v0.3 (7B) for free using our Google Colab notebook here-Conversational.ipynb)!
• Read our Blog about Devstral 1.1 support: docs.unsloth.ai/basics/devstral
• View the rest of our notebooks in our docs here.

Devstral Small 1.1

Devstral is an agentic LLM for software engineering tasks built under a collaboration between Mistral AI and All Hands AI 🙌. Devstral excels at using tools to explore codebases, editing multiple files and power software engineering agents. The model achieves remarkable performance on SWE-bench which positionates it as the #1 open source model on this benchmark.

It is finetuned from Mistral-Small-3.1, therefore it has a long context window of up to 128k tokens. As a coding agent, Devstral is text-only and before fine-tuning from Mistral-Small-3.1 the vision encoder was removed.

For enterprises requiring specialized capabilities (increased context, domain-specific knowledge, etc.), we will release commercial models beyond what Mistral AI contributes to the community.

Learn more about Devstral in our blog post.

Updates compared to Devstral Small 1.0:

• Improved performance, please refer to the benchmark results.
• Devstral Small 1.1 is still great when paired with OpenHands. This new version also generalizes better to other prompts and coding environments.
• Supports Mistral's function calling format.

Key Features:

• Agentic coding: Devstral is designed to excel at agentic coding tasks, making it a great choice for software engineering agents.
• lightweight: with its compact size of just 24 billion parameters, Devstral is light enough to run on a single RTX 4090 or a Mac with 32GB RAM, making it an appropriate model for local deployment and on-device use.
• Apache 2.0 License: Open license allowing usage and modification for both commercial and non-commercial purposes.
• Context Window: A 128k context window.
• Tokenizer: Utilizes a Tekken tokenizer with a 131k vocabulary size.

Benchmark Results

SWE-Bench

Devstral Small 1.1 achieves a score of 53.6% on SWE-Bench Verified, outperforming Devstral Small 1.0 by +6,8% and the second best state of the art model by +11.4%.

When evaluated under the same test scaffold (OpenHands, provided by All Hands AI 🙌), Devstral exceeds far larger models such as Deepseek-V3-0324 and Qwen3 232B-A22B.

!SWE Benchmark

Usage

We recommend to use Devstral with the OpenHands scaffold.
You can use it either through our API or by running locally.

API

Then run these commands to start the OpenHands docker container.

export MISTRALAPIKEY=<MY_KEY>


mkdir -p ~/.openhands && echo '{"language":"en","agent":"CodeActAgent","maxiterations":null,"securityanalyzer":null,"confirmationmode":false,"llmmodel":"mistral/devstral-small-2507","llmapikey":"'$MISTRALAPIKEY'","remoteruntimeresourcefactor":null,"githubtoken":null,"enabledefaultcondenser":true}' > ~/.openhands-state/settings.json

docker pull docker.all-hands.dev/all-hands-ai/runtime:0.48-nikolaik

docker run -it --rm --pull=always \
    -e SANDBOXRUNTIMECONTAINER_IMAGE=docker.all-hands.dev/all-hands-ai/runtime:0.48-nikolaik \
    -e LOGALLEVENTS=true \
    -v /var/run/docker.sock:/var/run/docker.sock \
    -v ~/.openhands:/.openhands \
    -p 3000:3000 \
    --add-host host.docker.internal:host-gateway \
    --name openhands-app \
    docker.all-hands.dev/all-hands-ai/openhands:0.48

Local inference

The model can also be deployed with the following libraries:

• vllm (recommended): See here
• mistral-inference: See here
• transformers: See here
• LMStudio: See here
• llama.cpp: See here
• ollama: See here

#### vLLM (recommended)

pip install vllm --upgrade

pip install mistral-common --upgrade

python -c "import mistralcommon; print(mistralcommon.version)"

vllm serve mistralai/Devstral-Small-2507 --tokenizermode mistral --configformat mistral --load_format mistral --tool-call-parser mistral --enable-auto-tool-choice --tensor-parallel-size 2

import requests
import json
from huggingfacehub import hfhub_download

url = "http://<your-server-url>:8000/v1/chat/completions"
headers = {"Content-Type": "application/json", "Authorization": "Bearer token"}

model = "mistralai/Devstral-Small-2507"

def loadsystemprompt(repo_id: str, filename: str) -> str:
    filepath = hfhubdownload(repoid=repo_id, filename=filename)
    with open(file_path, "r") as file:
        system_prompt = file.read()
    return system_prompt

SYSTEMPROMPT = loadsystemprompt(model, "SYSTEMPROMPT.txt")

messages = [
    {"role": "system", "content": SYSTEM_PROMPT},
    {
        "role": "user",
        "content": [
            {
                "type": "text",
                "text": "<your-command>",
            },
        ],
    },
]

data = {"model": model, "messages": messages, "temperature": 0.15}

Devstral Small 1.1 supports tool calling. If you want to use tools, follow this:
tools = [ # Define tools for vLLM
    {
        "type": "function",
        "function": {
            "name": "git_clone",
            "description": "Clone a git repository",
            "parameters": {
                "type": "object",
                "properties": {
                    "url": {
                        "type": "string",
                        "description": "The url of the git repository",
                    },
                },
                "required": ["url"],
            },
        },
    }
] 
data = {"model": model, "messages": messages, "temperature": 0.15, "tools": tools} # Pass tools to payload.

response = requests.post(url, headers=headers, data=json.dumps(data))
print(response.json()["choices"][0]["message"]["content"])

#### Mistral-inference

pip install mistral_inference --upgrade

from huggingfacehub import snapshotdownload
from pathlib import Path

mistralmodelspath = Path.home().joinpath('mistral_models', 'Devstral')
mistralmodelspath.mkdir(parents=True, exist_ok=True)

snapshotdownload(repoid="mistralai/Devstral-Small-2507", allowpatterns=["params.json", "consolidated.safetensors", "tekken.json"], localdir=mistralmodelspath)

mistral-chat $HOME/mistralmodels/Devstral --instruct --maxtokens 300

#### Transformers

pip install mistral-common --upgrade

import torch

from mistral_common.protocol.instruct.messages import (
    SystemMessage, UserMessage
)
from mistral_common.protocol.instruct.request import ChatCompletionRequest
from mistral_common.tokens.tokenizers.mistral import MistralTokenizer
from huggingfacehub import hfhub_download
from transformers import AutoModelForCausalLM

def loadsystemprompt(repo_id: str, filename: str) -> str:
    filepath = hfhubdownload(repoid=repo_id, filename=filename)
    with open(file_path, "r") as file:
        system_prompt = file.read()
    return system_prompt

model_id = "mistralai/Devstral-Small-2507"
SYSTEMPROMPT = loadsystemprompt(modelid, "SYSTEM_PROMPT.txt")

tokenizer = MistralTokenizer.fromhfhub(model_id)
model = AutoModelForCausalLM.frompretrained(modelid)

tokenized = tokenizer.encodechatcompletion(
    ChatCompletionRequest(
        messages=[
            SystemMessage(content=SYSTEM_PROMPT),
            UserMessage(content="<your-command>"),
        ],
    )
)

output = model.generate(
    input_ids=torch.tensor([tokenized.tokens]),
    maxnewtokens=1000,
)[0]

decoded_output = tokenizer.decode(output[len(tokenized.tokens):])
print(decoded_output)

#### LM Studio

pip install -U "huggingface_hub[cli]"
huggingface-cli download \
"lmstudio-community/Devstral-Small-2507-GGUF" \ # or mistralai/Devstral-Small-2507_gguf
--include "Devstral-Small-2507-Q4KM.gguf" \
--local-dir "Devstral-Small-2507_gguf/"

#### llama.cpp

pip install -U "huggingface_hub[cli]"
huggingface-cli download \
"mistralai/Devstral-Small-2507_gguf" \
--include "Devstral-Small-2507-Q4KM.gguf" \
--local-dir "mistralai/Devstral-Small-2507_gguf/"

./llama-server -m mistralai/Devstral-Small-2507gguf/Devstral-Small-2507-Q4K_M.gguf -c 0 # -c configure the context size, 0 means model's default, here 128k.

OpenHands (recommended)

#### Launch a server to deploy Devstral Small 1.1

Make sure you launched an OpenAI-compatible server such as vLLM or Ollama as described above. Then, you can use OpenHands to interact with Devstral Small 1.1.

In the case of the tutorial we spineed up a vLLM server running the command:

vllm serve mistralai/Devstral-Small-2507 --tokenizermode mistral --configformat mistral --load_format mistral --tool-call-parser mistral --enable-auto-tool-choice --tensor-parallel-size 2

The server address should be in the following format: http://:8000/v1

#### Launch OpenHands

You can follow installation of OpenHands here.

The easiest way to launch OpenHands is to use the Docker image:

docker pull docker.all-hands.dev/all-hands-ai/runtime:0.48-nikolaik


docker run -it --rm --pull=always \
    -e SANDBOXRUNTIMECONTAINER_IMAGE=docker.all-hands.dev/all-hands-ai/runtime:0.48-nikolaik \
    -e LOGALLEVENTS=true \
    -v /var/run/docker.sock:/var/run/docker.sock \
    -v ~/.openhands:/.openhands \
    -p 3000:3000 \
    --add-host host.docker.internal:host-gateway \
    --name openhands-app \
    docker.all-hands.dev/all-hands-ai/openhands:0.48

Then, you can access the OpenHands UI at http://localhost:3000.

#### Connect to the server

When accessing the OpenHands UI, you will be prompted to connect to a server. You can use the advanced mode to connect to the server you launched earlier.

Fill the following fields:

• Custom Model: openai/mistralai/Devstral-Small-2507
• Base URL: http://:8000/v1
• API Key: token (or any other token you used to launch the server if any)

Cline

#### Launch a server to deploy Devstral Small 1.1

Make sure you launched an OpenAI-compatible server such as vLLM or Ollama as described above. Then, you can use OpenHands to interact with Devstral Small 1.1.

In the case of the tutorial we spineed up a vLLM server running the command:

vllm serve mistralai/Devstral-Small-2507 --tokenizermode mistral --configformat mistral --load_format mistral --tool-call-parser mistral --enable-auto-tool-choice --tensor-parallel-size 2

The server address should be in the following format: http://:8000/v1

#### Launch Cline

You can follow installation of Cline here. Then you can configure the server address in the settings.

Examples

#### OpenHands:Understanding Test Coverage of Mistral Common

We can start the OpenHands scaffold and link it to a repo to analyze test coverage and identify badly covered files.
Here we start with our public mistral-common repo.

After the repo is mounted in the workspace, we give the following instruction

Check the test coverage of the repo and then create a visualization of test coverage. Try plotting a few different types of graphs and save them to a png.

!mistral common coverage - prompt

Then it sets up the testing dependencies and launches the coverage test:

!mistral common coverage - dependencies

Finally, the agent writes necessary code to visualize the coverage, export the results and save the plots to a png.
!mistral common coverage - visualization

At the end of the run, the following plots are produced:
!mistral common coverage - coverage distribution
!mistral common coverage - coverage pie
!mistral common coverage - coverage summary

and the model is able to explain the results:
!mistral common coverage - navigate

#### Cline: build a video game

First initialize Cline inside VSCode and connect it to the server you launched earlier.

We give the following instruction to builde the video game:

Create a video game that mixes Space Invaders and Pong for the web.


Follow these instructions:
There are two players one at the top and one at the bottom. The players are controling a bar to bounce a ball.
The first player plays with the keys "a" and "d", the second with the right and left arrows.
The invaders are located at the center of the screen. They shoud look like the ones in Space Invaders. Their goal is to shoot on the players randomly. They cannot be destroyed by the ball that pass through them. This means that invaders never die.
The players goal is to avoid shootings from the space invaders and send the ball to the edge of the over player.
The ball bounces on the left and right edges.
Once the ball touch one of the player's edge, the player loses.
Once a player is touched 3 times or more by a shooting, the player loses.
The player winning is the last one standing.
Display on the UI, the number of times a player touched the ball, and the remaining health.

!space invaders pong - prompt

The agent will first create the game:

!space invaders pong - structure

Then it will explain how to launch the game:

!space invaders pong - task completed

Finally, the game is ready to be played:

!space invaders pong - game

Don't hesitate to iterate or give more information to Devstral to improve the game!