Lovable CTO's Vision: The Future of SaaS Is Apps That Agents Can Call

A Paradigm Shift: From "Apps for Humans" to "Apps for Agents"

Lovable, the company known for AI-driven web application generation, is evolving from a pure app-building tool into a "capabilities platform" built on MCP (Model Context Protocol). In a conversation with Lovable CTO Fabian Hedin, a core thesis emerged: The future of SaaS isn't about interfaces designed for humans — it's about apps that agents can call directly.

Lovable CTO: The Future of SaaS Is Apps That Agents Can Use

This may sound radical, but it's actually a keen observation of how software is evolving today. Over the past two decades, SaaS success has been built on a "user-centric" product philosophy — carefully designed UIs, smooth interactions, elegant dashboards. But as AI agents start becoming the "users" of software, this entire logic is being reexamined. Agents don't need beautiful buttons. What they need are clear, programmable capability interfaces.

MCP Protocol: A Universal Standard Connecting AI Agents to Applications

MCP (Model Context Protocol) is the key to understanding Lovable's strategic pivot. As an open protocol, MCP aims to standardize how AI models interact with external tools and data sources. It plays a role similar to "the API standard of the AI era" — enabling agents to discover, understand, and invoke the capabilities of various applications in a unified way.

It's worth noting that MCP was officially introduced and open-sourced by Anthropic in late 2024. Its design was partly inspired by LSP (Language Server Protocol) — a standardization approach that has already been widely validated in the IDE ecosystem. LSP decouples programming language tooling support from specific editors; MCP attempts to decouple AI models' tool-calling capabilities from specific applications. MCP uses JSON-RPC 2.0 as its communication foundation and defines three core primitives: Tools, Resources, and Prompts, allowing AI agents to discover and invoke external capabilities through a unified interface description. This protocol fills an important gap: while major LLM providers all supported Function Calling, each had different implementation approaches, parameter specifications, and error-handling mechanisms, forcing developers to write redundant integration code for different models. MCP was created precisely to end this fragmentation.

Why MCP Is Critical to the AI Agent Ecosystem

In traditional software integration, every SaaS product has its own API specifications, authentication mechanisms, and data formats, requiring significant effort for each integration. When AI agents become the primary integrators, this fragmentation becomes a fatal bottleneck — agents can't read documentation, understand semantics, or write adapter code the way human engineers can.

By providing standardized "capability descriptions," MCP enables agents to automatically discover the features an application offers and invoke them in predictable ways. This means that in the future, an AI agent could chain together payment, scheduling, document, and communication capabilities across multiple apps to complete complex end-to-end tasks — all without human intervention.

However, this vision of agents autonomously orchestrating multiple applications still faces significant technical challenges. First, there's the permission management problem — existing authorization frameworks like OAuth 2.0 were designed for human users, involving browser redirects and interactive authorization, while agents need a delegated authorization mechanism that requires no human involvement. Second, there's idempotency and error recovery: if an agent's payment API call fails, should it retry? Could a retry cause duplicate charges? In human-operated scenarios, these issues can be resolved through UI prompts, but when agents execute autonomously, strict transactional semantics are required. Additionally, state consistency in multi-agent collaboration scenarios, observability of call chains, and audit trails are foundational infrastructure problems that must be solved for enterprise-grade applications. These challenges mean that significant engineering work remains before MCP can move from protocol specification to production-grade deployment.

Lovable's Strategic Extension: From Building Apps to Building Agent-Usable Apps

Lovable's original positioning was enabling anyone to quickly generate web applications through natural language. This capability has already proven AI's tremendous value in lowering the barrier to software development. Now, the "MCP-powered capabilities" that Hedin describes are a natural extension of this mission.

To understand the significance of this strategic extension, it helps to know Lovable's position in the industry. Lovable (formerly GPT Engineer) is a key player in the AI-driven code generation space, competing with Bolt.new, V0 by Vercel, Replit, and others. The core idea of this space is transforming natural language into runnable full-stack web applications, typically auto-generating code based on modern frontend frameworks like React/Next.js and integrating backend services like Supabase for data persistence. Lovable underwent a brand rebrand and product overhaul in 2024, emphasizing "deployment-ready" code quality rather than mere prototype-level output. The rapid evolution of this space shows that AI is moving from "assisting with code writing" (like GitHub Copilot's completion mode) to a new phase of "directly generating complete applications." Lovable's extension toward MCP compatibility marks its attempt to leap from being a "code generation tool" to becoming "agent ecosystem infrastructure."

