Command A is Cohere's March 2025 flagship, and inside Atlas it is the model you pick when you need to read a lot of code and write a little. It pairs a 256,000 token context with a deliberately modest 8,000 token output cap and a non-reasoning path, priced at $2.5 per Mtok input and $10 per Mtok output. That shape suits enterprises that want a large read window and predictable, short answers, and it is why Command A pairs so well with Atlas's plan agent, which decomposes the hard problems Command A will not reason through on its own.
What is Command A best at inside Atlas?
Command A is best at wide reads inside Atlas. Its 256,000 token context is 2x the 128,000 of Command R and Command R+, which means Atlas can load a large slice of a repository before it proposes a single edit. Cohere shipped Command A in March 2025.
Atlas searches code with hybrid semantic and keyword retrieval fused by reciprocal rank fusion, and it indexes code by AST declarations using tree-sitter, not blind line windows. Both of those produce a lot of retrieved context, and Command A's 256,000 token window absorbs it without forcing Atlas to drop candidate chunks. In practice that means a Command A session can hold an entire feature directory, its tests, and the surrounding call sites at once. Command A runs a non-reasoning path, so there are no hidden thinking tokens billed at the $10 per Mtok output rate. Every dollar of output you pay for is a token you can actually read in the terminal. Where Command A needs help is decomposition, and that is where Atlas's plan agent earns its keep: Atlas drafts a plan in a read-only plan agent and asks before switching to a build agent, so Command A gets a structured task list instead of an open-ended prompt.
How much does Command A cost to run Atlas?
Command A costs $2.5 per Mtok input and $10 per Mtok output in 2026. Filling the full 256,000 token context once costs about $0.64 in input alone, so Command A rewards teams who let Atlas retrieve precisely rather than dumping the whole tree into every turn.
Cost control on Command A comes down to input discipline. Because Atlas indexes code by AST declarations using tree-sitter rather than blind line windows, the retrieved chunks are whole functions and whole types, not ragged fragments, which keeps the token bill honest. On the output side, the $10 per Mtok rate is the flagship tier, but Command A's non-reasoning path means you are never charged for invisible chain-of-thought. Compare that against a reasoning model where a large share of billed output never reaches your screen. If you want to reduce spend further, put a cheaper Cohere id in the small_model slot so Atlas's titles, summaries, and background subagent calls do not run at $2.5 per Mtok, and keep Command A for the main loop where the 256,000 token window pays for itself.
Why is the 8,000 token output cap the real Command A constraint?
The 8,000 token output ceiling is Command A's sharpest limit for a coding agent. 8,000 tokens is roughly a few hundred lines of generated code, so a large refactor across many files must be split across turns. Atlas's setup guidance is explicit about this.
Atlas's documented advice for Command A is direct: because output is capped at 8,000 tokens, ask Atlas for one file at a time on large changes. That works well because Atlas computes a unified diff for every file edit and surfaces it for approval before writing, so a file-by-file cadence is already the natural review rhythm. Atlas also snapshots file changes as git patches so edits can be diffed and rolled back, which means a multi-turn refactor under an 8,000 token ceiling is recoverable turn by turn rather than all-or-nothing. If you routinely blow through 8,000 tokens of generation in one request, Command A is the wrong tool and you should move to a model with a larger generation budget.
Can Command A run on a private VPC or on-prem for Atlas?
Yes. Cohere is one of the few frontier vendors that will license the same model for private VPC and on-prem deployment, so Atlas can point at an internal endpoint instead of a public API. That makes Command A a realistic pick for regulated teams in 2026.
Command A's private deployment story stacks with the parts of Atlas that already keep code close to home. Atlas can build its code index with local Ollama embeddings, keeping code off third-party servers, so an organization can pair a locally embedded index with a Command A endpoint inside its own VPC. Every Atlas tool call is permission-gated against allow, ask, and deny rules before it runs, which gives the security team a second lever independent of the model. For teams whose blocker on agentic coding is data residency rather than raw capability, the combination of Cohere's licensable weights and Atlas's local index and permission gate is the practical way forward, and Command A is the checkpoint at the top of that family.
When should you pick a different model than Command A?
Pick a different model than Command A when you need reasoning or big generations. Command A has no reasoning mode and an 8,000 token output ceiling, so hard multi step debugging and single-turn multi file refactors both go better elsewhere. Atlas lets you switch models on the fly.
Concretely: if your task is a hard algorithmic bug, Command A leans on Atlas's plan agent to decompose the problem, and a reasoning checkpoint would simply do more of that work itself. If your task is emitting a large generated diff in one shot, Command A's 8,000 token cap is the wall you will hit. If your task is cheap, high-volume background work like title generation, Command A's $2.5 per Mtok input is overkill and a cheaper Cohere id belongs in the small_model slot instead. Atlas lets you switch the active model and provider on the fly with favorites and recents, so keeping Command A pinned as the wide-read model and something else for reasoning is a one-keystroke arrangement, not a config rewrite.
Setup
- 01Create a key in the Cohere dashboard and export it as COHERE_API_KEY.
- 02Or run `atlas login`, choose Cohere, and store the key in Atlas's credential store.
- 03Run `atlas models cohere` to confirm command-a-03-2025 resolved from the registry.
- 04Pin "model": "cohere/command-a-03-2025" in atlas.json.
- 05Because output is capped at 8,000 tokens, ask Atlas for one file at a time on large changes.
- 06Use Atlas's unified diff approval on each file edit so the multi-turn refactor stays reviewable.
Frequently asked questions
- how much does Command A cost per million tokens
- Command A costs $2.5 per Mtok input and $10 per Mtok output. Because Command A runs a non-reasoning path, there are no hidden thinking tokens billed at the $10 output rate.
- what is the Command A context window
- Command A has a 256,000 token context window, which is 2x the 128,000 token window of Command R and Command R+. Its output, however, is capped at 8,000 tokens.
- how do I use Command A in Atlas
- Export COHERE_API_KEY or run `atlas login` and choose Cohere, run `atlas models cohere` to confirm command-a-03-2025 resolved, then pin "model": "cohere/command-a-03-2025" in atlas.json.
- is Command A good for large refactors
- Command A reads large refactors well thanks to its 256,000 token context, but its 8,000 token output ceiling means it cannot emit one in a single turn. Ask Atlas for one file at a time.
- does Command A support reasoning mode
- No. Command A uses a non-reasoning path. Inside Atlas that means it depends on the read-only plan agent to decompose hard problems before the build agent starts editing.
- can I run Command A on-prem with a coding agent
- Yes. Cohere is one of the few frontier vendors that will license the same model for private VPC and on-prem deployment, so Atlas can point at an internal Command A endpoint.
- Command A vs Command R+ for coding
- Command A and Command R+ share the same $2.5 per Mtok input and $10 per Mtok output pricing, but Command A doubles the context to 256,000 tokens versus 128,000 for Command R+.
Try Atlas in your terminal
The terminal-native AI coding agent. Free core, single binary.
Install AtlasRelated guides
Atlas for WebAssembly: Terminal-Native AI Coding in 2026
Atlas is a terminal-native AI coding agent for WebAssembly. Audit wasm-bindgen exports, batch calls across the JS boundary, and run wasm-pack test --node in 2026.
Atlas for Symfony in 2026
Atlas is a terminal-native AI coding agent for Symfony in 2026. It reads autowired services and Doctrine mappings, and shows migration SQL before anything runs.
Atlas vs Ellipsis: Terminal AI Coding Agents in 2026
Compare Atlas, a terminal-native AI coding agent with free core and local embeddings, against Ellipsis, a cloud platform with usage-based pricing and live session tracing for 2026.
Atlas vs OpenAI Codex CLI: Terminal AI Coding Agents in 2026
Comparing Atlas and OpenAI Codex CLI for terminal AI coding in 2026. Atlas offers a TUI, permission-gated tools, and BYO models, while OpenAI Codex CLI provides sandboxed execution and OpenAI model integration.
Plan a Multi-File Change Before Editing with Atlas in 2026
How to plan a multi-file change with Atlas in 2026: the plan agent denies all edit tools, you research with codebase_search and lsp, then plan_exit hands off.
Atlas for Expo: Terminal-Native AI Coding for expo-router and Config Plugins in 2026
Atlas is a terminal-native AI coding agent for Expo apps in 2026, covering expo-router file routes, config plugins, and EAS build profiles with diff-first review.
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.
Atlas for Dart in 2026
Adopt Atlas, the terminal-native AI coding agent, for Dart development in 2026. Enhance productivity with intelligent code search, refactoring, and robust safety features across your Dart projects.