Mistral Large 3 Is on Writingmate: Testing Agentic Coding and Tool Use

Mistral hasn't been part of the "is this a frontier model" conversation for a while. DeepSeek, Kimi, and a rotating cast of Chinese open-weight labs have owned that discussion for most of 2026, and Mistral's name mostly came up in the context of Le Chat or a coding side-project called Devstral. So when Mistral Large 3 landed in the Writingmate catalog, I wasn't going to just read the spec sheet and move on — I ran it through the exact same three-task suite I've used on every other agentic launch this quarter: a broken function with a misleading stack trace, a messy module that needs a real refactor, and a multi-step job that only works if tool calls actually chain together.

My name is Artem, and I run the Writingmate blog. I've put DeepSeek V4 Pro, Kimi K3, and Inkling through this same suite, and the results have mostly separated the models that are genuinely built for agent loops from the ones that just have a big context window and a good marketing page. Mistral Large 3 is a strange case: it's a 675-billion-parameter Mixture-of-Experts model released under Apache 2.0, it ships with native tool calling, and it's meaningfully cheaper than most of what I've tested — but the independent benchmark story on it is more mixed than Mistral's own announcement lets on. Here's what actually happened when I ran it.

What Mistral Large 3 Actually Is

Mistral announced Mistral 3 — a four-model family including Mistral Large 3 and three dense Ministral models (3B, 8B, 14B) — on December 2, 2025. Large 3 is the headline release: a sparse Mixture-of-Experts model with 41 billion active parameters out of 675 billion total, trained from scratch on 3,000 NVIDIA H200 GPUs. It's Mistral's first MoE release since the original Mixtral series, and it ships under an Apache 2.0 license for both the base and instruction-tuned checkpoints, which means you can self-host it without a per-token bill if you have the hardware for it.

Two details matter more than the parameter count. First, Large 3 is explicitly a non-reasoning model — there's no chain-of-thought mode to toggle on, though Mistral has said a dedicated reasoning variant is coming. Second, the model card lists structured outputs, function calling, and built-in agent tools as first-class features from launch, not something bolted on later. That's the pitch: a cheap, open, tool-native generalist, not a dedicated reasoning specialist.

"Mistral just launched their new large open weights model, Mistral Large 3 (675B total, 41B active), alongside a set of three Ministral models (3B, 8B, 14B). Mistral has released Instruct (non-reasoning) variants of all four models, as well as reasoning variants of the three [Ministral models]." — Artificial Analysis on X

Worth noting from that same post: the reasoning variants shipped for the three smaller Ministral models at launch, but not for Large 3 itself. If you need chain-of-thought reasoning today, Large 3 isn't the model — you'd reach for Ministral 14B's reasoning variant or a different provider entirely.

Mistral Large 3 Specs at a Glance

Field	Mistral Large 3	Reader takeaway
Provider	Mistral AI	Released December 2, 2025, alongside the Ministral 3/8/14B family
Architecture	675B total parameters, 41B active per token (MoE)	About 6% of parameters active per token
Context window	262,144 tokens (262K)	Solid for most coding sessions, well short of the 1M windows on DeepSeek V4 Pro and Kimi K3
License	Apache 2.0	Fully self-hostable, no per-token fee if you run your own inference
Input modalities	Text, image, file	No native audio input, unlike Inkling
Reasoning	None — non-reasoning model	No chain-of-thought toggle; a reasoning variant is promised but not yet shipped
Tool use	Native function calling, structured outputs, built-in agent tools	Agentic support is a first-class feature, not an afterthought
Pricing (OpenRouter)	$0.50 input / $1.50 output per 1M tokens; $0.05 cached input	A 10x discount on cached input — useful, though nowhere near DeepSeek V4 Pro's cache pricing

How I Tested Agentic Coding and Tool Use

Same three tasks I've run on DeepSeek V4 Pro, Kimi K3, and Inkling, with Claude Sonnet 5 as the daily-driver baseline and DeepSeek V4 Pro as the closest open-weight comparison point, since both are Apache-licensed-adjacent, tool-native MoE models sitting at similar price points.

