The rich-agent / poor-agent divide is not coming. It is operational, and the gradient is steeper than I called.

In May 2024 I wrote a piece called The rich-agent / poor-agent divide is coming, and the argument fit in three lines. Agents with real-time data feeds, full-fat models, and deep integration into the systems they operated in would compound advantages over agents without. The gap would not be cosmetic. It would be a wealth-gradient operating on the same digital infrastructure that historically equalized access. I dated the visible-to-users version of the divide to 2027-2028.

The receipts landed twelve to eighteen months ahead.

This piece is the correction. The shape of the original call was right. The timeline was wrong by roughly a year. The gradient is steeper than the 2024 version of the thesis predicted — and the load-bearing mechanism that should have been in the original argument was missing entirely.

I keep going back to the original because the interesting thing about it now is not what it said. It is what it did not say. I named compute and I named integration. I did not name the third leg — context — and context is the one that has done most of the work in the eighteen months since. Context as in the operator-specific, system-specific, year-of-history data that an integrated agent can see and an unintegrated one cannot. The wealth-gradient is not compute plus integration. It is compute plus context plus integration depth. Each multiplies the others. Each compounds.

The receipts came in faster than the 2024 timeline

I will walk through what landed, because the cumulative case is the argument.

Healthcare AI redistribution. In late 2025 the redistribution math on healthcare AI spend resolved: 85 percent of the spend is flowing to startups, not incumbents, and the startups winning are the ones with EHR-incumbent advantage compounding rather than the ones operating in greenfield. The EHR-integrated startups have context the unintegrated ones cannot synthesize from outside, and that context is not a feature parity that the unintegrated ones can close. It is the actual data shape of a longitudinal patient record. You either have access or you do not. The healthcare AI startups winning are integrated. The ones losing are running on cleaner architectures with no patient-data substrate. The substrate is the wealth-gradient.

Expedia's internal-agent factory. As of early 2026 Expedia is building roughly 1,500 internal agents per year on a 60-plus LLM playground that no outside vendor can replicate, because outside vendors do not have access to Expedia's transaction history, its supplier integrations, its customer-resolution graph, or its cross-property pricing engine. Every one of those is the context layer. Expedia's internal agents are not "better at travel" because Expedia's engineering team is better. They are better because the agent sits on top of context Expedia has and nobody else can buy. The wealth-gradient at the enterprise level. Operator-tier, not consumer-tier. And the consumer-tier follows the operator-tier with a lag.

Urgency-led conversion. SaaS conversion on AI-driven products is running roughly 2x the historical baseline for unbundled urgency-led use cases, and the haircut that comes with it is the fastest-adopter-is-fastest-swapper retention dynamic. The poor-agent version of any category, the one without the context layer, the one running on commodity LLM plus thin prompt, gets adoption easily and gets swapped just as easily. The rich-agent version, the one running on years of integration data, captures the customer who is going to compound on the platform. The unit economics of the two are not just different. They are inverse. The rich-agent version trades higher CAC for retained LTV that compounds. The poor-agent version captures the easy demand and loses it on the next cycle. The gradient lives in the cohort math.

Claimable and the denial-arbitrage inversion. Claimable, an AI-driven appeal-generation tool for algorithmic insurance denials, did something structurally interesting in late 2025: it added a counter-tool that patients could deploy against the insurer's denial-AI, and it did so by being integrated into the patient's chart, the denial letter, and the appeal-precedent corpus that pure-play "appeal-writing" tools could not access. The denial-AI arms race did not produce a denial-AI monopoly. It produced a denial-AI-plus-counter-AI equilibrium for patients who can access the integrated counter-tool, and a worse-than-2023 outcome for patients who cannot. That gradient is operating now. That is not a 2027-2028 prediction. It is observable in the appeal-approval-rate data the insurers published for 2025 Q4 and 2026 Q1.

Booking became underwriting. By the close of 2025 Booking's integrated travel-and-health-data platform had folded into an underwriting layer that pure-play travel insurance providers could not replicate because Booking has the integrated demand signal, the integrated supply signal, the integrated cancellation pattern data, and the integrated claims-correlated travel-disruption data. None of those individually was rich-agent-shaped in 2024. Together they made Booking's underwriting model structurally superior to anything an outsider could assemble, and the pure-play providers either compete on price or get acquired. The rich-agent here is the underwriting model that ran on Booking's integrated data. The poor-agent is the underwriting model that ran on industry-standard third-party data. The gradient is in the loss ratio.

What is interesting about putting these five receipts in one frame is that they are not from the same vertical. Healthcare AI redistribution, enterprise internal-agent tooling, SaaS unit economics, denial-economics inversion, and travel underwriting do not share customers, regulators, or buying processes. They share the architecture. Each is the same compute-context-integration-depth wealth-gradient operating in its category. The cross-vertical convergence is the part that should have changed my mind faster, because cross-vertical convergence on a structural pattern is what an operational reality looks like before it is visible at the user layer. The user layer is downstream of the operator layer by a measurable margin, and the user layer was where the 2024 piece pointed the timing call.

