How to Set Up OpenClaw with Groq for Fast LPU Inference

Most LLM providers run inference on GPU clusters. Groq takes a different approach with its Language Processing Unit (LPU), custom silicon designed specifically for sequential token generation. The result is a measurable speed gap: Artificial Analysis independently benchmarked Groq serving Llama 3.3 70B at 276 to 334 tokens per second, the fast of any provider tested. With speculative decoding enabled, that number jumps to over 1,600 tokens per second.

For a standalone chatbot, the difference between 50 tokens per second and 300 is noticeable but not critical. For an OpenClaw agent running multi-step workflows, it changes what's practical. Tool-calling loops that previously took 30 seconds finish in 5. Heartbeat checks that felt sluggish become instant. An agent that needs to reason through a document, extract data, and write a report can complete the full cycle before a GPU-based provider finishes the first step.

OpenClaw includes Groq as a bundled provider, enabled by default. The integration uses an OpenAI-compatible API format, so there's no custom client or protocol to learn. You configure an API key, set a default model, and your agent routes requests through Groq's infrastructure automatically.

The tradeoff is model selection. Groq runs open-weight models (Llama, Mixtral, Qwen, DeepSeek) on its LPU hardware. You won't find Claude or GPT here. If your agent needs a specific proprietary model, Groq isn't the right provider for that task. But for agents built around open models, the speed advantage is significant.

Get your API key from console.groq.com/keys. Groq's free tier doesn't require a credit card.

OpenClaw recognizes Groq as a built-in provider. During the interactive onboarding flow, select Groq as your provider and paste your API key when prompted. OpenClaw stores the key in its local configuration automatically.

If you prefer to set the key manually, add GROQ_API_KEY to your environment. For Docker containers, CI pipelines, or other non-interactive environments, store the key in OpenClaw's local .env file rather than relying on shell exports. The daemon process needs access to the key, and shell-only exports won't persist across daemon restarts or container rebuilds.

Setting the Default Model

Configure Llama 3.3 70B Versatile as your default:

{
  agents: {
    defaults: {
      model: { primary: "groq/llama-3.3-70b-versatile" }
    }
  }
}

The groq/ prefix tells OpenClaw to route the request through the Groq provider. Any Groq model ID works with this prefix, so you can swap models at runtime without reconfiguring the provider.

Verifying the Connection

Confirm your setup:

openclaw models list --provider groq

This returns all available Groq models. If the command fails, check that your API key is valid and accessible to the daemon process. Running openclaw status shows overall provider health, and openclaw doctor --fix repairs common configuration issues.

Groq's model catalog covers chat, reasoning, multimodal, and audio transcription. The right choice depends on your agent's workload.

General-Purpose Chat

groq/llama-3.3-70b-versatile is the recommended default. It handles text generation, tool calling, and structured output with a 131,072-token context window. For agents that don't need reasoning chains or image understanding, this model hits the best balance of speed, capability, and cost.

Reasoning Models

When your agent needs to think through complex problems, Groq offers several options:

• groq/qwen-qwq-32b and groq/qwen3-32b support OpenClaw's thinking mode with none or default reasoning effort
• groq/deepseek-r1-distill-llama-70b runs native chain-of-thought reasoning on every request
• GPT OSS variants support low, medium, and high reasoning effort levels

OpenClaw maps the /think command to each model's native reasoning parameters automatically. You set the thinking level in OpenClaw and the provider translates it to the correct API format.

Multimodal Models

groq/llama-4-maverick-17b and groq/llama-4-scout-17b accept text and image input. If your agent needs to analyze screenshots, read documents from photos, or process visual data, these models handle it without switching providers.

Audio Transcription

Groq runs whisper-large-v3-turbo for audio-to-text conversion. Configure it under tools.media.audio in your OpenClaw settings. The endpoint follows OpenAI's /audio/transcriptions format, so existing audio processing workflows transfer directly.

Give your OpenClaw agent persistent storage that keeps up with Groq speed

generous storage workspace with MCP-native access, built-in semantic search, and ownership transfer. No credit card required.

Start 14-Day Trial

Groq's free tier is generous enough for development and prototyping, but the rate limits shape how you design agent workflows.

