Building a Team of AI Agents

In Brief

A standalone AI model cannot build a mobile app on its own. It can write a single function, answer a single question, but complex tasks require teams of collaborators. Lauren McHugh Olende from IBM Technology explains that building a team inside an AI agent looks surprisingly like building a human team: you need planners, doers, critics, and communicators. The video maps seven roles and four ways to make each one effective.

The roles in an agent team

The video frames everything around two questions: which roles does the agent need, and how do you make each role especially good at its job? Here are the seven roles with their human equivalents:

The doer exists in every agent system. It does concrete things but cannot handle complex tasks alone. It needs someone with the bigger picture.

The planner takes user input and creates a plan. In the mobile app example from the video, that means two planning steps: one for user requirements and one for the app architecture, before a single line of code is written. The role is to break a complex problem into parts the doers can handle.

The tool operator interacts with APIs (interfaces that let systems talk to each other), discrete scripts, and web services. It creates structured tool calls with the right arguments and passes results down the chain.

The learner is the agent's research arm. It pulls information from the outside world: competitor apps, user needs from blogs and social media, market trends. This is often a RAG setup (retrieval-augmented generation, a technique where the agent fetches relevant info from external sources), but it can also be a rules-based data retrieval step.

The critic checks whether the output is good enough. It can review responses for hallucinations (cases where the model confidently states something false), write and run tests against generated code, or score multiple outputs and pick the best one.

The supervisor monitors at the task or project level. It checks whether roles are getting stuck, identifies failing steps, and keeps the process moving.

The presenter pulls the pieces together and communicates the result to the user. In the mobile app example, it summarizes the user requirements, explains the codebase, and reports what the app actually does.

ReAct: four roles in one pattern

The ReAct pattern (short for Reasoning + Acting) is a popular combination of four of the seven roles and a common starting point for simple agent systems:

The four connect in a loop: the planner thinks, the tool operator acts, the critic observes the result, and the presenter delivers the answer. Simple enough to get started quickly, flexible enough to scale.

Making a role effective

Having the right roles is only half the work. There are four levers:

Prompting is the first step. Give instructions the way you would give them to a person. Something as simple as "if you get stuck, retry and try again" can help an agent push through walls it would otherwise stop at.

Model selection is about hiring the right person from the start. Not every model fits every role. Specialisation, model size, whether it is a reasoning model, and the model's character are all factors worth considering.

Fine-tuning means giving the model examples of what good performance looks like for that specific role. More resource-intensive, but produces more targeted behaviour.

Context is about giving the agent access to the right systems, files, and databases without overwhelming it with irrelevant information. The analogy is good onboarding: give new team members exactly what they need, not everything at once.

Start small, grow as the work demands

A startup can launch with a few smart people and solve a simpler problem first. An agent system works the same way: a few core roles, a working solution. Over time the team grows with more roles, more specialisation, and stronger quality control. The scaling logic is the same whether the team members are people or subagents.

Glossary

Sources and resources