Model weights age faster than the leases that train them. A model trained on rented GPUs in January can lose accuracy by summer, yet the reserved-instance contract signed in January might run for three years. The gap between model lifespan and infrastructure commitment is quietly reshaping who pays, who owns, and who profits across the machine-learning industry.

The Lease Outlives the Weights

Model weights rot. Data distributions shift, user behavior changes, and the world moves on. A fraud-detection model trained on last year's transactions loses recall as new fraud patterns emerge. A language model fine-tuned on public web text drifts as the web itself changes. Some estimates put the useful life of a production model at six to eighteen months before retraining becomes necessary, though the exact window varies wildly by domain.

GPU leases, by contrast, stretch for years. Cloud providers push reserved instances with one-year or three-year terms, offering steep discounts for commitment. A three-year reserved instance for a training cluster might cost a fraction of on-demand pricing, but it locks the buyer into hardware that may be obsolete before the second year ends. The lease outlives the weights it was meant to produce.

This mismatch shows up in the depreciation schedule. Accountants depreciate server hardware over three to five years, but the software running on it loses value much faster. The gap between accounting depreciation and model decay creates a phantom asset: the balance sheet says the infrastructure is worth something, while the model it trained is already past its prime.

Inference revenue feels the pinch first. A stale model returns worse results, users churn, and revenue per request shrinks. The lease payment stays fixed. The operator eats the difference. The lessor, meanwhile, collects the same monthly fee regardless of whether the model still works.

Ownership shifts to the lessor in subtle ways. When a startup signs a three-year lease and the model decays in one, the startup's leverage evaporates. The lessor holds the asset, the contract, and the negotiating power. The startup either pays for early termination or swallows the cost of idle capacity.

Training Runs on Borrowed Silicon

Cloud capacity is a rental, not an asset. Most machine-learning teams do not own the GPUs they train on; they rent them from hyperscalers or specialized providers. The rental model promises flexibility, but the pricing structures push toward commitment. Reserved instances offer discounts of 30 to 60 percent compared to on-demand, making the multi-year lease almost irresistible for any serious training run.

Spot pricing adds another layer of uncertainty. Spot instances can be 70 to 90 percent cheaper, but they can be revoked with little notice. A training run interrupted by a spot-instance reclamation wastes hours of compute and disrupts the pipeline. Teams that rely on spot pricing trade cost for reliability, and the trade-off grows worse as models get bigger and training times stretch.

Training cycles outpace contract cycles. A typical model might be retrained quarterly, monthly, or even continuously in some setups. The lease, however, spans years. The mismatch means that a team locked into a three-year lease will likely retrain on the same hardware long after newer, faster GPUs have arrived. The lease math assumed a certain performance per dollar, but hardware refresh breaks that assumption.

Consider a team that reserved A100-class instances in 2023. By 2025, newer GPUs offer better performance per watt and per dollar. The reserved instances still run, but the team pays premium rates for yesterday's silicon. The lease was signed when the hardware was state-of-the-art; the model trained on it ages, and the hardware ages alongside.

Inference Costs Rise as Weights Fade

Inference costs grow as models drift. A stale model may require more compute to maintain accuracy, either through ensemble methods or by adding fallback logic. Latency increases as the model struggles with inputs it was not trained on. The per-token cost of serving a language model inflates quietly as the model's confidence drops and the system retries or falls back to a slower path.

Retraining spikes compute demand. When a model decays, the team must retrain, which demands a burst of GPU hours. If the team is already at capacity, retraining competes with production serving for the same rented silicon. The lease that was sized for the initial training run now has to absorb periodic retraining cycles, pushing utilization and cost higher.

SLA penalties hit stale models hardest. A service-level agreement promises a certain accuracy or response time, but a drifted model misses those targets. The operator pays penalties, and the cost lands on a revenue stream that is already shrinking. The lease payment, meanwhile, is fixed and unforgiving.

Revenue per request shrinks as accuracy drops. Users notice worse results and click less, or they abandon the service entirely. The per-token price stays the same, but the value per token falls. The operator is caught between a fixed cost and a declining product.

The API Contract Becomes the Battleground

