GitHub Copilot's coding agent is no longer waiting for developers to tell it what to do. According to a new Microsoft research paper analyzing real production traffic from 3.2 million users, 87% of the language model (LLM) calls behind GitHub Copilot's agent mode are self-initiated, meaning the agent is autonomously chaining together multiple steps to explore code, run commands, and make edits before handing control back to the human developer.

This finding comes from "Agentic Coding in the Wild," a research paper by six Microsoft-affiliated researchers who analyzed anonymized telemetry data from one week of GitHub Copilot traffic in June 2026. The dataset is substantial: 13.5 million sessions, 760.5 million LLM calls, and 44.9 trillion prompt tokens. Unlike benchmark scores or vendor demos, this is real usage data from one of the world's largest AI coding tool deployments.

What Does "Agent-Initiated" Actually Mean?

When a developer sends a single message to GitHub Copilot's agent mode, they're not getting a single response. Instead, the agent autonomously chains together multiple steps. The median session contains 4.5 LLM calls and 4 tool invocations per turn, with an average of 6.6 LLM calls before the agent returns control to the human. This is fundamentally different from a chatbot exchange, where one question produces one answer.

The agent's workflow mirrors what any developer would recognize: it reads files to understand the codebase, runs terminal commands to test changes, and edits code across a repository with minimal human intervention between steps. The three most common tools the agent uses are file retrieval (35% of tool calls), running terminal commands (17%), and editing strings within files (9.8%), accounting for over 60% of all tool invocations.

Why Does the Token Math Look So Different From Chat?

The paper reveals a striking asymmetry in how these LLM calls are shaped. The median call processes about 68,000 prompt tokens but generates only 247 completion tokens, a roughly 275-to-1 input-to-output ratio. This inverted shape comes from the agentic loop itself: every step re-reads large amounts of code and prior tool output as context, then produces a comparatively tiny action, like a single edit or a short reasoning step.

Six distinct turn archetypes emerged from the data, each representing a different type of coding task the agent handles autonomously:

• Deep-loop read: Exploration-heavy file retrieval, accounting for 30.5% of turns
• LLM-only: Pure reasoning with no tool calls, representing 20.2% of turns
• Multi-cycle edit: Read-modify-build loops that make up 19% of turns
• Multi-cycle other: Read-dominant turns with minimal changes, comprising 13.2% of turns
• Deep-loop with failures: Retry loops that amplify compute up to 4 times, accounting for 9.1% of turns
• Deep-loop run: Terminal-heavy execution, representing 8.1% of turns

How Does This Break Traditional AI Infrastructure?

The paper's core argument is that serving systems designed for stateless, short chat requests are the wrong architecture for agentic coding traffic. Several infrastructure challenges emerge from the real-world data:

Cache behavior becomes fragile across session boundaries. Prefix cache hit rates climb from 45% on a turn's first call to 92-94% by the third or fourth call within that turn, but crossing a turn boundary with the same model drops the hit rate by 26 percentage points. Switching models entirely collapses cache hits to just 8%, effectively a full reset.

Session length is wildly skewed. The median session runs 4.2 minutes with 15 LLM calls across three turns, but the mean reaches 62.6 minutes, a nearly 15-fold spread showing that long-running outlier sessions dominate total resource consumption. User behavior also varies dramatically: five behavioral archetypes emerged, ranging from "Readers" using 203,000 tokens per turn to "Deep-loop users" consuming 1.1 million tokens per turn during large refactors.

What Does This Mean for the Future of AI Coding Tools?

The 87% figure signals that agentic behavior has already gone mainstream within professional software development, even if it hasn't yet become the dominant pattern for consumer AI use. This is a narrow but technically sophisticated surface: developers using GitHub Copilot's agent mode are already working in a fundamentally different paradigm than chat-based AI assistants.

The infrastructure implications are significant. Systems built to serve millions of simultaneous chat requests need rethinking when 87% of the traffic is self-extending chains of autonomous steps. Cache strategies, session management, and resource allocation all need to account for the fact that a single human turn can trigger dozens of model calls and tool invocations before completion.

Steps to Understand Agentic Coding Patterns

For developers and infrastructure engineers tracking this shift, several practical insights emerge from the research:

• Monitor turn composition: Track which of the six turn archetypes dominate your user base, since deep-loop reads and multi-cycle edits consume far more compute than LLM-only reasoning turns
• Plan for cache fragmentation: Design serving systems that expect 26-percentage-point cache hit rate drops at turn boundaries, and account for the 8% hit rate when switching between different models mid-session
• Account for behavioral variance: Recognize that your heaviest 9% of users (deep-loop users) may consume 5 times more tokens per turn than your median user, requiring infrastructure tuned for outliers, not averages
• Expect session length skew: Plan for a 15-fold spread between median and mean session duration, meaning long-running refactor sessions will dominate your total resource consumption despite being rare

The Microsoft research paper provides the first large-scale, production-level view of how agentic coding actually behaves when millions of developers use it simultaneously. The 87% figure isn't just a headline; it's evidence that the shift from request-response chat to autonomous, multi-step agent loops is already reshaping how AI coding infrastructure needs to be built.