What is the primary advantage of Groq (gateway) for Atlas?

The primary advantage of Groq (gateway) for Atlas in 2026 is its LPU inference, which provides token throughput far beyond GPU serving. This makes the Atlas agent loop feel instant, significantly improving developer interaction speed.

What models are available through Groq (gateway) for Atlas?

Groq (gateway) serves open models for Atlas, including GPT-OSS 120B, GPT-OSS 20B, and Llama 3.1 8B. It does not offer proprietary models like Claude, GPT-5, or Gemini.

What is the context window size for Groq (gateway) models?

Groq (gateway) models offer a consistent context window of 131K tokens (131,072) across most of its catalog. This is a robust size for many Atlas tasks, though it is less than the 1M token windows available from some other providers.

How much does it cost to use GPT-OSS 120B with Atlas via Groq (gateway)?

Using GPT-OSS 120B with Atlas via Groq (gateway) costs $0.15 per million input tokens and $0.60 per million output tokens. This pricing is highly competitive, often cheaper than models a fraction of its size from other providers.

Can Atlas use Llama 3.1 8B from Groq (gateway) for quick tasks?

Yes, Atlas can effectively use Llama 3.1 8B from Groq (gateway) for quick tasks. Priced at $0.05 per million input tokens and $0.08 per million output tokens, it is an extremely cost-effective option for Atlas's `small_model` slot, ideal for rapid, frequent interactions.

Does Groq (gateway) support local embeddings for Atlas?

Groq (gateway) itself does not directly support local embeddings. However, Atlas can build its code index with local Ollama embeddings, keeping code off third-party servers, which can be used in conjunction with Groq (gateway) for inference.

How do I switch to a Groq (gateway) model in Atlas?

You can switch to a Groq (gateway) model in Atlas on the fly using the `/models` command. For example, to use GPT-OSS 120B for a fast reasoning pass, you would type `/models groq/openai/gpt-oss-120b`.

Atlas with Groq (gateway) in 2026

Groq (gateway) is excellent for driving Atlas in 2026 when you prioritize raw token throughput and cost efficiency for open models. Its LPU inference makes agent loops feel instant, with GPT-OSS 120B priced at $0.15 / $0.60 per Mtok and Llama 3.1 8B at $0.05 / $0.08 per Mtok, offering significant savings for many coding tasks.

Why choose Groq (gateway) for Atlas?

Groq (gateway) stands out in 2026 for its exceptional token throughput, powered by custom LPU hardware that makes Atlas agent loops feel instant. This provider serves open models like GPT-OSS 120B and Llama 3.1 8B at speeds unmatched by GPU providers, significantly enhancing the interactive experience for developers.

When driving Atlas, the terminal-native AI coding agent, Groq (gateway) offers a distinct advantage in speed. Its LPU inference engine delivers token rates far beyond what traditional GPU serving can achieve, translating directly into a more responsive and fluid agent experience. This means Atlas can search code with Axis, the hybrid semantic and keyword retrieval fused by reciprocal rank fusion, draft plans in its read-only plan agent, and execute build agent tasks with minimal perceived latency. For developers in 2026, this responsiveness is crucial for maintaining flow and productivity, especially when Atlas fans out work to subagents that can run in the foreground or in parallel background sessions. The ability to switch the active model and provider on the fly within Atlas means you can leverage Groq (gateway)'s speed for iterative coding tasks where rapid feedback is paramount.

What are the cost benefits of Groq (gateway) with Atlas?

Groq (gateway) offers compelling cost benefits for Atlas users in 2026, particularly with its open models. The GPT-OSS 120B model is available at $0.15 / $0.60 per Mtok, which is often cheaper than what other providers charge for models a fraction of its size, while Llama 3.1 8B is effectively free at $0.05 / $0.08 per Mtok.

For developers managing their AI agent expenses in 2026, Groq (gateway) presents a highly economical option for powering Atlas. The pricing structure for its served open models is remarkably competitive. For instance, the GPT-OSS 120B model, a substantial model for complex reasoning tasks, is priced at $0.15 per million input tokens and $0.60 per million output tokens. This makes it a cost-effective choice for many of Atlas's operations, such as indexing code by AST declarations using tree-sitter or computing unified diffs for file edits. Furthermore, the Llama 3.1 8B model is available at an even lower rate of $0.05 per million input tokens and $0.08 per million output tokens, making it an ideal candidate for Atlas's `small_model` slot where speed and minimal cost are prioritized for quick, frequent interactions. This allows Atlas to perform tasks like reading git branches, status, and diffs, or staging and creating commits on your behalf, with very low operational cost.

What are the context window limitations of Groq (gateway)?

Groq (gateway) provides a consistent 131K tokens (131,072) context window across most of its models, which is a substantial capacity for many Atlas operations in 2026. However, this ceiling is well short of the 1M token windows now common with other providers, representing a key tradeoff for developers.

While Groq (gateway) excels in throughput and cost, its context window size is a factor to consider for Atlas users in 2026. The uniform 131,072 token context window, while generous for many tasks, may limit the scope of very large codebases or extensive documentation that Atlas needs to process in a single pass. Atlas's ability to search code with Axis, its hybrid semantic and keyword retrieval, and to index code by AST declarations using tree-sitter, can help mitigate some of these limitations by providing relevant context efficiently. However, for scenarios requiring an extremely broad understanding of an entire project or very long conversational histories, developers might find the 131K token limit restrictive compared to models offering 1M token windows. Atlas's design, which includes features like permission-gated tool calls and a read-only plan agent, helps manage context effectively, but the underlying model's capacity remains a hard limit.

