Nemotron 70B (Ollama) is NVIDIA's Llama-3.1-Nemotron-70B-Instruct, 43GB, tuned with reward modeling to follow instructions precisely rather than to be agreeable. Inside Atlas the pricing is Free (self-hosted) and the context window is 128K tokens (131,072). That distinction between precise and agreeable matters in an agent loop, where a model that quietly reinterprets your instruction is worse than one that refuses it. Nemotron 70B needs roughly 45GB to serve, which is workstation hardware, not a laptop, and only one size ships, so there is no tag confusion.
What makes Nemotron 70B (Ollama) different from Llama 3.1 70B?
Nemotron 70B (Ollama) is RLHF tuned by NVIDIA specifically for instruction adherence and helpfulness, on top of the Llama 3.1 70B base. The 43GB model follows instructions precisely rather than being agreeable, which is a different objective from the base weights it started as.
Agreeableness is a liability in an agent loop. A model that quietly reinterprets your instruction, deciding that what you asked for was probably not what you meant, produces plausible diffs that solve the wrong problem, and you find out three files later. Nemotron 70B is tuned in the other direction: NVIDIA used reward modeling to push the model toward doing what was asked. Inside Atlas that shows up as fewer surprises between the plan and the patch, which is worth real money on a large repository. Atlas drafts a plan in a read-only plan agent and asks before switching to a build agent, and a model that honors the plan it just wrote makes that seam do its job.
What hardware does Nemotron 70B need to run with Atlas?
Nemotron 70B (Ollama) needs roughly 45GB of free VRAM or unified memory to serve 43GB of weights, which is workstation hardware, not a laptop. A 48GB card or a 64GB unified-memory machine runs a 70B-class model with a 128K token (131,072) window.
The hardware conversation for Nemotron 70B is refreshingly simple because only one size ships, so there is no tag confusion: the 70b tag is the model. Pull it with ollama pull nemotron:70b (43GB, aliased to :latest and the only size published), and confirm roughly 45GB of free VRAM or unified memory with atlas device before serving. Then add nemotron:70b to the ollama models map in atlas.json with limit.context 131072 and limit.output 8192. One further step matters at this size: set small_model to a 3B tag so cheap Atlas calls do not evict 43GB of weights. Atlas generates titles, summaries, and subagent calls constantly, and each one that reloads Nemotron 70B is a stall you did not need.
How much does it cost to run a 70B model with Atlas?
Nemotron 70B (Ollama) is Free (self-hosted). A 70B-class model with a 128K token (131,072) window that costs nothing per token is the whole argument, and the price is paid once, in hardware: roughly 45GB of VRAM or unified memory.
Running a 70B through a hosted provider on an Atlas agent loop is where token bills get serious, because Atlas re-prompts every turn with retrieved code, unified diffs, and tool results. Nemotron 70B removes the meter entirely at Free (self-hosted) pricing. Keep the codebase index on Ollama embeddings so a model chosen for strict instruction adherence is also fed by a retrieval path you fully control. Atlas can build its code index with local Ollama embeddings, keeping code off third-party servers, so the combination is a 70B-class agent with a long window, a zero marginal cost, and no source code leaving the workstation.
When should you pick a different model than Nemotron 70B?
Pick a different model than Nemotron 70B (Ollama) when raw diff quality per gigabyte is the goal. Nemotron 70B is a general instruct model, and a 32B code specialist will often beat it on raw diff quality for a third of the memory, which is a hard fact to argue with.
Forty-three gigabytes is a lot of memory to commit, and Nemotron 70B does not spend it on code specialization. If the work is straightforward patch generation on a familiar codebase, a 32B coder is faster, lighter, and often better at exactly that. Nemotron 70B earns its footprint when the instruction itself is complex, when the cost of a model quietly doing something adjacent to what you asked is high, or when you want a single strong general model rather than a stack of specialists. Atlas lets you switch the active model and provider on the fly with favorites and recents, so running nemotron:70b alongside a 32B coder and cycling between them is the pragmatic setup on a machine that can hold both.
Does a stricter model make an Atlas agent safer to run?
Nemotron 70B (Ollama) reduces one failure mode, instruction drift, but Atlas safety does not depend on the model. Every Atlas tool call is permission-gated against allow, ask, and deny rules before it runs, regardless of whether the model in the slot is 43GB or 2GB.
Instruction adherence and permissioning solve different problems and you want both. Nemotron 70B, tuned with reward modeling to follow instructions precisely, makes it less likely that a correctly-permitted action is the wrong action. The Atlas permission layer makes it impossible for an action to run at all without matching your allow, ask, and deny rules. On top of that, Atlas 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. A stricter model shortens the review, the structure is what makes review possible.
Setup
- 01Pull it: ollama pull nemotron:70b (43GB, aliased to :latest and the only size published)
- 02Confirm roughly 45GB of free VRAM or unified memory with atlas device before serving
- 03Add nemotron:70b to the ollama models map in atlas.json with limit.context 131072 and limit.output 8192
- 04Set model to ollama/nemotron:70b and small_model to a 3B tag so cheap Atlas calls do not evict 43GB of weights
- 05Keep the codebase index on Ollama embeddings so a model chosen for strict instruction adherence is also fed by a retrieval path you fully control
Frequently asked questions
- how much VRAM does nemotron 70b need
- Roughly 45GB of free VRAM or unified memory to serve 43GB of weights, which means a 48GB card or a 64GB unified-memory machine. Confirm with atlas device before serving.
- what is nemotron 70b based on
- Nemotron 70B is NVIDIA's Llama-3.1-Nemotron-70B-Instruct, RLHF tuned by NVIDIA specifically for instruction adherence and helpfulness on top of the Llama 3.1 70B base.
- is nemotron 70b free
- Yes, Nemotron 70B on Ollama is Free (self-hosted). The cost is hardware: a 43GB pull and roughly 45GB of VRAM or unified memory to serve it.
- which nemotron tag should I pull
- There is only one. Run ollama pull nemotron:70b (43GB, aliased to :latest and the only size published), so there is no tag confusion.
- nemotron 70b vs a 32b code model
- Nemotron 70B is a general instruct model, and a 32B code specialist will often beat it on raw diff quality for a third of the memory. Choose Nemotron 70B for instruction adherence, not for patch quality per gigabyte.
- why set a separate small_model when running a 70b
- Set small_model to a 3B tag so cheap Atlas calls do not evict 43GB of weights. Atlas generates titles, summaries, and subagent calls constantly, and each reload of Nemotron 70B is a stall.
- what context window does nemotron 70b support
- 128K tokens (131,072). Add nemotron:70b to the ollama models map in atlas.json with limit.context 131072 and limit.output 8192.
Try Atlas in your terminal
The terminal-native AI coding agent. Free core, single binary.
Install AtlasRelated guides
Atlas vs Blackbox AI: Choosing Your AI Coding Agent in 2026
Comparing Atlas, the terminal-native AI coding agent, with Blackbox AI, a VS Code agent with 4.7 million installs, for developers in 2026. Evaluate features, pricing, and workflow.
Atlas vs GitHub Copilot CLI: A Developer's Guide for 2026
Comparing Atlas and GitHub Copilot CLI for developers in 2026. Explore pricing, privacy, agentic workflows, and extensibility to choose the best terminal AI coding agent.
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 vs Trae: AI Coding Agents in 2026
Atlas and Trae offer distinct AI coding agent experiences in 2026. Atlas provides terminal-native control and local data privacy, while Trae offers a full IDE with SOLO Builder and cloud tasks.
Atlas for React Native: Terminal-Native AI Coding Across the Native Boundary in 2026
Atlas is a terminal-native AI coding agent for React Native in 2026. Work across the New Architecture, native modules, and platform-specific files with diff-first review.
Atlas for Groovy: A Terminal-Native AI Coding Agent for Gradle, Spock, and Jenkins in 2026
Atlas is a terminal-native AI coding agent for Groovy in 2026. It reads build.gradle closures and Jenkinsfiles, writes Spock specs, runs ./gradlew test, and applies Spotless.
Atlas vs Sourcery: Terminal AI Coding Agents in 2026
Compare Atlas and Sourcery for 2026. Atlas offers terminal-native AI coding with permission-gated tools and local embeddings. Sourcery provides Python-first LLM review and rules-based refactoring, starting at
Atlas for Svelte in 2026
Adopt Atlas, the terminal-native AI coding agent, for Svelte and SvelteKit projects in 2026. Enhance development with intelligent code search, secure local embeddings, and guided code generation.