The Compounding Effect of Building on Palantir Foundry

When Michael Burry said Anthropic could eat Palantir’s lunch, it sounded like a clean market argument. One company builds frontier AI models. The other builds enterprise software around data, decisions, and operations. If models become smarter, cheaper, and easier to use, the thinking goes, maybe the platform layer gets compressed.

But I think the comparison deserves a deeper look. Anthropic and Palantir may both sit inside the enterprise AI conversation, but they are not solving the same layer of the problem. To understand where the overlap is real, and where it breaks down, we need to look beyond the model and into what it actually takes to run AI inside an enterprise.

Where AI Actually Fails

Most AI demos stop at the moment the model gives an answer. That is usually where the real enterprise problem begins.

An alert comes in. Context has to be assembled. Options need to be evaluated. A decision has to be approved. Something has to change in a system of record. Later, the outcome needs to be measured.

None of these steps are new. The problem is that they rarely exist as one continuous flow. Context gets reconstructed. Decisions get passed around. Actions get executed elsewhere. Somewhere along the way, the connection between signal, action, and outcome starts to weaken.

So the gap is not just reasoning. It is whether the system can carry a decision from signal to action, while preserving context, control, and accountability along the way.

Models vs Systems

This is where the comparison starts to break down.

Anthropic is pushing the boundaries of reasoning. It can understand context, generate responses, and increasingly orchestrate workflows. That layer is moving fast, and it will continue to improve.

Palantir is solving a different problem. It is building systems where decisions can exist inside structure, move through workflows, and execute within real operational constraints.

The difference is subtle at first, but it shows up quickly in production. A model can suggest what to do next. The system still has to carry that suggestion forward, through context, approval, execution, and into an outcome.

Intelligence without structure remains suggestion.

It is similar to having the fastest car. Speed matters, but it is not sufficient on its own. You still need roads, traffic systems, constraints, and a way to get from one point to another reliably. Without that, speed does not translate into movement at scale.

Enterprise systems behave in a similar way. The model can generate the next step. The system still has to carry it forward.

What It Takes to Become an Operational System

To move from intelligence to execution, a system needs more than a model.

It needs data pipelines that assemble reliable context. It needs a structure that defines what exists in the business. It needs workflows that carry decisions forward. It needs execution layers that commit actions safely. It needs governance that travels with every step. It needs evaluation systems that prove the reasoning works.

Individually, all of these exist across modern data and AI stacks. But they usually live in separate layers, owned by different tools, and stitched together over time.

That is where the difficulty starts to shift. The challenge is not building any one of these pieces. It is making them behave as one system, where a decision can move from signal to action without losing context, control, or continuity along the way.

The Collaboration Reality

This is where the natural question comes in. If Anthropic continues to improve and partners across the ecosystem, can it close the gap.

It can assemble a strong stack. Data platforms handle storage and pipelines, models handle reasoning, workflow tools orchestrate, and tooling or agents drive execution, with governance layered on top. Each part can be best in class, and together they can deliver real value.

But it is still a composed system.

The challenge is not whether the pieces exist. It is whether they behave as one when the system is under pressure, when something changes, when decisions have to move across layers and still hold together.

Recent developments like the Model Context Protocol shift this further. It becomes easier for models to interact with enterprise systems without wiring everything manually, and that reduces a lot of the friction that existed earlier.

But connecting tools is not the same as owning the system.

Why Composed Systems Break

The issue is not capability. Each layer in the stack can be strong on its own.

The issue is how they come together.

Data lives in one place, logic in another, and actions happen somewhere else. Each step depends on a different system, a different abstraction, and often a different team. That works as long as the flow stays contained, but it starts to strain the moment a decision has to move across all of them.

Context has to be reconstructed. Controls have to be enforced at each step. Small gaps do not stay local. They compound as the flow moves forward.

Even if one use case works well, the next challenge shows up when you try to extend it. Can the same system support another workflow, combine with other use cases, and still evolve without breaking what already exists. In most composed stacks, that requires additional glue code, new integrations, and workarounds for every change. What started as a working system begins to accumulate coordination overhead.

Modern frameworks are improving this. Agent orchestration, MCP, and enterprise gateways are reducing the friction and making it easier for systems to connect. Some of this is improving. Centralized AI gateways and audit layers are starting to bring consistency across these systems.

But the challenge does not disappear. The question shifts from whether systems can connect to whether they can behave as one under change, scale, and failure.

That is where the difficulty compounds. Not in building the first use case, but in making the system hold together as it grows.

The Quiet Advantage

The visible loop is easy to describe.

signal → context → decision → action → outcome

What matters in production is what travels through that loop without being rebuilt every time.

In most stacks, each step has to be wired explicitly. Permissions need to be enforced again, lineage has to be traced, context gets reassembled across tools, files, and workflows, and actions are validated separately. The system works, but the continuity does not carry through.

