Skip to content

Causal Tiling: Stop Paying for the Same Reasoning Twice

TL;DR

Modern AI keeps rediscovering the same structure, the same relationships, and the same explanations. Causal tiling offers a way to reuse reasoning the way cloud systems reuse infrastructure.

AI has a strange habit: it is expensive because it is forgetful.

We train giant models on staggering amounts of text, logs, time series, and behavioral traces. Then we ask them to solve the same classes of problems again and again: Why did demand move? What caused the outage? Which levers drive revenue? What happens if we change this constraint, this price, this power contract, this promotion?

The astonishing part is not that our models can answer these questions. The astonishing part is that they often answer them by recomputing similar reasoning from scratch every time.

That is wasteful. It is wasteful in tokens, wasteful in compute, and wasteful in latency. More importantly, it is wasteful in the deepest sense: we keep paying for intelligence as though intelligence has no memory.

The Hidden Cost of Starting Over#

Most modern AI systems still operate at a fairly low level of abstraction. Language models break the world into subword tokens. Time-series systems ingest streams of numbers. Monitoring tools ingest metrics, logs, and traces. Revenue systems ingest events, clicks, deals, and contracts.

Then the system tries to infer structure from those raw units.

That is fine when the structure is genuinely new. But in many of the domains that matter commercially, the structure is not new.

Consider a few examples:

  • In CPG, promotions, seasonality, lead times, and inventory almost always interact in recurring ways.
  • In cloud systems, traffic, service load, infrastructure choices, cost, and SLOs also follow recurring patterns.
  • In GTM funnels, engagement, trials, response time, pipeline, and win rate are not random strangers meeting for the first time.

And yet our systems often behave as if every new customer, every new dataset, and every new question is a first contact with alien life.

This is not merely inefficient. It is intellectually backward. Human experts do not solve problems this way. They build reusable mental models. They identify recurring mechanisms. They learn patterns of causation once and reuse them widely.

AI should do the same.

From Tokens to Tiles#

What if we stopped treating intelligence as an endless stream of tiny tokens and started representing it in reusable, higher-level units of reasoning?

That is the intuition behind causal tiling.

A tile is a composable causal subgraph: a small, reusable chunk of structure that captures a recurring relationship in the world.

Examples:

  • Promotion -> demand uplift
  • Inventory + lead time -> stock-out risk
  • Traffic -> compute load -> cloud cost
  • Response time + meeting quality -> win rate
  • Utilization -> power draw -> SLA risk

Each tile is not just a statistical motif. It is a causal mechanism. It encodes a structure we expect to recur across customers, across verticals, and across time.

Once a system can identify, learn, and reuse these tiles, something important changes:

  • It no longer needs to rediscover the same structure repeatedly.
  • It can shrink the search space of reasoning.
  • It can compose solutions out of known pieces.
  • It can reserve heavy compute for the genuinely novel parts of the problem.

This is the difference between building every house from raw lumber on-site and using prefabricated components. Both approaches can produce a house. Only one of them scales gracefully.

Why This Matters for Compute#

There are at least three ways causal tiling can materially improve efficiency.

1. It shrinks the search space#

If we know that certain variables belong together in a tile, we can drastically reduce how much computation is spent considering nonsense structures.

A brute-force model may entertain countless candidate relationships before it settles on something plausible. A tiled causal system starts with stronger priors: this kind of business process, system topology, or commercial funnel has recurring structure. Search is narrower. Discovery is cheaper.

2. It amortizes reasoning over time#

Once a tile has been learned in one context, it can be reused in another. The next customer in the same domain does not require full rediscovery; they require adaptation.

This is a profound difference. Instead of paying for intelligence as a pure variable cost per tenant or per question, you begin to turn intelligence into an asset. The tile library improves over time. Marginal cost of reasoning drops.

3. It enables cheaper what-if analysis#

Counterfactual reasoning is expensive when every answer requires a large model to rebuild the entire story from scratch. It is cheaper when the system already has a causal graph and only needs to intervene on a few nodes and propagate the consequences.

“What if we increase promo depth by 10%?”

“What if we relax this SLO?”

“What if we reduce retention from 90 days to 30?”

In a tiled causal system, these are interventions on a known structure. In a purely brute-force system, they are often fresh reasoning exercises disguised as queries.

A New Layer in the Stack#

The most interesting implication is that causal tiling is not just a modeling trick. It could become a new infrastructure layer.

Today, cloud systems reuse compute primitives. Databases reuse storage primitives. CDNs reuse delivery primitives. But most AI systems still have very little reuse at the level of reasoning structure.

A causal tile engine changes that.

Imagine a system that sits between raw data and applications:

  • It stores reusable causal tiles.
  • It composes them into larger causal graphs for specific customers or domains.
  • It caches interventions, sensitivities, and explanations.
  • It exposes a standard interface for applications, copilots, and agents.

In such a world, a co-pilot no longer has to infer from scratch what drives churn in this business or what drives spend in that cloud architecture. It can query a causal substrate already populated with reusable mechanisms.

This is where the idea starts to become bigger than Causify’s current products. It hints at causal infrastructure as a category.

Where This Could Go#

Once you see tiles, you start seeing them everywhere.

Observability and FinOps#

Service, queue, cache, database, and workload interactions are highly reusable. A causal tile library for infrastructure could explain not just where cost or latency increased, but why and what tradeoffs are available.

GTM and Revenue Systems#

Engagement, pipeline, conversion, response time, and sales cycle length form a repeating commercial grammar. Most companies keep relearning it through separate dashboards and analytics projects. Tiles would let them reuse the same causal skeleton and focus compute on the differences that matter.

Supply Chains and Operations#

Lead times, demand shocks, substitution, and capacity constraints are not random coincidences. They are recurring mechanisms. A tiled system can turn what is currently bespoke consulting logic into reusable intelligence.

Copilots and Agents#

Enterprise copilots are expensive partly because they repeatedly infer the same organizational logic. A persistent causal cache of tiles could give them a world model to think with, rather than forcing them to improvise one from prompt text again and again.

LLMs Themselves#

This may be the most provocative version of the idea.

Today, most language models operate on subword tokenization. That is a triumph of engineering, but not of semantics. The model processes a stream of text fragments and hopes the structure of the world emerges inside the weights.

What if, above those ordinary tokens, we introduced causal macro-units? Not just words, but reusable chunks of reasoning:

  • price change -> conversion impact
  • utilization -> power -> reliability
  • response time -> win rate

The model would still need fine-grained language when it writes or reads. But for many business and systems problems, it could reason primarily at the level of tiles and only drop to raw tokens when detail is necessary.

That would not magically replace every transformer. But it would represent a serious move away from the wasteful assumption that every inference must begin at the smallest possible unit.

Not Magic, Just Better Economics of Intelligence#

To be clear, causal tiling does not make all compute disappear.

Data still has to be ingested. Models still have to be trained. New phenomena still have to be learned. Some domains are too fluid or too unstructured for a rich tile library to help much.

But many economically important domains are not like that. They are structured, repetitive, and governed by recurring mechanisms. In those domains, causal tiling offers a much better economic model:

  • pay once to learn a mechanism,
  • reuse it broadly,
  • reserve heavy compute for novelty,
  • and make reasoning faster, cheaper, and more consistent.

In other words, it turns AI from an endless burn of tokens into a compounding library of causal knowledge.

That is the key idea.

We do not just need models that are larger. We need systems that are less forgetful.

And when you phrase it that way, the real opportunity becomes obvious:

The next wave of AI may not be about spending more compute to think harder. It may be about spending less compute to avoid thinking the same thought twice.