Ollama v0.21.0: Free Copilot CLI for Local AI Coding

GitHub Copilot CLI costs $10 a month. Ollama v0.21.0 just plugged directly into the same interface — for free, running entirely on your own machine. That's the headline from Ollama's latest double-release drop, which also patches AMD GPU support and fixes multiple bugs in Google's Gemma 4 model that had been silently dropping conversation context for some users.

The Copilot CLI Integration — And Why It Changes Local AI Automation

GitHub Copilot CLI is the command-line version of GitHub's AI coding assistant — the tool developers use to get command suggestions, explain shell scripts, and debug terminal workflows without leaving their editor. Until now, every query you made went to Microsoft's servers and cost $10/month per seat (or $19/month on a Copilot Business plan).

Ollama v0.21.0 adds direct Copilot CLI integration for the first time — contributed by first-time community contributor @scaryrawr via PR #15583. You can now point the Copilot CLI interface at your local Ollama server, processing coding questions on your own machine without sending any code off-device.

Who benefits most from this change:

• Developers at companies with strict data policies — proprietary source code never leaves your machine
• Solo developers watching costs — $0/month vs. $10/month adds up to $120/year in savings
• Teams in air-gapped environments (systems fully disconnected from the public internet, standard in government, finance, and healthcare) — local AI assistance becomes possible where cloud tools are blocked
• Anyone frustrated by rate limits — your local model has no usage cap or queue

This is a meaningful shift. Ollama has always been the free local alternative to cloud LLM APIs (application programming interfaces — the connections software uses to communicate with AI services). Adding Copilot CLI support moves it from "I use this instead of the OpenAI API" to "I use this instead of the Copilot subscription I'm already paying for." The integration targets developer workflows most people already have installed. For a broader look at how local AI fits into modern AI automation workflows, our guides cover practical setup patterns for developers.

Everything Else in Ollama v0.21.0 — 14 Local AI Improvements

The Copilot CLI story dominates, but v0.21.0 ships 14 merged pull requests (individual code contributions that have been reviewed and accepted by the team) across three major subsystems: launch integrations, MLX backend, and Gemma 4 model support.

Notable additions beyond the Copilot CLI:

