Why “Anthropic Cowork slow” is a routing-shaped story in 2026
If you landed here after typing combinations of Anthropic Cowork, Claude desktop, and Clash split routing, chances are the symptom felt insultingly vague: the collaborative workspace spins, dependency installs stutter, or model replies arrive in fits, yet a handful of ordinary browser tabs still fetch documentation quickly enough to trick you into blaming “the model” first. Early‑2026 coverage of Anthropic’s Cowork direction—desktop collaboration rather than a quiet terminal-only loop—reshaped how practitioners talk about the problem. The public narrative often compresses everything into a single brand, whereas packet traces almost always reveal multiple commercial stacks interleaving behind one window.
Routers cannot manufacture capacity that never existed, but they can stop you from sabotaging yourself. When Anthropic API traffic shares the same overloaded selector as fat GitHub downloads or bursty npm registry sessions, one congested exit poisons the whole loop. Mihomo‑compatible Clash cores give you programmable lanes—policy groups, ordered rules, visible connection logs—so your diagnosis distinguishes a flaky node from a misrouted CDN hostname.
This article assumes you already run Rule mode with a sane baseline profile. It focuses on the traffic families Cowork‑shaped workloads amplify, how to carve them without treating 2026 forum lists as scripture, and how to align DNS so fake‑ip surprises do not masquerade as API outages.
Cowork versus Claude Code CLI versus IDE agents: same vendor, different packet choreography
Confusion multiplies because every vendor article blurs the word “workspace.” Anthropic Cowork discussions center on collaborative desktop surfaces and shared project context—an experience closer to living inside an integrated environment than copy‑pasting into a headless REPL. By contrast, Claude Code style CLIs inherited shell inheritance quirks: HTTP_PROXY variables, tool subprocesses that bypass GUI toggles, and bursts of Git operations tied to scripted automation. IDE agents—think Cursor 3 Composer or cloud offload features—add yet another orchestra of orchestration calls distinct from both Cowork and the CLI.
Our companion write‑up for Claude Code CLI timeouts dives deep into terminal stacks. Read it when npm and GitHub failures propagate through bash or PowerShell sessions. Return here when the failure mode is anchored in a Cowork‑style desktop loop where UI responsiveness and streaming model tokens fight for the same path as background package installs.
Likewise, multi‑repository IDE guidance in Cursor 3 split routing remains relevant when editor extensions spam GitHub metadata. Cowork may not be Cursor, but the lesson rhymes: heterogeneous automation stacks collide if routing is monolithic.
Name the traffic families before you curse the CDN
Effective Clash profiles begin with observability buckets rather than trendy keywords. When a Cowork-style session fans out, you will usually see several recurring families—none of which deserve identical node policies.
Anthropic API plane. Long‑lived HTTPS requests, streaming token payloads, session renewals, and console‑adjacent calls that punish latency jitter. The user‑visible symptom might read as “thinking forever,” yet the underlying transport behaves like an SSE‑heavy API client more than a static site.
GitHub delivery plane. Metadata APIs, raw object retrieval, release artifacts, and large Git LFS transfers can each land on different host suffixes or geographic edges. A crude DOMAIN-KEYWORD,github hack may sort trivia nights; it will not reliably separate API throttling from multi‑megabyte blobs riding dissimilar paths.
npm registry and tarball plane. Small JSON metadata hops contrast sharply with lengthy .tgz downloads from edges that may follow unrelated geography. If your defaults send tarball hosts through a saturated upstream while metadata squeezes through DIRECT, installs fail mysteriously even when chat streaming “looks fine.” The registry versus tarball split article unpacks that split in detail.
Collateral SaaS calls. Authentication, billing checks, telemetry you approved, and third‑party crash reporters sneak into traces even if the UI never surfaces them. They matter when your catch‑all overseas pool introduces extra round trips unrelated to model quality.
The takeaway is pedestrian but worth spelling out: split routing survives because traffic shapes differ, not because marketing brochures invented new words in 2026.
Policy groups that respect streaming, bursts, and domestic shortcuts
Legible YAML begins with honest names—nothing stops you from renaming later, but ambiguity kills team runbooks. Consider illustrative selectors such as ANTHROPIC_API for model‑adjacent streaming hosts you actually captured, GITHUB_BLOB for large downloads if logs prove they warrant isolation, NPM_EDGE for registry plus tarball families once you differentiate them, and a conservative DEFAULT for everything else.
Within ANTHROPIC_API, emphasize exits that tolerate long sessions without excessive packet loss—not necessarily the same nodes that excel at saturating generic CDN throughput. Within GITHUB_BLOB, stability and bandwidth may matter more than the last‑mile latency score bragged about in flashy latency tests.
If your baseline profile already includes a dedicated domestic segment—often via GEOIP,CN,DIRECT or refined provider collections—think about whether collateral telemetry should ride that lane deliberately instead of inheriting an accidental foreign detour through fall‑through.
Readers leaning on general Claude advice should still skim the Anthropic Claude split routing primer for conceptual continuity. Cowork simply concentrates more simultaneous families in one desktop footprint.
Make Clash matching deterministic: DOMAIN lines before sleepy GEOIP defaults
Mihomo‑class cores pick the first matching rule and stop. Hobby templates love stuffing giant remote RULE-SET archives upstream of carefully crafted overrides, which effectively buries your lifesaving DOMAIN entries. Another frequent foot‑gun is a premature GEOIP,CN,DIRECT line that snatches hostnames you meant to steer through a latency‑aware proxy because the IP library insists the destination “looks domestic” while the SaaS stack still expects a stable overseas path for auth or token issuance.
Use a disciplined ordering recipe:
- Verified DOMAIN and DOMAIN-SUFFIX overrides sourced from reproducible captures—not nostalgic copy‑pasta—come first.
- Curated RULE-SET subscriptions you personally audited occupy the middle.
- Broad GEOIP shortcuts follow only when policy demands them.
- MATCH selectors conclude the story, preferably pointing at an intentional default rather than chaos.
Avoid lazy keyword rules that accidentally rope in marketing microsites or unrelated SaaS brands that happen to embed trendy substrings. SNI observations age more gracefully than SEO gimmicks.
YAML sketch—illustrative scaffolding you must reconcile with your logs
Never paste blindly into production. Treat the following block as structural inspiration: swap placeholder suffixes for the exact SNIs your connection export proves, insert the block ahead of bulky community rule decks, and delete lines referencing groups you never defined.
# Illustration only—substitute domains and proxies with values from YOUR traces.
proxy-groups:
- name: ANTHROPIC_API
type: select
proxies:
- stream-stable-a
- stream-stable-b
- DIRECT
- name: GITHUB_ASSET
type: select
proxies:
- throughput-stable-a
- throughput-stable-b
- DIRECT
- name: NPM_EDGE
type: select
proxies:
- balanced-a
- balanced-b
- DIRECT
- name: DEFAULT
type: select
proxies:
- daily-driver
- DIRECT
rules:
# Replace examples with suffixes your capture actually shows.
- DOMAIN-SUFFIX,anthropic.com,ANTHROPIC_API
- DOMAIN-SUFFIX,claude.ai,ANTHROPIC_API
- DOMAIN-SUFFIX,github.com,GITHUB_ASSET
- DOMAIN-SUFFIX,npmjs.org,NPM_EDGE
- DOMAIN-SUFFIX,registry.npmjs.org,NPM_EDGE
- GEOIP,CN,DIRECT
- MATCH,DEFAULT
Remember to create every referenced group before you reference it—orphaned names produce silent misroutes that waste hours of existential node rotation.
DNS alignment: fake‑ip, DoH escapes, and split‑brain resolutions
The fastest way to manufacture imaginary Anthropic outages is asking the operating system and Mihomo to resolve identical hostnames through divergent pipelines. Under fake‑ip, the core may synthesize answers that differ from what a browser extension’s hidden DoH client believes, yielding two contradictory endpoints for the same button click.
Before escalating to exotic transports, walk through the DNS hygiene expectations outlined in the connected‑but‑no‑internet DNS guide: reconcile listeners, confirm whether redir‑host or fake‑ip mode matches your subscription assumptions, and chase down any helper that punches past your tunnel with encrypted DNS unless you consciously scoped that behavior.
When QUIC or HTTP/3 compounds confusion, temporarily test a TCP‑only baseline after your DOMAIN mappings stabilize—UDP loss disguises itself as mysterious Cowork stalls when the truth is simply a firewall mangling alternate protocols.
Desktop workspace hooks: system proxy versus TUN when subprocesses misbehave
Cowork‑adjacent applications frequently inherit Electron assumptions: they respect system proxy integrations when listeners stay coherent and Rule mode matches mental models. Reach for TUN only after logs prove auxiliary processes still bypass Mihomo despite sane environment configuration—drivers add complexity you do not need while DNS remains split‑brained.
Terminal companions matter too. If engineers mix Cowork sessions with CLI tooling, align vocabulary using the CLI routing article so environment variables and GUI toggles tell a single story.
Verification ritual you can repeat after every profile edit
- Enable connection logging, reproduce one failing Cowork workflow calmly, and export the SNI or domain column for every participant inside the capture window.
- Tag each hostname with the policy bucket you intend—ambiguous rows mean incomplete data, not subtle Anthropic malice.
- Run three deliberate checks: a domestic site that must stay
DIRECT, a foreign newspaper proving your default foreign lane still moves, and an Anthropic‑shaped API call that confirmsANTHROPIC_APIwithout second‑guessing earlier fall‑through lines. - Contrast tarball downloads against streaming model sessions when npm installs fail—note whether the failing hop belongs to
NPM_EDGEinstead. - Enumerate IPv6 separately. Asymmetrical v6 routing remains an under‑reported culprit behind “random” desktop stalls.
- Restart the workspace client once after major rule edits so stale websocket sessions do not pin obsolete routes.
Symptoms practitioners blame on Cowork versus what logs usually prove
| User-visible pain | Check first in Mihomo logs |
|---|---|
| Streaming answers stutter yet small JSON calls feel crisp | Upstream session host riding a lossy proxy; rotate within ANTHROPIC_API before touching npm groups |
npm install stalls on the same machine where chat still responds |
Tarball host mapped to DIRECT under GEOIP while metadata used a proxied path; align NPM_EDGE |
| GitHub release downloads crawl during a Cowork session | Large object domains diverged from API metadata; refine GITHUB_ASSET overrides |
| Failures appear only on office Wi-Fi | Corporate DNS rewriting or UDP filtering—test with QUIC temporarily disabled |
FAQ: practical answers for 2026 routing threads
Does Cowork publish a blessed hostname matrix? Unlikely in any durable form. Treat vendor host lists as moving targets; your logs—not a screenshot from March—define today’s truth.
Is Global mode acceptable as a permanent fix? Only for narrow forensics. Chronic Global toggling masks GEOIP mistakes later and trains habits incompatible with audited corporate networks.
Should you MITM TLS locally? Almost never for routing. Mihomo already exposes SNI data for flows traversing your core—respect cryptography and local law before contemplating deeper interception.
Honest limits: outages, quotas, and application defects still exist
Disciplined routing cannot conjure capacity during genuine platform incidents, contractual quota exhaustion, or client‑side regressions introduced by rapid 2026 releases. Bailout signals include identical failures across unrelated networks with clean TLS handshakes, coordinated vendor status alerts, or reproducible crashes inside the workspace shell even when Mihomo idles.
Routing also cannot waive terms of service—you are responsible for compliant use of Anthropic, GitHub, and npm resources regardless of clever YAML.
Why programmable Clash cores beat opaque “VPN sliders” for Cowork workflows
Some all‑in‑one VPN apps optimize for glossy throughput charts while hiding actual routing behind unnamed regions. That opacity feels fine until a GitHub blob and an Anthropic API call share an exit that excels at neither job. Lightweight browser proxies are equally frustrating when they lack structured rule order: you end up rotating endpoints by superstition whenever a Cowork session flickers.
Clash and Mihomo‑class stacks sit in a more inspectable middle ground: explicit DOMAIN precedence, honest policy selectors, connection tables you can export, and community patterns that remain diff‑friendly in version control. Combined with DNS literacy and log‑first discipline, they reward practitioners who treat 2026 collaboration tools as systems engineering problems rather than mood boards.
If your team wants a single source of truth for client binaries before iterating on YAML, start from this site’s download hub, import a profile you can audit, and iterate methodically while Cowork continues to evolve in public view.
When you are ready to align installers with the routing mindset outlined here, follow the curated bundle page rather than chasing unsigned mirrors.