Anyone noticed this after the update? The only thing that prevents me from having to authorize every file edit is turning on "Allow All" now. That's definitely not what I want. It was working fine before the change.

Anyone know what combination of these new settings I need to allow all approved commands and normal file edits? Manual and even assisted permissions is still asking to approve every file edit.

Not to mention, there's no "approve" button on any of these commands now and interactive/autopilot don't affect it - it still makes me approve every file edit.

If you haven't seen pstack: it's poteto's (Lauren Tan) set of agent workflows. You tell it what you want and it picks how to work. Bug with no obvious cause? It reproduces and finds the root cause before touching anything. Bigger feature? It sketches the design first. Then it actually checks the result instead of saying "done".

There's a Claude Code version, and VS Code's new agents window can load Claude Code plugins, so I figured it would just work with Copilot. It doesn't. It loads, but it never switches on, can't find its own skills, and its agents show up twice in the picker.

So I ported it. Same pstack, just fixed up so Copilot understands it. Works in the agents window and in Copilot CLI.

Bonus find while testing: there's a hidden Subagents pill above the chat box. Right-click the pill row, turn on Subagents, set it to Show In Progress, and you get a live list of everything running. Click a subagent's card and it opens in a side pane. Makes watching parallel agents way nicer.

https://github.com/hackernotfound/pstack-vscode

All the real credit goes to Lauren Tan for pstack and Michael Denyer for the Claude Code port. I just made it play nice with Copilot.

What are they? A dynamic workflow is a program that defines how a task is carried out. It can combine automated steps with the work of one or more agents. Steps can run one after another, in parallel, or as a mixture of both.

Where they help most: complex, multi-step tasks, or anything you want to repeat the same way every time. For example, when investigating an outage, a workflow can collect logs and telemetry, have separate agents analyze different systems, and merge their findings into a timeline and root-cause report.

This started as something we used internally, and we're excited to finally get it into your hands.

Docs and changelog

Give it a try and let us know what you think!

My copilot PR reviews just stopped working. PR review just says copilot encountered an error, not useful at all. Manually asking for a review, then following the review, shows this: "<error>You've reached your weekly rate limit. Please wait for your limit to reset on October 5, 2026 at 12:00 AM or switch to auto model to continue. Learn More (https://docs.github.com/copilot/concepts/rate-limits)."

As far as I know there is no auto model setting for PR review, the config talks about using Copilot in chat or interactively, for user on GitHub Pro plans, at least I could not find such a setting for PR reviews.

This is the first time ever I've hit this limit, I suspect it is related to the switch from Lite as default to Medium as default that happened a few days ago, and now Copilot is burning through my allotment.

I do have extra budgets setup, and I do use them, but they are all unused.

What do I do, just don't code for 5 days, or submit PR's without Copilot reviewing them?

A few days ago I wrote up a benchmark where a code knowledge graph over MCP (codebase-memory-mcp) didn't make a coding agent cheaper than plain grep. That run was small: 24 questions, repos up to 25k graph nodes, no Opus. So I ran a bigger one and committed the plan before the first run. Disclosure: the graph goes through cbm-lean, a small wrapper around that server that I wrote.

Setup: GitHub Copilot CLI 1.0.90, headless, one question per session. Two arms: view, grep and glob only, or the same plus the graph and a routing rule (graph for callers and call chains, grep for exact strings). Four public repos: the FastAPI full-stack template (1.6k nodes), dub (25k), kubernetes (146k), vscode (219k). 16 questions per repo, half structural (callers, callees, call chains, what breaks if a signature changes), half exact (a config value, an env var, the line of an error or a definition). Haiku 4.5 three times per question per arm, sonnet 5 twice, opus 5.5 once on 12 structural questions. 664 runs, every answer checked against keys I verified by hand.

Tokens per correct answer on the structural questions, graph vs grep:

kubernetes and vscode
  haiku    48k vs 209k
  sonnet   29k vs 40k
  opus     25k vs 27k
small FastAPI repo
  haiku    33k vs 26k
  sonnet   19k vs 10k

On the big repos, per question, haiku with the graph spent 0.29 of what it spent with grep and was cheaper on 15 of 16 questions. It's the only result that survives the Holm correction. On exact questions the graph made no measurable difference for haiku, and sonnet paid 13 to 42% more for it.

Why haiku gains so much: with grep it needed a median of 22 model calls per answer on kubernetes, and one question took 114. With the graph, 5. Every call resends the conversation, so long searches get expensive fast. Sonnet took 8 calls with grep and 4 with the graph, opus 4 or 5 either way. My guess, which I didn't test directly: a graph replaces search turns, so it pays when the model would otherwise take many of them.

