🤖 AI

Building Persona-Based Agents On Demand: Tailoring Multi-Agent Workflows to User Needs

This paper proposes a pipeline for dynamically generating on-demand, persona-based agents at runtime to overcome the limitations of fixed, hard-coded multi-agent architectures by tailoring workflows to specific user needs and contexts.

Original authors: Giuseppe Arbore, Andrea Sillano, Luigi De Russis

Published 2026-05-01

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Giuseppe Arbore, Andrea Sillano, Luigi De Russis

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you walk into a restaurant where the kitchen is run by a team of robots. In the current version of this restaurant, the robots have fixed jobs that never change. One robot is always the grumpy chef who only speaks in short, technical commands. Another is always the slow, overly polite waiter. No matter who you are or what you order, the kitchen runs the exact same way. If you want a quick, casual meal, you still have to deal with the grumpy chef. If you want a detailed explanation of your food, you still have to wait for the slow waiter.

This paper argues that this "one-size-fits-all" approach is holding back the potential of AI. The authors, researchers from Politecnico di Torino, propose a new way to build these AI teams (called "multi-agent systems") where the robots can change their personalities and roles on the fly, just for you.

Here is how their idea works, broken down into simple steps:

The Problem: The Rigid Kitchen

Right now, most advanced AI systems are built with a "hard-coded" structure. The designers decide ahead of time: "Agent A will always be the planner, Agent B will always be the researcher, and they will always talk to each other in this specific order."

The Issue: If you are an expert who wants a quick answer, the system might still force you through a slow, beginner-friendly process. If you are a beginner who needs a friendly explanation, the system might give you a cold, technical report. The system doesn't know you; it only knows its pre-written script.

The Solution: The "Chameleon" Kitchen

The authors suggest a system where the AI team is built in real-time based on what you need at that exact moment. Think of it like a kitchen where the robots can instantly transform into whatever persona is needed to help you specifically.

If you ask a complex question, the system might instantly create a "strict but brilliant professor" persona to explain the details. If you ask a simple question, it might switch to a "friendly neighbor" persona to give a quick, casual answer.

How It Works: The Four-Step Pipeline

The paper describes a specific process (a pipeline) that happens every time you ask a question. Here is the flow:

Listening and Understanding (Query Analysis):
First, the system listens to your question. It doesn't just read the words; it tries to figure out who you are (are you an expert or a beginner?) and what you really want (do you need a quick summary or a deep dive?). It breaks your big question down into smaller, manageable tasks.
Creating the Team (Agent Generation):
This is the magic step. Based on what it learned in step one, the system creates the perfect AI agents on the spot.
- It doesn't pick from a pre-made list. It writes a new "job description" (a persona) for a robot that fits your needs.
- Example: If you need a coder, it creates a "precise, no-nonsense coder" persona. If you need a creative writer, it creates a "imaginative, flowery writer" persona.
- It then "wakes up" these new agents, giving them their specific instructions and personality traits.
The Team Gets to Work (Execution):
The system assigns the small tasks to the newly created agents. If two tasks can be done at the same time, the agents work in parallel. If one task needs the result of another, the system makes sure the first agent finishes before the second one starts. They work together, but they are all tailored to your specific request.
Serving the Final Dish (Aggregation):
Once all the agents finish their parts, the system gathers their work. It stitches the pieces together into one smooth, coherent answer. It makes sure the tone is consistent and that the final result matches exactly what you asked for, removing any repetition or confusion.

Why This Matters

The main point of the paper is that we should stop treating AI agents like static tools with fixed personalities. Instead, we should treat them like dynamic performers that can change their act to suit the audience.

Current Way: You have to adapt to the AI's fixed style.
New Way: The AI adapts its style, role, and team structure to fit you.

The authors believe this makes the technology more useful and less frustrating. It allows the system to be a "chameleon," changing its colors to match the user's expertise, preferences, and the specific situation, rather than forcing every user to fit into a single, rigid mold.

In short: Instead of a robot team that always acts the same, imagine a team that can instantly become the exact experts you need, speaking in the exact way you prefer, every single time you ask for help. That is what this paper proposes.

Based on the paper "Building Persona-Based Agents On Demand: Tailoring Multi-Agent Workflows to User Needs" by Arbore, Sillano, and De Russis, here is a detailed technical summary.

1. Problem Statement

Current multi-agent systems (MAS) powered by Large Language Models (LLMs) suffer from rigid architectural constraints.

