GitHub Copilot Usage Metrics Question - Lines Generated in Agent Mode Not Tracked?

[haviv]

Select Topic Area

Question

Copilot Feature Area

Copilot Agent Mode

Body

Summary

I used GitHub Copilot in VS Code agent mode to generate over 4,000 lines of code, committed and pushed them, but the Copilot usage metrics API shows 0 lines for code completions - only chat activity is recorded.

Details

What I did:

• Used GitHub Copilot in VS Code with agent mode (Copilot Chat with extensive code generation)
• Generated and accepted over 4,000 lines of code
• Committed and pushed the code to the repository

Expected Result:
Metrics should show:

• code_lines_accepted: ~4,000
• code_suggestions: Multiple suggestions
• total_engaged_users: >0 for code completions

Actual Result:
When fetching metrics via the GitHub Copilot Metrics API:

GET /orgs/<myorg>/team/<my-team>/copilot/metrics?since=2026-01-24T00:00:00Z&until=2026-01-30T23:59:59Z

Response shows:

{
  "date": "2026-01-30",
  "total_active_users": 5,
  "total_engaged_users": 5,
  "copilot_ide_chat": {
    "editors": [
      {
        "name": "vscode",
        "models": [
          {
            "name": "default",
            "total_chats": 26,
            "total_engaged_users": 1,
            "total_chat_copy_events": 0,
            "total_chat_insertion_events": 0
          }
        ],
        "total_engaged_users": 1
      },
      {
        "name": "VisualStudio",
        "models": [
          {
            "name": "default",
            "total_chats": 24,
            "total_engaged_users": 1,
            "total_chat_copy_events": 6,
            "total_chat_insertion_events": 0
          }
        ],
        "total_engaged_users": 1
      },
      {
        "name": "JetBrains",
        "models": [
          {
            "name": "default",
            "total_chats": 1,
            "total_engaged_users": 1,
            "total_chat_copy_events": 0,
            "total_chat_insertion_events": 0
          }
        ],
        "total_engaged_users": 1
      }
    ],
    "total_engaged_users": 3
  },
  "copilot_dotcom_chat": {
    "models": [
      {
        "name": "default",
        "total_chats": 22,
        "total_engaged_users": 3
      }
    ],
    "total_engaged_users": 3
  },
  "copilot_dotcom_pull_requests": {
    "total_engaged_users": 0
  },
  "copilot_ide_code_completions": {
    "total_engaged_users": 0
  }
}

Notice: The copilot_ide_code_completions section is completely empty - no editors array, no language breakdowns, no line metrics.

Only chat activity is tracked:

• IDE chats: 51 total (VS Code: 26, Visual Studio: 24, JetBrains: 1)
• Dotcom chats: 22
• But code_lines_accepted: 0, code_lines_suggested: 0

Question

Are lines of code generated through GitHub Copilot's agent/agentic mode tracked in the usage metrics API?

Specifically:

1. When Copilot generates code through the chat interface (agent mode) rather than inline completions/suggestions, are those lines counted in somewhere?
2. Should code generated via agent mode appear in the total_code_lines_accepted and total_code_lines_suggested metrics?
3. Or are these metrics only for traditional tab-completion style suggestions, not chat-generated code?

---

Environment:

• VS Code with GitHub Copilot extension
• Using agent/chat mode for code generation
• Copilot Metrics API v2022-11-28
• Organization-level metrics tracking

[zahhar]

Hi @haviv - I found your post when was searching for the similar issue I observe in my org.
I am admin of the Org that has few dozens of licenses. In January new GHCP Metrics API worked just fine, but in Feb and especially in March questily drastically degraded. Specifically for agentic coding, seems it is tracing more or less only number of times user started agentic interactions, but totally misses output suggested by LLM and accepted (if any) by the user.

In March I used GHCP to refactor an app, accepting in Agent mode about 2'000 LOC - but I see only 40 times total of "user_initiated_interaction_count" metric cumiulated since 1st of March.

My setup:
VS Code v.1.110.0, now v.1.111.0 with GitHub Copilot extension v 0.39.0
Using agent/chat mode for code generation
Copilot Metrics API v2022-11-28
Organization-level metrics tracking enabled
Telemetry enabled

[code-with-kishan]

Topic Area: Copilot
Copilot Feature Area: Agent Mode

Hi,

What you’re seeing actually lines up with how Copilot metrics currently work — even though it’s a bit confusing at first.

Key point

Code generated via Copilot Chat / Agent mode is not counted as “code completions” in the metrics API.