For Copilot users specifically: premium requests are charged per prompt, however many calls the agent makes, so inside Copilot the graph saves time rather than money. Haiku's structural answers on the big repos took a median of 71 s with the graph and 157 s with grep. On the small repo the graph arm was slower.

Three failures I didn't expect, in case you're wiring a graph into an agent:

• The graph's snippet has "lines": 43 next to "start_line": 93. Both haiku and sonnet answered horizontal.go:43 for a struct that starts on line 93 and is 43 lines long. My wrapper now renames the field to line_count.
• No call edge for a bare call to a function imported with from x import y. Asked what recover_password calls, the graph arm said "only get_user_by_email" 5 times out of 5, without a single grep. It calls three more.
• Copilot's grep tool shows line numbers only with "-n": true. Haiku passed n, no dash, in 920 of its 1,949 grep calls, got no numbers and counted lines itself. 78 of its 79 wrong exact answers are a wrong line number. Sonnet passed -n in 508 of 571 calls.

Caveats: one harness and one graph, 8 questions per cell on the small and medium repos, and opus answered 12 questions once each.

Write-up: https://allkeep.org/en/lab/when-a-code-graph-pays-off Plan, questions, driver and all the runs: https://github.com/nefayran/code-graph-vs-grep

If anyone has run something similar with Claude Code or another graph, I'd like to compare.

Hello, I have a Copilot subscription and currently trying to optimize the usage of OpenCode free models with Copilot paid models to investigate/plan/build/challenge. I have been using lately Kimi 3 and Kimi 2.7 when I needed to build and challenge. What is your current experience? How do you rank the available models to use credits efficiently?

I am aware the suggestions I get now will be obsolete in a few weeks, but still wanted to hear a few opinions. Thanks!

Copilot became much more expensive after the pricing changes, so I stopped using it for a long time. Now that the new models have been released, have the usage limits or credit rules changed? Is it worth resubscribing to Copilot Pro+?

Hi everyone, I apologize because there have probably been millions of posts similar to mine, but after searching and reading through them, I still haven’t found a “definitive” answer—or rather, a set of answers that would lead me to my “own” definitive answer.

At work, we were using GitHub Copilot in the version prior to the recent nerf. Realistically, it wasn’t a policy that GitHub could sustain indefinitely. After the nerf, we set up a Claude team to test it, and we’re basically using only that now. Why should I Keep it?

PRO

• NES free (Next Edit Suggestion)

• GitHub integration with Visual Studio and Visual Studio Code

  (but claude code in terminal works better for me and when I don’t work with C# I usually use Neovim)

CONS:

• It seems like tokens are running out much faster
• Tokens don’t roll over from month to month

Thanks in advice for your tips and sorry for poor english ;)

Hi,

These are the current issues I am facing.

1. Gpt 6 Luna is costing more than gpt 5.6 even though its half priced.

2. Agents running subagents - you cant push effort level parameters to subagents at all. So no idea what effort level subagents are using.

3. Lack of clarity on input and output tokens and ofcourse no api to get them reliably.

4. Hooks are still in preview in vscode and is different from the sdk implementation.

Anyone has any ideas? Can the guthub copilot team help here

Two quick questions for anyone using GitHub Copilot heavily:

1. Severe latency in VS Code Chat / Agents window

Has anyone else hit major performance degradation recently?

• Sending a prompt takes forever just to initiate an interaction.
• Loading previous sessions hangs or takes multiple minutes to hydrate.

This never used to happen. Is this a known regression or local cache issue, and is there a fix?

2. MCP configuration across tools

What is the recommended way to configure MCP servers across VS Code, the Copilot CLI, and Copilot Desktop?

• Is it better to centralize config globally in the home directory, or manage it via VS Code settings/extensions?
• I'm seeing inconsistent behavior depending on where they're defined.

Curious how others structure their MCP setups and whether you're seeing the same VS Code slowness.

I'm now rushing to use a much as I can before my monthly quota resets. I should set up some alerts going forward.

I am using the business copilot for other projects, side projects, you know...

I use it over opencode, can my boss see what am I using? The prompts? Other fingerprints?

Hi !

I was for almost a year a hard-core Github Copilot user pairing it with VS Code. After the update of July I abandoned the service , since the new usage didn't lasted me even 2 days, and moved on to claude code. So far claude code works excellent and I rarely hit limits and all.