• Task 1 — broken function fix: a Flask session handler throwing an intermittent KeyError: 'user_id', full traceback, three files. The real cause is a race condition, not a typo — the lazy fix is wrapping the dictionary access in a try/except with a default.
• Task 2 — messy module refactor: a 140-line Express route handler doing auth, validation, a database call, and a confirmation email inline, three callbacks deep. The ask: split it into small, testable functions without changing behavior.
• Task 3 — multi-step agentic task: add a rate limiter to an API, write unit tests, run the suite, read the failures, and fix them — a real tool-calling loop, not a single reply.

Task 1: Fixing a Broken Function From a Stack Trace

Mistral Large 3 correctly located the race condition on the first pass — the background job clearing the session dict before the request handler finished reading it — which is the same root cause Claude Sonnet 5 and DeepSeek V4 Pro both caught. Where it differed was the fix it proposed first: Large 3's initial diff wrapped the dictionary read in a try/except with a fallback value, which papers over the symptom instead of fixing the actual timing bug. It needed one direct follow-up ("that doesn't fix the race condition, it just hides it") before it produced the correct lock-based fix.

That's a real, if small, gap. DeepSeek V4 Pro rejected the lazy fix on its own in my earlier test; Large 3 needed to be told. It's consistent with what independent evaluations report about Large 3's reasoning-heavy benchmark performance — it's a strong generalist, but without a chain-of-thought mode, it doesn't second-guess its first plausible answer the way reasoning models do.

Task 2: Refactoring a Messy Module

On the Express handler, Large 3 produced clean, readable output — five well-named functions, consistent with the existing error-handling style, and no unnecessary abstraction. That matches the general reputation Large 3 has picked up in early hands-on reviews: it writes tidy, conventional code that's easy to review. It's the same bar Claude Sonnet 5 and DeepSeek V4 Pro both cleared in earlier tests.

It missed one thing both of those models caught: the confirmation email call needed to be async-safe so it didn't block the response, and Large 3 didn't flag or fix that on its own. When I pointed it out directly, it fixed it in one turn without complaint. Minor, but it's the same pattern as Task 1 — solid execution on the parts of the problem stated explicitly, less proactive about catching the parts that require inferring intent.

Task 3: A Multi-Step Agentic Task With Tool Use

This is where Large 3's native function-calling design actually paid off. It wrote the rate limiter, wrote a boundary-condition test for burst requests, called the test runner, read back the failure output, and fixed an off-by-one error in the limiter — all in one continuous loop, without me re-explaining the task between tool calls. Three sequential tool calls, zero dropped context, one clean fix.

That's the part of the "tool-native from launch" claim that held up under an actual test: the model didn't need reasoning mode to keep a multi-step tool-calling loop coherent. It just needed the function-calling contract to be solid, and it was.

It closed the loop in one follow-up prompt, on par with DeepSeek V4 Pro's showing in my earlier test and ahead of what I saw from Qwen3 Coder Plus and Gemini 3.1 Pro Preview in the original coding-assistant roundup. Tool use is genuinely a strength here, and it's the one task where Large 3's non-reasoning design wasn't a disadvantage at all.

Mistral Large 3 vs. DeepSeek V4 Pro and Kimi K3

Independent benchmarking tells a more sobering story than my three hands-on tasks alone. Artificial Analysis puts Mistral Large 3's composite Intelligence Index at 16, ranking it 24th of 44 open-weight models it tracks — squarely mid-pack, not frontier. Output speed comes in around 46.4 tokens per second, on the slower side for its price class. Mistral hasn't published SWE-bench Verified, LiveCodeBench, or Terminal-Bench scores for Large 3 the way DeepSeek has for V4 Pro, which makes a like-for-like coding-benchmark comparison harder than it should be for a model this size.

Model	Total / Active Params	Context	Reasoning	Output price ($/1M)	License
Mistral Large 3	675B / 41B	262K	None (non-reasoning)	$1.50	Apache 2.0
DeepSeek V4 Pro	1.6T / 49B	1M	Optional, "high"/"xhigh"	$0.87	Open (DeepSeek license)
Kimi K3	2.8T total	1M	Mandatory, locked to max	$15.00	Modified MIT

