Qwen3 235B-A22B (local via Ollama) is the open-weights flagship mixture of experts, self-hosted. Because only 22B of the 235B parameters activate per token, it generates far faster than its size suggests, provided you can hold the whole thing in memory. Pricing is Free (self-hosted), and the model gives Atlas frontier-class reasoning with no per-token bill and no code leaving your network. The weights are roughly 140 GB at 4-bit, which a 192 GB Mac Studio or a multi-GPU server can hold. The memory floor is brutal: this is not a laptop model.
What is Qwen3 235B-A22B (local via Ollama) best at inside Atlas?
Qwen3 235B-A22B (local via Ollama) gives Atlas frontier-class reasoning with no per-token bill and no code leaving your network. It is the open-weights flagship mixture of experts, self-hosted, with 22B active parameters out of 235B total in 2026.
The pitch for Qwen3 235B-A22B (local via Ollama) is narrow and strong: it is the only way to run a genuinely frontier-class reasoning model on hardware you own. For a team whose source code cannot leave the network but whose problems still need real deliberation, that combination has no substitute. Atlas can build its code index with local Ollama embeddings, keeping code off third-party servers, so pairing the OllamaEmbedder with Qwen3 235B-A22B (local via Ollama) means both the vectors and the generation stay inside your perimeter. Atlas drafts a plan in a read-only plan agent and asks before switching to a build agent, and a reasoning flagship is exactly the model you want writing that plan.
Why does 22B active out of 235B total matter locally?
Qwen3 235B-A22B (local via Ollama) has 22B active parameters out of 235B total, which means generation speed closer to a 22B model once weights are resident. That sparsity is what makes a 235B parameter model tolerable to self-host at all.
A dense 235B model would be unusable on local hardware because every parameter would run on every token. Qwen3 235B-A22B (local via Ollama) routes each token through roughly 22B active parameters, so once the weights are resident in memory, generation speed tracks a 22B model rather than a 235B one. That is the property that makes the whole configuration viable. The catch is in the word resident: the sparsity buys you speed only after all 235B parameters are loaded, because the router can send any token to any expert. Sparsity reduces compute per token, not memory.
What hardware can hold Qwen3 235B-A22B locally?
Qwen3 235B-A22B (local via Ollama) is roughly 140 GB at 4-bit, which a 192 GB Mac Studio or a multi-GPU server can hold entirely in memory. Run `atlas device` first to confirm you have the unified memory or VRAM headroom before pulling roughly 140 GB.
Roughly 140 GB at 4-bit is the number that decides everything about Qwen3 235B-A22B (local via Ollama). A 192 GB Mac Studio holds it with headroom for a KV cache. A multi-GPU server holds it across cards. Nothing smaller holds it, which is why the documented Atlas setup tells you to run `atlas device` before you run `ollama pull qwen3:235b-a22b` rather than after. Checking headroom first saves you a 140 GB download that will not run. The pull command is `ollama pull qwen3:235b-a22b`, and you should expect roughly 140 GB on disk at the default quantization.
What does Qwen3 235B-A22B (local via Ollama) cost to run?
Qwen3 235B-A22B (local via Ollama) is Free (self-hosted). There is no per-token bill and no code leaving your network, so the entire cost is the machine that holds roughly 140 GB at 4-bit, which is a capital decision rather than a usage decision in 2026.
Free (self-hosted) reframes what an Atlas session costs. Once a 192 GB Mac Studio or a multi-GPU server is holding Qwen3 235B-A22B (local via Ollama), a long reasoning run over the whole repository costs nothing but time, so there is no reason to ration the plan agent. Atlas fans out work to subagents that can run in the foreground or in parallel background sessions, and locally those subagents are free too, though they contend for the same GPU. The trade is that you paid up front for the memory, and the hardware that holds roughly 140 GB of weights is not incidental spend.
What are the tradeoffs of self-hosting Qwen3 235B-A22B?
The memory floor is brutal: Qwen3 235B-A22B (local via Ollama) is not a laptop model, and partial offload to system RAM destroys throughput. Prompt processing on a large Atlas context is also slow even when generation is fast, which surprises people who only measured tokens per second.
Two failure modes define Qwen3 235B-A22B (local via Ollama). The first is partial offload. If roughly 140 GB of weights does not fit, Ollama spills to system RAM, and the sparsity advantage evaporates because the router still has to reach experts that are no longer in fast memory. Throughput collapses. The second is prompt processing. Generation may be fast once it starts, but chewing through a large Atlas context, the kind Atlas produces when hybrid semantic and keyword retrieval fused by reciprocal rank fusion fills the window, takes real time before the first token appears. Cap `"limit"` to a context you can actually fit, for example `{ "context": 65536, "output": 16384 }`, rather than assuming the native 128K tokens (131,072) is free.
When should I use a hosted model instead of local 235B-A22B?
Use a hosted model whenever you do not have 192 GB of memory. Qwen3 235B-A22B (local via Ollama) is roughly 140 GB at 4-bit and partial offload to system RAM destroys throughput, so a machine that cannot hold it entirely is not a candidate in 2026.
Atlas lets you switch the active model and provider on the fly with favorites and recents, so a team can register Qwen3 235B-A22B (local via Ollama) on the one machine that can hold it and use hosted tiers everywhere else. The decision rule is memory, not preference. If a 192 GB Mac Studio or a multi-GPU server is available and the code cannot leave the network, Qwen3 235B-A22B (local via Ollama) is the right answer despite slow prompt processing. If neither condition holds, the local flagship is not a compromise you can tune your way into, because partial offload destroys the throughput that made sparsity worth having.
Setup
- 01Run `atlas device` first to confirm you have the unified memory or VRAM headroom before pulling.
- 02Run `ollama pull qwen3:235b-a22b` and expect roughly 140 GB on disk at the default quantization.
- 03Add the ollama provider block to atlas.json and register `"qwen3:235b-a22b"` with a `"limit"` you can actually fit, for example `{ "context": 65536, "output": 16384 }`.
- 04Set `"model": "ollama/qwen3:235b-a22b"` in atlas.json.
- 05Verify the provider is live with `atlas models ollama`.
Frequently asked questions
- how much memory do i need to run qwen3 235b a22b locally
- Qwen3 235B-A22B is roughly 140 GB at 4-bit, so a 192 GB Mac Studio or a multi-GPU server can hold it entirely in memory. Run `atlas device` first to confirm headroom before pulling.
- how do i pull qwen3 235b a22b in ollama
- Run `ollama pull qwen3:235b-a22b` and expect roughly 140 GB on disk at the default quantization. Verify Atlas sees it with `atlas models ollama`.
- why is my local qwen3 235b a22b so slow
- Partial offload to system RAM destroys throughput, so the whole roughly 140 GB has to be resident. Prompt processing on a large Atlas context is also slow even when generation is fast.
- does moe sparsity reduce memory requirements
- No. Qwen3 235B-A22B has 22B active parameters out of 235B total, which reduces compute per token, not memory. All 235B parameters must be resident because the router can send any token to any expert.
- what context limit should i set for local qwen3 235b a22b
- Cap `"limit"` to a context you can actually fit, for example `{ "context": 65536, "output": 16384 }`. The native window is 128K tokens (131,072), but the KV cache competes with roughly 140 GB of weights.
- how much does it cost to self host qwen3 235b a22b
- Qwen3 235B-A22B (local via Ollama) is Free (self-hosted). There is no per-token bill. The cost is the hardware needed to hold roughly 140 GB at 4-bit.
- can i run a frontier reasoning model with no code leaving my network
- Yes. Qwen3 235B-A22B (local via Ollama) gives Atlas frontier-class reasoning with no per-token bill and no code leaving your network, and Atlas can build its code index with local Ollama embeddings too.
Try Atlas in your terminal
The terminal-native AI coding agent. Free core, single binary.
Install AtlasRelated guides
Atlas vs Amp: Terminal AI Coding Agents in 2026
Compare Atlas, a terminal-native AI coding agent with free core and local embeddings, against Amp, Sourcegraph's agent featuring Oracle and Orbs, for developers in 2026.
Atlas for Nim: A Terminal-Native AI Coding Agent for Nimble Packages and Macros in 2026
Atlas is a terminal-native AI coding agent for Nim in 2026. It reads .nimble requires and asterisk-exported symbols, adds std/unittest suites, runs nimble test, formats with nph.
Atlas vs Tabby: Terminal AI Coding Agents in 2026
Atlas and Tabby comparison for 2026. Atlas offers terminal-native TUI with permission-gated tools and diff review. Tabby provides self-hosted GPU completion and a cloud agent.
Atlas for Elixir in 2026
Adopt Atlas, the terminal-native AI coding agent, for Elixir development in 2026. Enhance productivity with deep code understanding, safety features, and direct integration into mix projects and OTP applications.
Atlas vs Greptile: Terminal AI Coding Agents in 2026
Comparing Atlas and Greptile in 2026. Atlas offers terminal-native AI coding with permission-gated tools. Greptile reviews code with sandbox execution, catching 20% more bugs.
Atlas for Gin in 2026
Atlas is a terminal-native AI coding agent for Gin in 2026. It reads router groups and binding tags, then runs go test ./... -race behind a permission prompt.
Atlas vs GitHub Copilot: Terminal AI Coding Agents in 2026
Comparing Atlas, the terminal-native AI coding agent, with GitHub Copilot's editor extension and chat features for developers in 2026. Explore planning, pricing, and privacy.
Atlas for FastAPI in 2026
Atlas is a terminal-native AI coding agent for FastAPI in 2026. It reads Pydantic v2 models and Depends(), then runs pytest behind a permission prompt.