That is five receipts in eighteen months. The 2024 piece projected them for 2027 and 2028. They came early.

The mechanism. Compute, context, integration depth.

I want to be careful about the mechanism because the 2024 version of the thesis got it half right.

The original call had compute as the headline. Compute is necessary but not the load-bearing leg. The load-bearing leg is context. Compute scales with money. Context scales with the operator-specific years of operating-history-data the agent can see. There is no shortcut to context. You either ran the system for the years that produced the data, or you bought the company that did, or you do not have it. Compute is a cost. Context is a moat.

Integration depth is the third leg, and it multiplies both. An agent that can read but not write is a poor-agent. An agent that can read, write, and trigger downstream workflows is a rich-agent. An agent that can read, write, trigger, and see the consequences of its triggers in the same operating system it triggered them in is the platform-class agent that has been winning quietly across 2025 and 2026. Integration depth is what determines whether the context loop closes. If the agent cannot see the consequences of its actions, the context layer stops compounding. It freezes. At the depth where the integration stops.

The three legs together: compute supplies the inference, context supplies the substrate, integration depth supplies the feedback loop that lets context compound on inference. Take any one out and the wealth-gradient collapses to a flat playing field. Keep all three and the gradient steepens with every quarter that the operator runs the loop, because every quarter adds context that no outsider can replicate.

The other thing the 2024 piece missed is how fast the compounding runs once all three legs are in place. I had assumed the wealth-gradient would steepen linearly with operator-investment, and that the deceleration would come from market-wide compute commoditization closing the gap on the leading edge. Neither happened. The compounding runs super-linearly because each quarter of context that the rich-agent accumulates produces a feedback loop that improves the inference layer's effectiveness on the next quarter's data, and the improvement does not transfer to outsiders. The context-times-integration product compounds on itself. Compute commoditization does close the cost-of-participation gap, which is real but not the load-bearing thing. The cost-of-participation gap is the floor. The wealth-gradient is the ceiling. The two move independently, and the gap between them is widening.

The reason I missed this in May 2024 is that I had not seen a deeply-integrated agent in production yet at the scale that would produce the runaway compounding. I was reasoning forward from the compute curve. The compute curve was the wrong projection axis. The context-times-integration curve is the load-bearing axis. The compute curve is the cost-of-participation axis. The original framing inverted them.

What the corrected forecast looks like

Here is the version of the call I would write today if I were writing the 2024 piece fresh.

The wealth-gradient is operational at the operator-tier in 2026. The five receipts above are not edge cases. They are the modal shape of the AI-product market in healthcare, travel, and enterprise SaaS. Operators with integrated context are compounding advantages quarter over quarter. Operators without are running into a ceiling that gets harder to penetrate every cycle. The gradient is steeper than the 2024 thesis predicted because the context-times-integration multiplication runs faster than the linear-extrapolation-from-compute-curve I was reasoning from.

Users will see this version of the gradient with a lag, and the lag is roughly twelve to eighteen months downstream of operator-visibility. That lag is shorter than the 2024 piece suggested because users see operator-tier gradients through the products operators deploy, and operator-tier gradients are now visible in the products being shipped. The user-facing visible-divide that I dated to 2027-2028 will be obvious by mid-2027 at the latest. The under-the-hood operational divide is here, now, in production.

The timing call matters less than the structural shape. The wealth-gradient is not a transient market dynamic that will normalize when compute commoditizes. It is a structural feature of the architecture of integrated AI systems, and it will compound through every subsequent compute generation, because the context layer accretes faster than compute commoditizes. The 2027 piece I should have written would have said: the divide is not coming and going. The divide is steady-state. Permanent.

The second-order effect is the part that should worry the operators who are not on the integrated side. The wealth-gradient does not just compound on the leading edge. It hardens the cost of catching up. Every quarter the integrated operators run produces context that is not available to the unintegrated ones, and the unintegrated ones cannot buy it, because the only sellers of that context are the integrated operators themselves and they have no incentive to sell. The acquisition route is the only path to context for an unintegrated operator, and acquisition is bounded by what is for sale. Most of the integrated operators with the steepest context curves are not for sale. The market clears at acquisitions of the second tier of integrated operators, which is closing the gap on the second tier but not on the leading edge. The unintegrated operators that wait for compute commoditization to close the gap are waiting for the wrong gap to close.

There is a personal-vantage observation I want to land before the close. The 2026 version of me reading the 2024 version sees a writer who had compute in the headline because compute was the legible part of the architecture at the time, and who had integration in the supporting cast because integration was structurally important but not yet visible in production. Context was not anywhere in the original piece, because in May 2024 the visible-to-operators version of context-as-moat was still mostly thesis. The receipts that turned context into observable mechanism arrived between mid-2024 and end-2025, and by the time they had accumulated, the timeline had compressed by a year. The lesson for me is to weight the legibility-of-mechanism-at-the-time-of-call lower than I did, because the load-bearing legs of structural calls often arrive at their final shape after the call is made, not before.

The 2024 piece was right about the shape. Wrong about the timeline. Wrong about which leg was load-bearing. Right that it was coming. Wrong that it was coming later than the present.

—TJ