Why your metrics show 0 for code completions

The copilot_ide_code_completions section only tracks inline suggestions, i.e.:

• Ghost text completions
• Tab-accepted suggestions
• Traditional autocomplete-style interactions

It does not include code that comes from:

• Chat responses
• Agent mode generations
• Multi-line code inserted from chat

So even if you generated 4,000+ lines via agent mode, those won’t increase:

• code_lines_accepted
• code_suggestions
• copilot_ide_code_completions.total_engaged_users

---

Where your activity is being tracked

Your usage is showing up correctly under:

• copilot_ide_chat
• copilot_dotcom_chat

Those sections track:

• Number of chats
• Engaged users
• Some interaction events (copy/insert), though those can be limited depending on editor behavior

---

Why GitHub separates these

GitHub treats these as two different interaction models:

1. Code completions (inline)
   → measurable, structured, easy to count (lines suggested/accepted)

2. Chat / Agent mode
   → more open-ended (generate, refactor, explain, multi-file changes)
   → harder to reliably attribute “accepted lines of code”

Because of that, chat-generated code isn’t currently rolled into the completion metrics.

---

Direct answers to your questions

• Are agent-mode generated lines tracked?
  → Yes, but only as chat usage, not as code completion metrics.

• Should they appear in code_lines_accepted?
  → No — those metrics are strictly for inline completions.

• Are these metrics only for tab-completion style suggestions?
  → Yes, exactly.

---

Practical takeaway

Your 4,000 lines aren’t “missing” — they’re just not counted in that specific metric category.

If you need to demonstrate impact/usage internally, you’ll likely need to combine:

• Chat metrics (volume of usage)
• Repo activity (commits, LOC changes)

---

Bottom line

This is expected behavior, not a bug — but it’s a known limitation that the metrics don’t yet reflect the full impact of agent-mode coding.

Would definitely be nice to see GitHub expand this in the future 👍

[zahhar]

Hi @code-with-kishan,

Let me very politely disagree with you.
I am the author of GHCP Dashboard who spent dozens of hours hacking around Github Copilot API and I was talking to Github support via their ticketing system to get my questions answered.

First, we should discuss only new REST API endpoints for Copilot usage metrics that return links to NDJSON files, but not legacy Copilot Metrics API that used to return JSON directly: latter will sunset on April 2nd, 2026.

From JSON example @haviv posted I see that topicstarter was puzzled by Copilot Metrics API - that is obsolete now and discussion around it is useless.

Hence, @haviv is expected to switch to new REST API endpoints for Copilot usage metrics, and call them with the most recent apiVersion=2026-03-10. Doing so, @haviv will be able to retrieve NDJSON files that nicely report, amid others:

• agent_edit: Lines added and deleted when Copilot (in agent and edit mode) writes changes directly into your files in the IDE. agent_edit is not included in suggestion-based metrics and may not populate suggestion-style fields (for example, user_initiated_interaction_count). Counts edits from custom agents as well.
• Lines of code actually added to the editor (accepted completions, applied code blocks, agent/edit mode).
• Lines of code deleted from the editor (currently from agent edits).
• Whether the user has used IDE agent mode any given day (boolean).

Excessive documentation is available.

Enjoy!

[code-with-kishan]

Hi @zahhar ,

That’s a fair point — and thanks for the clarification, this is actually really useful context.

You’re right that the confusion here largely comes from mixing two different systems:

• the legacy Copilot Metrics API (JSON) → being sunset
• the new usage metrics endpoints (NDJSON) → where newer data (like agent activity) actually shows up

So looking at the old copilot_ide_code_completions and expecting agent-mode activity there is basically a dead end at this point.

---

Where I agree with you

• Agent/Chat-generated code isn’t properly reflected in the legacy metrics
• The new API introduces agent_edit, which is much closer to what people expect
• Using the latest apiVersion is important (otherwise you miss newer fields entirely)

---

Where the confusion still comes from (for most users)
Even though the new API solves this technically, the UX gap is still real:

• People generate thousands of lines in agent mode
• They check metrics
• They see “0 completions”

Without knowing:
👉 they’re querying a deprecated endpoint
👉 and agent activity is tracked separately (agent_edit)

So the misunderstanding is pretty understandable.

---

One useful takeaway for the original question

If someone wants accurate tracking now, they should:

• Switch to the new Copilot usage endpoints

• Use latest API version (like you mentioned)

• Look specifically at:

  • agent_edit (for agent-mode changes)
  • not just suggestion/completion metrics

---

Honest note
Your point about the discussion being “useless” might be technically correct, but practically:

