Nadella Says You're Paying Twice. Do You Know If You Are?

Last month Satya Nadella published a post on what he calls the "Reverse Information Paradox." Around the same time, Alex Karp told CNBC that enterprise clients are privately livid about their AI vendors. Two CEOs who agree on little, saying the same thing: the value is not in the model you rent. It is in the knowledge layer you own.

That points at something easy to miss: even when retrieval works, you are still paying twice for every answer you get.

Nadella's point is simple. You pay for the compute. But to get useful output you also feed the model context: your documents, your corrections, your know-how. The better you want it to perform, the more you have to reveal. As he put it: "You essentially pay for intelligence twice, once with money, and again with something even more valuable: the proprietary knowledge you must reveal to make that intelligence useful."

Karp made the same argument from the buyer's side: technical customers want control over their compute, their models, their data stack, and their alpha. They want to own the means of production, not hand it to someone else.

The objection, and why it misses

The obvious objection is that enterprise contracts prohibit training on customer data. OpenAI and Anthropic are not using your prompts to train the next GPT. But that is not what Nadella is talking about. The asset is not the data you sent. It is the context you assembled around it: the prompts you refined, the corrections you made, the mental map of which document answers which question. If you never compile that into something you own, you re-buy it every session. You reconstruct the same context, feed the same files, rewrite the same instructions. That is the second payment.

Prompt Debt

You do not need to be an enterprise for this to be true of you.

In Why AI Tools Fail at Your Document Archive, I wrote about why retrieval breaks on real document archives, and why the problem lives upstream of the model. That post was about the archive not answering you. This one is about what it costs you every time you make it answer.

I learned this the hard way as a solo consultant. I had a few hundred PDFs, notes, and client briefs scattered across folders. Every time I started a new ChatGPT session, I would drag in the same ten files, paste the same preamble, and hope the model remembered what mattered. It never did. I was not leaking data to OpenAI in any contractual sense. I was just paying twice: once in tokens, and once in the re-transferred context I had to reconstruct from memory.

I think of this as the real Prompt Debt. Where the term already circulates it tends to mean prompts going stale, instructions written once that rot quietly as the models underneath them change. I mean something narrower, and closer to home: the individual version of what Nadella described. Every session, you re-feed loose files to an LLM and rebuild the context that should have been compiled once. The tokens cost money, but the real cost is attention. You spend your cognitive budget reconstructing what you already knew.

The way out

There is a way out. In my own testing, which I wrote up in full, I showed what happens when you stop re-buying context and compile it once. The compilation approach did not just retrieve better. It retained relationships across documents that RAG flattened. The numbers are in the post, but the takeaway is simple: compiling once beats reconstructing every time.

Compiling once means you stop re-buying your own context every session. Your source documents stay your own files, untouched. Everything runs and lives on your machine. Nothing feeds anyone else's model. You do not need an enterprise orchestration layer to own your knowledge. You just need to stop starting from zero every time you open a chat window.

Related

• Why AI Tools Fail at Your Document Archive — why retrieval breaks on real archives, and why the problem lives upstream of the model
• I benchmarked plain RAG against corpus compilation on my own vault — controlled numbers on what compilation actually changes