Why Open Plus Paid Beats a Closed Suite in the Era of Artificial Intelligence

AI can already draft the campaign, write the connector, and clone a mediocre product’s feature list. Hiding how your platform works is a thinner moat than it used to be. Transparency is a blessing and a curse. You publish the complexities and a lot of the intellectual property. Anyone determined to copy you will copy you. The model that keeps winning is not a sealed suite. It is an open edition people can run, plus a paid edition that funds support, infrastructure, and the next release.

I first made a narrower version of this argument in 2005, as Open = Growth, after an NFL stack evaluation. That piece was about APIs. The math is bigger now. Open the product, or at least the interfaces. Charge for the hard parts: uptime, identity, compliance, scale, and someone who answers when it breaks.

The Blessing and the Curse

The blessing is distribution. An open project becomes the default in a developer’s laptop, a marketer’s test site, a data team’s warehouse. People extend it. They write about it. They hire for it. When they need SLAs, single sign-on, or a team that will take the 2 a.m. page, they already know your name. The paid product is not a bait-and-switch. It is the same engine without the burden of running the plant.

The curse is real. You show competitors how the sausage is made. You inherit support from people who will never pay you. License fights erupt when a cloud giant hosts your work and sells it back to you. Some vendors respond by relicensing. That is a separate mess. The companies that keep growing treat the open layer as marketing and R&D, and the paid layer as the business. They do not pretend the GitHub repo is free labor that replaces a company.

Open Plus Paid Is a Growth Engine

This is not a sports story. It is how many durable software companies fund themselves while staying easy to integrate. These teams ship something you can run, then sell the hosted, supported, or enterprise version of the same idea.

• WordPress: The GPL CMS is free. Automattic sells hosting, Jetpack, commerce, and enterprise operations around it. The software being copyable did not kill the company. Running it well, at scale, with support, is the product many teams actually buy.
• GitLab: Open-core by design. GitLab’s public filings describe a model that generates almost all revenue from paid tiers (Premium, Ultimate, and hosted SaaS), while the free tier remains the on-ramp. Contributors extend the product. Revenue still comes from subscriptions and, increasingly, AI consumption.
• PostHog: Product analytics, session replay, flags, and experiments as OSS you can self-host, plus a paid cloud. Their docs are blunt: hobby self-hosting is for small volume; they don’t support it like cloud, and they want production teams on the hosted product. Open got them into the stack. Cloud is how they get paid.
• RudderStack: An open-source event engine and a paid Cloud CDP. You can collect and route events yourself. Reverse ETL, warehouse-native activation, and the control plane most teams want live in Cloud. That is householding with a 2026 name: own the pipeline, pay when you want someone else to run identity and destinations.
• Grafana: Dashboards, logs, traces, and metrics projects are open. Grafana Cloud and Enterprise fund the work. Practitioners install the free visualization layer. Finance buys managed backends and support when operating the plant stops being fun.
• Mistral: Open-weight LLMs you can self-host, plus a paid API and Le Chat. Public weights don’t erase the bill for GPUs, routing, and uptime. Teams that want a contract, a rate limit that is not their problem, and a model that is someone else’s pager still pay.
• n8n and Matomo: Workflow automation and analytics with a source-available or OSS core and a paid cloud or supported on-prem edition. Marketers who outgrow a hobby deployment do not need a new vendor. They need the same product without babysitting servers.

None of these companies grew because nobody could read the code. They grew because the open layer made them the default, and the paid layer made them a business. Copycats still have to staff support, keep the lights on, pass security review, and show up when a release goes bad. That is the work AI does not finish for you.

Closed Interfaces Are the Other Trap

Open source is one kind of open. Documented, writable APIs are the other. I learned that on an NFL franchise evaluation, not in a vendor keynote. Ticketing had the seats. The CRM had the conversations. Email had the list. None of it moved until data could leave without an intern copying spreadsheets at midnight.

I scored vendors on integration, automation, ease of use for junior marketers, and whether account management picked up on a game week. Features were how a closed vendor won the bake-off. Integration is how you still grow when the business adds a loyalty program or a household that buys for four people. We split the stack on purpose: ticketing stayed in ticketing, sales and service moved to Salesforce, campaigns ran in Marketing Cloud, and householding sat in its own tool. We sent a season-ticket email within a week of the first integration.

The ceiling was the closed box. Ticket data into the CRM had no usable API and no events. Every improvement walked around it. I still see that pattern outside sports. Pacers Sports & Entertainment has talked about unifying more than 30 sources, including Ticketmaster, before marketing can act. The United Football League described Ticketmaster extracts into a warehouse, then into Salesforce. That is the cost of a revenue system that will not open.

AI Does Not Doom SaaS. It Dooms the Generic UI

I want to be precise about what is dying. I already wrote this in The Coming SaaS Apocalypse: agentic AI and the API economy are decoupling the front end from the infrastructure. Rigid dashboards and basic middleware are the vulnerable layer. The irreplaceable layer is the data, the connectivity, the execution, and the SDK you cannot fake in a weekend. That article is about the UI apocalypse, not the death of SaaS.

