Magistral Small (local via Ollama) is an open reasoning model you can run on one GPU, and inside Atlas it is the plan agent you use when the codebase is not allowed to touch a hosted API. Pricing is Free (self-hosted), so the reasoning tokens that make a reasoner expensive elsewhere cost nothing here. The context window is 128,000 tokens nominal, but Mistral recommends capping around 40,000 for stable output, and Ollama surfaces the model with a 39K window by default for exactly that reason.
What is Magistral Small (local via Ollama) best at inside Atlas?
Magistral Small (local via Ollama) is best at being the Atlas plan agent on a private codebase. The 14GB `magistral:24b` model produces its thinking trace locally, which is the only way to get chain-of-thought debugging on a repository that is not allowed to touch a hosted API.
Atlas drafts a plan in a read-only plan agent and asks before switching to a build agent, which is precisely the shape a reasoning model fits. The plan agent reads, thinks, and proposes; nothing is written until you approve the switch. Magistral Small (local via Ollama) at 14GB is one of the smallest genuinely open reasoning models, so a single GPU can host the thinking step. Pair the plan pass with a faster local model such as devstral for the build pass, and Atlas gives you a reasoner where reasoning pays and a quick model where speed pays.
Why cap Magistral Small at 40,000 tokens instead of 128,000?
Magistral Small (local via Ollama) advertises 128,000 tokens nominal, but Mistral recommends capping around 40,000 for stable output. Ollama surfaces the model with a 39K context window by default because quality degrades past roughly 40,000 tokens, an honest limit worth respecting rather than overriding.
The atlas.json consequence is concrete: do not configure limit.context to the nominal 128000 for Magistral Small (local via Ollama). Register `magistral:24b` with `"limit": { "context": 40000, "output": 8192 }` instead. Over-declaring the window does not buy you recall, it buys you unstable output at exactly the moment Atlas is holding a long chain of tool results and asking for a plan. Because Atlas indexes code by AST declarations using tree-sitter, not blind line windows, the retrieved context tends to be dense and relevant, which makes a 40,000 token budget more workable than the raw number suggests.
How much does reasoning cost with Magistral Small?
Reasoning costs $0 with Magistral Small (local via Ollama), because self-hosted thinking tokens are free. A hosted reasoning model bills every thinking token, while `magistral:24b` runs on your own GPU, so the only bill is electricity and the roughly 16GB of VRAM it needs to stay resident.
The cost shifts from dollars to wall-clock. Magistral Small (local via Ollama) reasoning is token-hungry, so on a mid-range GPU a hard bug can take minutes of local generation before Atlas even shows you a plan. That trade is often worth it: the alternative on a locked-down repository is no reasoning at all. Budget the time, run the plan pass in the background if you can, and remember that Atlas fans out work to subagents that can run in the foreground or in parallel background sessions, so a slow local reasoner does not have to block the terminal.
What hardware does magistral:24b need?
Magistral Small (local via Ollama) is a 14GB download at `ollama pull magistral:24b`, and it needs roughly 16GB of VRAM or unified memory to stay resident. Run `atlas device` first to confirm Ollama and a GPU are detected before committing to the pull.
Atlas reaches Magistral Small (local via Ollama) through a custom provider block in atlas.json registered with `@ai-sdk/openai-compatible` and baseURL `http://localhost:11434/v1`. The 14GB weight file is the floor, not the ceiling, of memory use: the KV cache for whatever window you declare sits on top. Capping limit.context at 40000 rather than 128000 is therefore doubly sensible, since it respects Mistral's own quality guidance and keeps the cache small enough to stay resident on a 16GB card. Confirm the model resolved with `atlas models ollama` before starting a session.
When should you pick a different model than Magistral Small local?
Pick something other than Magistral Small (local via Ollama) when speed matters more than reasoning depth. The `magistral:24b` reasoner is token-hungry, and on a mid-range GPU a hard bug can take minutes of local generation, which is the wrong trade for a routine edit or a rename.
Atlas lets you switch the active model and provider on the fly with favorites and recents, so the right configuration is usually two models, not one. Point `"model"` at ollama/magistral:24b when planning a genuinely hard problem, then move to a faster local model such as devstral for the build pass, where Atlas computes a unified diff for every file edit and surfaces it for approval before writing. If your repository can touch a hosted API at all, a hosted reasoner will be faster than Magistral Small (local via Ollama) on the same problem. The local reasoner exists for the repositories that cannot.
Does Magistral Small keep code fully off third-party servers?
Yes, when configured completely. Magistral Small (local via Ollama) runs `magistral:24b` on your own GPU through baseURL http://localhost:11434/v1, and Atlas can build its code index with local Ollama embeddings, so both the reasoning traces and the semantic index stay on localhost.
The privacy claim only holds if the embedder is local too. Atlas searches code with hybrid semantic and keyword retrieval fused by reciprocal rank fusion, and building that index means embedding your source. A hosted embedder would leak the repository even while Magistral Small (local via Ollama) reasons privately on your own hardware. Set the ollama provider in atlas.json with baseURL `http://localhost:11434/v1`, point the index at the local embedder, and confirm with `atlas models ollama`. Every Atlas tool call is still permission-gated against allow, ask, and deny rules before it runs, which is unchanged by going local.
Setup
- 01Run `ollama pull magistral:24b` (14GB, needs roughly 16GB of VRAM or unified memory to stay resident).
- 02Check `atlas device` to confirm Ollama and a GPU are detected.
- 03In atlas.json, register the ollama provider with `@ai-sdk/openai-compatible` and baseURL `http://localhost:11434/v1`, adding `magistral:24b` with `"limit": { "context": 40000, "output": 8192 }`.
- 04Point `"model"` at ollama/magistral:24b for planning and keep a faster local model such as devstral for the build pass.
- 05Run `atlas models ollama` to confirm the model resolved before starting a session.
Frequently asked questions
- how do i run magistral small locally with atlas
- Run `ollama pull magistral:24b` (14GB), check `atlas device`, register the ollama provider in atlas.json with `@ai-sdk/openai-compatible` and baseURL `http://localhost:11434/v1`, then point `"model"` at ollama/magistral:24b.
- what context window should i set for magistral small in atlas
- Set `"limit": { "context": 40000, "output": 8192 }`. The nominal window is 128,000 tokens, but Mistral recommends capping around 40,000 for stable output, and Ollama defaults the model to a 39K window.
- how much vram does magistral:24b need
- Magistral Small (local via Ollama) is a 14GB download and needs roughly 16GB of VRAM or unified memory to stay resident. Run `atlas device` to confirm Ollama and a GPU are detected first.
- can i use a local reasoning model as the atlas plan agent
- Yes. Atlas drafts a plan in a read-only plan agent and asks before switching to a build agent, so point `"model"` at ollama/magistral:24b for planning and keep a faster local model such as devstral for the build pass.
- how much do reasoning tokens cost with magistral small
- Nothing. Magistral Small (local via Ollama) is Free (self-hosted), so reasoning tokens cost only GPU time, which removes the main cost objection to running a reasoner as the plan agent.
- why is magistral small slow on my gpu
- Magistral Small (local via Ollama) reasoning is token-hungry, so on a mid-range GPU a hard bug can take minutes of local generation. Run the plan pass as a background subagent in Atlas rather than blocking the terminal.
- does magistral small keep my code off third-party servers
- Yes, if you also use the local embedder. Magistral Small (local via Ollama) reasons on your GPU, and Atlas can build its code index with local Ollama embeddings, so neither the prompts nor the index leave the machine.
Try Atlas in your terminal
The terminal-native AI coding agent. Free core, single binary.
Install AtlasRelated guides
Atlas for Haskell in 2026
Atlas is a terminal-native AI coding agent for Haskell in 2026. Run it in a project with a .cabal file or a stack.yaml, let cabal build drive it, and review the diff.
Atlas for Express in 2026
Atlas is a terminal-native AI coding agent for Express in 2026. It reads your middleware order, wraps async route handlers, and runs mocha behind a prompt.
Atlas vs Amazon Q Developer: Terminal AI Coding Agents in 2026
Comparing Atlas and Amazon Q Developer in 2026. Atlas offers terminal-native AI with permission-gated tools and local code indexing. Amazon Q Developer excels in AWS services, providing Java upgrades and security
Atlas for Node.js in 2026
Node.js developers in 2026 can adopt Atlas, the terminal-native AI coding agent, for secure, efficient development. Leverage local embeddings, AST indexing, and robust safety features.
Migrate a Deprecated API Across Every Callsite with Atlas (2026 Workflow)
How to migrate a deprecated API across every callsite with Atlas in 2026: the lsp tool's findReferences enumerates callers, todowrite tracks them, apply_patch migrates each one.
Atlas for Phoenix in 2026
Atlas is a terminal-native AI coding agent for Phoenix in 2026. It reads contexts, LiveView modules, and Ecto changesets, then runs mix test behind a prompt.
Atlas for Astro: Islands, Content Collections, and Zero JS by Default in 2026
Atlas is a terminal-native AI coding agent for Astro in 2026. It reads astro.config.mjs, src/pages, and content collection schemas, drops needless client:load directives, and runs astro check.
Atlas for C++ in 2026
In 2026, C++ developers adopt Atlas, the terminal-native AI coding agent, to enhance productivity. Atlas offers secure, context-aware assistance for modern C++ projects, integrating with CMake and ensuring code quality