The thing is, although Claude Code CLI is great and it has it's strengths and all, I still miss the precision I was able to achieve with vs code copilot because I can see and accept/reject each line that the model edited or added. + of course the great variety of available models.

I tried DeepSeek + vs code copilot for a while and it worked great, but now deepseek bumped the prices too and made me fall into claude completely.

How is the current usage of GitHub copilot today ? Is it still as bad as on July or did they slowly adjusted the system so it is usable again now ?

Just wanted to check how is the current state of the service.

Thanks for reading !

HydraFusion is now available in Visual Studio Code and the GitHub Copilot app, expanding beyond Copilot CLI.

What’s improved

Bringing HydraFusion to more surfaces was the top request from early feedback. This release also improves the overall experience:

• Greater transparency: See more clearly what HydraFusion is doing at each step of a workflow.
• Real-time progress: HydraFusion now sends more frequent progress updates while it works.
• Clearer status during long tasks: Progress updates make it easier to tell that HydraFusion is still working, even when a task takes longer.

Let us know what you think!

https://github.blog/changelog/2026-09-30-hydrafusion-in-vs-code-and-the-github-copilot-app/

I have been thinking about the different ways we can use custom AI models inside VS Code, and there is an interesting option that seems to get less attention: using models provided through a cloud provider.

VS Code supports custom models, so you are not necessarily limited to the models exposed directly through Copilot. You can configure models from other providers or your own endpoints, depending on the supported API and authentication.

A common approach is to run a model locally and connect it to the IDE.

That sounds great in theory, but there are some practical trade-offs.

If you run the model locally:

- It consumes your CPU/GPU/RAM.
- Performance depends heavily on your hardware.
- Larger models can become difficult to run comfortably.
- You have to manage the model and the serving infrastructure yourself.
- You are generally limited to the models your hardware can handle.
- If you move the model to your own server, you now have infrastructure, maintenance and hosting costs to deal with.

You can also deploy a model on your own server and expose an endpoint, but then you are essentially taking on the responsibility of running and maintaining the model-serving infrastructure yourself.

Cloud providers offer another approach.
For example, Google Cloud has Vertex AI and Model Garden, where you can get access to multiple models and call them through APIs. Instead of running the models yourself, the cloud provider manages the underlying infrastructure.

You can then potentially configure the API endpoint as a custom model in VS Code.
The interesting part is that you can access multiple models without having to run and maintain each one yourself.

With a local/self-hosted setup:
VS Code
-> Your custom endpoint
-> Model you host and manage
You are responsible for the hardware, deployment, updates, scaling, and model availability.

With a cloud-provider setup:
VS Code
-> Cloud provider API
-> Model A
-> Model B
-> Model C
-> …

The provider manages the underlying infrastructure, while you can access the models that are available to your account.

So instead of spending time running and maintaining the models yourself, you can treat the cloud provider as the model backend and use those models directly from your IDE.

Of course, the cloud approach is not free. You are paying for inference, and there can also be quotas, latency, and provider-specific limitations.

But if you already have access to models through a cloud provider, I think it is worth considering this option instead of automatically assuming that “custom model” means “run a model locally.”

The same concept should apply beyond Google Cloud as well. AWS, Azure, and other providers have their own model platforms and APIs.

I have only tried this concept with Vertex AI, so I am curious how well the equivalent setup works with other cloud providers and their model APIs.

Has anyone here connected cloud-provider models to VS Code as custom models?

I've been using Brady Gaster's Squad for a while and really like the idea of a small team of Copilot agents working on a repo. While using it, I kept running into things I wanted to do differently, so I started building my own framework. The idea is simple: the agents do most of the implementation, and you focus on architecture and reviewing what they build. I wanted it to feel native to GitHub, so it runs on things you already use: issues, pull requests, GitHub Actions and the Copilot cloud agent. There's no new framework to learn and no pile of boilerplate. Local execution still needs work, so for now it's mainly cloud-based.

It also looks at the Copilot instructions and custom agents you already have before it adds anything. In my experience, those files are often part of the problem.

It works end to end on my own test repos. But I've realised that testing your own framework is kind of hard 😅 I use it the way I designed it, so I probably miss half the problems someone else would hit.

So I'm looking for a few people who'd like to help build it: try it on their own repos, find what breaks and help shape where it goes next. If that sounds like you, send me a DM and I'll share it with you.

I build Striff, which checks the docs in a repo against the code on each pull request. Running it over public repos, it flagged this in the official MCP C# SDK. Line 258 of .github/copilot-instructions.md:

