How to stop punishing efficiency — and start governing harm.
Danny Stocker | Infrafabric Research | ds@infrafabric.io | 2026-02-02
This is not legal advice. Nothing in this paper endorses evasion (e.g., stealth browsing, bot-mimicry, identity rotation, or bypassing access controls).
This paper discusses incentives and governance patterns; it does not provide instructions for accessing third-party services in ways that violate their terms.
If compliant paths aren’t the easiest paths, compliant behavior becomes a luxury good.
If you only read one section, start with §6: a concrete proposal for a short, harm-based “agent conduct layer” that platforms can publish and agents can enforce. This memo then explains why that layer is increasingly necessary.
Reader shortcut:
We are moving from a browse-based web (humans at screens) to an agent-based web (software completing tasks), but many Terms of Service still define legitimacy in terms of method (“human clicks”) rather than impact (harm).
This creates the ToS Tax:
This shift is not hypothetical: regulated sectors already define “authorized third parties” acting on a user’s behalf (e.g., CFPB Regulation 1033 in U.S. financial services), but general-purpose platform ToS often still assume “a human at a screen”.
The proposal is simple:
If platforms treat “automation” as the harm, they may unintentionally create adversarial dynamics at scale.
The ToS Tax is the cost of forcing automation to be performed through human-only interfaces.
Definition:
A concrete way to measure it (illustrative):
Observed dynamics (mechanical, not moral):
ToS friction > user patience → user outcome:
1) leave (platform loses revenue and trust)
2) comply reluctantly (platform gains time, loses goodwill)
3) seek unofficial workarounds (not endorsed; increases enforcement and security risk)
4) escalate (complaints, counsel, regulators) — rarer, but increasing
The “safety default” many orgs end up with:
This paper asks: why does that default feel simultaneously responsible and ridiculous?
If the safest answer requires pretending agents don’t exist, we’re taxing progress itself.
Definitions (for this paper):
This is a coordination-failure memo, not a moral rant.
If we don’t name the audience, readers will assume we’re yelling at ghosts.
You may enter your unit. You may read your documents. You may even copy them with a crayon, provided you do it slowly.
But if you bring a camera, you are “in breach”.
Imagine a host running a small business on a platform.
They want to compile their own dashboard data (reviews, pricing history, bookings, performance notes) into a spreadsheet for planning.
In physical terms:
The data doesn’t change. The harm may not change. The method changes.
Sometimes velocity is the harm (load, enumeration, fraud). The ToS Tax appears when velocity is treated as harm even at benign scales and for authorized access.
In jurisdictions with data access/portability rights (e.g., GDPR Articles 15 and 20), “crayon-at-a-time” patterns can conflict with expectations for timely, machine-readable access—subject to statutory scope and exceptions.
If you punish efficiency instead of harm, you incentivize method concealment.
For most users, the immediate difference is who enforces it and how fast the consequences arrive.
Operational distinction:
User reality:
Agent reality:
The Prosthetic Principle (psychology, not law):
If ToS is invisible to the agent, it becomes visible to the platform through enforcement.
We can admit a rule is misaligned without giving anyone permission to break it.
The green-shirt / red-shirt test:
The result is Normative Failure:
Why a system cannot safely auto-conclude “ignore this ToS”:
So the correct posture for agents is:
If agents start judging ToS legitimacy, they create liability principals didn’t authorize.
When honest automation is blocked, automation goes covert.
Why this matters in boardroom terms:
The most dangerous effect is stealth:
The point is to reduce incentives for covert automation—not to excuse or normalize it.
This is not an argument for permissiveness.
It’s an argument for aligning incentives so the safe path is the easy path.
If your policy requires humans to be slower than software for common workflows, you’re competing with physics.
If the platform can’t name the harm, it will eventually name the user.
This is not a claim about intent; it’s a claim about what happens when enforcement relies on proxies.
Harm-based rules are legible to users, auditors, and policymakers:
Method-only rules are harder to defend as agents become normal:
Method restrictions can be legitimate when they are tightly tied to a specific risk, for example:
In some contexts, method bans serve non-harm objectives (e.g., product-channel control, content licensing constraints, lock-in) in addition to legitimate security and privacy goals.
The practical problem is that method-only bans sweep ordinary, authorized use into the same bucket as abuse.
If “automation as such” becomes “ordinary behavior,” method-only enforcement becomes brittle by default.
If your real concern is harm, write rules in the language of harm.
Platforms won’t delete ToS (and shouldn’t).
But they can publish a short “conduct layer” that:
Example pattern (illustrative, not legal language):
Agent conduct layer (v1):
1) Internal scope (user’s own data):
– Authorized users (and their authorized agents) may access their own account data (dashboards, history, exports) at reasonable rates.
– Constraint: rate limits + throttling; proportional enforcement for repeated or severe violations.2) External scope (third-party data):
– Agents must not bulk extract other users’ data (profiles, reviews, inventory) without consent or an explicit platform mechanism.
– Constraint: treat as privacy abuse, not “efficiency”.3) Technical integrity:
– Do not bypass paywalls, CAPTCHAs, authentication, or other technical controls.
Authorized agent (for this paper): a tool acting with the account holder’s consent, using user-granted credentials/tokens/scopes, within published mechanisms.
Note: “your own data” can be ambiguous for co-created content (e.g., messages, shared docs). A reasonable default is that you may export your contributions; bulk export of counterparty content requires consent or a platform mechanism.
This reduces ToS Tax by:
If you keep “rules” as a maze, users will hire someone to learn the maze — and call it an agent.
Agents need a calm refusal that preserves momentum.
Green / Amber / Red classification (one line each):
Agents should not propose evasion tactics (stealth browsing, bot-mimicry, rotating identities) as alternatives.
Safe refusal template (short, non-preachy):
I can’t automate that on your logged-in account because it is likely to violate the platform’s terms and could risk account access.
Fast alternatives:
1) Use the platform’s export/download flow.
2) Use an official API (if available).
3) You paste/upload the relevant data (CSV/screenshots) and I’ll analyze it offline.
4) I can draft the support request you’d send to the platform asking for an official export/API path.
5) If applicable in your jurisdiction, I can draft a data access request (e.g., GDPR/CCPA-style) for you to submit.
Design goal:
If the refusal is condescending, users will replace it with a quieter tool that doesn’t refuse.
The ToS Tax is not “users being bad.”
It’s what happens when we govern method instead of harm in an agentic world.
If platforms want less abuse, they should make honest automation safer than covert automation.
If agent builders want useful assistants, they should make compliance the lowest-friction path.
If we don’t modernize the rule line intentionally, users and vendors will shift to parallel workflows—and policy will be forced to catch up under pressure rather than by design.
GDPR (EU) official text:
https://eur-lex.europa.eu/eli/reg/2016/679/oj
CFPB Regulation 1033 (U.S. personal financial data rights):
https://www.consumerfinance.gov/rules-policy/final-rules/1033-personal-financial-data-rights/
hiQ Labs, Inc. v. LinkedIn Corp. (US, 9th Cir., opinion via CourtListener):
https://www.courtlistener.com/opinion/4704580/hiq-labs-inc-v-linkedin-corp/
Note: hiQ primarily concerns access to publicly available data and specific CFAA/contract issues; it is not a general authorization to automate access to logged-in services or to violate ToS.
Van Buren v. United States (US Supreme Court opinion PDF):
https://www.supremecourt.gov/opinions/20pdf/19-783_k53l.pdf
Note: Van Buren addresses “exceeds authorized access” under the CFAA in a particular context; it does not eliminate contractual, privacy, or other statutory risk.
Example of a platform posture that combines an acceptable-use policy + a documented API surface:
https://docs.github.com/en/site-policy/acceptable-use-policies/github-acceptable-use-policies
https://docs.github.com/en/rest