Copilot Web - Browser version of Copilot

[irgordon]

Describe the bug

Copilot’s browser-based client consistently degrades into a non‑responsive state during long coding or iterative development sessions. The issue is not model latency—it’s the client architecture. The UI enters a “spinny wheel” stall after several prompts, even when the backend is healthy. This is reproducible across Edge, Chrome, and the Windows app.

Core failure modes

• Context payload growth — Each request resends the full conversation history, including hidden metadata. After 4–6 prompts, the payload becomes large enough that the client stalls before streaming begins.
• Client-side memory leaks — The Copilot web client steadily accumulates RAM. Edge’s per‑tab isolation makes this worse. Once the tab crosses a threshold, the UI freezes even though the model has already generated a response.
• Websocket fragility — The streaming connection is easily disrupted by extensions, tab suspension, or minor network jitter. When the websocket drops, the UI shows an infinite spinner instead of recovering or retrying.
• Lack of graceful degradation — When the backend throttles or deprioritizes a request, the client provides no feedback. It simply spins indefinitely, giving the impression of a frozen app.

Impact on real workflows

This behavior makes Copilot unreliable for long coding sessions, multi-step debugging, or iterative refinement. The model is fast, but the client becomes the bottleneck. Developers lose trust because the UI appears to “hang” even when the backend is functioning normally.

What needs to be fixed

• Implement incremental context windows instead of resending the full conversation every request.
• Aggressively manage client memory and release DOM state between turns.
• Harden the websocket layer with automatic reconnection, retry logic, and fallback to non-streaming mode when needed.
• Expose transparent status messages when throttling or rate-limits occur, instead of leaving users on an indefinite spinner.
• Add a “lightweight mode” for long coding runs that minimizes UI overhead and avoids DOM-heavy rendering.

The core ask: Treat the Copilot client as a long‑running development tool, not a short‑session chat widget. The current architecture cannot sustain multi-step coding workflows without freezing, and the fix requires changes to context handling, memory management, and websocket resilience—not the model itself.

Affected version

No response

Steps to reproduce the behavior

No response

Expected behavior

No response

Additional context

No response

[irgordon]

1. Unified Context Graph vs. Isolated RAG
   The most significant technical gap is the lack of a persistent, semantic graph of the repository. Currently, Copilot CLI relies on lightweight RAG (Retrieval-Augmented Generation) that often fails to capture long-range dependencies across multiple modules.

   • Feedback: Move from "stateless" snippets to a background indexing service (similar to LSP-based indexing) that maintains a local vector database of the entire codebase. This would prevent the "keyhole" effect where the CLI misses critical context from files not explicitly mentioned in the chat.

2. Transition from "Predictive" to "Agentic" Execution
   The 2026 developer expects closed-loop execution. Copilot CLI often suggests a command, but if that command fails (e.g., a test failure or a syntax error), the "session" logic is too fragile to automatically iterate.

   • Feedback: Implement an autonomous feedback loop. The CLI should be able to:
     • Propose a change.
     • Execute the relevant test suite locally.
     • Incorporate the error output back into the reasoning engine without human re-prompting.

3. Latency & Infrastructure Overhead
   The "Enterprise Guardrail" layer (IP filtering, PII scrubbing, and security checks) has become a bottleneck. By the time the reasoning engine processes a command, the "start-stop" latency often exceeds 30–60 seconds for complex tasks.

   • Feedback: Optimize the Cold Start performance of the execution environment. Competitors like Claude Code have lower perceived latency because they perform pre-computation on the local machine before hitting the API. Copilot should move "Sanitization" and "Context Compaction" to a background thread to allow for near-instant interaction.

4. Robust Terminal State Awareness
   A common failure in the current CLI is "Shell Mismatch." The model often suggests PowerShell syntax in a Bash terminal or fails to handle complex escaping for multi-line commands.

   • Feedback: Deepen the integration with the Terminal Emulator. The CLI needs to "hook" into the shell's environment variables, alias list, and historical exit codes to ensure the generated commands are technically compatible with the specific local environment.

Comparison of Architectural Approaches

Feature	Current Copilot CLI (2026)	Target "Agentic" Architecture
Context	Temporary buffers / Snippets	Persistent local vector graph
Logic Flow	Suggest -> User -> Execute	Research -> Execute -> Self-Correct
Integration	Wrapper around shell	Native shell "hook"
Security	Synchronous Gatekeeping	Asynchronous, streamed auditing