In Palantir, much of that continuity is carried by the platform itself. A marking applied early in the data flow propagates downstream through pipelines and applications. Identity remains stable even as systems evolve, and decisions stay tied to the objects, the context, and the actions that produced them. Lineage is not something reconstructed after the fact, it is already part of how the system understands itself.

The difference is not whether memory exists. It is whether it is shared, structured, and carried across the system. The builder defines the structure once, and the system keeps carrying it forward as it grows.

In most stacks, you wire the system. In Palantir, the system carries the wiring.

Where Anthropic Will Win

None of this means Anthropic is not a serious force. It is.

What we are seeing now is a rapid expansion of the model layer. Systems that once generated answers are now able to plan, call tools, execute code, and carry multi-step workflows forward with much less friction.

This is no longer limited to lightweight use cases. These systems are already moving into research, engineering, finance, and operational environments, often with enterprise controls wrapped around them.

That matters because the boundary is moving.

What starts as assistance becomes workflow, and what starts as workflow begins to touch execution. The system is no longer just suggesting the next step. It is starting to carry parts of the work forward.

That is where Anthropic will continue to move quickly and win. And that is where the real comparison begins.

The Real Risk to Palantir

The risk to Palantir is real, and it is evolving. Model-first systems are moving beyond reasoning into control, orchestrating workflows, triggering actions, and interacting directly with systems of record through agents, tool execution, and protocols like MCP. If that layer matures into durable workflows with approvals, auditability, memory, and outcome tracking, the gap starts to narrow quickly.

This is also where Palantir’s advantage becomes clearer. It was not built around a single workflow and then expanded. It was shaped over time across industries against real operational constraints. Defense, manufacturing, healthcare, energy, and finance bring different edge cases, but the same requirements keep appearing. Permissions, audits, approvals, lineage, writebacks, and human accountability.

That does not get recreated in weeks.

The first workflow can often be replicated. The difference starts to show as the system grows, when the tenth or twentieth workflow needs to behave consistently with everything that already exists, and when changes have to propagate without breaking what is already in motion. That is where the system either holds or starts to fracture.

This is also why Palantir becomes sticky. As more workflows move into the ontology, more actions are governed through the system, and more decisions create history, the system starts to accumulate context about how the business actually operates.

At that point, replacing it is no longer just a technical decision. It is replacing the operating context of the business, which is significantly harder.

A Useful Benchmark

One useful benchmark for this debate is SAP migration. A lot of what I am saying about Anthropic could change over time. The pace of progress on the model layer is real, and this benchmark is not static.

The question is not whether a model can generate mappings or explain legacy tables. It is whether it can help run something like an SAP migration end to end, where decades of custom business logic need to be understood, source structures mapped, transformations generated, outputs validated, exceptions managed, approvals routed, lineage maintained, and the business kept confident before anything moves forward.

That is the kind of benchmark that matters.

And even then, SAP migration is only one example. It is still a relatively contained workflow compared with ongoing operational systems, where decisions are not one-time but continuous, and where context, actions, and outcomes keep evolving together.

The harder test is not migration, but running continuous operational systems where decisions, constraints, and outcomes evolve in real time.

If a model-first approach can handle something like this end to end, not just generating parts of the solution but running the process in a faster, safer, and more reliable way, then the conversation changes. That is when this comparison becomes real.

Until then, the gap remains.

The Direction Matters

It is also worth noting that this is not a static comparison.

Anthropic is moving downward, from reasoning into workflows, execution, and system interaction. Protocols like MCP and agent frameworks are accelerating that shift.

At the same time, Palantir is moving upward, embedding intelligence deeper into operational systems. What started as data integration and workflow orchestration is now being extended with AI-driven decision support, agents, evaluation layers, and new ways to build and operate workflows inside the same system.

Palantir is also moving faster than it may appear from the outside. The important part is not just the pace of new AIP capabilities, but where they land. They are being added into the same operational layer, not as disconnected tools that each need to be stitched together later.

Both are evolving quickly, but they are starting from different foundations.

One is trying to make intelligence operational. The other is making operations intelligent.

The direction is clear. The question is where these two paths meet, and whether they converge into the same system or remain fundamentally different.

Closing

The fastest model is not the limiting factor in enterprise AI. The limiting factor is whether the system can take a decision, carry it through the business, and remain reliable as everything changes.

Anthropic is rapidly expanding from reasoning into execution, pushing further into workflows, tools, and actions. Palantir is already operating in environments where execution, governance, and continuity are built into the system, where decisions are not just made but carried forward and tracked.

These are starting to overlap, but they are not the same yet.

One is accelerating what machines can do. The other defines how those capabilities hold in production.

The real question is not who wins. It is how far that overlap goes.