AWS Builder Center
What I Learned Building Agentic Architectures on AWS Serverless

What I Learned Building Agentic Architectures on AWS Serverless

Two Ways to Make AI Agents Work Together (Orchestration vs Choreography Patterns)

I joined the BeSA (Become A Solutions Architects) Cohort 10 program, and Week 2 threw me straight into the deep end: "Building Agentic AI architectures with AWS Serverless."
Now, I have built plenty of AWS stuff before. But this one was different. The whole workshop was about a question I had never really sat down and thought about:
When you have several AI agents that need to work together to get a job done, how do you actually make them coordinate?
It sounds simple but It is not. And by the end of the week I realized this is one of those things that separates people who "use AI" from people who can actually architect AI systems.
Let me walk you through what I learned, with the same analogies that finally made it click for me.



First, What Even Is an "Agentic" AI System?

Let's clear this up before anything else, because the word "agent" gets thrown around a lot.
A normal AI call is like asking one smart friend a single question. You ask, they answer, done.
An AI agent is more like a smart friend who can also do things. Instead of just answering, it can check the weather, call an API, look something up, and make a decision based on what it finds. It has a goal and some tools, and it figures out the steps.
An agentic system (or multi-agent system) is when you have several of these smart friends, each specialized in one thing, working together on a bigger job.
Think of planning a wedding. You do not hire one person who does everything. You hire:
  • A planner who owns the overall plan
  • A caterer who only worries about food
  • A photographer who only worries about pictures
Each is an expert in their lane. The magic (and the difficulty) is in how they coordinate.
In the workshop, our "wedding planners" were three agents for a fictional company called TravelCorp:
  • The Planner Agent – the brains that figures out what the trip needs
  • The Weather Agent – checks the weather for the destination
  • The Flight Manager Agent – handles booking flights
