Claude Code Agent View Slow? Stabilize Parallel CLI Sessions With Clash in 2026

Why Agent View turns one developer into a small traffic fan-out

A single interactive Claude Code session already blends model calls with local tooling. Agent View stacks several of those loops side by side, which means your workstation may sustain multiple outstanding requests to api.anthropic.com while also pulling documentation, refreshing OAuth tokens, streaming large repository reads, and downloading incidental assets from CDNs that only appear in logs when something stalls. The mental model is no longer “open one tab and wait.” It is closer to a CI farm that happens to live inside your editor: bursty parallelism, shared kernel buffers, and UI threads that paint partial results as soon as any child process returns bytes.

From a networking standpoint, parallel agents punish inconsistent split rules. One terminal might honor HTTPS_PROXY while another inherits a sanitized environment; macOS sandboxed helper processes sometimes ignore GUI proxy panels; on Windows under WSL you can resolve DNS on the NT side while TCP exits through a Linux adapter that points elsewhere. Clash cannot rewrite every IDE bug, but it can ensure the externally visible destinations—especially the Anthropic API family and the developer bundle around Git, npm, and GitHub—resolve to the same policy group so sessions stop racing each other across unrelated pools.

Stalls are not always “Anthropic is down”—split routing vs saturation

Before you rewrite profiles, classify the stall. If CPU pegs or disk I/O is saturated, no proxy will fix frame drops in the IDE—profile locally first. When CPU is calm yet tokens trickle and terminals report ETIMEDOUT to registries, you are usually looking at network contention masquerading as product lag. Mixed exits produce the cruelest pattern: one agent streams smoothly while another silently retries behind a half-open tunnel, so the UI paints “active” states that mask a dying connection.

Service-side throttling can also appear when you launch many parallel sessions at once, but routing-induced problems are distinguished by domain-specific failures: model calls fail while GitHub looks fine, or the inverse when large tarball hosts take a domestic shortcut. Clash connection logs make that separation obvious because you can read the matched policy row beside each failing hostname. If you skip logging, you end up cycling node selection at random, which occasionally works and therefore convinces you the stack is mystical instead of measurable.

Build one Anthropic-plus-CLI bundle ahead of coarse GEOIP

Clash evaluates split rules from top to bottom until the first match. Remote providers are convenient until a freshly merged GEOIP,CN row leaps above your hand-crafted developer stack or a tracker list accidentally captures OAuth telemetry you still rely on. For Claude Code, pin suffixes for anthropic.com and the Anthropic API edges your organization actually calls—some enterprises front the vendor with regional gateways—then group npm registry hosts, GitHub domains, and any authenticated download mirrors your logs reveal. The objective is not “maximize blocking,” it is predictable routing so every concurrent agent competes fairly for the same healthy exit rather than randomly inheriting leftover rows intended for entertainment traffic.

Place those explicit DOMAIN-SUFFIX entries above broad imports. Keep domestic-only services on DIRECT with their own precise rows so they never wander into foreign pools by accident. Push catch-all MATCH decisions to the bottom only after you are satisfied that parallel tool traffic cannot be swallowed by a neighbor category like “cloud storage” that might include release artifacts or model weights mirrors. When merged lists collide, narrow the upstream list or insert a narrower local row—whichever preserves developer workflows without silently breaking unrelated consumer rules.

This layering pairs naturally with the guidance in the Cursor developer routing companion, because many teams run Cursor and Claude Code concurrently; consistent bundles across editors reduce the odds that two products fight for different exits on the same machine.

Parallel sessions change the shape of TLS: plan for concurrency, not bursts

Interactive chat in a browser often resets connections frequently enough to hide mediocre proxies. Parallel CLI agents keep multiple TLS sessions hot simultaneously, interleaving chunked uploads, tool metadata fetches, and streaming completions that resemble server-sent events. Some exit nodes optimize for short web bursts and collapse when four independent agents hold long idle phases while still expecting timely heartbeats. Others handle concurrency well but sit behind relays that add compounding jitter.

Connection pools add another axis: npm clients may open numerous parallel sockets while Git runs fetch concurrently; if those pools exit through different policy groups, the operating system still schedules disk writes fairly, yet the network stack contends with asymmetric latency. You experience that as uneven progress bars scattered across Agent View, even though each isolated test looks green.

If you operate under WSL2, treat split-brain DNS as a first-class suspect—Windows and Linux stacks frequently disagree about resolvers. Our WSL2 mirrored networking walkthrough walks through port alignment patterns that reduce mysterious half-timeouts when Linux tools spawn beside a Windows-hosted IDE.

• Anthropic API streams: keep on a pool tuned for long sessions rather than headline Mbps.
• Package downloads: ensure tarball CDNs share the same policy group as API calls unless you consciously isolate bulk transfers.
• Git and GitHub: pin both command-line Git and HTTPS helper traffic so large clones do not contend with unrelated streaming rules.

DNS alignment, fake-ip, and when TUN rescues Agent View shells

Misaligned DNS is a classic parallel-session amplifier. Under fake-ip, applications may receive synthetic addresses that only make sense inside Clash’s mapping; if any resolver bypasses the core while packets still traverse it, each concurrent agent multiplies the odds that one process resolves “real” addresses while another consumes fake ones. Under redir-host or mixed stacks, ensure DHCP-provided servers, OS caches, and Clash nameserver entries agree about which queries forward where.

