GitHub Copilot Just Got Memory — and It Runs

GitHub shipped a quietly massive update to Copilot for JetBrains on August 11, 2026. Two features stand out: persistent memory across chat sessions and Ollama as a bring-your-own-key provider — meaning you can now run free local models directly inside Copilot without sending code to the cloud. There are also enterprise controls, expanded Codex workflow visibility, and easier CLI setup.

If you use Copilot in IntelliJ, WebStorm, PyCharm, or any JetBrains IDE, this update changes how the agent works day to day. Here is what each feature does, who should care, and how to try it today.

Copilot remembers what you told it

Every developer who uses an AI coding agent has felt this pain: you spend five minutes explaining your project’s naming conventions, folder structure, or preferred testing framework, close the chat, open a new one, and the agent forgets everything. You explain it again. And again.

Copilot memory fixes that. When enabled, Copilot retains information across chat sessions — your project details, your preferences, your past instructions — and recalls them automatically in future conversations.

Think of it as the agent keeping a notebook. You tell it once that your team uses Vitest instead of Jest, that your API routes live under /app/api/, or that you prefer functional components over class components. Next time you start a new chat, it already knows.

How to enable it

Open Settings in your JetBrains IDE.
Navigate to the GitHub Copilot section.
Find the Copilot Memory toggle and turn it on.

You can manage what Copilot remembers through the Copilot settings portal. If you ever want to wipe the memory — say, when switching projects — you can toggle it off and back on, or manage stored entries through the portal.

Why beginners should care

If you are new to coding agents, memory is the single biggest quality-of-life improvement you will get. Without it, every new conversation starts from zero. With it, the agent builds context over time, and its suggestions get better the longer you work together. It is the difference between explaining yourself to a new colleague every morning and having someone who already knows your team’s style guide.

Run free local models with Ollama

This is the feature that privacy-conscious developers and budget-minded teams have been waiting for. GitHub Copilot for JetBrains now supports Ollama as a BYOK (Bring Your Own Key) provider.

Ollama is an open-source tool that runs large language models locally on your machine — no cloud, no API key, no monthly fee beyond the hardware you already own. With this integration, you can configure Ollama as a model provider inside Copilot and use locally-hosted models for chat and code suggestions.

What this means in practice

Zero cost per token. Running Llama 3, Qwen, DeepSeek, or any Ollama-compatible model on your machine costs nothing beyond electricity.
Full privacy. Your code never leaves your laptop. No data sent to OpenAI, Anthropic, or GitHub servers.
Offline capability. Once the model is downloaded, you can use Copilot without an internet connection.
Model choice. Pick the model that fits your task — a small fast model for quick completions, a large model for complex refactoring.

How to set it up

Install Ollama on your machine.
Pull a model: ollama pull llama3.2 (or any model you prefer).
In JetBrains, open Settings → GitHub Copilot → Models.
Add Ollama as a provider and select your installed model.
Start chatting — Copilot routes requests to your local Ollama instance.

The integration supports provider configuration and model selection throughout the JetBrains experience, so you are not limited to a specific panel or feature. Local models work wherever Copilot works.

What beginners should know

Local models are powerful but come with trade-offs. A 7B-parameter model running on 8GB of RAM will be slower and less capable than GPT-4o or Claude Sonnet. For simple tasks — writing tests, explaining code, generating boilerplate — local models work great. For complex multi-file refactoring or nuanced architectural decisions, cloud models still have an edge. The smart move is to keep both options available and switch based on the task.

Enterprise managed settings

For teams using Copilot at scale, the update adds server-based enterprise controls. Administrators can now manage:

Plugin availability — control which Copilot plugins are installed across the organization.
MCP server access — restrict which Model Context Protocol servers the agent can connect to.
Permission bypass behavior — enforce or restrict auto-approval policies org-wide.
OpenTelemetry settings — configure observability and monitoring for agent usage.

These settings are applied at the organization level and override individual developer configurations. If your security team has been asking “how do we control what Copilot can do?”, this is the answer.

Expanded Codex workflows in JetBrains

Copilot’s integration with OpenAI’s Codex is now more visible in JetBrains. Two changes matter:

Codex sessions appear in agent debug logs. You can see exactly what Codex did during a session — which tools it called, what it read, what it modified.
Codex workflows support custom instructions and skills. Your project-level .github/copilot-instructions.md and any custom skills you have configured now apply to Codex sessions too.

This makes Copilot feel less like a black box and more like a tool you can inspect and customize.

Easier CLI setup

If you have ever wanted to use Copilot’s terminal agent but could not be bothered to install the CLI separately, this release fixes that. JetBrains can now automatically install Copilot CLI from integrated terminals on macOS, Linux, and Windows. Open a terminal in your IDE, and the setup happens behind the scenes.

UX improvements worth noting

The release also includes several quality-of-life tweaks:

File references restored. Type # in Copilot chat to reference files and folders again — this was broken in recent versions and is now fixed.
Customization button moved. The customization entry point is now at the top of the Copilot chat panel, making it easier to find.
Agent debug logs relocated. Moved to the Options dropdown at the top of chat — less visual clutter, same access.
Model name display. Long model names no longer overflow the model picker; they are properly truncated.

Quality and reliability fixes

Behind the scenes, this release cleans up several reliability issues:

MCP server execution and approval workflows are more stable.
Terminal output and auto-approval no longer misfire.
Customizations persist correctly across sessions.
Cloud agent connections are more resilient.
ANSI escape codes in terminal output render properly.
Terminal scrollbars behave predictably.

How this compares to other agents

Memory and local model support are not unique to Copilot — Claude Code has had persistent memory since its launch, and tools like Hermes Agent, Cline, and OpenClaw all support local model providers. What makes this update notable is that it brings these features to the JetBrains ecosystem, where millions of Java, Kotlin, Python, and JavaScript developers work daily.

If you have been using a terminal-based agent like Claude Code or Codex for memory and local models, but your day-to-day work happens in IntelliJ or PyCharm, you no longer need to switch tools to get those capabilities.

Getting started

Update your plugin. Open JetBrains → Settings → Plugins → Updates, and install the latest GitHub Copilot version.
Enable memory. Settings → GitHub Copilot → Copilot Memory → toggle on.
Install Ollama (optional). Follow the setup steps above if you want local models.
Try it. Start a new Copilot chat, mention your project’s conventions, close the chat, open a new one, and see if it remembers.

The update is available now for all GitHub Copilot plans that include JetBrains support.

GitHub Copilot Just Got Memory — and It Runs Free Local Models Too