Don’t Plug AI Into Legacy Workflows. Build New Ones.
A practical guide to redefining blueprints and user journeys for AI-native experiences.
For decades, the service designer’s toolkit has remained reliably elegant. We conduct research, map the messy reality of the present in a current-state blueprint, align stakeholders around an aspirational North Star, and design future-state journeys. When technology changed, our blueprints simply swapped out the tools: “User submits form via website” became “User submits form via mobile app.” The underlying choreography remained exactly the same…more or less.
But we have hit a wall.
Right now, enterprises are rushing to sprinkle AI onto their legacy architectures like fairy dust. They are plugging a Large Language Model (LLM) chatbot into an archaic, disjointed customer journey and wondering why the experience feels brittle, unhelpful, and disjointed.
AI is not a feature you plug into an old legacy journey. It is an entirely new operational paradigm.
To unlock the maximum potential of this technology, we cannot just use AI to optimize current systems. We have to design services from scratch, with the AI engine at the core, shifting our focus from passive software to autonomous, multi-agent workflows.
The Legacy Trap: Why “Optimizing” Old Journeys Fails
When we map traditional services, we design around human limitations and software silos. We assume information moves slowly, departments don’t talk to each other, and users must manually bridge the gaps between systems.
If you merely overlay AI onto this old structure, you get an expensive, slightly faster version of a broken service.
- The Old Way: A user encounters a complex problem, navigates a fragmented dashboard, digs through documentation, triggers a customer support ticket, waits for a human agent to query three internal databases, and finally receives a resolution.
- The Lazy AI Way: A user encounters a problem, talks to a front-end chatbot that reads the documentation for them, fills out the same ticket behind the scenes, and tells the user to wait.
This isn’t transformation; it’s lipstick on a pig. True AI-native service design flips the paradigm. It asks a fundamental question:
If an autonomous intelligence could instantly access data, predict user intent, and orchestrate actions across disparate systems simultaneously, what would this service look like from first principles?
Deconstructing the AI Backstage: Multi-Agent Choreography
In an AI-native service, the “backstage” is no longer just a collection of rigid APIs and human databases. It is a dynamic ecosystem of Specialized AI Agents — discrete models configured to autonomously execute narrow tasks, reason through complexity, and collaborate with one another.
When mapping the future-state backstage, we are no longer just mapping department handoffs (e.g., Sales transfers to Billing); we are mapping Context Passing and State Machines.
│ USER INTENT INPUT │
└───────────┬───────────┘
│
▼
┌─────────────────────────────────────┐
│ ORCHESTRATOR / ROUTER │
│ (Evaluates intent, assigns tasks) │
└──────────────────┬──────────────────┘
│
┌─────────────────────────────┼─────────────────────────────┐
▼ ▼ ▼
┌──────────────────┐ ┌──────────────────┐ ┌──────────────────┐
│ DATA ARCHIVIST │ │ EXECUTION │ │ QUALITY AUDITOR │
│ AGENT │ │ AGENT │ │ AGENT │
├──────────────────┤ ├──────────────────┤ ├──────────────────┤
│ Fetches history, │ │ Calculates fees, │ │ Checks outputs │
│ vectorizes context│ │ updates contract │ │ against guardrails│
└──────────────────┘ └──────────────────┘ └──────────────────┘
Instead of a linear assembly line, an AI-native backstage behaves like an orchestra coordinated by a central engine:
- The Orchestrator / Router: The front-facing triage engine. It takes unformatted human input (voice, text, or behavior), extracts semantic intent, and assigns chunks of work to the rest of the ecosystem.
- The Data Archivist (RAG Agent): Dynamically searches vector databases and legacy software to fetch only the context, account history, and parameters relevant to the current task.
- The Execution Agent: Operates within a strictly sandboxed environment to perform calculations, draft documentation, or trigger specific third-party APIs.
- The Quality Auditor (The Critique Agent): A separate LLM instance with a deterministic rubric whose sole job is to review the Execution Agent’s output for hallucinations, corporate compliance, and tone before it ever reaches the user surface.
As service designers, our job is to design the boundaries, the handoffs, and the collaborative principles of this engine.
The Core Principles of AI-Native Service Design
To design services that actually unlock this full potential, we need to establish a new set of foundational principles:
1. Shift from “Search & Fill” to “Intention & Orchestration”
Traditional UX/UI forces users to browse complex menus, apply filters, and fill out endless fields to tell a system what they want. AI-native services invert this. The user states their intent or goal in natural terms, and the service orchestrates the backstage workflow to make it happen. The interface adapts entirely to the user’s context, rather than forcing the user to conform to the system’s structure.
2. Design for Asynchronous Workflows
AI isn’t just a conversational partner for quick Q&As; it’s a worker that runs deep in the workflow. A user might initiate a request that requires an agent to spend 15 minutes parsing historical data, coordinating with another internal agent, and generating a comprehensive, customized strategy. We must design services that handle these asynchronous pauses beautifully, ensuring the user feels supported — not abandoned — during the wait.
3. Build a “Glass-Box” Transparency Layer
Because multi-agent processes happen autonomously deep within the backstage, the classic black-box design (“Please wait while we process your request”) breeds user anxiety. We must transform backend agent logs into a human-readable narrative, surfacing the backstage choreography to the frontstage in real time.
4. Design the “Human-in-the-Loop” Handrail
Autonomy without control is terrifying. The service must be mapped with explicit control gates. Where does the AI pause to ask for human confirmation? How easily can a user override an agent’s decision? We aren’t designing a system that replaces the human; we are designing a collaboration loop where the human acts as the director, and the AI acts as the crew.
The Glass-Box Framework: Transforming Logs to UX
To make this practical, service designers need to map backend technical events directly to user-facing transparency cues. When the backend agent triggers an event, the interface must reflect the intent of that execution to build trust.
The New Mandate for Service Designers
The true value of a service designer has never been the sticky notes themselves; it has been our unique ability to see the holistic picture, the system, bridge rigid organizational silos, and advocate fiercely for the human experience.
In the era of agentic AI, that holistic view is more vital than ever. If we leave AI implementation solely to engineering teams and technical product managers, we will end up with highly optimized, incredibly fast, completely soulless ecosystems that alienate users.
We have to move past the static North Stars of the past decade. Our new mandate is to design the systemic choreography of humans and AI agents working in perfect tandem.
Don’t look at your current service map and ask where AI can be plugged in. Roll out a blank canvas, put the user and after the multi-agent engine at the absolute center, and design the future from scratch.
Fredy Pascal — Principal Designer
Ciao ciao
Don’t Plug AI Into Legacy Workflows. Build New Ones. was originally published in Bootcamp on Medium, where people are continuing the conversation by highlighting and responding to this story.