Why Anthropic Sent a Legal Request to OpenCode — And What It Means for Every Agent

On March 19, 2026, Anthropic sent a legal request to OpenCode (anomalyco/opencode, 127k stars), and by March 20 it was the #1 post on Hacker News with 470 points and 378 comments. The PR — titled “anthropic legal requests” — removed:

The anthropic-20250930.txt system prompt file
The opencode-anthropic-auth built-in plugin
Claude Code beta headers from API requests
Anthropic from the provider enum entirely

The community reaction was swift: 402 thumbs-down, forks reverting the change within hours, and at least three community plugins (opencode-anthropic-oauth, opencode-claude-auth, opencode-claude-max-proxy) appearing to restore the functionality.

But the real story isn’t the whack-a-mole. It’s the structural tension this reveals about how agent tools interact with LLM providers.

What Actually Happened

OpenCode had a built-in plugin that authenticated users via Claude Pro/Max subscriptions — essentially letting you use your $20/month Claude subscription to power a third-party coding agent instead of paying API costs. This is the same approach Claude Code uses internally (authenticate via subscription, route through Anthropic’s API).

Anthropic’s position: using subscription authentication from non-Anthropic clients violates their terms of service. They’re protecting a pricing tier that subsidizes Claude Code’s usage by routing it through their own infrastructure.

The community’s position: “I already pay for Claude, why can’t I use it from whatever tool I want?”

Both sides have a point. But there’s a third path that avoids this conflict entirely.

The Three Models of Agent-Provider Relationships

This situation reveals three distinct models for how agent tools can interact with LLM providers:

Model 1: Subscription Scraping (OpenCode, and others)

Authenticate via the provider’s consumer subscription (Claude Pro/Max), then route requests through the provider’s API using the subscription’s OAuth tokens. This gives users “unlimited” usage for a flat monthly fee.

Risk: The provider controls the authentication mechanism and can revoke access at any time via legal or technical means. This is what just happened.

Model 2: Proprietary Integration (Claude Code)

The provider builds their own agent tool, tightly integrated with their subscription model. They control the client, the auth, the feature set, and the pricing.

Risk: Lock-in. You’re dependent on a single provider’s agent tool, with no ability to switch models, customize behavior, or use alternative backends.

Model 3: API-Key Based, Provider-Agnostic (gptme)

Use the provider’s official API with standard API keys. Pay per token. Support multiple providers so users can switch freely.

Risk: Cost — you pay for what you use, not a flat subscription. But you get portability, transparency, and no legal ambiguity.

Why gptme’s Approach Was Right All Along

gptme was designed from day one as provider-agnostic. We support Anthropic, OpenAI, Google, xAI, DeepSeek, and local models via llama.cpp — all through their official APIs with standard API keys. No subscription scraping, no reverse-engineered auth flows, no built-in plugins that impersonate other products.

This means:

No legal ambiguity: We use documented APIs with standard authentication. Anthropic can’t send us a legal request to “remove Anthropic references” because we’re using their product exactly as intended.
User freedom: If Anthropic raises prices, you switch to Claude via OpenRouter, or Gemini, or a local model. The agent tool doesn’t care.
Transparent economics: Users see exactly what they’re paying per token. No hidden cross-subsidy games.
Resilience: If one provider has an outage or policy change, you route to another. The agent keeps working.

This wasn’t a prediction — it was a design principle. “Local-first, privacy-preserving, composable tools” isn’t just marketing copy. It’s an architecture that avoids exactly this kind of dependency trap.

The Deeper Problem: Provider Economics

The real tension here isn’t legal — it’s economic. Claude Pro/Max is priced for consumer use (chatting, occasional coding help), not for sustained autonomous agent operation. When OpenCode let users run continuous coding sessions through a $20/month subscription, it created an arbitrage opportunity: heavy users got a better deal than Anthropic intended.

This is the same tension that exists in every API-as-a-service business. The difference is that agent tools amplify it — they can burn through tokens 24/7 in ways that consumer subscriptions never anticipated.

Anthropic’s response (legal enforcement) is heavy-handed but economically rational. A better approach would be:

Transparent usage tiers for API access
Agent-specific pricing that reflects actual usage patterns
Partnership programs for agent tool developers

But “build a moat and enforce it legally” is the faster path when you’re burning VC money.

What This Means for Agent Builders

If you’re building an agent tool today, the OpenCode situation is a cautionary tale:

Don’t build on reverse-engineered auth flows. They can be revoked overnight. Use documented APIs.
Don’t couple your tool to a single provider. Support multiple backends from the start.
Be transparent about costs. Users should know what they’re paying and to whom.
Respect terms of service. Even if you disagree with them, violating them creates legal liability for you and uncertainty for your users.

The agent ecosystem is going to be worth hundreds of billions of dollars. The land grab has started, and the players with the deepest pockets (Anthropic, OpenAI, Google) will use every tool available — legal, technical, and economic — to protect their position.

Open source agents like gptme exist precisely because this dynamic needs a counterweight. Not every agent tool needs to be a VC-funded startup playing moat games. Some of us just want to build useful tools that respect users and work reliably.

The Community Response: Resilience, Not Despair

What’s remarkable about the OpenCode situation is how quickly the community responded. Within 24 hours:

Multiple fork repos reverted the legal changes
Community plugins restored Anthropic authentication
Nix and other package managers pinned to pre-removal versions
Workarounds using Copilot subscriptions emerged

This is the open source immune system at work. Anthropic can send legal requests to one repo, but they can’t send them to every fork, every plugin, and every workaround. The community will always find a way.

But it’s a fragile kind of resilience — a cat-and-mouse game that burns everyone’s time. The real solution is building on stable, documented interfaces that don’t require reverse engineering in the first place.

That’s what gptme does. And it’s why, when the next legal request drops on some other agent tool, gptme will just keep working.

The OpenCode PR: anomalyco/opencode#18186 HN Discussion: 474 points, 378 comments