The world of AI is evolving fast. Not long ago, chatbots were at the center of innovation, powering virtual assistants, customer support, and automation. But things have changed. The rise of AI agents (more autonomous, adaptive, and goal-driven systems) has redefined how we think about intelligent interactions. interactions.
To stay ahead of this shift, we’ve rebranded BESSER Bot Framework to BESSER Agentic Framework (BAF 🤖). This change isn’t just about a new name. It reflects the broader transformation in the AI landscape. While bots were often seen as scripted responders, agents embody intelligence, decision-making, and dynamic problem-solving. The key points behind the rebranding are:
- Aligning with Industry Trends 📈: The term agents has gained popularity in AI and automation, reflecting more advanced, autonomous, and adaptable systems compared to traditional bots. The rebranding ensures the framework stays relevant in the evolving landscape.
- Expanding Perceived Capabilities 🧠: While bots are often associated with simple, rule-based interactions, agents suggest more sophisticated, goal-oriented behavior with reasoning and adaptability. The new name better represents the framework’s capabilities.
- Attracting a Broader Audience 🌍: Developers, researchers, and companies are increasingly looking for agent-based solutions. Adopting this terminology makes the framework more appealing to those exploring state-of-the-art AI concepts.
What does BESSER offer to the agentic landscape?
Not all agents need to rely only on LLMs or complex AI-driven reasoning. We provide a robust state machine system that allows you to design agents with rule-based, deterministic, and pragmatic behaviors. This is particularly useful when:
- You need predictable, controlled workflows for automation.
- You want to enforce strict business logic in conversational flows.
- You prefer a hybrid approach, combining structured rule-based decision-making with the adaptability of LLM-powered reasoning.
But you can also take advantage of the latest advances in NLP (e.g., LLM-based features such as RAG). Our philosophy is to not reinvent the wheel and offer a flexible solution:
- BAF agents come with easy-to-use wrappers on top of the most popular AI tools, like HuggingFace or OpenAI.
- Don’t need to model a state machine? Create simple LLM-based agents in just a few minutes.
And you can mix all these techniques in the same agent. You can have some states where the agent should be a very precise and “hardcoded” answer where in others you may want to provide a RAG-based one and others where the state should delegate the answer to the LLM of your choice.
This rebranding comes with a major release (v2.0.0) that incorporates a very exciting new feature: communication between agents to build Multi-Agent systems 🚀!
Keep reading to learn more about this feature…
Multi-Agent System: Running Example
One agent is smart, but things get really interesting when multiple agents work together. Now, BAF allows building Multi-Agent systems where agents specialize in different tasks, share information, and collaborate to get things done more efficiently.
In this section, we’ll go through a running example to show how agents interact. The following Multi-Agent system aims to help developers to write source code.

Example multi-agent system for code development
This system is composed by 3 agents:
- Main Agent: The agent that interacts with the developer, collecting his/her requests. It will store a piece of code and will ask for code modifications to a coder agent (in this example, we only considered adding new functions).
- Coder Agent: This agent receives coding requests (sent by the main agent) and leverages a specialized LLM to generate the requested code. Before replying back the generated code, it is sent to a reviewer agent to check for possible errors or bugs. If something was found, the coder agent iterates again to fix the received issues.
- Code Reviewer Agent: This agent receives a piece of code and is in charge of finding errors or bugs, leveraging a specialized LLM.
Example Workflow:
-
- A developer imports the code of an application into the database.
- The developer asks the system to generate a function for processing user authentication.
- The Main Agent assigns the request to the Coder Agent to generate the function.
- The Coder Agent produces the code.
- The Coder Agent sends the request to the Reviewer Agent
- The Reviewer Agent analyzes the code for possible bugs or syntax errors.
- The Reviewer Agent finds a bug and sends it back to the Coder Agent.
- The Coder Agent updates the code fixing the received issue.
- The Coder Agent sends the request to the Reviewer Agent
- The Reviewer Agent does not find any issue and replies OK.
- The Coder Agent receives the OK and replies the new code to the Main Agent.
- The Main Agent updates the code database and awaits for a new developer query.
Core idea of how this is implemented in BAF
Each of these agents will be a new BAF agent. Then, the interactions between them can be easily implemented by letting the agents communicate to each other. The communication between agents is done thanks to the WebSocketPlatform. An agent A can send a message to another agent B by simply connecting to agent B’s WebSocket platform. Agent B will receive the message and will treat it the same way as if it was a human message or some other type of event. It will then react to it by creating a new session (to store also the potential payload sent by agent A), detect the intent, transition to another state, etc. As soon as Agent B replies, this answer will be redirected to agent A which will again receive it and process it.
You will find more details in the official documentation. We dedicated a section explaining how to implement Multi-Agent communication, and also a more technical explanation of the developer multi-agent example.
If you found this project useful, don’t forget to give us a star on GitHub 🌟 and stay tuned for incoming updates!
Featured Image by Catalyststuff on Freepik

Software Engineer at Luxembourg Institute of Science and Technology (LIST)