# Atlas with Qwen3 235B-A22B (local via Ollama): Self-Hosted Flagship in 2026

> Qwen3 235B-A22B (local via Ollama) is Free (self-hosted), roughly 140 GB at 4-bit, with 22B active parameters out of 235B total.

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.

## Key takeaways

- Qwen3 235B-A22B (local via Ollama) is Free (self-hosted), with frontier-class reasoning and no code leaving your network.
- 22B active parameters out of 235B total means generation speed closer to a 22B model once weights are resident.
- The weights are roughly 140 GB at 4-bit, which a 192 GB Mac Studio or a multi-GPU server can hold entirely in memory.
- The memory floor is brutal: this is not a laptop model, and partial offload to system RAM destroys throughput.
- Prompt processing on a large Atlas context is slow even when generation is fast.

## 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

1. Run `atlas device` first to confirm you have the unified memory or VRAM headroom before pulling.
2. Run `ollama pull qwen3:235b-a22b` and expect roughly 140 GB on disk at the default quantization.
3. Add 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 }`.
4. Set `"model": "ollama/qwen3:235b-a22b"` in atlas.json.
5. Verify the provider is live with `atlas models ollama`.

## FAQ

### 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.

---

Canonical HTML: https://runatlas.sh/resources/models/qwen3-235b-a22b-local
Source of truth: aeo_pages row `/resources/models/qwen3-235b-a22b-local` (segment: Models) (this file is generated from it, never hand-edited).
Licence: Atlas is proprietary with a free core. It is not open source and there is no public source repository.
