Is SaaS dead? This punchline (quite effective at grabbing attention) is increasingly brandished by numerous Californian software experts. The idea behind the provocation is to say that the interface as we know it is becoming, if not obsolete, at least outdated.

AI is disrupting the status quo and redefining possibilities through a tidal wave of transformations. Among these, numerous and protean, there is indeed the question of user interface. How can we rethink it, too, in light of an application capable of adapting to the current context?

Agentic: A Buzzword or a New Design Model?

Agentic. Here's the emerging trend, with ChatGPT as its finest banner (along with all the copycats that have since flourished). We might not realize it, but as soon as we talk to ChatGPT, the interface adapts to our response. Depending on the intent, the conversational agent can perform a web search for you, display image results or summarize documents, even write code and execute it to run calculations. It might seem like nothing, but the transformation is significant:

1. Natural language has replaced interface components (Google's keyword input is replaced by a natural language question)
2. The LLM becomes the switchboard between different available application possibilities (context replaces the dropdown list, the button, or the right-click context menu)
3. We haven't seen anything yet, because under this paradigm, the entire software design must be rethought.

The Brain, The Body

The principle of an agentic application is simple in its essence: rather than designing an interface for every possible scenario, an LLM is placed in front of the user with the role of understanding their intent. The interface then adapts dynamically: if a component is needed, it's displayed; if an action is requested, it's executed. And so on.

The LLM plays the role of the brain here, and the code, that of the body.

If we take a more conceptual look, in the computer science sense, an agentic application can be defined as:

a decision loop in which an LLM receives a state (the context), acts or reasons, then decides either to respond or to ask for more information from the user. And the loop continues.

Concretely, the system components are therefore:

• A structured context LLM (a conversational memory that allows the user to interact implicitly)
• A controlled output format: the code interprets the LLM's responses (command execution, display, etc.)
• An orchestrator capable of:
  • restarting the loop based on returns (output analysis, adapted relaunch)
  • stopping if a final response is produced (often via an interface modification)

It's an abstract state machine: the states are potentially infinite and dynamic. The major difference is that the orchestrator is no longer rigid or pre-coded, but embodied by an LLM.

And that changes absolutely everything.

So, Is SaaS Dead?

No. Of course not. Saying that would be like believing voice commands will replace the keyboard. It hasn't happened, and it won't happen, for the simple reason that these are different interaction modalities, each with their own relevance, usage, and constraints. To convince yourself, imagine an open office where everyone dictates commands to their computer...

The same goes for SaaS, or more precisely, for the rigid interface and the agentic approach. One won't disappear in favor of the other; they will complement each other.

However, a SaaS that doesn't reinvent itself from an agentic perspective will likely struggle to remain relevant.

A simple example that will resonate with everyone: booking a train ticket. Today, you need to go to the company's website, enter a date, choose a departure city, an arrival city (or vice versa, UI/UX choices can be surprising...), then select a ticket, a class, a seat, etc.

Tomorrow, with an agentic version of the same SaaS, we could easily imagine a single ChatGPT-style input field where you could say:

I want a round trip from Paris to Lille for June 11th, morning departure before 8am. Evening return.

The application could then propose eligible tickets and take the opportunity to display available options as widgets: seat selection (here the current interface is optimal, you visualize the seat, click, etc.), class choice.

Imagine the ease of use. It would be SaaS, but agentic.

A Seductive Future, But Complex Implementation

Now, let's be honest: the scenario of an agentic application with a simple text field is seductive. But its implementation is far from trivial.

Designing a UX capable of reacting to non-deterministic reasoning, maintaining interface consistency in the face of ambiguous intentions, ensuring the security of automatically triggered actions... all of this requires a much more refined, modular, and resilient software architecture than traditional SaaS.

The challenges are everywhere: in the interface (which must be completely rethought to accommodate a chameleon logic), in the backend (where orchestration becomes fuzzy, guided by probabilities), and even in the way we conceive the product.

Finally, injecting an LLM into an app isn't enough. It's not a layer on top; it's a profound model change.

But for the product that succeeds in this transformation, that knows how to implement agentic where it makes the most sense, and finds that sweet spot between conversational fluidity and application solidity, then the ground is fertile for massive adoption.

Going Further

A podcast focused on this topic, from YCombinator, with an excellent example: GMail's automatic email writing feature. Why it's poorly thought out, why it's not agentic, how it could become so.

The metaphor mentioned in this video will be a perfect conclusion: injecting an LLM into an existing SaaS without deep agentic thinking (what GMail did with its auto-writing feature) is like replacing a carriage horse with an engine. It doesn't work. Adding an engine implies... inventing the car that goes with it.