In 2025, Crisp turns 10.

Over the past decade, the product has steadily evolved to help companies communicate with their customers. Millions of conversations now happen through the Crisp chatbox every day, connecting businesses and their users across the web.

But the world of software has changed dramatically. The rise of AI has accelerated the pace of innovation across the entire SaaS industry. New models appear every few months, and product capabilities improve at a speed that traditional software architectures were never designed for.

Like many companies, we started experimenting with AI features. Very quickly, however, we realized something uncomfortable: simply adding AI features on top of a 10-year-old SaaS would not be enough.

Instead of patching the existing product, we made a difficult decision. We began rebuilding parts of Crisp from the ground up.

Over the past year, that work led to the creation of Hugo, our AI support agent.

A product used by millions

If you've ever visited a website and clicked the chat bubble in the bottom-right corner, there's a good chance you've already used Crisp.

Today, more than 200 million people use Crisp every month across thousands of companies worldwide. Since the early days of the product, our mission has been simple: help companies stay connected with their users through messaging.

Over time, the platform expanded with new capabilities such as:
• shared team inbox,
• knowledge base,
• chatbot,
• integrations,
• status page.

Each of these features solved a specific problem for support teams, while the core idea remained the same: messaging as the primary interface between companies and their customers.

In 2018, we introduced our first workflow-based chatbot system.

**The first version of Crisp’s workflow-based chatbot builder.**

These chatbots allowed companies to route users based on intent, suggest knowledge base articles, or direct conversations to the right team. It was our first step toward support automation.

Understanding workflow-based chatbots

Traditional chatbots operate using predefined rules.

A typical workflow follows a simple structure: a customer message is detected, keywords or conditions are matched, and the system routes the conversation through a predefined path before generating a response.

🔀

This approach works well for structured scenarios such as directing customers to the right department, suggesting documentation, or collecting information before escalation.

However, these systems have clear limitations.

Every possible conversation path must be configured manually. As support scenarios grow more complex, maintaining these workflows becomes increasingly difficult. Automation can scale, but only within the limits of the rules that define it.

Experimenting with AI before the boom

Our interest in AI actually started before the recent wave of generative AI.

During the COVID-19 pandemic, we began exploring how transformer-based models could be integrated into Crisp.

At that time, the goal was not to build an AI agent. Instead, we focused on improving existing support workflows.

These early experiments included training models to understand help center articles, ranking documentation relevance, generating suggested replies for operators, and improving knowledge base search.

Running these experiments required building internal datasets and testing early models on rented GPU infrastructure. It was still early-stage research, but the results were promising.

**GPU server setup used to run and test our first AI models at Crisp.**

Large language models showed a clear potential to improve support automation.

Those early explorations later became the technical foundation for the systems we would build.

The breaking point

Everything changed in December 2022, when ChatGPT was released.

For the first time, millions of people experienced conversational AI that felt genuinely intelligent. The impact on the software industry was immediate.

Inside Crisp, we quickly began experimenting with how these models could improve support workflows.

Within days, we built our first AI-powered feature: Magic Reply.

Magic Reply allowed support agents to generate responses with a single click. Instead of writing answers manually, operators could generate a draft and adjust it before sending.

At first, Magic Reply was designed as an assistant for human agents. But it did not take long before we started integrating it directly into our existing chatbot workflows. AI-generated responses could now be triggered inside predefined automation scenarios.

**Magic Reply integrated into Crisp’s workflow-based chatbot system.**

The system effectively became a hybrid model, combining rule-based automation with AI-generated responses. It was still powered by the same workflow engine, but now augmented by large language models.

This hybrid approach worked well and demonstrated something important: AI could significantly accelerate support conversations.

But internally, another realization began to emerge. The architecture of Crisp had been designed long before the AI era, and integrating AI capabilities into that architecture was becoming increasingly complex.

From chatbot to AI agent

For several years, Crisp relied on workflow-based chatbots built around rules and conditions. These systems are predictable, reliable, and easy to control.

When we integrated AI features like Magic Reply, these workflows became more powerful. Static replies could now be replaced with AI-generated responses, allowing automation to adapt more dynamically to user questions.

🤔

However, the underlying architecture still depended on predefined flows and manual configuration.

AI agents represent a fundamentally different model. Instead of following scripts, they understand user intent, retrieve knowledge dynamically, generate responses in real time, and interact with external systems when needed.

This shift changes how support software must be designed. Rather than building predefined conversation paths, teams must design systems capable of understanding problems and resolving them dynamically.

When a stable system becomes a constraint

The existing Crisp chatbot system was solid. It powered thousands of websites and worked reliably for companies around the world.

However, it had been built around a workflow engine. AI systems operate very differently.

Instead of following predefined rules, they must:
• interpret natural language,
• search knowledge dynamically,
• access external systems,
• and perform actions when necessary.

Trying to integrate these capabilities into the existing architecture revealed the limits of the legacy codebase. The system worked well for the previous generation of automation, but it had not been designed for AI agents.

At that point, the question became unavoidable: should we keep improving the existing system, or build something entirely new?

Internally, the decision was far from obvious. Crisp was already used by thousands of companies every day. The existing system was stable, reliable, and deeply integrated into the product.