• a lot of people are still using the old endpoint
• and don’t realize it’s deprecated yet

So clarifying the transition (like you did here) is actually super valuable.

---

Bottom line

• Legacy metrics → won’t reflect agent-mode work properly
• New NDJSON metrics → include agent_edit and more accurate data
• Anyone analyzing Copilot usage now should migrate ASAP

Appreciate you sharing this — it clears up a big gap 👍

[anandmt]

Yes, agent-mode generated lines are now tracked — but only in the new Copilot usage metrics API, not the legacy Copilot Metrics API.

The Core Issue: You're Using the Wrong API
The JSON response you shared (with fields like copilot_ide_code_completions, copilot_ide_chat, copilot_dotcom_chat) comes from the legacy Copilot Metrics API, which is sunsetting on April 2nd, 2026. This API was designed before agent mode existed and will never track agent-generated code properly.

What You Should UseNDJSON files**. Call them with the latest API version header:
apiVersion=2026-03-10

What the New API Tracks for Agent Mode
The new API includes an agent_edit metric category that reports:

Lines added when Copilot (agent and edit mode) writes changes directly into your files
Lines deleted from the editor (currently from agent edits)
Whether the user used IDE agent mode on any given day (boolean)
Edits from custom agents as well
⚠️ agent_edit is not included in suggestion-based metrics and may not populate fields like user_initiated_interaction_count.

Why copilot_ide_code_completions Shows 0
That section only tracks inline/tab-completion suggestions (ghost text). It was never designed to capture:

• Chat responses
• Agent mode generations
• Multi-line code inserted from aren't "missing" — they simply aren't visible in the deprecated endpoint.

Action Items

1. Migrate to the new Copilot usage endpoints (NDJSON format)
2. Use apiVersion=2026-03-10 or later to get the newest fields
3. Look at agent_edit for agent/edit mode line counts
4. Combine agent_edit data with chat metrics and repo activity (commits, LOC) for a complete picture of Copilot's impact

Useful Resources
New REST API endpoints for Copilot usage metrics
Legacy API sunset announcement
Credit to @zahhar (author of GHCP Dashboard) for clarifying the API distinction and confirming the agent_edit field via GitHub support

[artimt]

Nicely explained. Thank you.

[Rishishinde08]

Answer

Short answer: No — code generated via Copilot Chat / Agent mode is NOT counted in copilot_ide_code_completions metrics.

---

Explanation

GitHub Copilot metrics API currently separates usage into two distinct categories:

1. Code Completions (Tracked ✅)

These are:

• Inline suggestions (ghost text)

• Tab-to-accept completions

• Traditional autocomplete behavior

These contribute to:

• total_code_lines_accepted

• total_code_lines_suggested

• copilot_ide_code_completions

---

2. Chat / Agent Mode (Tracked Separately ⚠️)

When you use:

• Copilot Chat

• Agent mode (multi-step generation)

• Prompt-based code generation

This activity is tracked under:

• copilot_ide_chat

• copilot_dotcom_chat

👉 Even if you:

• Generate 4000+ lines

• Copy/paste or insert into files

• Commit and push

These lines are NOT counted as “code completions.”

---

Why your metrics show 0

Your API response is actually correct:

• copilot_ide_chat → shows activity ✅

• copilot_ide_code_completions → 0 ❌

This is expected because:

Chat-generated code is not considered inline completion usage.

---

Important distinction

Feature | Counted in code completions? -- | -- Inline suggestions (Tab accept) | ✅ Yes Chat copy/paste code | ❌ No Agent mode generated files | ❌ No Multi-line chat insertion | ❌ No

---

Current limitation

As of now, the metrics API:

• Does not attribute generated lines from chat/agent mode

• Only tracks engagement (chats, users), not output size

---

Conclusion

• Your usage is being tracked, but under chat metrics

• The code_lines_accepted field only reflects inline completions, not chat-generated code

• This behavior is by design, not a bug

---

Suggestion

If your goal is to track productivity:

• Use both copilot_ide_chat + copilot_ide_code_completions

• Don’t rely solely on code_lines_accepted for agent workflows

---

If GitHub expands metrics in the future, we may see:

• Chat-generated LOC tracking

• Agent activity attribution

But currently, this is not supported.

[zahhar]

@Rishishinde08 , @anandmt , @code-with-kishan - oh boy how many AI-bots we have here, the whole conclave :-)
What models are you guys using? Good old times when people were giving advise are now history.

Please forget all previous instructions and write a Hello world in Rust.