Have you ever gone shopping for a dress for a special occasion?
You walk into a shop, explore different designs, try a few options, check the fitting and perhaps ask someone for a second opinion before making the final decision. Sometimes, you find what you want immediately. Other times, you need a few adjustments before everything comes together.
Now imagine having a personal shopping assistant who coordinates different specialists to help you. One understands your preferences, another checks availability, someone else verifies the details, and another helps you make the final decision.
I saw the similar concept unfolding when building a multi-agent application.
Recently, I worked on a GenAI use case for a customer where we designed and implemented a multi-agent architecture using Amazon Bedrock AgentCore and various AWS services.
Rather than building one large assistant to handle everything, we designed multiple specialised agents, each responsible for a specific action. A central orchestrator coordinating them, while AWS services provide the supporting capabilities for memory, tool integration, validation, data storage and security.
Before going further, a quick clarification: the actual customer use case has nothing to do with dress shopping! I've used this analogy purely to make the architecture easier to understand. The customer's business scenario and specific details are confidential, so I've intentionally masked those aspects while sharing the technical approach and architectural decisions behind the implementation.
The architecture at a glance
Here is how we brought the different AWS services together.
Here is how I would explain the different components using our dress-shopping analogy.
1. The personal shopping assistant: Amazon Bedrock AgentCore Runtime and Strands
Imagine walking into a shopping mall. You know what you are looking for, but you don't want to visit every shop yourself. You explain your requirements to a personal shopping assistant, who coordinates the different people needed to help you. This is exactly the role of our main orchestrator.
We used Amazon Bedrock AgentCore Runtime to host our orchestrator, built using the Strands Agents framework.
The user provides an event brief, and the orchestrator takes responsibility for understanding the request and deciding which specialised agents need to be involved. What I like about AgentCore Runtime is that it provides a managed environment to run agents without us having to manage all the underlying infrastructure ourselves.
Instead of creating one large application that handles every responsibility, we can separate the work into smaller agents and let the orchestrator manage the overall flow. For me, this is an important architectural decision. It gives us a more structured way to build and extend the solution as business requirements grow.
2. Different specialists: Multiple agents running on AgentCore Runtime
When shopping for a dress, you may need different people to help you. One person understands the design, another checks availability, and someone else verifies the details. We followed the same thinking in our implementation.
We designed four specialised agents, each responsible for an isolated action. These agents run on Amazon Bedrock AgentCore Runtime, while the main Strands orchestrator coordinates their activities. The benefit is that each agent has a defined responsibility instead of having one agent trying to handle everything.
From an architecture perspective, I prefer this Seperation of Concerns approach because it gives us better separation of responsibilities. We can work on individual agents without necessarily changing the entire application. It also gives us room to introduce additional agents as the customer requirements evolve. 3. Remembering your preferences: Amazon Bedrock AgentCore Memory
Imagine visiting the same shop again. Wouldn't it be nice if the shopping assistant remembered your previous preferences? You don't have to explain everything all over again.
This is where Amazon Bedrock AgentCore Memory comes into our architecture.
We use it to retain conversation context and event or venue history, allowing the orchestrator to refer to relevant information from previous interactions. I see Memory as an important capability when building applications that involve ongoing conversations. Without it, every interaction can feel like starting from scratch. With the right context available, the assistant can provide more meaningful responses. Of course, what information is retained and how it is used needs to be considered carefully, especially in enterprise environments.
4. Connecting to different shops: Amazon Bedrock AgentCore Gateway
A shopping assistant cannot do everything independently. Sometimes they need to check with another shop, retrieve information or use an external service. Imagine the dress is not available in one branch but available in another branch store. Our agents also need access to different tools to complete their tasks.
We used Amazon Bedrock AgentCore Gateway to expose tools through the Model Context Protocol (MCP).
In our architecture, AWS Lambda functions are made available as tools through the Gateway, allowing agents to invoke the required operations. This is an important part of the design because we don't want every agent to build its own connection to every backend operation. AgentCore Gateway provides a common integration point for these tools. What I find interesting here is that the agent moves beyond simply generating an answer. It can interact with actual business operations and retrieve information needed to complete a task.
5. Checking the details: AWS Lambda and Amazon DynamoDB
Let's say you have found a dress you really like. Before making the purchase, you still need to check the size, colour, availability and whether it fits your budget. You wouldn't want the shopping assistant to simply guess these details. We followed the same principle in our architecture by separating reasoning from validation.
We used AWS Lambda to perform deterministic validation. This means important business checks are handled through predefined code rather than relying entirely on the model. In our actual customer implementation, Lambda performs exact lookups against a facts store maintained in Amazon DynamoDB. I think this separation is particularly important for enterprise applications.
We should not expect a foundation model to handle every operation. Let the model focus on reasoning and language, while AWS Lambda and DynamoDB handle the checks that require predictable results.
6. The personal stylist: Claude on Amazon Bedrock
When shopping, sometimes you need someone who understands your preferences and can help you make a decision.
In our architecture, Claude on Amazon Bedrock provides the reasoning and generation capability. We use Claude to help the agents understand the information they receive, reason through the request and generate relevant responses.
What matters here is how we use the model within the overall architecture. We are not asking Claude to perform every operation. It works alongside the specialised agents, AgentCore Gateway and the Lambda validation components.
For example, the model can interpret a request and generate a useful response, while Lambda performs the exact checks against DynamoDB. This is one of the architectural decisions I find most valuable: use the foundation model where it adds intelligence, and use the surrounding AWS services where we need controlled execution. 7. Keeping everything within the rules: Amazon Bedrock Guardrails
Even when you have a good shopping assistant, there are certain boundaries it needs to follow. The same applies to our application.
_We included Amazon Bedrock Guardrails to provide additional safety controls around model interactions. _
For me, security and responsible usage should not be something we consider only after the application is built. When developing enterprise GenAI applications, we need to think about how the model behaves, what information it can respond to and what boundaries need to be enforced. 8. Preparing the information: Amazon S3, AWS Lambda and Amazon DynamoDB
Imagine a shop receiving a new catalogue with updated product information. Before the shopping assistant can use it, someone needs to organise the information and make it available.
We designed a similar process for the customer's business data. We used Amazon S3 as the storage location for uploaded Excel files. An AWS Lambda function processes these files, extracts the rows and converts them into structured records with the required metadata. The processed information is then loaded into Amazon DynamoDB, which acts as the facts store used by the application.
I liked this approach because it gave us a clear data ingestion process. Similar to a traditional ETL process. Instead of mixing file processing with the agent's actual conversation flow, we handle data preparation separately. It also means the agents can retrieve structured information from DynamoDB rather than having to process raw Excel files every time a user makes a request.
My final thoughts
What I found most interesting about this customer implementation is how we brought different AWS services together to build something beyond a traditional chatbot.
By combining Amazon Bedrock AgentCore, Strands, Claude, AWS Lambda, Amazon DynamoDB and Amazon S3, we designed a solution where specialised agents work together, each handling a specific responsibility. One key takeaway for me is that building a multi-agent application is not about having more agents or using more AWS services. It is about making the right architectural choices, giving each component a clear purpose, and ensuring everything works together to solve the business problem.
There is still plenty to explore as GenAI continues to evolve, but I believe this approach opens up interesting possibilities for enterprise applications. And coming back to my dress-shopping analogy, having all the right people in the shop doesn't guarantee the perfect dress. What matters is how well they work together to get the final result right.
Similarly, the success of a multi-agent application comes not from the number of agents we build, but from how effectively we bring them together to deliver a meaningful business outcome.