Rebuilding core components of a product at this scale carries real risks. Even small architectural changes can have unexpected consequences.

But as experimentation with AI continued, one thing became increasingly clear: the existing architecture had been designed for a different generation of automation.

If we wanted to build a true AI support agent, we needed foundations designed for it from the start.

AI moves faster than traditional SaaS

For many years, software evolved at a relatively predictable pace. Product teams shipped new features every few months, infrastructure changed slowly, and architectures could remain stable for years.

AI moves differently.

New models appear every few months. Capabilities improve continuously, and entire product categories can evolve in less than a year. What worked six months ago can already feel outdated today.

For product teams, this introduces a new constraint: the architecture must be able to evolve extremely quickly.

Legacy SaaS products were designed for stability and gradual feature growth. AI introduces a different dynamic, one defined by rapid experimentation, short iteration cycles, and constant technological shifts.

In that context, the ability to move quickly becomes just as important as the ability to build reliable systems.

Rebuilding the foundations

Eventually, we chose the harder path.

Instead of patching the existing system, we began rebuilding the core architecture required for an AI-first product. This meant rewriting major parts of the system using more modern technologies.

At one point, this process required deleting more than 100,000 lines of code from the legacy system.

Not because the code was bad, but because the architecture needed to evolve.

In mature software products, complexity accumulates over time. New features are added on top of older ones, creating layers of dependencies.

Sometimes the only way to unlock faster innovation is to simplify the foundation.

🧘‍♂️

Rewriting parts of a system can reduce technical debt, simplify architecture, enable faster experimentation, and improve long-term scalability.

Deleting code can feel uncomfortable, but it is often a sign that a product is evolving.

One of the most important changes involved the Crisp chatbox itself.

The chat widget had originally been designed for human-to-human conversations, where response time and message length follow a natural rhythm.

AI conversations behave differently. AI responses can be longer, and users expect answers instantly.

To support this new interaction model, the team rebuilt the entire chat widget using a modern frontend stack.

**The Crisp chat widget when Hugo generates a response to a customer.**

Visually, the interface remains almost identical. But internally, the new architecture provides a much more flexible foundation, allowing developers to iterate faster and implement new AI capabilities more easily.

Designing a new kind of AI agent

Once we understood that workflow-based chatbots would not be enough, the next challenge was defining what an AI support agent should actually look like.

What capabilities should it have? How should it interact with company systems? And how could it safely perform actions on behalf of users?

Instead of following predefined paths, the agent needed to retrieve knowledge, understand customer requests, access external systems, and execute actions when necessary.

A support AI agent could search company knowledge bases, answer product questions, retrieve invoices, check order status, and perform actions through integrations.

To support these capabilities, new infrastructure was required. One example is support for MCP servers, an emerging standard that allows AI agents to securely connect with external systems and retrieve structured data.

**Hugo can connect to external tools and MCP servers to perform actions automatically.**

This enables the agent not only to answer questions, but also to perform useful actions directly.

Example: what an AI support agent can do

Consider a simple customer question:

“Where is my order? I placed it two days ago.”

An AI support agent can automatically identify the user, retrieve the order from the company system, check the shipping status, and generate a natural response.

The answer might look like this:

“Your order was shipped yesterday and is expected to arrive tomorrow. Here is your tracking number.”

The entire process can happen in seconds, without requiring human intervention.

Naming the product: Hugo

As the project evolved, it became clear that this AI system needed its own identity.

We did not want to present it as just another feature inside Crisp. The more we developed the system, the clearer it became that we were building something fundamentally different.

Crisp had always been designed as a human-first messaging platform, where operators manage conversations and collaborate with customers.

Hugo was built for a different role.

It acts as an AI support agent capable of answering questions, retrieving information, and performing actions alongside human teams.

For that reason, we decided to treat Hugo as a separate product, while keeping it deeply integrated with Crisp.

**Hugo, the AI customer support agent built by Crisp.**

Crisp remains the platform where teams manage conversations, while Hugo acts as the AI layer that automates and assists those conversations.

As AI assistants become more capable, people increasingly interact with them as collaborators rather than tools. Giving the agent a name helps make that interaction feel more natural.

That product became Hugo.

The vision behind Hugo

Customer support is evolving rapidly.

In many situations, customers simply want answers immediately. Waiting for a human response is not always necessary when the solution is straightforward.

At the same time, support teams often spend a large portion of their time answering repetitive questions.

AI agents can now handle a significant share of these requests automatically, allowing human teams to focus where they create the most value.

Human operators remain essential. But their role evolves. Instead of responding to repetitive questions, they focus on more complex conversations that require empathy, judgment, and deeper expertise.

Our vision is simple.

Let AI handle the repetitive work.
Let humans focus on the conversations that truly require human understanding.

**Crisp and Hugo working together as human and AI support systems.**

Together, Crisp and Hugo create a support system where AI and humans work side by side.

Watch our documentary

Over the past year, this journey involved countless discussions, experiments, and technical decisions.

We decided to document the process to show what it actually looks like inside a 10-year-old SaaS adapting to the AI era.

You can watch the behind the scenes below.

AI Customer Support Agent

Ready to build exceptional customer support?

Meet Hugo, your brand's most efficient support teammate.