The Reverse Information Paradox describes a problem every company using LLMs runs into, and software factories run into it harder than most. That’s why I believe enterprises will be very hesitant to set up their software factory inside a single lab.
Satya Nadella wrote a short article in July. It’s called The Reverse Information Paradox. I’ve read it many, many times and sent it to my friends and colleagues many times since it was published.
It turns Kenneth Arrow’s old problem with the value of information (how do you prove that information has a value without disclosing the information? Then the information is, more or less, free for the buyer?) on its head. “The risk of the buyer giving away knowledge in the AI age, just to be able to utilize what they purchased.” A few lines later. “In effect, you pay for intelligence twice. Once in cash. And then again in something even more valuable. The disclosure of the proprietary knowledge required to put the intelligence to use.”
Most of the responses I saw were that it was an article about data privacy. Which is a completely reasonable thing to consider. But there’s one sentence further down that stands out for me. And one that I see on a daily basis in my work. “They learn from ‘exhaust.’ From the prompts people write, from the tools the agents are using. And especially from corrections people make when the model is wrong.” A team working on software with agents creates that kind of “exhaust” by the hour. In every prompt. In every plan. In every review comment. In every correction. A large part of that exhaust is produced in what we are calling the software factory nowadays. It’s where the paradox is resolved for the software teams. And it’s also what the frontier labs would like to own the most.
If you want another way to see how much these traces are worth to the labs, look at companies like Mercor, Surge AI, and Scale AI. They’ve become multi-billion-dollar businesses largely by selling the labs training data and expert human feedback, which is exactly the kind of material your engineers produce for free every day.
The factory owns the outer loop.
And when I say software factory, I don’t mean a magic black box that you throw a product idea in and a few hours later you have production software. It’s simpler than that. That the software factory is the owner of the outer loop of the software delivery process. Triage, specification, planning, implementation, review, verification, shipping, monitoring. It’s the factory that decides what to build and when to build it. It’s the factory that keeps track of the work state. It’s the factory that verifies the outcome. The coding agent is in the loop. It’s the coding agent who decides how the code is written.
So, from that perspective. The coding models and the agents and agent harnesses around the coding models are just workers. They’re very capable workers. They get even more capable every few months. Workers. But you can replace them with another one in a well-designed software factory. You can start with one agent and then hand over the work to another one when the first one is hitting a limit or just performing worse on that type of work. I think that’s where the models are heading anyway. The gap between the frontier and open-source models keeps getting smaller; the best model in the eyes of your team members changes every other month. There is constant innovation towards commoditization. And you can achieve the same work with three or four different providers at pretty much the same quality level. The commoditization of the worker layer is an inevitable market direction. This will be uncomfortable for the labs. And it’s a good thing for all of us who are buying from them.
All the numbers shared by early adopter companies or individuals point in the same direction. One of the teams that runs the factory internally. Has over 1000 prs opened with agents. And over 1/3 of them have been merged. With 6h cycle times approx. Another team has 16x more commits YoY, but about only 2.3x more production deploys. Another example of code being cheap is Cursor, rewriting SQLite from scratch with agents. It’s all the knowledge and decisions that the factory needs to remember and make about the code that’s the scarce resource.
So you can see the bottleneck is shifting from writing code to code review and verification. V-Bounce whitepaper is also a good read and a metaphor about how SDLC is changing.
Your judgment is worth more than your code
Compare what a team gets done in a week. Once agents have done most of the typing. Ok, there’s code. But the most valuable thing is the judgment. It’s the spec that was rewritten because the first one omitted a constraint. It’s the plan that was blocked at inception because it’d violate another team’s contract. It’s the comment you make in the PR review saying why we never call that service synchronously. It’s the eval (if you have any!?) that starts failing after some model update. That’s what Satya is referring to. “Every correction is distilled into institutional know-how. It’s the kind of know-how you can never purchase from a competitor, and it’s the kind of thing that almost invisibly leaks. Trace by trace. Correction by correction. Eval by eval.”
For most of my 21 years in software (including when I managed >100+ engineers) we almost never documented this sort of know-how. Only when I was in AWS, we did pretty good on the documentation front, because everything starts with a document there, but that is for another conversation.
In most places I have been, it was in the hallway. It was in the brains of a few people who understood a module. That’s why bus factor was so real. You can’t just walk to someone’s desk and get the know-how. So when teams work with agents, there’s a big shift in that they start documenting their judgment for the first time. In specs, in rules files, in review comments, in evals. And yeah, I’d consider that an improvement. Now it’s all written in text. It’s in a system that dictates who has know-how about your company.
A good factory will take these comments and use them as raw material for improvement. Your PR comments will be harvested to improve the factory. A user making corrections to an agent in chat will become an update for the spec. Or the guardrails. A failed run becomes a new eval. This is all a “hill climbing machine” (Satya’s words), it’s a loop over months. The factory improves for your work. The question is, is this loop good for you or your model provider?
Hill climbing
Hill climbing is a local search optimization algorithm used in artificial intelligence and operations research that iteratively improves a candidate solution by making small changes and keeping each change if it produces a better outcome, discarding it otherwise. The name is a spatial metaphor: imagine standing on a hilly landscape where elevation represents solution quality; the algorithm always steps in the direction that goes uphill, stopping when no uphill step is available. Hill climbing is a foundational algorithm in classical AI search and remains widely used in optimization problems ranging from scheduling and routing to neural architecture search and hyperparameter tuning.
A simple rule of thumb for understanding the algorithm’s behavior: hill climbing will always find a solution, but it will only guarantee a locally optimal solution, not a globally optimal one. If the search landscape has multiple peaks and the algorithm starts near a small hill, it will climb to the top of that hill and stop — unaware of the taller mountain across the valley. This local maxima problem is the central limitation of basic hill climbing and the reason its variants exist.
Quote from Decagon.ai Glossary.
Will the models just build the factory?
Thariq (@trq212 on X), who until last month was working on Claude Code at Anthropic, shared something that got thousands of bookmarks. “Software factories feel like a temporary problem. Models will learn to build factories for you”. And then he added, “How do you build a workspace where you can work with agents? Is more interesting to me.”
I take this seriously because he was part of a team that built one of the best coding agents. Some of it is totally right. Scaffolding is something models start to get over time. Many complex prompt chains that teams built two years ago can be done in a one-shot prompt these days.
Some benchmarks show, and labs also announce, that training the model and the harness together gets better results. This also means that if your factory needs to do better than, or at least as well as, a lab-provided foreseeable factory, it should let you swap not only models, but also the harnesses that come with them. In other words, you should be able to run Claude Code or Codex CLI, not just use those models with your own harness.
In a conflicting theory, there are also opposing benchmarks suggesting that some harnesses introduce a “harness tax,” with some Anthropic models performing the same but costing less in different harnesses instead of the Claude Code harness. In this benchmark, pi-harness seems to perform the same for Fable but at a lower cost.
Finding 3/3: Models can perform competitively outside their own harness
Provider-specific optimization does not guarantee the best pairing. Providers sometimes optimize models for their coding environments: OpenAI, for example, describes GPT-5-Codex as optimized for software engineering in Codex.12 Yet across the six Anthropic and OpenAI models and both benchmarks, an alternative harness achieves the highest observed success rate in nine of twelve comparisons.
Our results show that the same model can achieve similar success rates at substantially different costs. On the benchmarks we test, simple open-source harnesses can be competitive, and models can perform well outside their own harness. A harness tax can go unnoticed when we focus only on task success.
So whether you need lab model and harness matching for the highest efficiency, or a matrix of harness and model matching, your factory still needs to support different harness and model combinations.
The part I disagree with Thariq’s view is what a factory means for an enterprise. If your factory is built for you by a model as part of a frontier lab’s (OpenAI, Anthropic) product, then all your specs, review history, and traces, along with every correction your engineers make, live in one provider’s system. They’ll be used only with that provider’s models. That’s lock-in. It’s a deeper kind of lock-in than we had with SaaS. (It’s the learning that’s locked in. Not just data).
Now. I do understand that, as a business, the labs want that. It’s the natural thing to do. When the worker layer is commoditized beneath you, having a factory just for your models is the best way to protect yourself from being switched off. But that’s their incentive; you don’t have to do it as an enterprise.
And Thariq has also said that he hates “one workspace app”. You should be “able to bring your own tools and services”, and I agree. I think the same applies at the model level.
Satya’s 5 Cs are the same thing!
At the end of Satya’s article, he has the 5 Cs. They’re really a spec for a provider-neutral factory from the software team's perspective.
Control
“Your own evals. Since evals define what ‘good’ is for your organization, you should build your own. Also “possession of your own org’s memory, traces, feedback, decisions, and org/team level context”. This is as simple as having your own benchmarks/evals. Building benchmarks from your own tasks on your own codebase. Ability to export and query your own traces. Evals and traces in a vendor’s dashboard belong to the vendor.
Choice
This is probably the one I’d start with. “Be sure that your orchestration layer is 100% decoupled from a specific model. And the question you should ask yourself is: if you take away a specific model that you’re using today, do you still have the ability to execute and optimize your evals with other models?” Maybe do it as a fire drill. Just switch off your default model for a week and see what breaks. You’ll know in a day or two if your skills, specs, and memory are all tied to the harness of a single lab.
I love the way he put the same point in his previous article:
A frontier without an ecosystem is not stable
“It should be possible to switch the ‘generalist’ model without losing the ‘company veteran’ knowledge that’s part of their learning system.”
Cost
This is a direct consequence of Choice. When Cursor’s agents rebuilt SQLite from its manual, every model mix they tried passed the full held-out test suite, but the cost ranged from about $1,300 to over $10,500 depending on which models did the planning and which did the work. In their words, “every mix produced similar quality, but the costs varied enormously.”
You can only make that kind of trade-off if you own your orchestration layer.
Capability
This means having learning environments set up within your own team or organization, so you can adjust models to fit your real workflows. At the same time, you want to keep your knowledge private.
Satya asks for learning environments “within the tenant boundary,” so models learn against real workflows without the knowledge leaving. A year ago that sounded like a research project. It doesn’t anymore.
AWS offers multi-turn reinforcement learning for agents on SageMaker, and Microsoft Foundry now lets you fine-tune open-weight models with rewards built from your own tests and acceptance checks, or write the training loop yourself on their GPUs.
And Amazon described running 3.1 million coding-agent sandboxes for its own training in two weeks. The GPUs and the training loops are becoming a commodity too.
What none of them give you is the training data. A trace tells you an agent called a tool and whether it worked. It doesn’t give you a clean copy of the repo at that commit, the acceptance criteria, the tests that decide pass or fail, or the reviewer comment that said why the first attempt was wrong. That’s what you need to take a real task from your history, let an open model try it in a sandbox, and score the result. And that’s exactly what a factory already holds: the spec, the plan, the environment, the checks, the corrections. A factory that keeps all of that on your side can feed it to whichever cloud trains best this year. A factory that lives inside one lab feeds it to that lab.
The test isn’t whether the tuned model is cheaper per call. It’s cost per task that actually gets done. A model that’s a fraction of the price but needs more retries or more human fixes isn’t a saving. You can only measure that with your own evals, which brings you back to Control.
Compound
You get this when you have all the other stuff. Your factory has loops that make it incrementally better at your work each month. But you have learning that’s on your side of the line. Doing all this will let your AI investments compound the value of your company.
So since Microsoft sells models, it’s totally reasonable to read this as the Microsoft CEO pushing for model independence with an eye to that. But I still think it’s a good point on its own. Because there are no assumptions in the logic about which provider will win.
What I think enterprises will do.
I think enterprises and especially companies are going to not want to be tied to any one provider. I think they’ll be jumping around between Codex, Claude Code, Grok, Cursor, Antigravity, Deepseek, GLM, Nemotron, Muse Spark etc based on price and quality and what job they’re doing. And their factory isn’t moving at all.
First and foremost, I think they’ll want to keep their traces internally. To improve the factory itself. So that each PR comment and each chat correction makes the next iteration better.
And then, as time goes on and it’s easier and cheaper, they’re going to be able to use those same traces to fine-tune their own models for their own use cases. Possibly using open models. This is Satya’s Capability point in his list.
And you can’t do any of this if the factory and the traces belong to the company you’re buying the model from.
I’m putting my bet on this. I’ve got to declare my bias. I’m working on fabriqa.ai at night and on weekends. The whole point is to have a provider-neutral open factory. You bring your own keys. You bring your own subscriptions. You have all the traces on your side of the fence. If you are using subscriptions, your provider can still keep your traces and train on them based on your agreement, but you still keep your traces and learning, and can move them between providers when you need to. You have loops that you can run to have the factory learn from your own team’s corrections.
Naturally, Satya’s article sounds like it supports what I’m building. The only thing I’m unsure about is timing. If labs start offering real trust boundaries in contracts and true portability for traces and evaluations, the need for a separate system might become less urgent. Still, I think most organizations should keep their systems within their own boundaries.
Referenced posts:
Satya Nadella, The Reverse Information Paradox (July 12, 2026)
Satya Nadella, A frontier without an ecosystem is not stable (June 14, 2026)
Thariq (@trq212), software factories feel like a temporary problem (November 16, 2026) and on bringing your own tools (November 17, 2026)