SaaS still has a job. Someone has to send the email, authorize the refund, keep the identity graph honest, stay on the right side of deliverability, and answer when a pipeline fails on a Friday. An LLM can draw a prettier screen than your product team shipped. It cannot mint your production data, your reputation with mailbox providers, or your uptime. If you sell seats to a generic interface on top of data you do not uniquely hold, you are in the camp I called vulnerable. If you open the gates and charge for the plant, you are in the camp I called irreplaceable.

That is why closed suites feel doomed and open platforms do not. The suite’s product is the screen. The open platform’s product is work that still happens when the screen is gone. I also argued, in LLM-Native UX, that the answer is becoming the interface. Agents will not click your left nav. They will ask for an outcome. If the only way to get that outcome is a human in your UI, the agent will pick a vendor who published a tool.

MCP Is the Gateway, Not a Chat Widget

APIs were how software talked to software. MCP, the Model Context Protocol, is how agents talk to software without waiting for a one-off integration on a vendor roadmap. It is an open standard: a server advertises tools, resources, and prompts; a client discovers them and calls them. Under the hood, it is JSON-RPC. In practice, it is a contract. Here is what I can do. Here is what I need. Here is what I return. Auth still sits on your side. Destructive actions still require permission. The difference is that Claude, Cursor, an internal agent, or a custom operator console can all use the same door.

That door is the growth move. A native connector in one automation product used to be a quarter of professional services. An MCP server is a catalog of capabilities you publish once. A marketer’s agent can create a segment, a sales agent can pull a household, a support agent can issue a refund, and none of them had to learn your UI. Workflows can live inside your product or completely outside it. n8n can orchestrate. An IDE can orchestrate. A site-level bridge can orchestrate. I wrote about that last pattern as WebMCP: give agents a real door into the site, store, or platform, instead of hoping they guess at clicks.

Custom interfaces come from the same opening. If the tools are real, a dealership group can generate a VIN-aware console. A franchise can generate a season-ticket desk that speaks packages, not generic contacts. You did not have to staff every vertical UI on your roadmap. They built the screen. You still ran the system of record. That is the Overfuel lesson from the SaaS Apocalypse piece, applied to every category: keep the irreplaceable infrastructure, stop forcing specialists through a generalist’s layout.

Close that door, and you are doomed. Not next decade. As soon as a competitor publishes tools and you still require a seat in your app to do the work. Agents will skip you. Customers will wrap a thin client around whoever answered. Your screenshot will get pasted into a prompt, and the prompt will go somewhere else to execute. Lock-in that depends on the user not being able to leave the page does not survive a model that can call a function.

Make It Easy to Open, Then Charge for Running It

Open in 2026 is a stack, not a slogan. Documented read-and-write APIs remain the floor. Events remain how you avoid polling. An SDK remains how human developers start. MCP is how agents start. Treat the tool list with the same seriousness as the endpoint list: stable names, JSON schemas, idempotent writes, errors a model can parse, and auth that maps to the same roles your UI already has. Don’t hide useful tools behind a sales call. Do not ship a toy “chat with your data” that cannot mutate anything that matters. If an intern can do it in the product, an agent should be able to do it through the protocol, with the same audit trail.

You still get paid. Hosting, rate limits, deliverability, compliance, identity resolution, and a human on the pager are not free because the protocol is open. That is the same dual model as WordPress, GitLab, PostHog, and RudderStack, pointed at agents instead of only at developers. The open layer is how you become the default in the agent’s toolbox. The paid layer is how you survive the copycats, including the ones using AI. Anyone who wanted your IP was going to try to take it. MCP just makes the honest path, integration, cheaper than the dishonest one.

What to Demand Before You Buy

Ask for a live integration, not a slide. If the vendor also ships an open edition, ask how the paid edition differs: hosting, support, identity, compliance, or withheld features. Then walk this list with the people who will run the tools.

• Read and write APIs: You can create and update records, not only download a report. Docs are public or at least current.
• An open path and a paid path: You can start without a contract. You can grow into hosting, support, and enterprise controls without a migration.
• Events: Purchases, refunds, and preference changes emit webhooks or a stream. You don’t wait for a batch window or a nightly SFTP drop.
• Keys you own: Email, phone, and an external ID travel with the record. The vendor ID is not the only join.
• Full export: You can leave. If legal has to negotiate a data dump, you are already stuck.
• Operator UI: A junior marketer can build the segment and send. Specialists exist for the hard cases, not for Tuesday.

If a vendor cannot clear those, the feature matrix is entertainment. I will take the quieter product that I can open, pay to run, and connect to the rest of the stack before the welcome series is supposed to send.

Open still equals growth. Closed still equals a ceiling. In an AI market, the ceiling arrives faster, because a competitor can approximate your sealed product without ever seeing your source. Publish the layer people will copy anyway. Charge for the plant, the pager, and the people.