Exploring Agentic AI: Agent Composition with BeeAI

In this blog post, we’re going to explore a new framework from IBM named BeeAI, which is set to solve a very important problem for me: agent composition.

I’ve been using relatively simple agents for a while now. They’re incredibly handy for repetitive tasks, coding assistance, marketing, or testing. Sometimes it feels like using a cannon to shoot sparrows, but it’s often a tradeoff worth making: allowing AI to figure out how to solve problems, rather than defining all the rules myself, is usually quicker. When results don’t need to be overly precise or when the task involves working with unstructured data, this approach tends to be ideal for my needs.

Agentic composition

Most agentic frameworks focus on solutions that build single agents or multi-agent solutions running within a single process. If we consider agents as first-class citizens in our organizations, we need to approach them differently: they become smart services running independently within our organization, offering interfaces for interaction.

Previously, I thought exposing agents as tools via APIs was the best solution. However, creating and managing APIs is costly, and quite frankly, I don’t want to spend my time designing them. This is where BeeAI becomes interesting—it supports agent composition through an open protocol called ACP. My guess is that it’s heavily inspired by MCP, which standardizes the integration and interaction of tools. ACP, on the other hand, standardizes the way agents communicate with each other.

Imagine an army of busy bees collaborating efficiently. I could have an agent regularly checking my support tickets and triaging them to specialized agents: one handling sales-related issues, another managing technical support. I can’t wait to build this!

Installation

The getting-started experience is always critical for me. I genuinely dislike spending hours setting up my environment. Additionally, I learn much faster by doing rather than just reading documentation.

I typically work in a containerized development environment on Ubuntu, and initially, the installation via brew didn’t quite work smoothly. However, I learned brew isn’t only for macOS—another useful tool added to my toolbox. 🙂

After setting up brew, I followed the official installation guide:

brew install i-am-bee/beeai/beeai

Unfortunately, this initially failed with an error that seemed straightforward at first but took quite some time to resolve. Brew’s verbose and debug modes were lifesavers for troubleshooting. Specifically, the postinstall step for GCC failed, and after several attempts and some helpful suggestions from ChatGPT, I eventually got it working:

brew postinstall gcc --verbose --debug

Although not particularly exciting, I think it’s fair to share that setting up my environment took around three hours. I tried building my container in an emulated x86_64 mode, ensuring Docker was functioning correctly, recreating the environment multiple times, dealing with proxies, and fixing various network issues.

Finally, I was able to start BeeAI, only to discover it wasn’t actually communicating with the LLM!

In a containerized environment, the intended approach is straightforward:

beeai serve

As mentioned, I ultimately gave up on running everything inside a container for now.

Hello world

Originally, I intended to share more about agentic composition in this initial post, but the setup ended up taking longer than anticipated. Specifically, I planned to use my Azure OpenAI models but ran into constant issues. I tried proxies and various forms of troubleshooting, but nothing resolved the issue. It seems containerization added complexity I wasn’t ready to handle at the moment. Eventually, I switched to OpenAI’s native platform and installed everything directly on my macOS host machine—luckily, that setup was supported out of the box.

Configuration

After switching to OpenAI’s platform, configuration became straightforward:

beeai env setup

Once the environment was properly configured, launching the UI and starting the “hello world” chat agent was effortless:

beeai ui

In the next blog post, I’ll dive deeper into building my first multi-agent system using BeeAI and explore how ACP facilitates seamless interactions between agents. Stay tuned!