Headless or Headed

The first MCP server I ever built, sometime in early 2025, was a digital twin of myself. Dedicated to my co-founder Fahd, in theory. Built for the whole team, in practice.

The premise was half joke, half load-bearing. Fahd was making engineering and design calls across the company faster than I could keep up with, and the rest of the team was doing the same. I figured the kindest thing I could do for all of them was to bottle the way I think about scaffolding a project, structuring an API, making a UX call, and let them ask the bottle instead of asking me. So I wrapped my judgment into an MCP server. They'd query it from Claude, it would answer the way I would, and we'd all move faster. Most importantly, I'd stop being the bottleneck on questions I'd already answered.

I remember sitting back from my laptop after the first clean tool call came through, and thinking, this is the thing. Not the digital twin specifically. The shape of it. Every business is going to need one of these inside five years, and almost nobody has said it out loud yet.

That instinct turned into a bet. The unit of business presence in the next decade is not the website, not the dashboard, not the chatbot. It's the MCP App.

The companies that build them right are going to own their category for the decade after. The ones that don't are going to spend the next three years watching their customer relationships migrate into agents they don't control.

Let me explain what I mean, because the whole argument turns on two words.

Head and Pipe.

Every piece of software in the last twenty years has been some combination of a head and a pipe.

• 1.The head is what the user sees and clicks. Buttons, screens, workflows, the interface that wraps the product.
• 2.The pipe is what's underneath. The data, the schema, the actual record of what's happening in the business. The dashboard is a head. The database is a pipe. The mobile app is a head. The API behind it is a pipe.

For fifteen years, every SaaS company had to be both. You earned the right to hold the pipe by building a great head, because the only way the customer could reach the data was through the screen you put in front of it. Head and pipe were the same company because they had to be. The interface was the product. The interface was the moat.

That arrangement quietly ended when the user stopped being a human.

When the User Became an Agent.

The user is now, increasingly, an agent acting on behalf of a human. The agent does not want your head. It wants your pipe. It wants a clean way to read your data, write back to it, and do work on top of it, without ever touching the screen you spent two years polishing. Every pixel you ever shipped is friction between the agent and the thing it actually wants. Which means the moat you built around the head evaporates the moment a credible alternative head shows up. And credible alternative heads now show up roughly every six weeks. ChatGPT is a head. Claude is a head. Whatever ships next quarter is a head. They're all reading the same pipes underneath.

So the position that holds in this world is the pipe. Whoever owns the pipe owns the business. Heads come and go. Pipes get entrenched.

Whoever Owns the Pipe.

Most people hear pipe and picture some enterprise data infrastructure play. Databricks for SMB. That's not it. Every small business already has a pipe. It's just scattered across their POS, their inbox, their CRM, their Instagram, their head. Nobody has assembled it into something an agent can actually use. Until somebody does, the agent revolution happens around small businesses, not through them.

That's what Noodle Seed is. We assemble every business's pipe into a structured MCP App, generated automatically the moment they sign up, served from infrastructure we own end-to-end. Their MCP App becomes their canonical presence in every AI surface that matters. ChatGPT. Claude. Whatever comes next, on the same primitives, with no work required from the business. Their customers reach them through whichever agent they happen to be in, and we don't care which one wins next quarter, because the pipe underneath is the same.

We made the deliberate decision to build this on multi-tenant infrastructure, not as separate deployments per customer. Outsourcing the MCP layer would have been outsourcing the company. The pipe isn't a hosting problem. It's where the business lives in the agent era.

This is the part of the story you can hold in your hand. A website is a head. The MCP App is a pipe with hooks for any head. You can grow a hundred heads on the same pipe. You cannot grow a hundred pipes on the same head. That's why the position compounds.

Owning the Pipe Is the Beginning.

Owning the pipe is not the end of the war. It's the beginning of a different one.

The moment you open your pipe to third party agents, the strongest of them are going to come for you. Not by building a better head. By trying to commoditize your pipe. The well-capitalized agent companies will abstract your MCP App, cache it, build a translation layer on top, and quietly offer their customers a bundled version of you for free. The agent gets to be the brand the customer thinks about. You get to be a cost line in the agent's infrastructure budget.

The defense is shipping your own head on top of your own pipe. That's what Halo is for us. A conversational engagement layer that gives every business a great default the day they sign up, so the customer doesn't experience the relationship through someone else's agent. The interface era taught a generation of operators that the head is downstream of the pipe. That instinct is now the trap. In the agent era, the head is upstream of the trust. You either ship the head your customer would otherwise hire from someone else, or you become invisible to the customer you're holding the pipe for.

We Ran It on Ourselves.

We learned this by running it on ourselves first. Internally we built Mars, our company brain, on the same architectural principle. One consolidated pipe for everything Noodle Seed does, agents on top to make it useful. The lesson from running Mars for a few quarters was that the agents I initially built were not the ones the team ended up using. The ones that mattered emerged from the consolidated pipe itself, small and weird and impossible to specify in advance. When the pipe is fragmented, every agent is an expensive bet. When the pipe is consolidated, agents become disposable experiments. That asymmetry told us the customer-facing architecture had to be the same shape. Consolidate first, agentify second.

The next move on Mars is to wrap it in an MCP App of its own. Same primitive we ship to customers, turned on ourselves. When I'm using Claude on a Sunday night thinking through a deal, I want Mars reachable from the surface I'm already in, not a separate destination I have to remember to open. If your internal tooling and your customer product can converge on the same primitive, the primitive is right. If they can't, one of them is wrong.

The Call.

Here's the call I'm willing to date. By the end of 2027, every successful small-business software category will have one winner that built a great pipe with a credible default head on top. Zero successful winners will have retrofitted from being pure-head companies. Website builders. Dashboard tools. Chatbot vendors. They won't make the jump. Organizations built to ship heads cannot become organizations built to ship pipes inside the window the market is going to give them.

Different discipline. Different pricing. Different customers to fire. Most won't.

Two paths. Build the pipe, ship the head that protects it, and let the customer reach the business from wherever they are. Or keep polishing your head, and watch the pipe migrate out from under you, one integration at a time.

We picked the first one in 2025. Most of you reading this still have time to pick. But not as much as you think.