Harvey just announced they will be training their own models.
We've already seen this with Cursor, who recently worked their way into profitability with the success of their Composer model. Harvey is now following in their footsteps.
In the early AI startup cycle, application-layer companies were mocked as “GPT wrappers.” If you were building a product on top of OpenAI or Anthropic, the default criticism was that you had no moat. You were just wrapping a better interface around someone else's model.
But the opposite is starting to happen. The best application-layer companies are becoming deeply rooted with customers, building workflow-specific data advantages, and then using those advantages to reduce their dependence on model companies. Cursor and Harvey are the first 2 major players, but there will probably be many more after them.
The wrappers that were supposed to get crushed by the model companies are becoming model companies themselves.
The wrapper critique got it all wrong
The model layer (OpenAI, Anthropic, Google DeepMind, xAI, Meta, and other labs building general foundation models) produces raw intelligence at massive scale and exposes it through APIs.
The application layer sits above that. These companies take the raw capability of foundation models and turn it into something useful for a customer or industry. Cursor does this for software engineering. Harvey does it for legal work. Other companies are doing it for sales, finance, medicine, travel, education, insurance, etc.
That is where “GPT wrapper” came from. The critique was that application companies were not really AI companies, just interfaces around someone else's API. Popular expectation was that the frontier labs would eventually expand upward and eat them alive. The opposite pattern is instead becoming visible.
The most successful application companies are becoming more self-sufficient, not less. They start by depending on frontier models, but over time they learn exactly where general models fail inside a specific workflow. They collect proprietary feedback, observe edge cases, and understand the customer's job better than the model lab does.
And once you have customers, workflow knowledge, and proprietary data, you have the ingredients for specialized models.
The customer is the moat
From first principles, perhaps this was obvious all along.
AI on its own is useless, it's the conversion of that raw intelligence into units of digital work that brings in returns that businesses are willing to pay for.
Traditionally, the closer you are to the customer, the more value you can create, and the more of that value you can capture. Infrastructure is essential, but it often becomes a utility. The end product, the thing that owns the relationship, understands the pain, and shapes the workflow, is where value turns into pricing power.
If you live in Florida, you know FPL, Florida Power & Light, as the company that keeps the lights on. It is critical infrastructure, and heavily regulated. But most of the value in the economy does not go to the utility simply because it supplies the power every business needs to operate. The value goes to the businesses that use that power to build something specific for customers.
The model labs may end up playing a similar role. OpenAI, Anthropic, Google, and the others provide the underlying intelligence. That intelligence is extremely important, but it may become more like electricity: powerful, expensive to produce, broadly available, and increasingly taken for granted.
The application layer, meanwhile, gets closer and closer to the customer. It owns the kind of data that is not generic internet text. It is behavioral, contextual, and specific.
That is why the “wrapper” critique missed something important. A wrapper with no customers is fragile. A wrapper with deep customer adoption is not just a wrapper anymore. It is a distribution channel, a data engine, and a product lab all at once.
From application to model
It makes sense that Cursor and Harvey are investing in their own proprietary models. Owning more of their respective value chains can make the product better, cheaper, faster, and harder to copy.
Yes, they may have spent years with low or negative margins, with much of the value being eaten up by OpenAI and Anthropic. But they were able to use that period of struggle to collect data and build the moat they needed to train their own specialized models and reduce their upstream dependence.
Composer is a good example. It is already a genuinely strong coding model, and I find myself enjoying using it inside of Cursor. We are likely to see Harvey find similar success in legal work.
This will not be limited to coding and law, either. Any application-layer AI company that gets deep enough into a valuable workflow can start to develop the same pattern.
First, use frontier models to build the product.
Then, use the product to understand the workflow.
Then, use the workflow data to build specialized models.
The lay of the land
The model labs still matter enormously. They will keep pushing the frontier, and many application companies will continue depending on them. But the relationship may look different than people expected.
Instead of a simple hierarchy where foundation model companies sit at the bottom and eventually consume everything above them, we may get a more complicated market. Foundation models provide broad intelligence. Application companies provide context, workflow, distribution, and proprietary data. Over time, the strongest application companies use those assets to train models that are better suited to their own domains.
That does not mean every wrapper becomes durable. Most will not. A thin UI on top of an API is still easy to copy.
But the best ones were never just thin UIs. They were entry points into customer behavior.
Cursor and Harvey are early signs of this. They spent years being dismissed as companies built on someone else's intelligence. But while the market was arguing about whether wrappers had moats, the best of them were quietly accumulating the exact assets needed to build moats of their own.
The GPT wrappers were not a temporary layer waiting to be crushed, after all. They've been learning how the next models should be built.