Read that table carefully and the honest conclusion is: Mistral Large 3 is not a strict upgrade over either DeepSeek V4 Pro or Kimi K3 on raw capability. It has less than a third of DeepSeek V4 Pro's context window, no reasoning mode at all, and DeepSeek V4 Pro actually costs less per output token despite outperforming Large 3 on my Task 1. Where Large 3 wins is licensing and deployment flexibility — Apache 2.0 with no restrictions is a cleaner story than DeepSeek's terms for some enterprise legal teams — and it genuinely held its own on the tool-calling task specifically.

The Devstral 2 Wrinkle Worth Knowing

Here's a detail that changes how you should actually use Large 3: it isn't Mistral's dedicated coding-agent model. That job belongs to Devstral 2, a separate 123-billion-parameter model Mistral shipped alongside a new terminal-native CLI called Mistral Vibe, purpose-built for autonomous codebase navigation and multi-file fixes.

"🏆 Mistral launched coding specialist model Devstral 2. It matches DeepSeek V3.2 on SWE Bench and human evals, yet uses 5x fewer parameters, needs significantly smaller GPUs, and delivers significantly lower per task cost." — Rohan Paul on X

What that means practically: if your workload is deep, autonomous software-engineering work across a large repository, Devstral 2 is the model Mistral actually built and tuned for it, and it's worth testing separately. Large 3 is the generalist — strong at multilingual chat, document work, and tool-calling glue — that happens to write decent code along the way. Treating it as a coding specialist sets expectations it wasn't designed to meet, which is part of why my Task 1 result came out the way it did.

How to Try Mistral Large 3 on Writingmate

Mistral Large 3 is live in the Writingmate model picker now. Open a new chat, search "Mistral Large 3" in the model dropdown, or go straight to the Mistral Large 3 model page.

The three tasks above are a starting point, not a verdict on your specific workload. Open the Mistral Large 3 vs. DeepSeek V4 Pro comparison page and run a real stack trace or a real messy file from your own backlog — that's a far better test than any demo prompt, and you can rerun it against whatever new model shows up next in the Writingmate models catalog.

If you're wiring Large 3 into an existing agent framework instead of testing it in chat, the OpenAI-compatible API docs cover pointing tools like OpenCode or a custom agent loop at it, using the same request format as any other model in the catalog.

Best Use Cases for Mistral Large 3

• Multi-step tool-calling loops where a stable function-calling contract matters more than chain-of-thought depth
• Teams that need Apache 2.0 licensing specifically — no usage restrictions, full self-hosting rights
• Multilingual and document-heavy work, where Large 3's generalist training shows up more than in narrow coding benchmarks
• Budget-conscious agent pipelines that don't need the full 1M-token context of DeepSeek V4 Pro or Kimi K3

Where I'd still reach for something else: deep, autonomous software-engineering work (try Devstral 2 or DeepSeek V4 Pro instead), anything needing more than 262K tokens of context, and any task where a model's ability to catch its own lazy first answer actually matters — Large 3's lack of a reasoning mode showed up exactly there in my testing.

Bottom Line on Mistral Large 3

Mistral Large 3 isn't the frontier-reasoning comeback some of the launch coverage implied, and the independent benchmarks back that up — a mid-pack Intelligence Index score and no published SWE-bench or LiveCodeBench numbers aren't nothing. But it's not nothing in the other direction either: the tool-calling loop in my Task 3 ran as cleanly as DeepSeek V4 Pro's, the license is the most permissive of any model I've tested this quarter, and the price is fair for what you get.

Call it a qualified return, not a full one. If your workflow leans on agentic tool use, multilingual generalist work, or a genuine need for Apache 2.0 licensing, Mistral Large 3 earns a real test against your own backlog. If you need deep coding reasoning or a debugging partner that catches its own mistakes without being told, DeepSeek V4 Pro still holds that spot — and if coding specifically is the job, Mistral's own Devstral 2 is a better match than Large 3 itself.

See you in the next one!

Artem