Mellum2.1: el modelo abierto de JetBrains para agentes de código, local con vLLM

1. Qué publicó JetBrains

Mellum nació como modelo de autocompletado de código. Mellum2, lanzado en junio de 2026 con un reporte técnico en arXiv, fue el salto a un diseño mixture-of-experts de 12B que activa unos 2.5B parámetros por token. Mellum2.1 es la siguiente versión de ese modelo Thinking: misma arquitectura, post-entrenamiento nuevo.

Los pesos están en Hugging Face como JetBrains/Mellum2.1-12B-A2.5B-Thinking. El post de lanzamiento lo posiciona para agentes de código y sub-agentes rápidos en tu propio hardware. No encontré una API alojada de JetBrains ni precio por token, así que el camino es autoalojarlo.

2. Qué cambió frente a Mellum2

Mismo esqueleto, entrenamiento distinto. JetBrains dice que la arquitectura no cambia y que el aprendizaje por refuerzo pasó a ser la parte principal del entrenamiento, no una etapa final corta. Los datos se ampliaron a matemática, programación competitiva, ciencia, tool use e ingeniería de software, y JetBrains armó infraestructura propia que lanzó millones de sandboxes.

El cambio práctico lo dice sin vueltas el post de lanzamiento: Mellum2 no podía trabajar dentro de un repositorio al nivel que JetBrains quería, mientras que Mellum2.1 está pensado para explorar un codebase, editar archivos y verificar sus propios cambios. Esa es la diferencia entre un modelo de completado y uno que podés meter en un loop.

Los tres saltos (model card, autoinformado)

3. Los números, con procedencia

Cada puntaje de abajo sale de la model card de Hugging Face y lo produjo JetBrains. Los benchmarks no agénticos usaron decodificación greedy. Los agénticos usaron un harness llamado Pi (v0.73.1) con herramientas de shell y archivos, contexto de 114K tokens, hasta 16K tokens por turno y temperatura 1.0. El set de comparación es Mellum2, Gemma 4 (E4B) y Qwen3.5 (9B).

La velocidad es un reclamo aparte del post de lanzamiento: en una H200, bajo carga alta, JetBrains dice que Mellum2.1 sirve casi el doble de tokens que Qwen3.5-9B, y que la multi-token prediction haría una request individual unas 1.6 veces más rápida. Los valores exactos aparecen solo en un gráfico, y el head MTP para vLLM figura como próximamente.

4. Quickstart: servilo con vLLM

La receta de serving de la card son dos comandos: uno sin tool calling y otro con. Para un agente querés el segundo. Ambos pasan --max-model-len 131072 y el reasoning parser qwen3, que separa la traza de razonamiento de la respuesta final. La página de modelos soportados de vLLM lista la arquitectura MellumForCausalLM; la card no indica versión mínima de vLLM, así que usá un release reciente.

La memoria es la pregunta real, y la card no da guía de VRAM. Los números de abajo son aritmética mía a partir del tamaño del checkpoint y del config.json, no mediciones. Los 2.5B parámetros activos bajan el cómputo por token, no la memoria: los 12B tienen que estar residentes.

vllm serve JetBrains/Mellum2.1-12B-A2.5B-Thinking \
  --max-model-len 131072 \
  --reasoning-parser qwen3

vllm serve JetBrains/Mellum2.1-12B-A2.5B-Thinking \
  --max-model-len 131072 \
  --reasoning-parser qwen3 \
  --enable-auto-tool-choice \
  --tool-call-parser hermes

from openai import OpenAI
# Configured by environment variables
client = OpenAI()

messages = [
    {"role": "user", "content": "Find the bug in this function and explain the fix: def mean(xs): return sum(xs) / len(xs) - 1"},
]

chat_response = client.chat.completions.create(
    model="JetBrains/Mellum2.1-12B-A2.5B-Thinking",
    messages=messages,
    max_tokens=81920,
    temperature=0.6,
    top_p=0.95,
    extra_body={"top_k": 20},
)
print("Chat response:", chat_response)

# JetBrains GGUF repo, Q4_K_M (the quant its card marks as recommended)
ollama run hf.co/JetBrains/Mellum2.1-12B-A2.5B-Thinking-GGUF:Q4_K_M

# or llama.cpp
llama-server -hf JetBrains/Mellum2.1-12B-A2.5B-Thinking-GGUF:Q4_K_M --ctx-size 131072 --temp 0.6 --top-p 0.95 --top-k 20