Fixed Design-Time Choices: Existing systems rely on hard-coded agent roles, pre-defined coordination patterns, and static interaction flows established before deployment.
Lack of Adaptability: These fixed schemas make it difficult to tailor interactions to specific user needs, expertise levels, or contextual nuances without manually rewriting prompts or re-engineering orchestration logic.
The Gap: While "persona prompting" is known to influence LLM reasoning and output style, current agentic architectures do not treat personas as dynamic, runtime variables. Instead, they remain static "styling editors" rather than core architectural components for adaptivity.

2. Methodology: The On-Demand Persona Generation Pipeline

The authors propose a novel pipeline that shifts agent configuration from design-time to run-time. The system synthesizes agent personas and roles dynamically based on the user's query, characteristics, and task context.

The pipeline operates on a session-based model (maintaining coherence across multiple queries within a session) and consists of four distinct steps managed by a central Orchestrator:

Step 1: Query Analysis

The orchestrator transforms raw, open-ended user input into a structured representation without forcing predefined templates.

ProfileEncode: Analyzes the user query (explicit or implicit signals) to generate a user profile ( $u$ ). This captures domain expertise, preferred communication style, task familiarity, and specific intent.
TaskDecompose: Breaks the query into a set of discrete tasks ( $t_1...t_n$ ). Crucially, this step maps dependencies between tasks, determining which can be executed in parallel and which must be sequential.

Step 2: Agent Generation and Instantiation

This is the core innovation where static roles are replaced by dynamic synthesis.

PersonaCraft: For each sub-task, the system dynamically crafts a Persona Specification ( $p_i$ ). This specification defines the agent's role, domain competencies, communication style, and tool-use capabilities. It ensures no duplicate roles are created and aligns with the user profile.
AgentFactory: Instantiates an LLM-backed agent instance ( $a_i$ ) using the synthesized persona. The persona acts as a configuration layer that shapes the agent's reasoning style, interaction behavior, and output format.

Step 3: Agent Assigning and Execution

The orchestrator manages the execution flow based on the dependency graph generated in Step 1.

Scheduling: Tasks with no dependencies are executed in parallel; dependent tasks are queued sequentially.
Controlled Information Routing: Agents receive only the specific context and partial results they require from preceding agents. This preserves modularity and prevents agents from needing to know the internal workings of others.
Execution: Each agent executes its assigned task ( $r_i$ ) and returns a partial result.

Step 4: Answers Aggregation and Displaying

Integration: The orchestrator aggregates all partial results ( $r_1...r_n$ ).
Refinement: It merges answers, resolves inconsistencies, removes redundancies, and aligns the final output with the user's requested style and format.
Delivery: A single, coherent response ( $R$ ) is delivered to the user.

Session Continuity: If a user submits a new query within the same session, the pipeline re-executes. Previously instantiated agents and personas are retained, and new ones are appended only if additional specialization is required.

3. Key Contributions

Runtime Persona Synthesis: The paper introduces a framework where agent roles and interaction policies are not fixed constants but runtime variables generated on-demand to match user context.
Systematic Integration Pipeline: It details a four-step technical pipeline (Analysis, Generation, Execution, Aggregation) that integrates persona crafting directly into the agent orchestration loop.
Session-Based Adaptivity: The design allows the system to evolve within a session, retaining useful agents while dynamically adding new ones, ensuring coherence without requiring a full system reset.
Decoupling User and System Topology: The system adapts to the user, rather than forcing the user to adapt to a fixed agent topology.

4. Results and Evaluation

Note: As this appears to be a position paper or a proposal for a workshop (AutomationXP26), the text does not present quantitative empirical results (e.g., benchmark scores, latency metrics, or user study statistics).

Qualitative Argument: The authors argue that this approach addresses the "friction" users experience with rigid multi-agent systems.
Theoretical Validation: The methodology leverages existing research showing that persona prompting influences reasoning strategies, zero-shot performance, and interaction quality (credibility, engagement).
Design Paradigm Shift: The "results" are presented as a new design paradigm for agentic platforms, moving beyond "one-size-fits-all" configurations toward context-sensitive adaptivity.

5. Significance and Impact

Enhanced Personalization: By treating personas as controlled variables, the system can tailor interactions to diverse user backgrounds, expertise levels, and preferences (e.g., tone, verbosity).
Scalability of Adaptation: It solves the scalability problem of manual configuration. Instead of creating thousands of pre-defined agent profiles, the system generates the necessary profile for the specific moment.
Human-AI Collaboration: This approach reduces the cognitive load on users who no longer need to understand complex agent hierarchies. The system becomes a "fluid" interface that molds itself to the user's intent.
Future of Agentic AI: The paper positions on-demand persona generation as a fundamental architectural pillar (alongside memory, tools, and orchestration) for the next generation of accessible and meaningful agentic systems.