There's a specific kind of frustration familiar to anyone who's used an AI coding agent: you send a request, it starts running, and thirty seconds later you realize you forgot to add a critical constraint. Or you think of a follow-up. Or you can see it heading somewhere wrong, and there's nothing you can do but sit there and watch.
That's been the workflow. One prompt, one response, wait, repeat. The February 2026 release of VSCode (1.110) changes this in a way that's simple to describe but surprisingly powerful in practice: you can now send messages while a request is still running.
What's actually changed
The new behavior covers two distinct scenarios. The first is mid-flight intervention: if Copilot is in the middle of generating a response and you realize it's going in the wrong direction, you can now type a corrective message immediately. You don't have to wait. The agent incorporates your guidance and adjusts course without restarting the session or losing context.
The second is message queuing: you can send multiple follow-up requests while the agent is busy, and they'll be held in a queue. If you change your mind about the order — say you realize step 3 needs to happen before step 2 — you can drag them to reorder before the agent gets to them.
Notice that both messages were sent while the agent was still mid-task. They appear in a queue beneath the active conversation, and you can drag them into whatever order makes sense. The agent will work through them in sequence once it finishes the current step.
Why I like this feature
The old model had a hidden cost: it forced you into a passive role the moment you hit enter. You'd context-switch to something else, come back, find the agent had made reasonable but wrong assumptions, and undo a bunch of work. The new queuing model changes that dynamic entirely.
It's closer to how you'd actually work with a junior developer sitting next to you. You give them a task, they start, and as you watch you naturally add "oh, also make sure you…" or "wait, actually do that part first." The conversation is continuous, not transactional.
A few scenarios where this genuinely shines:
-
Architecture constraints: Add "only modify this component" or "reuse existing utilities" before the agent drifts too far.
-
Multi-step workflows: Queue several tasks upfront and reorder them as you think through dependencies.
-
Long-running refactors: Stay engaged with a sprawling refactor instead of waiting passively for it to complete.
Pro tip
If you queue a message and then change your mind, you can remove it from the queue before the agent picks it up — no need to send a correction after the fact.
Getting started
You need VSCode 1.110 or later and GitHub Copilot with agent mode enabled. Update VSCode if you haven't, open the Copilot Chat panel, and switch to Agent mode. From there, just start an agent task — the input box stays active while the agent is running, and any messages you send will steer the agent. If you use alt-enter, it will arrive in the queue automatically.
Remark: Message queuing and mid-request messages are specific to Agent mode. In regular Copilot Chat (ask/edit modes), the existing behavior applies — you still wait for a response before sending the next message.
Conclusion
It's one of those features that's hard to describe as transformative on paper, but once it's part of your workflow, going back feels genuinely painful. Give it a try on a task that normally takes several back-and-forth rounds and see how much faster it moves when you can stay in the conversation the whole way through.