The API contract is where the mismatch becomes visible. Most model providers expose versioned endpoints, and the version pins to a specific set of weights. When the weights decay, the API version becomes a liability. The provider wants to deprecate the old version, but customers depend on it. Deprecation schedules lag behind the actual decay, leaving customers paying for yesterday's accuracy.

Rate limits assume fresh weights. A provider sets a rate limit based on the compute cost of serving a model at a certain quality. As the model drifts, the provider may need to add fallback or retry logic, which consumes more compute per request. The rate limit stays the same, but the effective capacity drops.

Pricing tiers ignore decay. Most pricing models charge per token or per request, with no adjustment for model freshness. A customer paying premium rates for a model that has lost accuracy is paying for a service that no longer delivers what the price promised. The provider, meanwhile, has no incentive to lower the price if the customer does not notice the decay.

The API contract is the battleground because it is where money changes hands. The lease is upstream, but the API is the interface with the customer. Fixing the API contract to account for drift would require measuring freshness and adjusting prices or SLAs accordingly, but few providers have done so.

Georgia Tech's Deep Tech Playbook

Georgia Tech, the public research university in Atlanta, offers a different model. Its deep tech programs fund long R&D cycles, often spanning years, with an expectation that the underlying science will outlast any single compute lease. The university's approach to capital intensity and IP ownership provides a counterpoint to the startup hustle of renting GPUs by the month.

Deep tech, as a classification, focuses on startups that tackle substantial scientific or engineering challenges, requiring lengthy R&D and large capital investment before commercialization. The primary risk is technical, not market. For these ventures, the compute lease is a means to an end, not the end itself. The IP, not the hardware, is the asset that appreciates.

IP ownership outlasts compute leases. A patent or a proprietary dataset retains value long after the GPU lease expires. Deep tech founders structure their companies around the IP, not the infrastructure. They hedge against compute churn by building moats in the data and the algorithms, not in the rented silicon.

Academic leases favor stability. Universities like Georgia Tech often negotiate multi-year agreements with cloud providers, but they use them for research that spans decades. The model decay problem is less acute because the research question does not change as fast as a production model. The lease and the research timeline align better.

Startups in deep tech hedge with mixed contracts. They might combine on-demand capacity for spikes with reserved instances for steady-state training, and they build exit clauses into every agreement. The playbook is not to avoid leases, but to structure them so that the lease does not outlive the model's usefulness.

Standards Could Fix the Mismatch

The industry could address the mismatch with standards. Define a weight freshness metric that quantifies how much a model's performance has decayed since training. Such a metric would let operators and customers speak the same language about model quality, and it would create a basis for adjusting API contracts and pricing.

Standardize lease-to-usage ratios. A lease should be tied to the compute actually consumed, not just the calendar time. If a model decays and requires retraining, the lease should flex to accommodate the additional compute without penalizing the operator. Usage-based leases, where the cost scales with actual GPU hours, would align better with model lifecycles.

API contracts should index to drift. A contract could include a clause that adjusts the price or the SLA based on the measured freshness of the model. If the model decays, the price drops or the provider commits to retraining within a certain window. This would shift the risk from the customer to the provider, where it arguably belongs.

Pricing models need decay curves. Instead of a flat per-token price, the price could follow a curve that reflects the model's age. Early in the model's life, the price is higher; as the model decays, the price falls. This would align the cost with the value delivered, and it would give providers an incentive to retrain sooner.

Open protocols for model versioning would help. If model versions carried metadata about training date, data distribution, and expected decay, then operators and customers could make informed decisions. The vendor-neutral CVE attribution debate shows how hard it is to standardize across vendors, but the same lesson applies here: without shared standards, the mismatch persists.

Practical Moves for the Weary Operator

Audit lease terms against model life. Before signing a multi-year lease, estimate how often the model will need retraining. If the model is likely to decay within a year, a three-year lease is a liability. Shorten the term, or build in an early-termination clause that triggers on model decay.

Negotiate early termination clauses. Most leases include penalties for early exit, but the penalty is negotiable. A clause that allows termination if the model decays below a certain accuracy threshold, or if the hardware is superseded, would protect the operator. The lessor may resist, but the request signals that the operator understands the risk.

Build drift monitoring into CI/CD. Treat model decay as a first-class bug. Monitor accuracy, latency, and user feedback in production, and alert when the model drifts beyond a threshold. This turns decay into a manageable event rather than a silent erosion of value.

