Qwen3 8B (local via Ollama) is the easiest fully local Atlas setup that still gives you a thinking model. It pulls in around 5 GB and runs on a laptop GPU, which makes it the default choice for offline flights and air-gapped client work. Pricing is Free (self-hosted). The native window is 128K tokens (131,072), but you set limit.context to 32768 locally because a 131,072 token KV cache will not fit on a laptop. Qwen3 8B is small enough that it will misread ambiguous tool schemas, so keep Atlas permissions on ask rather than allow.
What is Qwen3 8B (local via Ollama) best at inside Atlas?
Qwen3 8B (local via Ollama) is the easiest fully local Atlas setup that still gives you a thinking model in 2026. At roughly 5.2 GB at Q4_K_M it runs on an 8 GB RTX 3060 or a 16 GB MacBook Air, which makes it the default for offline flights and air-gapped client work.
Most local models small enough for a laptop cannot reason at all. Qwen3 8B (local via Ollama) is the exception: hybrid thinking mode is preserved in the open weights, so the checkpoint you pull with `ollama pull qwen3:8b` is the same thinking-capable model, not a stripped variant. That combination, a 5.2 GB download and a real chain-of-thought, is why it is the default answer for developers who want Atlas working on a plane or inside a client network with no egress. Atlas can build its code index with local Ollama embeddings, keeping code off third-party servers, so combining Qwen3 8B (local via Ollama) with the OllamaEmbedder gives you a codebase index that never touches a cloud provider.
What hardware runs Qwen3 8B on Ollama?
Qwen3 8B (local via Ollama) is roughly a 5.2 GB download at Q4_K_M, so it runs on an 8 GB RTX 3060 or a 16 GB MacBook Air. Run `ollama pull qwen3:8b` (about 5.2 GB) and verify with `ollama list`, then run `atlas device` to confirm Ollama is detected and a GPU is present.
The hardware bar for Qwen3 8B (local via Ollama) is low enough that most developer laptops already clear it. An 8 GB RTX 3060 holds the weights with room for a modest KV cache, and a 16 GB MacBook Air runs it on unified memory without a discrete card. The verification sequence matters: `ollama pull qwen3:8b` first, then `ollama list` to confirm the tag is actually present, then `atlas device` so Atlas reports whether it detected Ollama and a GPU. Skipping `atlas device` is how people end up running an 8B model on CPU and concluding that local Atlas is unusable, when the fix was a driver.
What does Qwen3 8B (local via Ollama) cost?
Qwen3 8B (local via Ollama) is Free (self-hosted). There is no per-token bill at all, and unlike larger local checkpoints, the hardware cost is close to zero too, because roughly 5.2 GB at Q4_K_M fits on a laptop you already own in 2026.
Free (self-hosted) is the headline, but the more interesting property of Qwen3 8B (local via Ollama) is that it is the only local Atlas configuration where the hardware is also already paid for. A 72B local model demands a Mac Studio or multiple cards. Qwen3 8B (local via Ollama) demands a laptop. That means the offline path is available to a developer on a plane without a procurement conversation. Set both `"model"` and `"small_model"` to `"ollama/qwen3:8b"` for a fully offline session, and every Atlas turn, including the titles and summaries Atlas normally routes to the small model slot, stays on the machine and costs nothing.
Why set limit.context to 32768 for local Qwen3 8B?
Qwen3 8B (local via Ollama) has a native 128K token (131,072) window, but you set limit.context to 32768 locally. A 131,072 token KV cache will not fit on a laptop, so you will realistically run at 32K, and Atlas needs to know that before it packs a prompt.
Registering `"qwen3:8b"` with `"limit": { "context": 32768, "output": 8192 }` in the atlas.json provider models map is not a downgrade you are choosing, it is the honest number for the hardware. On an 8 GB RTX 3060 or a 16 GB MacBook Air, the memory left over after the roughly 5.2 GB of weights is what caps your key-value cache, and a full 131,072 token cache is far past it. Telling Atlas the truth about the limit is what keeps the agent from packing a prompt the model cannot hold. Atlas indexes code by AST declarations using tree-sitter, not blind line windows, which helps here: 32K tokens of whole declarations carries more useful signal than 32K tokens of arbitrary slices.
Why keep Atlas permissions on ask with Qwen3 8B?
Qwen3 8B (local via Ollama) is small enough that it will misread ambiguous tool schemas, so keep permissions on ask rather than allow. Every Atlas tool call is permission-gated against allow, ask, and deny rules before it runs, which is the mechanism that contains an 8B misread in 2026.
A misread tool schema is the characteristic failure of an 8B model driving an agent. Qwen3 8B (local via Ollama) will occasionally fill an argument with something plausible but wrong, and if the bash tool is set to allow, that wrong argument executes. Setting the gate to ask turns the same mistake into a prompt you decline. Atlas also computes a unified diff for every file edit and surfaces it for approval before writing, and Atlas snapshots file changes as git patches so edits can be diffed and rolled back, so even a write that slips through is recoverable. The rule of thumb for Qwen3 8B (local via Ollama): the smaller the model, the more of the safety you should be getting from the permission system rather than from the model's judgment.
When should I pick a different model than local Qwen3 8B?
Pick a different model when the task needs more than 8B of reasoning or more than 32K of usable context. Qwen3 8B (local via Ollama) will misread ambiguous tool schemas, and a 131,072 token KV cache will not fit on a laptop, so hard multi-file work belongs on a bigger tier.
Atlas lets you switch the active model and provider on the fly with favorites and recents, so the sensible pattern is to keep Qwen3 8B (local via Ollama) as the offline profile and switch to a larger model when you are back on a network and the task is genuinely hard. The two triggers are concrete. If Atlas keeps surfacing tool calls with malformed arguments, the 8B is the problem. If the retrieved context keeps getting truncated at your 32768 limit, the laptop is the problem. Neither is a reason to abandon the local setup, because the value of Qwen3 8B (local via Ollama) is that it works when nothing else can: on a plane, or inside a client network with no egress.
Setup
- 01Run `ollama pull qwen3:8b` (about 5.2 GB) and verify with `ollama list`.
- 02Add the ollama provider block in atlas.json: `"npm": "@ai-sdk/openai-compatible"`, `"baseURL": "http://localhost:11434/v1"`.
- 03Register `"qwen3:8b"` with `"limit": { "context": 32768, "output": 8192 }` in the provider models map.
- 04Set both `"model"` and `"small_model"` to `"ollama/qwen3:8b"` for a fully offline session.
- 05Run `atlas device` to confirm Ollama is detected and a GPU is present.
- 06Keep permissions on ask rather than allow, because an 8B model will misread ambiguous tool schemas.
Frequently asked questions
- how do i run qwen3 8b locally with atlas
- Run `ollama pull qwen3:8b` (about 5.2 GB), verify with `ollama list`, add the ollama provider block to atlas.json with `"baseURL": "http://localhost:11434/v1"`, register `"qwen3:8b"` with a 32768 context limit, and set `"model"` and `"small_model"` to `"ollama/qwen3:8b"`.
- can i run a coding agent offline on a laptop
- Yes. Qwen3 8B (local via Ollama) is roughly 5.2 GB at Q4_K_M and runs on an 8 GB RTX 3060 or a 16 GB MacBook Air, which makes it the default Atlas choice for offline flights and air-gapped client work.
- does local qwen3 8b still have thinking mode
- Yes. Hybrid thinking mode is preserved in the open weights of Qwen3 8B, unlike most 8B local models which cannot reason at all.
- why should i set limit.context to 32768 for qwen3 8b
- A 131,072 token KV cache will not fit on a laptop, so you will realistically run at 32K. Register `"qwen3:8b"` with `"limit": { "context": 32768, "output": 8192 }` so Atlas packs prompts the model can actually hold.
- how much does qwen3 8b local cost
- Qwen3 8B (local via Ollama) is Free (self-hosted). There is no per-token bill, and the roughly 5.2 GB download fits on hardware most developers already own.
- is an 8b model safe to let run tools automatically
- No. Qwen3 8B is small enough that it will misread ambiguous tool schemas, so keep Atlas permissions on ask rather than allow. Every Atlas tool call is permission-gated against allow, ask, and deny rules before it runs.
- how do i check that atlas sees my gpu and ollama
- Run `atlas device` to confirm Ollama is detected and a GPU is present. Skipping that check is how a local Qwen3 8B session ends up running on CPU.
Try Atlas in your terminal
The terminal-native AI coding agent. Free core, single binary.
Install AtlasRelated guides
Audit a Repo with Parallel Subagents in Atlas (2026 Workflow)
How to audit a repo with parallel subagents in Atlas in 2026: the task tool launches explore subagents in their own sessions, so only conclusions return to your context.
Atlas for R: A Terminal-Native AI Coding Agent for tidyverse, roxygen2, and testthat in 2026
Atlas is a terminal-native AI coding agent for R in 2026. It reads roxygen2 docblocks and renv.lock, rewrites loops as dplyr or purrr pipelines, and runs devtools::test().
Atlas vs Jules: Terminal AI Coding Agents in 2026
Atlas and Jules comparison for 2026. Atlas offers terminal-native TUI and local code indexing. Jules provides cloud VMs and a Critic agent for PR review.
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 vs JetBrains Junie in 2026: Terminal Agent vs IDE Debugger-Driving Agent
Atlas vs JetBrains Junie in 2026: Junie drives the IDE debugger and reports 61.6% resolved on SWE-Rebench, bundled from $10/mo. Atlas is a free, open source terminal agent with permission gates.
Atlas for Three.js: Terminal-Native AI Coding for Scenes, Materials, and Disposal in 2026
Atlas is a terminal-native AI coding agent for Three.js in 2026, where geometry, material, and texture disposal is the difference between a demo and a leak.
Diagnose a Hanging or Long-Running Command with Atlas in 2026
How to diagnose a hanging command with Atlas in 2026: the bash tool races every command against a timeout and tells you whether it is slow or blocked on input.
Atlas for Godot: Terminal-Native AI Coding for GDScript and the Node Tree in 2026
Atlas is a terminal-native AI coding agent for Godot in 2026, working across GDScript, the node tree, and signals, where scene structure is half the program.