5. Enchufalo a un loop de agente de código

vLLM expone un servidor compatible con OpenAI, así que cualquier harness que acepte una base URL y hable chat-completions con tools puede apuntarle. El boceto de abajo es el loop más chico que usaría para probar el modelo: una tool, un tope de pasos, sin trucos de memoria, los ajustes de sampling de la card y un tope de tokens por turno.

Dos detalles de la doc de vLLM importan. El razonamiento vuelve en su propio campo (hoy reasoning, antes reasoning_content, así que leé ambos). Y los tool calls se parsean solo del content, no de adentro del razonamiento: si el modelo emite una llamada dentro de su bloque de thinking, tu loop no ve nada.

import json
import subprocess
from openai import OpenAI

# Sketch: not from the model card, not run by me.
client = OpenAI(base_url="http://localhost:8000/v1", api_key="local")
MODEL = "JetBrains/Mellum2.1-12B-A2.5B-Thinking"

TOOLS = [{
    "type": "function",
    "function": {
        "name": "run_shell",
        "description": "Run a shell command in the repo; returns stdout and stderr.",
        "parameters": {
            "type": "object",
            "properties": {"cmd": {"type": "string"}},
            "required": ["cmd"],
        },
    },
}]

def run_shell(cmd: str) -> str:
    # DANGER: model-written commands. Run inside a container, no secrets mounted.
    p = subprocess.run(cmd, shell=True, capture_output=True, text=True, timeout=120)
    return (p.stdout + p.stderr)[-8000:]

messages = [
    {"role": "system", "content": "You are a coding agent. Explore with run_shell, edit files, run the tests, stop when they pass."},
    {"role": "user", "content": "tests/test_mean.py fails. Find the cause and fix it."},
]

for step in range(20):
    resp = client.chat.completions.create(
        model=MODEL,
        messages=messages,
        tools=TOOLS,
        tool_choice="auto",
        max_tokens=16384,          # per-turn cap; the card quickstart uses 81920
        temperature=0.6,
        top_p=0.95,
        extra_body={"top_k": 20},  # same sampling as the card quickstart
    )
    choice = resp.choices[0]
    msg = choice.message
    reasoning = getattr(msg, "reasoning", None) or getattr(msg, "reasoning_content", None)
    print(f"[step {step}] finish={choice.finish_reason} reasoning_chars={len(reasoning or '')} tool_calls={len(msg.tool_calls or [])}")

    assistant = {"role": "assistant", "content": msg.content or ""}
    if msg.tool_calls:
        assistant["tool_calls"] = [
            {
                "id": c.id,
                "type": "function",
                "function": {"name": c.function.name, "arguments": c.function.arguments},
            }
            for c in msg.tool_calls
        ]
    messages.append(assistant)

    if not msg.tool_calls:
        print(msg.content)
        break

    for c in msg.tool_calls:
        args = json.loads(c.function.arguments)
        messages.append({"role": "tool", "tool_call_id": c.id, "content": run_shell(args["cmd"])})

6. Dónde encaja y los límites honestos

JetBrains presenta Mellum2.1 como un modelo para agentes de código y sub-agentes rápidos en tu propio hardware, no como reemplazo de un modelo de frontera. Su set de comparación son solo modelos chicos. No tengo números del mismo harness para modelos más grandes o cerrados, así que no voy a inventar una brecha; esa es la pregunta que tiene que responder tu propio eval.

Para Mellum2, el post de lanzamiento sugería tareas de sub-agente como planificación, validación, transformación y preparación de contexto. Mellum2.1 mantiene ese rol y suma ediciones a nivel repositorio, pero la tabla de la propia card muestra a un rival de 9B adelante en los evals agénticos más duros.

Veredicto

Mellum2.1 es un modelo creíble de huella chica para trabajo de agentes local: Apache 2.0, una GPU, y un salto autoinformado de 2.0 a 47.0 en SWE-bench Verified que viene solo de RL. No es un reemplazo de frontera, y la propia card muestra a Qwen3.5 (9B) adelante en SWE-bench Verified, SWE-bench Pro y Terminal-Bench 2.1.

Lo que haría: bajar los pesos, servirlos con el comando de tool calling, correr entre 20 y 50 tickets tuyos con tests como juez, y comparar tasa de resolución, tiempo de pared y costo de GPU contra lo que corrés hoy. Hasta que alguien fuera de JetBrains re-ejecute SWE-bench, tomá el 47.0 como un número prometedor, no uno cerrado.