On MCP

Why the hype is half right

Every conversation about software in 2026 eventually arrives at three letters: MCP.

If you spend any time near AI infrastructure, AI tooling, or the people who fund both, you have heard the claim. Model Context Protocol is going to change everything. It is the USB-C of AI. It is the death of dashboards. It is the moment when language models finally stop being chatbots and start being agents that actually do things.

Half of that is true. The other half is selling something.

What MCP actually is

MCP is a protocol. That is the whole story.

It is an open standard, introduced by Anthropic in late 2024, that lets an AI model talk to external systems in a consistent way. Instead of every developer building a custom integration to plug their software into Claude or ChatGPT or any other model, the model speaks MCP, the application speaks MCP, and the two find each other.

Think of it as a translation layer. Before MCP, every AI integration was a bespoke project. After MCP, the integration becomes plug-and-play. A model asks a question. The application responds with structured context. The model makes a decision or surfaces an answer.

This is genuinely useful. I am not going to argue against the protocol itself. Standards are how software ecosystems mature, and AI needed one badly.

But MCP is the transport layer. It is the wire. It is not the truth.

Why everyone is suddenly excited

The excitement has nothing to do with the protocol itself and everything to do with what it suggests is possible.

If a model can call any tool through a standard interface, the argument goes, then the dashboard becomes obsolete. You stop opening tabs and clicking through reports. You ask your AI assistant a question, and it queries 12 different systems in parallel, pulls back the data, reasons across it, and gives you the answer.

This is the post-dashboard era. The interface moves from screens to conversations. Software stops being something you look at and starts being something that thinks for you.

The vision is correct. The timing is not.

The thing that gets glossed over

For MCP to deliver the future people are selling, one assumption has to hold: that the application on the other end of the protocol has a coherent, unified data model the model can reason against.

This assumption is almost never true.

Most software products in 2026 are not built around a coherent data model. They are built around a user interface that sits on top of a mess. The mess is usually a collection of database tables that were added incrementally over years, each one solving an immediate need, each one defining the same concept slightly differently.

In a typical SaaS product, ask three different parts of the system what a "customer" is and you will get three different answers. Ask what an "order" is, what "revenue" is, what "this month's performance" is, and the disagreement compounds.

Humans have learned to work around this. We squint at the dashboard, mentally apply the correction we know is needed, and trust our gut to fill the gaps. We are very good at this because we have to be.

A language model cannot do this. It will read whatever data is presented to it as if it were truth. It will reason confidently across inconsistencies it cannot detect. It will produce answers that sound right and are wrong.

I wrote about this in January in Context Graphs. The short version: AI without a structured data foundation is not analytics. It is hallucination at scale.

MCP does nothing to fix this. MCP just makes it faster.

The application problem

Consider what happens when you bolt MCP onto a product that does not have a unified data foundation.

The model asks: "What was our revenue last week?"

The application responds with whatever its "revenue" endpoint returns. But that endpoint is reading from three different tables, two of which use different definitions of revenue (gross or net, including or excluding refunds, currency-converted on which date), and the model has no way to know which definition is correct for the question being asked.

The model returns a confident answer. The executive nods. The number is wrong by 8 percent.

This is not a hypothetical. This is what is happening right now in companies that have rushed to slap MCP servers onto their existing products. The infrastructure works. The protocol works. The data does not.

The hard part of building for the AI era was never the protocol. It was always the data.

Why dashboards do not die yet

Here is the contrarian position: dashboards are going to outlive most predictions of their death.

Not because dashboards are great. Most of them are not. But because dashboards have one property that the post-dashboard vision conveniently ignores: they let humans verify the data.

When a number on a dashboard surprises you, you can click into it. You can see where it came from. You can spot the inconsistency. You can call the analyst and ask why the definition changed. The dashboard, for all its friction, is a forcing function for trust.