We built these agents using the Strands SDK (AWS's open-source toolkit for building agents), and the whole thing ran on AWS Serverless, meaning no servers to manage, everything scales on its own, and you only pay when it runs.
The big question the workshop kept coming back to: how do these three agents talk to each other and get the trip booked?
There are two main patterns. This is the heart of the whole thing.



Pattern 1: Choreography (The Dance Floor)

Imagine a dance floor full of skilled dancers. There is no one standing in the middle shouting "now you spin, now you dip!" Instead, every dancer knows their own moves, and they react to what is happening around them. Someone raises a hand, the next person responds, and the whole thing flows.
That is choreography.
In a choreography pattern, there is no central boss. Each agent just listens for events (things that happened) and reacts when something relevant to it occurs. When it finishes its part, it announces "I'm done, here's what happened," and whichever agent cares about that news picks it up and does its thing.
On AWS, we built this using:
  • Amazon EventBridge – think of this as the announcement system, the "event bus." When an agent finishes, it drops a message here. EventBridge makes sure the right agents hear about it.
  • AWS Lambda – each agent lives in a Lambda function that wakes up, does its job, and goes back to sleep.
So the flow looks like this:
  1. A trip request comes in. An event fires: "New trip needs planning."
  1. The Planner Agent hears it, wakes up, figures out the plan, and fires a new event: "Plan ready, need weather check."
  1. The Weather Agent hears that, checks the weather, and fires: "Weather checked, ready to book."
  1. The Flight Manager Agent hears that and books the flight.
Nobody is directing traffic. Each agent just knows what to listen for and what to shout when it is done.
Why this is beautiful: the agents are loosely coupled. The Planner Agent has no idea the Weather Agent even exists. It just shouts into the room. This means you can add or remove agents without breaking everything. (More on that later, because this became my favorite part.)
The trade-off: because nobody is in charge, it can be harder to see the whole picture. If a trip gets stuck halfway, you have to go digging through events to figure out where it stalled. It is like a dance where everyone is doing their part beautifully, but if someone trips, it is not always obvious who or why.



Pattern 2: Orchestration (The Conductor)

Now picture an orchestra. Every musician is talented, but they are not just reacting to each other. There is a conductor at the front, baton in hand, telling the violins when to come in, cueing the drums, controlling the tempo. Nothing happens until the conductor says so.
That is orchestration.
In an orchestration pattern, there is one central controller that owns the workflow. It calls Agent A, waits for the result, decides what to do next, then calls Agent B, and so on. The agents themselves do not need to know about each other at all, they just do what the conductor tells them.
On AWS, we built this using:
  • AWS Step Functions – this is the conductor. It is a visual workflow service where you literally draw out the steps: "first do this, then if this happens do that, otherwise do this other thing." It calls each agent in order and keeps track of the whole state.
So the flow looks like this:
  1. A trip request comes in and starts the Step Functions workflow.
  1. Step Functions calls the Planner Agent, waits, gets the plan.
  1. Step Functions calls the Weather Agent, waits, gets the weather.
  1. Step Functions calls the Flight Manager Agent, waits, books the flight.
  1. Step Functions marks the whole thing complete.
Why this is beautiful: you can see everything. Step Functions gives you a visual map that lights up green as each step completes and red if something fails. You know exactly where a trip is in the process and exactly where it broke. For anything that needs control, auditing, or careful step-by-step logic, this is gold.
The trade-off: the conductor has to know about every musician. If you want to add a new agent, you have to update the workflow to include it. It is more tightly coupled, more control, but a bit less flexible.



Choreography vs Orchestration: The Simple Way to Remember It

Here is the cheat sheet I wrote for myself:

Choreography (Dance Floor)
Orchestration (Conductor)
Who's in charge?
Nobody, agents react to events
One central controller
AWS service
EventBridge + Lambda
Step Functions
Coupling
Loose (agents don't know each other)
Tighter (controller knows all agents)
Visibility
Harder to see the whole flow
Easy, you see every step
Best for
Flexibility, easy to add/remove agents
Control, auditing, complex logic
Analogy
Dancers reacting to each other
Orchestra following a conductor
Neither one is "better." They are tools for different jobs. A quick, flexible system that changes a lot? Lean toward choreography. A system where you need tight control and a clear audit trail? Orchestration.



The Human in the Loop (Because AI Shouldn't Book a $5,000 Trip on Its Own)

Here is something I really appreciated about the workshop: it did not pretend AI should run wild.
Sometimes an agent hits a decision that is too big or too risky to make alone, like a really expensive booking. In those cases you want a human to approve it first. This is called human-in-the-loop.
The clever part is how each pattern handles pausing to wait for a human:
  • In choreography, we used Amazon SQS (a queue). When a booking needs approval, the request drops into a queue and just waits patiently. A human reviews it, approves it, and the flow continues. The queue is like a "pending approvals" tray on someone's desk.
  • In orchestration, we used Step Functions Activities. The workflow literally pauses at that step and waits, holding its place, until a human sends back a "yes, go ahead" or "no, stop."
I actually did this myself during the lab: a high-value booking came through, the system paused, and I had to approve it before it went ahead. Seeing that pause-and-wait behavior work end to end was the moment the concept became real for me. AI does the heavy lifting, humans keep the final say on the big stuff.



The Part That Blew My Mind: Adding an Agent Without Touching the Others

At the end there was a bonus challenge: add a brand new Hotel Recommendation Agent to the system.
In the choreography setup, this was almost magical. I built the new agent, told it what event to listen for, and... that was it. I did not touch a single line of the Planner, Weather, or Flight agents. The new agent just started listening to the announcement system, and the existing agents never even knew it joined.
This is the real-world payoff of loose coupling. It is like a new dancer joining the floor, they learn the rhythm and blend in, and nobody else has to change their steps. In a real business, this is huge: you can grow your system feature by feature without the risk of breaking what already works.
(In an orchestration setup, adding the hotel agent would mean editing the conductor's sheet music, the Step Functions workflow, to fit it in. Still very doable, just a different kind of work. This contrast is exactly why the "which pattern" question matters.)



What I Actually Walked Away With

Going in, "agentic AI" sounded like a buzzword. Coming out, I see it as a genuine architecture discipline with real design decisions:
  1. Multi-agent systems are just specialists coordinating. The hard part is never the individual agent, it is the coordination.
  1. Choreography vs orchestration is the core decision. Dancers reacting to each other, or an orchestra following a conductor. Loose and flexible, or controlled and visible.
  1. Serverless is a natural home for this. EventBridge, Lambda, Step Functions, and SQS let you build these systems without managing a single server, and you only pay when things actually run.
  1. Keep humans in the loop for the big calls. Good AI architecture knows when to stop and ask.
  1. Loose coupling is a superpower. Being able to add a whole new agent without touching the existing ones is the kind of thing that keeps real systems alive as they grow.
If you are getting into AI architecture, do not just learn how to call a model. Learn how to make several of them work together. That is where the actual engineering lives.
Onward to Week 3.


I'm Pauline Namwakira, an AWS trainer and Solutions Architect based in Nairobi, Kenya. I'm sharing what I learn as I go through the BeSA Cohort 10 program. If you're on this journey too, let's connect.
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article