Conversational agents are software applications that interact autonomously with end-users in natural language, supporting task completion, conversational web, service delivery, as well as social engagement and entertainment. Known under other names such as chatbots or digital assistants, they have become a ubiquitous component of modern platforms and services, especially with the rise of Large Language Models (LLMs) which highly augment their natural language understanding and text generation capabilities.
Conceptually, conversational agents may support different types of conversations, ranging from predefined, task-oriented dialogues based on deterministic rules to open-ended interactions enabled by LLMs, or a combination of both.
On the other hand, personalized conversational agents aim to further elevate the users’ experience by adapting the interaction to fit an individual user’s needs, preferences, and context offering an optimal user experience. For instance, for extroverted users, aligning conversational agents to act extroverted by adapting communication styles has been shown to increase engagement and usage intention (see here).
While personalized conversational agents have been widely studied (both in terms of supporting technologies and their effects on users) their implementation remains complex and requires substantial technical expertise.
In this sense, our latest paper proposes a low-code/no-code pipeline to create personalized conversational agents, enabling non-technical people to define the type of users they want to support, the adaptations to be done for each user type and the generation of the corresponding personalized agents.
The low-code personalization pipeline
1. Modeling the user profile, agent, and agent profile
Here, the designer models the user profiles (representing the types of users we target in our application), the base agent model (with the common functionality) and the agent profiles (representing the different agent adaptations to be mapped to the corresponding user profiles). Separating the agent profile from the base agent model makes the agent profiles agent-agnostic, as they can be applied to any agent. Similarly, separating user profiles from agent profiles also enables the mapping of the same agent profile to different users, fostering reusability.
In the following metamodel, we combine the base agent, the user profile, and the agent profile / configuration.
We have one concrete syntax to define each part of our personalized agent (user, agent and agent configuration), which we’ll illustrate with a running example of a gym agent. The gym agent’s job is to provide answers to common questions related to working out, while providing adapted answers with different styles depending on the end-user.
We propose a graphical modeling language to model user profiles based on a modeling language presented in a previous paper (see here). This graphical extension currently only consists of a subset of the complete syntax, chosen to represent the most commonly modeled user information. The idea here is to model the different user categories you expect are relevant for your application. Given our gym example, it makes sense to take into account whether our user has any disability (such as paraplegia), and many other attributes (age, spoken language, size, etc.)
For modeling the agent, our graphical language is (as usual for chatbots) based on the UML state machine formalism. This is directly linked to the BESSER-Agentic-Framework’s philosophy of combining the best of both worlds between deterministic states with pre-defined responses and the option to opt for LLMs if necessary (where you’ll find more about on the official repository, and blog post 1 and blog post 2). As seen in the picture below, one defines which intents (user sentences) can be understood by the agent, and with the state machine, define the different states the agent can find itself in, the transition rules with the arrows, and the actions executed in each state (such as a predefined answer or an LLM powered AI response).
Finally, we propose a form-based syntax to configure different aspects of the conversational agent, which we call agent profile. We separate these aspects into four distinct categories: Presentation (how content is delivered), Modality (channel over which content is delivered), Content (what is shown or done), and Behavior (how the interaction unfolds). Per user profile, an agent profile will exist and will be applied to the base agent.
2. Design time personalization and 3. Model validation
As a sidenote, depending on the targeted component, the adaptation will be applied at different stages of the pipeline.
If the agent contains predefined responses (and not only AI ones), any personalization related to text will be applied at the model level. A process will be started where all the messages are combined with a set of prompts and sent to an external LLM to transform the messages into their adapted form.
Once finished, the personalized model (with the personalized messages) will be given to the designer. This allows the designer to check the changed messages and validate whether they fit their expectations and do not contain harmful content (biases / hallucinations).
4. Runtime personalization
During code generation, we apply the deterministic personalization. This refers to either features that are turned on or not (such as voice recognition or increasing text size) or appending context to the LLMs. The latter specifically refers to the AI responses where LLMs are used. Compared to the predefined messages, which are static, we don’t have the opportunity to check the automated generation and need to hope that the LLM behaves as expected. It’s, as usual, a tradeoff between controlled but less creative answers and open but riskier answers. The processes for predefined and AI responses are shown in the figure below. 
The generated app
In its current version, the generated app (a BAF agent) will provide a menu where end-users can log in and then select the profile that corresponds the most to them. Once chosen, they can start chatting with the agent that will provide a personalized experience.
Recap
We lower the barrier to create personalized conversational agents by providing a pipeline using low-code and no-code principles. The web-based implementation and the automatic generation of code further improves the accessibility of the approach, removing any need for the designer to install software or do any manual programming. Furthermore, to start the agent, one can either launch it locally, or deploy it using functions integrated into the web-based editor. A pilot study which prompted participants to try the tool and evaluate the perceived usability and usefulness showed promising results, for both technical and non-technical participants.
In the future, we plan to add additional personalization options, conduct a larger user study to evaluate both the creation process but also the quality of the produced agents, and explore opportunities to do dynamic user profiling during runtime. Beyond conversational agents, we will attempt to expand this pipeline to personalize additional interfaces.
I am a PhD student at the Luxembourg Institute for Science and Technology. My research focuses on leveraging software engineering techniques to democratize the development of adaptive user interfaces, seamlessly integrating AI technologies with everyday applications.
Recent Comments