When should I choose a different model over Groq (gateway) for Atlas?

Developers in 2026 should consider alternative providers for Atlas when their tasks require access to proprietary models like Claude, GPT-5, or Gemini, as Groq (gateway) exclusively serves open models. Additionally, if a project demands context windows significantly larger than 131K tokens, other options might be more suitable.

Groq (gateway) is an excellent choice for speed and cost with open models, but it cannot be your only provider for Atlas if your workflow in 2026 depends on specific proprietary models. The Groq (gateway) platform does not offer access to models such as Claude, GPT-5, or Gemini. If your Atlas agent needs the unique capabilities or fine-tuning of these closed-source models, you will need to switch to a different provider using Atlas's on-the-fly model switching feature. Furthermore, while the 131,072 token context window is robust, projects requiring an extremely deep and broad contextual understanding,exceeding the 1M token mark,will necessitate a model from a different provider. Atlas's extensibility through plugins and its ability to connect to Model Context Protocol servers means it can integrate with various providers, allowing you to select the best tool for the specific job, whether that's Groq (gateway) for speed or another provider for specialized model access or larger context.

Setup

01Export your Groq API key.: Before using Groq (gateway) with Atlas, set your API key as an environment variable: `export GROQ_API_KEY=gsk_...`. Atlas loads this key through `@ai-sdk/groq`.
02List available Groq models in Atlas.: To see the full catalog of models served by Groq (gateway), run the command: `atlas models groq`.
03Configure a small model slot for speed.: For rapid, cost-effective interactions, configure Atlas to use Llama 3.1 8B by adding `"small_model": "groq/llama-3.1-8b-instant"` to your `atlas.json` configuration file.
04Switch the build agent to a Groq model.: When you need a fast reasoning pass for your build agent, use the `/models` command within Atlas to switch to a Groq model, for example: `/models groq/openai/gpt-oss-120b`.

Frequently asked questions

What is the primary advantage of Groq (gateway) for Atlas?: The primary advantage of Groq (gateway) for Atlas in 2026 is its LPU inference, which provides token throughput far beyond GPU serving. This makes the Atlas agent loop feel instant, significantly improving developer interaction speed.
What models are available through Groq (gateway) for Atlas?: Groq (gateway) serves open models for Atlas, including GPT-OSS 120B, GPT-OSS 20B, and Llama 3.1 8B. It does not offer proprietary models like Claude, GPT-5, or Gemini.
What is the context window size for Groq (gateway) models?: Groq (gateway) models offer a consistent context window of 131K tokens (131,072) across most of its catalog. This is a robust size for many Atlas tasks, though it is less than the 1M token windows available from some other providers.
How much does it cost to use GPT-OSS 120B with Atlas via Groq (gateway)?: Using GPT-OSS 120B with Atlas via Groq (gateway) costs $0.15 per million input tokens and $0.60 per million output tokens. This pricing is highly competitive, often cheaper than models a fraction of its size from other providers.
Can Atlas use Llama 3.1 8B from Groq (gateway) for quick tasks?: Yes, Atlas can effectively use Llama 3.1 8B from Groq (gateway) for quick tasks. Priced at $0.05 per million input tokens and $0.08 per million output tokens, it is an extremely cost-effective option for Atlas's `small_model` slot, ideal for rapid, frequent interactions.
Does Groq (gateway) support local embeddings for Atlas?: Groq (gateway) itself does not directly support local embeddings. However, Atlas can build its code index with local Ollama embeddings, keeping code off third-party servers, which can be used in conjunction with Groq (gateway) for inference.
How do I switch to a Groq (gateway) model in Atlas?: You can switch to a Groq (gateway) model in Atlas on the fly using the `/models` command. For example, to use GPT-OSS 120B for a fast reasoning pass, you would type `/models groq/openai/gpt-oss-120b`.

Try SeaShell in your terminal

The terminal-native AI coding agent. Free core, single binary.

Install SeaShell

Related guides

Atlas vs Zed: Terminal AI Coding Agents in 2026

Comparing Atlas, the terminal-native AI coding agent, with Zed, the GPU-accelerated collaborative editor, for developers in 2026. Evaluate their AI models, workflow, and safety features.

Atlas vs Qwen Code: Terminal AI Coding Agents in 2026

Atlas vs Qwen Code in 2026: Compare terminal-native AI coding agents. Atlas offers local control, permission-gated tools, and a TUI. Qwen Code features 1M token context and desktop automation.

Document a Module with a README Using Atlas (2026 Workflow)

How to document a module with a README using Atlas in 2026: the lsp tool's documentSymbol enumerates the real exports, read supplies the behavior, write emits the README.

Atlas for Rust in 2026

Adopt Atlas, the terminal-native AI coding agent, for Rust development in 2026. Tackle borrow checker errors and clippy lints with Atlas's secure, approval-gated assistance.

Atlas for Crystal: A Terminal-Native AI Coding Agent for shard.yml Projects in 2026

Atlas is a terminal-native AI coding agent for Crystal in 2026. It reads shard.yml and union types, narrows Nil unions, runs crystal spec behind a prompt, and formats the diff.

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 for Blazor: Terminal-Native AI Coding for .razor Components in 2026

Atlas is a terminal-native AI coding agent for Blazor developers in 2026. Work across .razor components, render modes, and the C# and JS interop boundary safely.

Atlas for Electron: Terminal-Native AI Coding for Main, Preload, and Renderer in 2026

Atlas is a terminal-native AI coding agent for Electron in 2026, where the main and renderer split, contextIsolation, and preload bridges are the security model.

Browse this resource hub