Why We Built drio

We built drio because building MCP apps is unreasonably hard — requiring specialized engineers, months of work, and $200K+ per year — yet every business will need to show up inside AI clients like ChatGPT and Claude. drio makes that as easy as building a no-code website.

If you have been paying attention to how people use the internet in 2026, you have probably noticed something. The way people discover and interact with software is changing — again. And it is happening fast.

The numbers that caught our attention

Over 1 billion web visits per month now come from AI referrals. That number has grown 357% year over year. AI-referred traffic converts at roughly 2X the rate of traditional web traffic — people who arrive through an AI recommendation already know what they want and why.

1.2 billion people use AI clients monthly. ChatGPT, Claude, Cursor, Copilot, Gemini — the list keeps growing. These are not niche developer tools anymore. They are mainstream interfaces that millions of people use for work every day.

Here is the part that matters for businesses: SEO is becoming "selected in answers." When someone asks ChatGPT to recommend a project management tool, they do not get ten blue links. They get a curated answer. If your product is not available as a tool inside these AI clients, you are invisible to a growing share of your customers.

Human interfaces are becoming human-agent interfaces. Every business needs to show up inside the AI clients their customers already use. The question is how.

What we tried first

When Anthropic launched the Model Context Protocol in late 2024, we were immediately interested. An open standard for connecting AI apps to external tools and data? That sounded like exactly what the ecosystem needed.

So we started building MCP servers for our own workflows. The protocol itself was well-designed — built on JSON-RPC 2.0, with clean primitives for tools, resources, and prompts. The specification was thoughtful. The SDKs were solid.

But the developer experience of going from zero to a production MCP app was painful.

Every app required:

• Building from scratch — No mature frameworks or abstractions. You start with the raw SDK and write everything yourself.
• Defining tool interfaces in code — Writing TypeScript, understanding the MCP spec in detail, getting the JSON schema right for every input parameter.
• Managing infrastructure and auth — Standing up servers, handling OAuth, configuring security policies, setting up CORS for streamable HTTP transport.
• Developing widget UIs — If you wanted anything beyond plain text responses, you needed to build React components that render inside AI clients. Each client renders differently.
• Deploying and monitoring — CI/CD pipelines, uptime monitoring, error tracking, usage analytics.
• Multi-client compatibility — Ensuring your tool works correctly across 70+ AI clients that each support different subsets of the protocol.
• Doing it all over again with every update — Schema changes, API version bumps, new widget requirements — each change cycles through the entire stack.

This needs a highly specialized engineering team. We estimated the cost at $200K+ per year for a single MCP application with moderate complexity. We spent more time on plumbing than on the actual tool logic.

And we knew that if it was hard for us — a team of experienced engineers who already understood the protocol — it would be impossible for the millions of non-technical users who had great ideas for AI tools but no way to build them.

The question that became drio

We asked ourselves: what if building an AI-native app was as easy as building a no-code website?

Think about it. Before Shopify, building an online store required hiring developers, setting up payment processing, managing inventory databases, and handling shipping logistics. Shopify made all of that visual. Pick a template, add your products, customize your brand, hit publish. Millions of businesses that could never have built a custom e-commerce site suddenly had online stores.

The same thing needs to happen for AI-native apps. The tools that live inside ChatGPT, Claude, and Cursor should not require a team of protocol engineers to build. That question became drio.

What drio actually is

drio is a visual builder where you:

• Select a template or start from scratch — We ship 9 production-ready templates across e-commerce, healthcare, legal, productivity, analytics, and food & beverage.
• Connect your APIs without writing HTTP client code — URL templates, variable interpolation, custom headers, query params, auth handling — all configured visually.
• Design your widgets visually — 21 built-in primitives: tables, charts, forms, maps, product cards, carousels, stat dashboards. Drag, configure, brand.
• Publish to 70+ AI clients in one click — With built-in auth and checkout support. Your tool gets a dedicated MCP endpoint that works across all supported clients.

No inference. No "AI magic." No hallucinated code.

This is worth emphasizing: drio is a compiler architecture, not an AI code generator. Your visual configuration gets compiled into a typesafe, spec-compliant MCP application. The output is deterministic. Every build produces the same result for the same input. If you want to understand the protocol that makes this possible, we wrote a detailed What Is MCP? explainer.

Who we are building for

drio is not just for developers. We are building for:

• Product managers who want to prototype AI-powered tools for their teams without filing engineering tickets
• Designers who want to create beautiful tool interfaces without backend knowledge
• Developers who want to ship MCP tools faster without boilerplate — focus on the logic, not the plumbing
• Entrepreneurs who see an opportunity in the AI-native app ecosystem and need to move fast
• Enterprises who need to show up inside AI clients but cannot justify a dedicated MCP engineering team

The common thread is people who have a clear idea of what they want to build but are blocked by the technical complexity of the MCP stack. drio removes that block.

What makes this moment different

Platform shifts happen roughly once a decade. Websites in the 2000s. Mobile in the 2010s. AI clients in the 2020s.

Each shift followed a similar pattern: a new interface emerged, early adopters built custom solutions, then platforms emerged that made building for the new interface accessible to everyone. WordPress and Squarespace did it for websites. The App Store and Flutter did it for mobile.

We are at the beginning of that cycle for AI-native apps. The Model Context Protocol is the standard that makes AI tool interoperability practical. Anthropic open-sourced it, and adoption has been staggering — the reference server repository has over 80,000 GitHub stars. SDKs exist for 10 programming languages. OpenAI, Google, Microsoft, JetBrains, and dozens more have committed to supporting it.

The protocol layer is mature. The tooling layer is not. That gap is where drio lives.

If you want to see the broader vision for Build AI Apps Without Code, we wrote about the no-code AI builder category in detail.

Where we are headed

We believe AI-native apps will become as ubiquitous as mobile apps. Every SaaS product, every API, every database will eventually have an interactive interface inside AI clients. The businesses that build these interfaces first will have a structural advantage — they will be present where their customers increasingly spend time.

drio aims to be the platform that owns the interactive experience layer for this shift. Creation, distribution, and monitoring — a complete stack for building and running AI-native apps.

The creation, distribution, and monitoring layers of the AI stack are wide open. No one owns them yet.

We intend to.

The best tools are built by people closest to the problem. Our job is to remove the technical barriers so anyone can build.