---
title: "The Economics of Incremental AI: Stopping the Re-computation Cash Burn"
date: "2025-01-29"
dateModified: "2025-01-29"
author: "Marcel Kornacker"
tags:
  - FinOps
  - Infrastructure
  - Cost Optimization
  - Strategy
description: "How Jevons Paradox and the 280x drop in inference costs are driving a data explosion, and why re-computing everything is killing your budget."
url: "https://www.pixeltable.com/blog/economics-of-incremental-ai"
---

# The Economics of Incremental AI: Stopping the Re-computation Cash Burn

Inference costs have dropped 280x in 18 months. This should mean cheaper AI, right? Wrong. Jevons Paradox has kicked in: as AI gets cheaper, we use it exponentially more. The hidden cost isn't the inference itself; it's the massive waste of re-computing data you've already processed.
 

 
## The Jevons Paradox in AI

 
 

 When processing one hour of video cost $100, enterprises processed only critical security footage. At <$0.10/hour, they process *everything*: every Zoom call, marketing asset, and QA log. (Jevons Paradox is the 1865 efficiency effect. TypeSafe’s 2026 model named *Jev* after the same economist is a classifier, not this argument — [What Is Jev?](/blog/jev-system-one-model).)
 

 

 This volume explosion breaks the "script-based" architecture of the last decade. Pipelines that worked for 100 files fail catastrophically at 100 million. But the real budget killer is subtle: **redundant computation**.
 

 
## The Hidden Cost of Re-computation

 

 Imagine you have 10,000 hours of video. You've extracted frames and generated embeddings using CLIP. Now, you want to:
 

 

 - Change the frame extraction rate from 1fps to 2fps.

 - Update the embedding model to a newer version.

 - Fix a bug in your metadata extraction logic.

 

 

 In a traditional pipeline (Airflow + Scripts), you often have to **re-run the entire pipeline**. You can't easily say "only re-compute the frames that are missing" or "only update embeddings for videos added last week."
 

 

 **The Math:**
 

 10,000 hours * 60 mins * 60 secs = 36M seconds.
 

 Processing at 1fps = 36M frames.
 

 If you re-run everything, you pay for 36M inferences again.
 

 
## Incremental View Maintenance (IVM)

 

 This is a solved problem in the database world. It's called Incremental View Maintenance. When you update a row in a SQL database, the materialized views update automatically, but *only* the affected rows are recomputed.
 

 

 Pixeltable brings IVM to unstructured data and AI models.
 

 
```python
# Define the transformation
frames = pxt.create_view('frames', videos, iterator=frame_iterator(videos.video, fps=1))
frames.add_computed_column(
 embedding=huggingface.clip(frames.frame, model_id='openai/clip-vit-base-patch32')
)

# Later... new videos arrive
# Pixeltable extracts and embeds only the NEW videos' frames
videos.insert([{'video': 'new_clip.mp4'}])
```

 

 In this scenario, Pixeltable already has frame rows and embeddings for every existing video. It only computes the frames of the new one. A different frame rate is a new view, which extracts and embeds every frame again.
 

 
## Feature-Level Cost Attribution

 

 Another major pain point for engineering leaders (like those at Adobe and Rosnik) is cost attribution. "How much did the 'smart search' feature cost us last month?"
 

 

 Because a computed column stores the provider's response, including the token usage it reports, cost attribution becomes a simple query:
 

 
```python
# Sum the tokens the provider reported for this feature
tokens = t.select(
 pxt.functions.sum(t.response.usage.total_tokens.astype(pxt.Int))
).where(
 t.timestamp >= datetime(2024, 1, 1)
).collect()
```

 
## Stop Burning GPU Cycles

 

 As your data volume grows, "re-run everything" stops being a viable strategy. It's too slow and too expensive. You need infrastructure that is **incremental by default**.
 

 

 Pixeltable's architecture stores every inference result, so reading it back never calls the model again. It's not just a technical optimization; it's a fundamental requirement for the economics of modern AI.
 

 
## Further Reading

 

 - [AI Transformations Belong in the Schema](/blog/ai-transformations-in-the-schema): why IVM works when AI transformations are part of the table definition

 - [Dependency Graph Magic](/blog/dependency-graph-magic-computed-columns): how computed columns track and propagate changes

 - [Schema-Driven Infrastructure](/blog/schema-driven-infrastructure-ai): the broader architecture that makes incremental computation automatic