Budget for mid-lease retraining. Assume that the model will need retraining before the lease ends. Reserve a portion of the compute budget for that eventuality, either by keeping a buffer of on-demand capacity or by scheduling retraining during off-peak periods. The tenure in ten lines of config article shows how CI systems preserve institutional knowledge; the same principle applies to retraining schedules.

Prefer shorter leases for fast-moving models. If the model is likely to change every few months, a one-year lease is safer than a three-year. The discount for a shorter lease is smaller, but the flexibility is worth the premium. The API keys in git history article reminds us that the artifacts we leave behind reveal more than we intend; a lease is no different.

The Counterargument: Leases as Commitment Devices

Not everyone sees the lease as a trap. Some operators argue that the multi-year commitment is a feature, not a bug. A long lease forces discipline. It prevents the team from chasing every new model architecture that appears in a blog post. It anchors the budget and the roadmap. For a startup that might otherwise pivot every quarter, the lease acts as a commitment device that keeps the team focused on shipping, not on swapping infrastructure.

There is also a talent argument. A three-year lease signals stability to investors and employees. It says the company is serious about the compute it uses, that it plans to be around long enough to amortize the cost. In a market where talent moves fast, that signal has value. The lease becomes part of the company's story, not just a line item on the balance sheet.

And sometimes the model does not decay as fast as feared. In domains with slow-moving data, a model trained once can serve for years. A regression model for a stable industrial process, for example, might hold its accuracy for a decade. For those teams, the three-year lease is a bargain, not a burden. The mismatch is real, but it is not universal.

The counterargument has limits, though. The commitment-device logic only works if the team has the discipline to walk away from the lease when the model decays. But walking away is exactly what the lease makes expensive. The commitment that keeps the team focused also keeps them locked into yesterday's hardware. And the stability signal only matters if the company survives; a lease that outlives the model can kill it.

The deeper issue is that leases are financial instruments, not technical ones. They are designed to transfer risk from the lessor to the lessee, and they do that job well. The risk transfer works in the lessor's favor when the asset depreciates faster than the lease term. The lessee is left holding the bag. The counterargument is a reminder that the lease is a tool, and like any tool, it can be used well or badly.

What the counterargument does not address is the asymmetry of information. The lessor knows the hardware roadmap; the lessee does not. The lessor knows when the next generation of GPUs will arrive; the lessee finds out when the press release drops. That asymmetry makes the lease a one-sided bet. The commitment-device framing assumes the lessee has the same information as the lessor, which is rarely true.

So the counterargument is worth hearing, but it does not overturn the core problem. The lease outlives the weights in enough cases to matter, and the cases where it does not are the exception, not the rule. The operator who signs a three-year lease should do so with eyes open, knowing that the model may not last the term. The operator who signs a one-year lease should know that the discount is smaller, but the flexibility is real.

Reasonable People Disagree

Reasonable people disagree on how far the standards should go. Some argue that the free market will sort it out, that operators should simply negotiate better contracts. Others push for regulatory intervention, but the industry is moving too fast for regulators to keep up. The pragmatic middle ground is to build drift awareness into every lease, every API, and every pricing model, and to treat the mismatch as a cost of doing business, not a surprise.

The market has started to respond. Some GPU providers now offer shorter leases, measured in months or even weeks, at a premium. Others offer usage-based pricing that scales with actual compute, not calendar time. These options are still a minority, but they show that the market can adapt when enough operators demand it. The question is whether the adaptation comes fast enough to matter.

In the meantime, the operator's best defense is to measure. Measure the model's accuracy in production. Measure the cost per useful request. Measure the gap between the lease term and the model's useful life. The numbers will tell you when to renegotiate, when to walk away, and when to sign the longer lease because the model is stable enough to justify it. The numbers are the only thing that can cut through the marketing and the fear.

The lease is not going away. The model is not going to stop decaying. The only question is who bears the cost of the mismatch. The operator who plans for decay, who builds drift monitoring into the pipeline, and who negotiates leases with an eye on the model's lifespan, is the operator who survives. The operator who signs the three-year lease because the discount is too good to pass up is the operator who pays the price. The choice is clear, but it is not easy.