Embedded terminals complicate inheritance: a parent IDE might pick up system proxy settings while a child shell drops them depending on how the integration bootstraps PTY sessions. Environment-based routing helps until it does not—some language runtimes and package managers ignore proxies outright. Kernel-level TUN capture drags those stubborn binaries into the same policy world as everything else, at the cost of revisiting DNS because more processes participate. After enabling TUN, revalidate fake-ip interactions immediately; TUN magnifies resolver drift, especially when parallel sessions each spawn their own language runtimes.

If you see ETIMEDOUT, read the DNS and fake-ip troubleshooting guide before you interpret the symptom as vendor outage. Most “Claude is slow today” reports collapse into resolver or mapping issues once you log per-host failures while agents run in parallel.

Node selection under load: fewer vanity tests, more steady concurrent streams

Synthetic speed tests rarely predict how an exit behaves with three simultaneous hour-long coding loops. Prefer routes with stable small-packet latency and low loss toward both Anthropic edges and GitHub fronts, not only whichever city topped a leaderboard over the weekend. Watch tail latency: developer tooling frequently waits on the slowest round-trip in a pool, and parallel sessions amplify tails.

If your subscription offers health checks, tune intervals to avoid flapping—aggressive probes can mark good nodes “bad” while sluggish probes keep you glued to a degrading path. When large downloads must coexist with interactive streams, split bulk pools from API pools if your client allows concurrent selections; otherwise schedule heavy installs between agent bursts so you do not starve token flows. Treat relay chains skeptically: every extra hop multiplies failure modes, and concurrent agents multiply the probability that one hop misbehaves at any instant.

For always-on remote builders running multiple agents continuously, see the headless Clash Meta Linux guide for systemd persistence ideas that keep unattended hosts from reverting to broken defaults overnight.

YAML sketch: where to pin Anthropic, terminals, and shared CDNs

The following fragment is illustrative—rename AI_DEV to match your profile and expand suffixes from your own logs. Keep Anthropic rows near the top, ahead of imported GEOIP data.

# Illustrative split rules—verify policy groups and expand domains from logs
rules:
  - DOMAIN-SUFFIX,anthropic.com,AI_DEV
  - DOMAIN-SUFFIX,api.anthropic.com,AI_DEV
  - DOMAIN-SUFFIX,claude.ai,AI_DEV
  - DOMAIN-SUFFIX,npmjs.org,AI_DEV
  - DOMAIN-SUFFIX,github.com,AI_DEV
  - DOMAIN-SUFFIX,githubusercontent.com,AI_DEV
  # Add OAuth or enterprise front domains your org uses
  - GEOIP,CN,DIRECT
  - MATCH,AI_DEV

Quarterly maintenance matters because CDNs migrate and vendor edges add hostnames. Diff your overrides against fresh Clash logs after major subscription updates; delete stale rows that no longer appear in traffic captures and add newcomers the first day you see them during a real multi-agent session rather than months later when nobody remembers which import broke things.

Symptom	First check	Second check
One agent fast, another frozen	Per-host policy mismatch in logs	Child process bypassing proxy env
Token stream stalls mid-run	Node idle timeout behavior	Concurrent large downloads on other agents
npm or Git errors only under parallel load	Tarball CDN hostname coverage	DNS fake-ip vs resolver drift

FAQ

Why does Agent View lag only when I run multiple sessions?

Parallel loops multiply concurrent HTTPS work. If any subprocess exits elsewhere, the UI waits on the slowest leg. Align Anthropic API, package, and Git traffic into one coherent policy group so contests happen on throughput—not on conflicting routes.

Does this replace MCP-focused Claude Code guidance?

No—combine both. MCP adds tool transports and discovery calls; Agent View adds simultaneous orchestration pressure. The routing primitives stay the same: ordered rules, honest DNS, steady nodes, and logging that attributes each failure to a hostname.

When should I skip TUN?

If every process in your stack already respects a single system proxy and logs show uniform policy matches under parallel load, TUN may be unnecessary overhead. Reach for TUN when embedded terminals spawn binaries that ignore environment variables while the IDE itself behaves.

Practical checklist for parallel Agent View sessions

Choose clarity over mystery when terminals multiply

Many turnkey network utilities optimize for a single browser window. They leave terminal stacks fractured: one process respects legacy proxy variables, another follows the system menu, and embedded shells spawned by AI panels inherit whichever environment the integration remembered that morning. Under parallel sessions, that inconsistency surfaces as phantom “Agent View jank” and mysterious Anthropic outages when the real issue is simply several egress stories competing on one machine.

Clash is built for legibility: named policy groups, rule order you can defend in code review, and logs that map each flow to the row responsible. When Anthropic API calls, CLI tooling, and package CDNs share a coherent path, the split routing work you invest pays off every time you spin up another parallel agent without rewiring the house.

If you want that predictability while building with Claude Code in 2026, download Clash for free and codify your developer bundle once; future Agent View sessions stay responsive for the right reasons—stable nodes, honest DNS, and routing you can explain to your team.