The Tax Nobody Budgeted Is Sinking Corporate AI Agents
There is a particular moment in enterprise technology adoption where enthusiasm transforms into an accounting obligation. With artificial intelligence agents embedded in corporate products, that moment arrived earlier than most technical teams anticipated, and the mechanism that triggered it was neither the wrong language model nor a lack of data. It was an architectural decision that nobody presented as a decision.
Calling it the "context tax" — as Anthropic's engineering team and a growing number of analysts do — is a precise denomination. Not because it is metaphorical, but because it operates exactly like a tax: invisible in the individual transaction, devastating in the aggregate. Every time an enterprise agent receives a raw 150-kilobyte HTML file to process a question about five rows of data, the company pays approximately 37,500 inference tokens that produce no value. Multiply that by every active user, by every session, by every month of scaling, and what appears to be a technical detail becomes the element that determines whether the product's gross margin survives.
The data circulating throughout the ecosystem confirms this from multiple angles. Splunk's analysis of isolated agent costs documented how a single customer support interaction went from costing four cents to one dollar and twenty cents over three years, even as per-token prices fell. The mechanism behind that increase was not vendor inflation: it was the volume of context the agent was relaying at every step of the workflow. A study from Concordia University quantified the ratio between input and output tokens in agentic flows at 2:1, and found that code review alone consumed 59% of every token spent. These are numbers that transform the infrastructure budget into something very different from what appeared on the roadmap.
What Gets Decided Without Saying It Is Being Decided
The central argument introduced by the Forbes Technology Council analysis — written by a software engineer at Walmart Global Tech who leads the construction of agentic experiences for marketplace sellers — is not about tools or vendors. It is about three architectural decisions that teams make by omission, before anyone names them in a design meeting.
The first is the representation the model receives. Between raw HTML, screenshots, and semantic fragments there exists a difference of 30 to 50 times in cost per task, with effects on precision that run in the opposite direction to what intuition suggests. Amazon Science's research on the AgentOccam agent documented a 29.4% improvement on the WebArena benchmark by switching from visual representation to a structured accessibility tree. The model was not modified. What the model saw was changed.
The second decision is the moment of capture. When an agent captures the page state at the moment of load rather than at the moment of submission, it captures the loading skeleton, not the data the user is actually looking at. The report describes cases where the snapshot fired 1,500 milliseconds before the API responded. The agent responded with confidence from an empty page. That is not hallucination in the technical sense: it is incorrect context served at the wrong moment.
The third is what simply does not get sent at all. A lightweight classifier that routes before retrieving can eliminate between 70% and 85% of context snapshots in real-world flows. A user asking how to update a configuration in bulk needs documentation, not a photograph of their current data view. Those are tokens that never get spent in the first place.
What makes these three decisions especially costly is not that they are bad decisions: it is that nobody presents them as decisions. They execute by default. Raw HTML is the option that requires no preprocessing. Capture on load is what the framework does automatically. Sending all available context seems "safe." That inertia has a price.
The Difference Between an Internal Product and a Market Product
The analysis distinguishes with precision a point that most discussions about enterprise agents fail to separate with sufficient clarity: there is a structural difference between an agent that serves internal employees and one embedded in a commercial multitenant product.
An internal IT team can absorb a deficient context architecture. They redeploy it. They adjust it. They have a controlled blast radius. A B2B software vendor that embeds an AI assistant in its product charges by seat, not by infrastructure. Every inefficiency in context representation multiplies across the entire customer base simultaneously. The cost per active user that the piece describes — rising from $0.40 to $1.10 per month within eight weeks of general availability — is not an anecdote from a poorly calibrated deployment: it is the mechanics of what happens when you scale without having audited the context architecture first.
Chroma published in 2025 an evaluation of 18 frontier models that adds another dimension to the problem. Accuracy does not only degrade when context is expensive: it degrades when context is extensive. The greater the volume of input context, the greater the loss of precision on long-context tasks, regardless of the model. The context tax is not solely a margin problem. It is a product problem.
This reframes the discussion in a way that project approval committees rarely articulate. When evaluating whether to incorporate an AI agent into a SaaS platform, the conversation typically centers on the model, the vendor, and data security. The context representation architecture almost never appears in that conversation as a variable with gross margin implications. It appears afterward, in the postmortem, when the feature promised margin expansion and instead delivered compression.
The Market That Comes After the First Wave of Failures
The Gartner statistic projecting the cancellation of more than 40% of agentic projects before the end of 2027 is not simply a warning about technological maturity. It is an anticipatory description of the purging process that follows any adoption cycle where hidden costs exceed original projections. The MIT analysis that found 95% of generative AI deployments produced no measurable business value documents the same pressure from a different angle.
What remains unclear in the public debate about agents is whether organizations that cancel projects do so for model reasons or for architectural reasons. If the majority of failures originate in context decisions — representation, moment of capture, volume sent — then the problem is not that agents do not work. It is that the teams building them are measuring the wrong variables.
Hyland, in its analysis of AI return on investment in enterprises, calculates that a unified enterprise context layer can generate up to 10.3 times the return on AI and automation investments. The mechanism it describes is direct: teams that rebuild integrations, mappings, and business rules for every new agent are paying a fragmentation tax before the agent even begins to operate. Each agent inherits the architectural debt of the previous one. Scale does not solve that problem: it amplifies it.
The transition taking shape is not between more or less powerful language models. It is between organizations that treat context architecture as an infrastructure variable — one to be optimized when there is time — and those that treat it as a gross margin variable to be designed before the first deployment. The difference between these two positions does not appear in the first months of piloting. It appears when the user base grows and cost per query becomes the metric governing whether the feature can continue to exist.
The Next Front Is Not the Model — It Is Who Governs the Context
The language model wars generated a comprehensible illusion: that the central problem of enterprise agents was inference quality. That illusion was useful during the experimentation phase, when companies needed to validate that models could do something useful within their domains. That phase is over.
What begins now — and what makes the analysis of the context tax relevant beyond its technical details — is the competition over who builds and governs the enterprise context layer. Not the model that reasons, but the infrastructure that decides what the model sees, when it sees it, and what it never needs to see at all.
The signals are already visible. CIO Dive's argument that agents should go to the data rather than having data travel to agents points to the same knot. Seekr's proposal to measure cost per verifiable response — rather than gross cost per token — introduces a metric that makes the context tax transparent in the income statement. The pre-retrieval routing classifiers that the Forbes analysis describes are a component that still lacks a consolidated market name, but which represents a function that mature agentic platforms will need to offer natively.
For leaders who are in the middle of architectural decisions right now, the operational lesson is narrower than any strategic framework. The model is not the bottleneck. Context representation is. And that is a design variable, not a vendor decision, which means that responsibility for its consequences is internal. Organizations that build that layer with a gross margin mindset in 2026 will have cost-per-query data when the market begins demanding accountability in 2027. Those that do not will be explaining why the AI feature that promised to expand margins ended up being their primary source of compression.