If the first phase was "enabling everyone to build apps," the second phase is "making every app people build usable by agents." When apps generated through Lovable natively support MCP compatibility, they're no longer isolated products but "capability nodes" that can be invoked by the broader agent ecosystem.

The Potential Ecosystem Flywheel

This contains the seeds of a powerful ecosystem flywheel:

The more apps that support the MCP protocol, the richer the tasks AI agents can accomplish
The more capable agents become, the stronger the incentive for users to build MCP-compatible apps
The more vibrant the app ecosystem, the more pronounced the platform's network effects

Lovable is trying to secure a key position in this flywheel early on — as both a producer of applications and a champion of the capability protocol.

Far-Reaching Implications for the SaaS Industry

If Hedin's thesis proves correct, it will deliver structural disruption to the entire SaaS industry.

Shifting the Focus of Product Design

The center of gravity in product design may shift from UI/UX to capability interface design. When the primary "users" become agents, product teams need to think not just about "Is the interface easy to use?" but "Are capabilities easy for machines to discover and invoke?"

This shift requires product teams to fundamentally reconstruct their thinking. In traditional layered architectures, business logic is often deeply coupled to the UI layer — form validation, workflow guidance, and exception handling are all accomplished through interface interactions. An agent-friendly architecture demands that business capabilities be thoroughly abstracted into an independent, self-describing service layer, with UI and agent interfaces each serving as separate "consumers" of this capability layer. This aligns with the rising "Headless" architecture movement (such as Headless CMS and Headless Commerce). In fact, API-first companies like Stripe and Twilio proved the commercial value of this approach years ago. The difference in the agent era is that this requirement expands from the developer community to every SaaS product — not just developer-facing infrastructure products need excellent APIs, but collaboration tools and project management software aimed at everyday users also need to provide standardized, agent-callable capability interfaces.

Restructuring Distribution Channels

SaaS distribution logic may be completely rewritten. In an agent-dominated world, applications are no longer dependent on users actively opening, clicking, and using them — instead, they're invoked by agents on demand. This means traditional metrics like user acquisition and interface retention may give way to new measures like "invocation frequency" and "capability coverage."

This fundamental shift in distribution channels isn't unprecedented in SaaS history. From desktop software to web applications in the 2000s, from web to mobile App Store distribution, to the "workflow-embedded SaaS" spawned by platforms like Slack in the 2010s — every shift in computing paradigm has been accompanied by a restructuring of distribution logic. The current agent-driven distribution shift shares similarities with platform-based distribution models like Salesforce AppExchange or Shopify App Store — an app's value is no longer entirely perceived directly by end users but reaches them indirectly through platforms (or the agent orchestration layer). Stripe is a classic example of an "API-first" company: it never had a consumer-facing interface, yet through exceptional developer experience and API design, it became a payment infrastructure giant. This may foreshadow one possible form for SaaS companies in the agent era — the most successful application might not be the one users see directly, but the one agents call most frequently.

Reshaping Competitive Moats

SaaS moats are changing. Competitive advantages used to come from brand, interface experience, and user habits. In the agent era, whoever can provide the most reliable, standardized, and composable capability interfaces is most likely to be included in an agent's workflow.

Opportunity and Uncertainty Coexist

The vision of "apps that agents can use" is still in its early stages. MCP, as a relatively young protocol, is still exploring its degree of standardization, security model, and commercialization paths. Agents autonomously invoking multiple applications to complete tasks also raises a series of not-yet-fully-resolved issues around permission management, error handling, and accountability.

Moreover, human users will remain the direct users of much software for the foreseeable future. UI won't disappear — it will likely coexist with agent interfaces in a "dual-track" paradigm. The real challenge lies in making a single application serve both humans and agents as two types of "users" equally well.

That said, Lovable's strategic pivot reveals a direction worth watching: as AI agent capabilities continue to grow, the form, construction, and usage patterns of software may all be redefined. For developers and SaaS professionals, now may be exactly the right time to start thinking about "how to make your application understandable and usable by agents."