Source: GitHub Changelog — 2026-08-11
Summary
GitHub shipped persistent agent memory and local-model support via Ollama to Copilot in JetBrains IDEs, alongside MCP and terminal reliability fixes. Memory means Copilot's agent mode can now retain context about a project and a developer's preferences across separate sessions instead of starting cold every time. The Ollama integration lets developers route agent requests to a locally-run model instead of a cloud API call.
Key Takeaways
- Persistent memory means Copilot's agent mode in JetBrains no longer resets its understanding of your project and preferences at the start of every session — it carries context forward.
- Ollama support lets developers point Copilot's agent at a model running entirely on their own machine, which matters for offline work, cost control, and code that can't leave the local environment.
- The update also includes MCP and terminal-tool reliability fixes, suggesting GitHub is treating the agent harness itself (not just the model) as the thing that needs continuous hardening.
- Combining persistent memory with local-model routing is a meaningful harness-design pattern: it decouples "does the agent remember me" from "which model is answering," letting a team swap the backend without losing accumulated context.
Reel Script
Hook: Every AI coding assistant you've used forgets you the moment you close the IDE. GitHub just shipped a Copilot update that doesn't — and it can run against a model on your own laptop instead of the cloud.
Core Concept: Two separate features landed together here, and they're worth understanding as distinct problems. The first is agent memory — think of it as the difference between hiring a new contractor every morning versus keeping the same one who already knows your codebase's quirks. Before this update, Copilot's agent mode in JetBrains started every session from zero context. Now it persists what it's learned about your project and your preferences across sessions. The second is Ollama support — Ollama is just a way to run an LLM directly on your own hardware instead of calling out to a cloud API. Wiring that into Copilot means the same agent interface can now talk to a model that never leaves your machine, which matters a lot if you're working with code you can't send to a third party, or you just don't want the API bill.
Hands-On: The architecture worth noticing is that these two features are decoupled by design: memory is a property of the harness — the layer that manages context and state — not the model itself. So swapping which model answers your prompts, whether that's a cloud model or a local Ollama instance, doesn't reset what the agent remembers about your project. That's the right way to build this: keep the "who are you talking to" layer separate from the "what do you remember" layer, so you can change one without losing the other.
Takeaway: If you're building or evaluating any agent harness, this is the pattern to copy — treat memory as infrastructure that survives a model swap, not something baked into a single provider's session. For developers on regulated or offline codebases, the Ollama option alone might be the reason to switch. Try the JetBrains update if you're already in the Copilot ecosystem.