• Hermes model support — the Hermes series (instruction-tuned models from Nous Research optimized for complex multi-turn conversations) can now be served through Ollama's launch module, contributed by @ParthSareen via PR #15569
• Inline config for Launch/OpenCode — previously, setting up Ollama's coding integrations required a separate configuration file; v0.21.0 supports inline configuration (PR #15586), cutting setup time from several minutes to under 30 seconds
• MLX closure support — MLX is Apple's open-source machine learning framework built for Apple Silicon chips (M1 through M4). Closure support, added by @jessegross in PR #15590, enables proper memory cleanup after model calls, reducing memory leaks during long inference (text generation) sessions
• Gemma 4 fused operations in MLX — fused operations combine multiple computation steps into a single GPU pass, reducing memory bandwidth usage and improving throughput for Gemma 4 on Apple Silicon (PR #15587)
• Gemma 4 size-based rendering — v0.21.0 now selects a different rendering path depending on Gemma 4's parameter count (PR #15612), allowing optimizations tuned for the 4B, 12B, 27B, or larger variants
• Gemma 4 cache logical-view fix — the attention cache (a memory buffer that stores recent context to avoid recomputing it every token) now uses a logical view rather than a physical view of memory, correcting subtle generation errors (PR #15617)
• Gemma 4 router precision fix — the router projection layer — the internal component in Gemma 4's mixture-of-experts architecture (a design where multiple specialized sub-networks handle different types of inputs) that assigns tokens to experts — now maintains source numerical precision throughout inference to prevent accuracy degradation (PR #15613)
• Cloud recommendations listed first in launch UI — the Ollama launch screen now surfaces popular cloud-hosted model recommendations at the top, improving discoverability for users new to the ecosystem (PR #15593)

v0.20.8 — The AMD GPU Fix AMD Users Were Waiting For

While v0.21.0 adds integration features, v0.20.8 is a stability and compatibility patch — and its most impactful change is for the segment of users historically underserved by open-source AI tooling: AMD GPU owners.

The update bumps ROCm to version 7.2.1 on Linux. ROCm (Radeon Open Compute — AMD's GPU compute platform, the AMD equivalent of NVIDIA's CUDA software layer) is what enables AI frameworks to actually use AMD graphics cards for acceleration rather than falling back to the CPU. NVIDIA CUDA has had mature ecosystem support for years; AMD ROCm has historically lagged months behind, forcing many AMD users to either use CPU-only mode or apply custom workarounds.

ROCm 7.2.1 brings improved driver compatibility and performance for AMD RX 7000-series and Radeon PRO cards. If you have tried running a local LLM on AMD hardware and hit cryptic runtime errors, this is the release to test.

New MLX Operation Wrappers for Apple Silicon

v0.20.8 adds five categories of MLX operation wrappers (pre-built connectors that translate common AI math operations into Apple Silicon-accelerated calls). This expands which model architectures can run fully accelerated on Mac hardware:

• Conv2d — 2D convolution, used in the image-understanding components of multimodal models that process both text and pictures
• Pad — sequence padding, which adds filler tokens to make inputs the same length for efficient batch processing
• Activation functions — mathematical gates like ReLU and GELU that control how each neural network layer responds to input signals
• Trigonometric functions — sin and cosine operations essential for rotary position encodings (the method modern LLMs use to track the order of words in a sequence)
• Masked SDPA — Scaled Dot-Product Attention with masking, the fundamental computation that lets transformer models (the architecture underlying virtually every LLM in production today) understand relationships between distant words in a sequence

Mixed-Precision Quantization and the Gemma 4 Context Bug

v0.20.8 also implements mixed-precision quantization with improved capability detection. Quantization (a compression technique that reduces model memory footprint by representing weights with fewer bits — for example, 4-bit integers instead of 32-bit floats) is what makes 13B and 70B parameter models practical on consumer hardware. The improved capability detection means Ollama now correctly identifies what your hardware supports before attempting to load a quantized model, cutting down on the "failed to load model" errors that plagued earlier versions.

The most urgent fix in v0.20.8 is a bug in Gemma 4's RotatingKVCache — the data structure that stores recent conversation tokens to avoid recomputing attention over the entire context every single step. The bug was silently dropping context during mid-rotation, meaning Gemma 4 could effectively "forget" the first half of a long conversation with no error message or warning. Fixed by core team member @dhiltgen (PR #15591). If you run Gemma 4 for multi-turn conversations, this patch is worth the upgrade alone.

Install Ollama and Try It on Your Machine Right Now

If you are not running Ollama yet, the install takes under 60 seconds on most systems. It runs as a background local server and you pull AI models on demand — no GPU required for models under 7 billion parameters, which run comfortably on 8GB of RAM using the CPU alone. New to local AI? Our local AI setup guide walks through full platform configuration including GPU acceleration and model selection.

# Install Ollama — Linux/macOS
curl -fsSL https://ollama.ai/install.sh | sh

# Or on macOS via Homebrew
brew install ollama

# Start the local server
ollama serve

# Pull and run any model
ollama pull mistral
ollama run mistral

# Gemma 4 — all fixes from both releases apply:
ollama pull gemma4
ollama run gemma4

To use the new Copilot CLI integration, install the GitHub CLI with Copilot extension first (gh extension install github/gh-copilot), then configure it to point at your local Ollama endpoint at http://localhost:11434. Commands like gh copilot explain "git rebase -i HEAD~3" or gh copilot suggest "compress a folder" will be handled entirely on your machine — no Microsoft servers, no monthly bill.

For AMD GPU users on Linux: upgrade to v0.20.8 and ensure your ROCm 7.2.1 drivers are installed via your package manager. For Apple Silicon Mac users: v0.21.0's Gemma 4 fused operations stack on top of v0.20.8's broader MLX wrappers — together they represent the most significant Apple Silicon acceleration improvement Ollama has shipped in months. Watch out for the Gemma 4 context bug fix specifically if you have been running longer conversations and noticing the model going "off-track" partway through — that was a real bug, now confirmed resolved.

Related Content — Get Started | Guides | More News