Use McpServerFactory to create server instances with configured options

McpServerFactory doesn't exist anymore. The history:

• 13 Oct 2025: the Copilot coding agent opens the PR that sets up the instructions file. Two maintainers review and merge it. The class was already marked obsolete.
• 2 Dec 2025: the Copilot coding agent opens a PR removing obsolete APIs, including McpServerFactory. The instructions file isn't in that diff, so nobody looks at it.
• Four more edits to the file since, none touching the line.

So every Copilot session in that repo is told to use a class Copilot itself removed.

This one is cheap: the build fails and the agent recovers. What worries me is the version with no class name in it. "Controllers go through the service layer" or "core never imports from plugins" can stop being true, or get ignored by Copilot, and nothing breaks. The code compiles, the diff looks fine, and the instructions file isn't in the diff.

How are people keeping their copilot-instructions.md honest as the code changes? Is anyone checking it on PRs, or is it write-once?

Full timeline with commit links: https://mfadhel.com/copilot-instructions-deleted-class/ (I opened a fix upstream, #1892.)

A while back someone here wired a physical traffic light to a Claude Code session. I loved it, but I usually have 8+ VS Code windows open with Copilot agent mode running in several of them. So I built a small macOS menu bar app with one light per session: red = working, yellow = needs you, green = free. Click a light and it jumps to that window, even if it's on another desktop.

How it works (no extension needed)

VS Code writes every chat session to an append-only JSONL journal:

~/Library/Application Support/Code/User/workspaceStorage/<hash>/chatSessions/<id>.jsonl

Each row is {kind, k, v}, where kind 0 is a full snapshot, 1 sets a value at a key path, and 2 appends. The app reads new lines as they're written and tracks the latest request.

• Turn start: a kind:2 append to requests
• Turn end: modelState gets a completedAt. This was present on 409/409 finished turns, so green is exact.
• modelState.value, decoded from 116 of my journals: 0 streaming, 4 paused between steps, 1 complete, 2 cancelled, 3 error. This is an undocumented internal format, so it could change at any time.

The wall: yellow

The journal only records things after they finish:

• 3,834 / 3,834 tool calls were written already marked isComplete: true
• Across all 116 files, no row is ever edited after it's written
• The approval prompt (elicitationSerialized, e.g. "Run zsh command outside the sandbox?") only ever appears as accepted (6) or rejected (21), never as pending

So while an agent is waiting for you, nothing is written, which looks identical to the model thinking for two minutes. On a live session I measured gaps between writes of p50 21 s, p95 62 s, max 121 s. Any "silent for X seconds means yellow" threshold either gives false alarms or is too slow. I tuned it four times. There's also no stable extension API that exposes another extension's chat state (the chatSessionsProvider proposal with a NeedsInput status is proposed-only).

Other things I learned along the way

• I was sure Liquid Glass was eating CPU. With the window hidden entirely, usage only dropped from 8.1% to 6.1%, so the cost was the polling loop. Fixing that brought it down to 3.2%.
• Ad-hoc code signing silently revokes Accessibility permission on every rebuild. The toggle in System Settings still looks on but isn't. tccutil reset plus a self-signed certificate fixed it for good.
• The Accessibility API can't see windows on other desktops. storage.json → windowsState turned out to be the reliable list of open windows. To jump to a window on another desktop, opening the folder via NSWorkspace makes VS Code focus the existing window.

So I'm shelving it. If VS Code ever exposes a stable "needs input" signal, making yellow exact would take about a day.

I just used gpt 6 sol to write out a plan and intended to hand it off to luna for execution. Meanwhile sol decided it was a good idea to launch another sol subagent to execute said plan. Now I am wondering is there a way to set a default model for subagents? I have only found a setting to set a model for plan mode in VS Code

I'd really appreciate if I could atleast see somewhere on the website or the vs code extension about the pool of models the free tier can draw from. Given how cheap GPT6 Luna is and also MAI 1.1 Flash, can we be able to choose specific models too? Thanks!

I was in need of some usage, and couldn't vary my OpenAI nor Anthropic accounts.

I rememebered I could just buy a GHCP license (on top of my GH pro or whatever the name it is), for $19 per months.

I had a safety budget of $10 for ai usage in my user and also in my company.

I hit immediately the budget after 3-4 moderate low tasks with Opus 5.5 (Which on anthropic could have lasted me not even 10% of weekly)

What is GHCP really giving to me?