From pair to peer programmer: Our vision for agentic workflows in GitHub Copilot

Software development has always been a deeply human, collaborative process. When we introduced GitHub Copilot in 2021 as an “AI pair programmer,” it was designed to help developers stay in the flow, reduce boilerplate work, and accelerate coding.

But what if Copilot could be more than just an assistant? What if it could actively collaborate with you—working alongside you on synchronous tasks, tackling issues independently, and even reviewing your code?

That’s the future we’re building.

Our vision for what’s next 

Today, AI agents in GitHub Copilot don’t just assist developers but actively solve problems through multi-step reasoning and execution. These agents are capable of:

• Independent problem solving: Copilot will break down complex tasks and take the necessary steps to solve them, providing updates along the way.
• Adaptive collaboration: Whether working in sync with you or independently in the background, Copilot will iterate on its own outputs to drive progress.
• Proactive code quality: Copilot will proactively assist with tasks like issue resolution, testing, and code reviews, ensuring higher-quality, maintainable code.

Rather than fitting neatly into synchronous or asynchronous categories, the future of Copilot lies in its ability to flexibly transition between modes—executing tasks independently while keeping you informed and in control. This evolution will allow you to focus on higher-level decision-making while Copilot takes on more of the execution.

Let’s explore what’s already here—and what’s coming next.

Copilot in action: Taking steps toward our vision 

Agent mode: A real-time AI teammate inside your IDE

If you’ve used agent mode with GitHub Copilot (and you should, because it’s fantastic), you’ve already experienced an independent AI agent at work. 

Agent mode lives where you code and feels like handing your computer to a teammate for a minute: it types on your screen while you look on, and can grab the mouse. When you prompt it, the agent takes control, works through the problem, and reports its work back to you with regular check-in points. It can:

• Read your entire workspace to understand context.
• Plan multi‑step fixes or refactors (and show you the plan first).
• Apply changes, run tests, and iterate in a tight feedback loop.
• Ask for guidance whenever intent is ambiguous.
• Run and refine its own work through an “agentic loop”—planning, applying changes, testing, and iterating.

Rather than just responding to requests, Copilot in agent mode actively works toward your goal. You define the outcome, and it determines the best approach—seeking feedback from you as needed, testing its own solutions, and refining its work in real time. 

Think of it as pair programming in fast forward: you’re watching the task unfold in real time, free to jump in or redirect at any step. ✨

Coding agent: An AI teammate that works while you don’t 

Not all coding happens in real time. Sometimes, you need to hand off tasks to a teammate and check back later.

That’s where our coding agent comes in—and it’s our first step in transforming Copilot into an independent agent. Coding agent spins up its own secure dev environment in the cloud. You can assign multiple issues to Copilot, then dive into other work (or grab a cup of coffee!) while it handles the heavy lifting. It can:

• Clone your repo and bootstrap tooling in isolation.
• Break the issue into steps, implement changes, and write or update tests.
• Validate its work by running your tests and linter.
• Open a draft PR and iterate based on your PR review comments.
• Stream progress updates so you can peek in—or jump in—any time.

Working with coding agent is like asking a teammate in another room—with their own laptop and setup—to tackle an issue. You’re free to work on something else, but you can pop in for status or feedback whenever you like.

Less TODO, more done: The next stage of Copilot’s agentic future

The next stage of Copilot is being built on three converging pillars:

1. Smarter, leaner models. Ongoing breakthroughs in large language models keep driving accuracy up while pushing latency and cost down. Expanded context windows now span entire monoliths, giving Copilot the long-range “memory” it needs to reason through complex codebases and return answers grounded in your real code.
2. Deeper contextual awareness. Copilot increasingly understands the full story behind your work—issues, pull-request history, dependency graphs, even private runbooks and API specs (via MCP). By tapping this richer context, it can suggest changes that align with project intent, not just syntax.
3. Open, composable foundation. We’re designing Copilot to slot into your stack—not the other way around. You choose the editor, models, and tools; Copilot plugs in, learns your patterns, and amplifies them. You’re in the driver’s seat, steering the AI to build, test, and ship code faster than ever.

Taken together, these pillars move Copilot beyond a single assistant toward a flexible AI teammate—one that can help any team, from three developers in a garage to thousands in a global enterprise, plan, code, test, and ship with less friction and more speed.

So, get ready for what’s next. The next wave is already on its way.