The Dependency Window

You've been paying $30 a month for AI subscriptions and calling it your AI strategy. Your engineers have their own seats. Maybe you have enterprise licenses. The tools are running, the team is happy, and nothing about the bill has ever forced you to think harder about what any of this is actually worth.

That's intentional.

Every major AI lab is running a playbook the tech industry has seen before. Ride-sharing rides were $2 in 2015. Short-term rentals were $40 a night. Prices that made no economic sense, subsidized by venture capital at scale, designed to build one thing: habits. The bet was that once behavior changed, pricing could follow. The technology sector watched that playbook work twice, then raised its own version of it. Flat-rate AI subscriptions exist to build dependency, not to reflect cost. The gap between what you pay and what the compute actually costs is real, and it's being financed by someone else's capital — not yours.

When that financing shifts — when enterprise AI moves from competitive-pressure subscriptions to honest usage-based pricing — the question you'll face is simple: what are we actually getting for this compute?

The companies with a clear answer won't even notice the transition. The ones that don't will be reading their first usage-based invoice trying to reverse-engineer a ROI case that should have been built eighteen months earlier.

What Agents Actually Cost

Flat subscriptions produce what you'd expect: teams that treat tokens like tap water.

At usage-based pricing, the economics of AI agents get specific fast. A developer building a small personal project over a long weekend — one page, one feature, nothing complex — can spend $50 using an agent connected to the API directly. Scale that usage across a team of twenty engineers, multiply by the exploratory, iterative, start-and-restart nature of real software work, and the per-seat math stops looking like a subscription. It starts looking like infrastructure spend.

Some teams are already there. Enterprise AI spend in five-figure-monthly territory is becoming common for organizations that have moved past tool experimentation into agentic workflows. Those numbers work — for some teams, in some configurations, on some problem types. They don't work uniformly, and they don't work by default. The difference isn't the tool. It's the intent behind the invocation.

The Dependency Window

The period between now and honest usage-based pricing is the dependency window: the finite time when AI tools are priced to build your team's habits rather than to reflect what the compute is worth.

Used well, it's an extraordinary gift. Teams that use it to build genuine AI-value discipline — who connect every agent invocation to a specific outcome, who learn which tasks actually benefit from agents versus which ones just feel like they should — will arrive at usage-based pricing with a clear sense of where to spend and where not to. The bill will be predictable, defensible, and worth paying.

Teams that drift through it will arrive with the opposite. They'll have built reflex-reach habits: the engineer who throws a vague problem at an agent before thinking through it themselves, the manager who asks an agent to generate a strategy document that a thirty-minute whiteboard session would produce faster and better, the workflow where the agent reruns context it's already seen fifty times because no one thought about caching. These teams will get their first honest invoice and discover they've been training for the wrong race.

The Purposeful Signal

Distinguishing purposeful AI usage from habitual usage is harder than it sounds, because both look identical from outside the context window.

Purposeful usage starts with the decision already made. The engineer knows what they need — a specific refactor, a test harness for a defined interface, a first draft of a module whose inputs and outputs are already clear. The agent executes a clear brief. The loop is tight, the output is checkable, and the token count correlates to the value.

Habitual usage starts with an open question. "Let me see what it can do with this." The problem statement shifts mid-conversation. The agent builds something, the engineer decides it's not quite right, the context grows, the iterations multiply. The result is sometimes valuable and often not, and the bill for both looks identical.

The organizations that consistently get purposeful output from AI agents have one thing in common: they treat the quality of the input as the job. The brief, the spec, the framing — that's where the senior judgment goes, before the context window opens. The agent executes. The human decides.

This is the same discipline that separates outcome-based work from activity-based work. You don't bill for hours of exploration dressed up as output. You bill for a specific result against a clear standard. The teams that have internalized that distinction in their AI usage will navigate the pricing transition cleanly. The teams that haven't will have to learn it at the per-token rate.

What to Build Before the Meter Flips

The usage-based transition isn't a prediction. Enterprise AI contracts are already moving there. The flat-rate subscriptions your developers rely on are subsidized adoption vehicles, not a long-term pricing model. The question is how much runway you have.

Most teams have enough to build the right habits if they start now.

The work isn't complicated: name the tasks where AI agents produce genuine leverage in your org, and name the tasks where they produce the appearance of leverage. Build the habit — individually, not just as policy — of connecting AI invocations to specific outcomes before opening the context window. Instrument the spend by task type. When the usage-based bill arrives, you want to look at it line by line and say: that spend produced this result, and it was worth it.

The companies that can't do that will make the same error twice: they'll treat the cost problem as a tooling problem, buy a governance dashboard, and continue burning tokens on habit. That's the reflex that built the current situation in the first place.

Token costs are coming down — the model economics are real, and open-weight models are closing the gap with frontier performance faster than most people expected. But usage is expanding at the same rate, and the teams burning compute habitually will absorb every efficiency gain without producing more value. The dependency window closes whether you use it or not.

If you're trying to build AI usage discipline before the meter flips — or you're already staring at a bill you can't explain — that's the conversation we're built for.