Strip away the dashboard and replace it with a chat interface, and you have removed the verification layer. You are now trusting the model to be right because the model sounds right.

For low-stakes decisions, this is fine. For business decisions that involve real money, real inventory, real customers, this is reckless until the data layer underneath has been rebuilt.

The companies pushing "AI agents replace dashboards" are doing so before doing the unglamorous work of fixing the data foundation. That order is wrong. The dashboard should die after the foundation is fixed, not before.

What the right path actually looks like

I think the future plays out in three phases. We are at the beginning of the first.

Phase one is now. Companies rebuild their data foundations. They unify their definitions. They store not just outputs but the reasoning behind those outputs. They turn fragmented schemas into coherent models. This is boring work. It does not generate magazine covers. It is also the only thing that matters.

Phase two is the AI layer on top of the foundation. Once the data underneath is coherent, AI starts to actually help. Anomaly detection works because the model can tell the difference between a real anomaly and a definitional inconsistency. Natural language queries work because the model is querying truth, not noise. Recommendations become trustworthy because the underlying signal is trustworthy.

Phase three is the post-dashboard era. Eventually, with the foundation right and the AI mature, the human stops opening the interface. Intelligence flows to where the human already is: Slack, email, the AI assistant they are already using. The dashboard does not disappear. It becomes the source of truth that machines query rather than the screen that humans squint at.

This is the path we are building at Clarisix. We started with the foundation. The dashboard is the surface, but the unified data model underneath is the product. We are not bolting MCP onto a mess. We are building the mess-free foundation that MCP will eventually consume.

What we believe

A few specific positions on this.

• The bottleneck of AI in business software has never been the model. It has been the data underneath.
• A model connected to a fragmented data source is more dangerous than a human working with the same fragmented source, because the model has confidence without context.
• Every company that wins the next decade of software will have spent the boring years rebuilding their data foundation while their competitors were demoing chatbots.
• The companies that lose will have skipped the foundation work and tried to retrofit AI on top of a mess. Their AI features will impress in demos and fail in production.
• Standards are good. MCP is a good standard. But standards do not fix bad data. They just move bad data faster.
• The interface of the future is not chat. It is whatever surface delivers a trustworthy answer the moment it is needed. Sometimes that is chat. Sometimes that is a notification. Sometimes that is still a dashboard.

The bet we are making

When we built Clarisix, we made an explicit choice. We were not going to bolt features onto an inherited mess. We were going to build the data foundation first, even if that meant slower visible progress.

We unified definitions before we built dashboards. We treated content changes and customer experience signals as first-class data, not as bolt-ons. We built the system to answer questions correctly before we worried about how those questions would be asked.

This was the unsexy decision. We watched competitors ship faster, demo bigger, raise more money. We kept working on the foundation.

The reason: we believe the AI-native future is real. We also believe it cannot be retrofitted. The companies that will deliver real AI value over the next decade are the ones whose data is already coherent, whose definitions are already unified, whose foundation is already ready for an agent to query.

MCP is here to stay. The transport layer will commoditize. The application layer beneath it will not.

When the AI-native future arrives, we will already be there. Not because we adopted MCP fastest. Because we built the foundation it deserves.

Why this matters for you

If you are building a SaaS product right now, the question is not "should we add MCP support?" The question is "is our data model coherent enough that MCP would expose value, or expose chaos?"

If you are buying SaaS as a customer, the question is not "does this tool have AI features?" The question is "is this tool's data model coherent, or are they painting AI on top of a mess?"

The difference matters. The first kind of product will deliver real value over the next ten years. The second kind will deliver demo-grade features that fall apart the moment real decisions depend on them.

The future is not built by the loudest. It is built by the ones doing the unglamorous foundational work while everyone else is talking about the protocol.

We are doing the foundational work. So should everyone else who actually wants to be there when the future arrives.

— Claudiu Clement Co-Founder & CEO, Clarisix

Read the manifesto → · More essays at claudiuclement.com →