The numbers that matter:

• 30 requests per minute (RPM)
• 6,000 tokens per minute (TPM)
• 14,400 requests per day for smaller models, 1,000 requests per day for most larger models like Llama 3.3 70B

These limits apply at the organization level. Creating multiple API keys doesn't bypass them.

The daily request cap is typically the binding constraint. An OpenClaw agent making 20 tool calls per task burns through 1,000 daily requests in 50 tasks. For development and side projects, that's plenty. For production workloads, Groq's paid tier removes these caps.

Practical strategies for staying under limits:

• Batch related questions into single prompts rather than making separate requests for each piece of information
• Use the agent's local context and memory before making additional LLM calls
• Route high-volume, low-complexity tasks to a smaller model like groq/llama-3.1-8b-instant that has higher daily limits
• Cache responses for repeated queries using OpenClaw's built-in conversation memory

Comparing free tiers: Gemini offers 60 RPM and 1,000 RPD through Google AI Studio. Groq's RPM is lower (30 vs 60), but the raw speed means each request completes faster, freeing the rate limit window sooner. For latency-sensitive agent loops, Groq's approach often produces better throughput in practice despite the lower RPM cap.

Fast inference solves the speed problem but creates a new one: your agent generates output faster than you can organize it. A Groq-powered OpenClaw agent can complete a research task, write a report, and produce a summary in seconds. If all of that lands in a local directory or disappears when the container restarts, the speed doesn't help.

Local filesystems work during development. For anything beyond a single developer on one machine, you need somewhere persistent and shareable.

Common approaches:

• Local disk: Fast, simple, breaks on container restart or multi-machine setups
• S3 or GCS: Durable, but no built-in search, sharing, or collaboration layer
• Google Drive or Dropbox: Sharing works, but not designed for programmatic agent workflows with structured handoff

Fastio provides a workspace layer built for this use case. Your agent writes files through the MCP server or REST API, and collaborators see them immediately in the browser.

What this looks like for Groq-powered agents:

• MCP-native access: Fastio exposes Streamable HTTP at /mcp and legacy SSE at /sse. Your OpenClaw agent reads, writes, searches, and manages workspace files through 19 consolidated MCP tools
• Built-in Intelligence: Enable Intelligence on a workspace and every uploaded file gets automatically indexed for semantic search with citation-backed answers. No separate vector database to configure
• Ownership transfer: Your agent builds a workspace with organized research and reports, then transfers the organization to a client or teammate. The agent keeps admin access for ongoing updates
• Business Trial: 50GB storage, included credits, 5 workspaces. No credit card, no trial expiration. Get started with the trial

The speed of Groq inference means your agent can produce a complete deliverable in one session. Fastio makes sure that deliverable is immediately accessible to the humans who need it.

API key not found by the daemon

If openclaw models list --provider groq works in your terminal but agent tasks fail, the daemon can't see your key. Shell-only exports (like export GROQ_API_KEY=... in .zshrc) don't propagate to launchd or systemd-managed processes. Store the key in ~/.openclaw/.env instead.

Model not available errors

Groq periodically updates its model catalog. If a model ID returns an error, run openclaw models list --provider groq to see the current list. Model IDs follow the groq/ prefix pattern, so groq/llama-3.3-70b-versatile is correct while llama-3.3-70b-versatile without the prefix routes to your default provider instead.

Rate limit errors during agent workflows

If your agent hits rate limits mid-task, the error appears as a 429 status code. Reduce the number of tool calls per task, or switch to a model with higher free-tier limits. The groq/llama-3.1-8b-instant model allows 14,400 daily requests compared to 1,000 for the 70B variant.

Thinking mode not working

Not all Groq models support reasoning. Llama 3.3 70B Versatile doesn't have a thinking mode. Use groq/qwen-qwq-32b or groq/deepseek-r1-distill-llama-70b for tasks that need explicit chain-of-thought reasoning. Run openclaw models status to see which models support thinking on your current Groq endpoint.

Configuration validation

After any configuration change, run:

openclaw config validate

This checks for deprecated entries, malformed model references, and provider conflicts. Follow up with openclaw doctor --fix if the validator flags issues it can auto-repair.