
From Chatbots to Digital Teams: Building Agentic AI on AWS
A practical mental model for Bedrock Agents, multi-agent workflows, memory, Strands Agents, Agent Squad, AgentCore, MCP, OpenAPI, human approval, Amazon Q, and Amazon Quick.
Imagine building an AI operations team
The easiest way I found to understand agentic AI was to stop thinking about chatbots and start thinking about an operations team. A chatbot sits at an information desk: you ask a question and it gives you an answer. An agent behaves more like an engineer with a task. It can decide what it needs, call an API, inspect the response, change course, and keep going until the job is done or until a safety boundary tells it to stop.
Take a cloud incident. Someone has to check customer impact, search runbooks, query logs, draft a fix, and get approval before touching production. You could ask one agent to do all of it. In practice, though, separating the work among an observability agent, a security agent, and a remediation agent often makes the system easier to understand and control.
That team analogy ties the AWS pieces together nicely. The model does the reasoning, tools let the agent interact with real systems, memory carries useful context forward, and orchestration keeps the work organized. AgentCore provides the production plumbing. Humans still own the decisions that carry real risk.
What makes a system agentic?
- Goal: the desired outcome, not merely the next sentence.
- Reasoning loop: observe, plan, act, inspect the result, and continue or stop.
- Tools: APIs, functions, knowledge bases, browsers, code interpreters, or other agents.
- State and memory: information that persists during or across interactions.
- Boundaries: permissions, validation, timeouts, budgets, and stopping conditions.
- Observability and evaluation: evidence of what the agent did and whether it succeeded.
- Human control: approval or escalation when risk, uncertainty, or policy demands it.
A useful distinction: Not every workflow is an agent. Step Functions follows branches that a developer defines in advance; an agent chooses among available actions at runtime. Real systems often need both.
Bedrock Agents: the managed-agent mental model
Bedrock Agents gave AWS developers a managed way to connect a foundation model with instructions, knowledge bases, and action groups. In plain English, the agent figures out what the user wants, gathers missing details, chooses an action, and returns the result. Those actions are usually described with function details or an OpenAPI schema and often run through Lambda.
Even if you never build a new system with Bedrock Agents Classic, its design is worth learning. Tool descriptions need to be specific. Parameters need validation. Permissions should be narrow. Important actions need confirmation. And every orchestration step should leave enough evidence to debug later.
Multi-agent workflows: when one agent becomes a bottleneck
A multi-agent workflow is simply a division of labor. A supervisor breaks down the request, sends pieces to specialists, and combines the results. Bedrock Agents Classic supports this supervisor-and-collaborator pattern for existing customers.
The practical benefit is separation. A security agent can review IAM findings without receiving permission to change IAM. An observability agent can query logs. A remediation agent can prepare a fix. The supervisor compares their evidence and gives the user one coherent response.
There is a catch: adding agents does not magically add intelligence. It can add latency, duplicated context, conflicting answers, and a much messier debugging session. My rule of thumb is to begin with one agent and split the work only when the tasks, permissions, models, or success criteria are genuinely different.
Common orchestration patterns
Pattern | How work moves | Best fit |
|---|---|---|
Supervisor | One agent delegates to specialists and combines results | Central control, unified user interaction, and clear specialist roles. |
Router | A classifier sends the request to the most suitable agent | Low-latency handling when one specialist usually owns the request. |
Agents as tools | An orchestrator invokes specialist agents like functions | Hierarchical systems with explicit delegation boundaries. |
Graph / workflow | Agents execute along defined dependencies and branches | Repeatable multi-step work requiring structure and parallelism. |
Swarm | Agents hand work to one another dynamically | Exploratory collaboration where coordination can remain decentralized. |
Agent memory: continuity is not the same as intelligence
Without memory, an agent comes back to a clean desk every time. It may answer the current question well, but it cannot remember the customer’s preferences, the steps already tried, or the conclusion from yesterday’s investigation.
Three ideas are easy to mix up here. Working context is what the model can see in the current request. Short-term memory carries state through a session or a nearby interaction. Long-term memory saves selected information for later sessions. AgentCore Memory offers managed short- and long-term memory, while Strands supports session-management patterns in agent code.
Memory sounds convenient until the agent remembers the wrong thing. Preferences expire, summaries lose nuance, and tenant data must never cross boundaries. Before storing anything, decide who owns it, how long it lives, where it came from, how it can be corrected, and how a user can delete it.
Strands Agents: model-driven agents in code
Strands Agents is an open-source SDK, initiated by AWS, for writing agents in Python or TypeScript. The basic idea is refreshingly small: give a model instructions and tools, then let the model decide when to use them. A tool might be a Python function, an MCP server, a packaged integration, or even another agent.
Strands is appealing when you want to stay close to the code. You can control models, tools, state, hooks, streaming, and orchestration patterns such as graphs, swarms, workflows, and agents-as-tools. What it does not try to be is every piece of production infrastructure around the agent.
A helpful way to remember the boundary is this: Strands helps you write the agent; AgentCore can help you run, secure, connect, remember, and observe it.
Agent Squad: lightweight multi-agent routing
Agent Squad, originally called Multi-Agent Orchestrator and previously hosted under AWS Labs, is a lightweight open-source framework for routing conversations among specialized agents while maintaining shared context. It supports Python and TypeScript and can coordinate agents backed by different services or implementations.
As of 2026, the project has moved from the former AWS Labs repository to 2FastLabs. It remains useful for understanding intent-based routing and multi-agent orchestration, and it may still appear in learning material under its AWS origins. Treat it as an open-source framework, not as a managed AWS service.
Amazon Bedrock AgentCore: production infrastructure for agents
Once an agent leaves a notebook and starts serving real users, the less glamorous questions arrive quickly: Where does it run? How are sessions isolated? Which identity does it use? Where do its tools live? How do we trace a bad decision? AgentCore addresses that production layer without requiring every agent to use the same framework or model.
AgentCore capability | Responsibility | Why it matters |
|---|---|---|
Runtime | Serverless execution, scaling, session isolation, and long-running agents | Hosts agent workloads without building custom agent-serving infrastructure. |
Memory | Managed short- and long-term memory | Adds continuity without creating a bespoke memory pipeline. |
Gateway | Turns APIs, Lambda functions, and services into governed agent tools; supports MCP | Centralizes tool discovery, authentication, policy, and connectivity. |
Identity | Inbound user identity and outbound access to AWS or third-party services | Separates who the user is from what the agent may do on the user’s behalf. |
Observability | Metrics, traces, spans, and execution visualizations | Makes planning and tool-use paths inspectable in production. |
Built-in tools | Browser and Code Interpreter capabilities | Provides isolated web interaction and code execution for appropriate tasks. |
The key word is modular. A Strands agent, another open-source agent, or your own implementation can use the AgentCore pieces it needs instead of being rewritten around one SDK.
MCP: a common language for agent tools
MCP is easiest to picture as a common plug shape for AI tools. An MCP server publishes capabilities through a standard interface; an MCP client discovers those capabilities and calls them. The payoff is that every agent framework does not need a completely different connector for the same tool.
Strands can act as an MCP client, and AgentCore Gateway can connect agents to MCP servers or turn existing APIs into MCP-compatible tools. That removes integration work, not security work. Authorization, input validation, rate limits, audit logs, and safe tool design still matter.
OpenAPI: turn existing APIs into understandable actions
If MCP is the plug shape, OpenAPI is closer to a detailed instruction card for an HTTP API. It describes the operations, parameters, request bodies, responses, and schemas in a format a machine can read. Bedrock Agents Classic can use that schema to understand which actions exist and what information it must collect.
In AgentCore, Gateway can wrap OpenAPI-defined services and expose them to agents as governed tools. This is powerful because organizations can reuse existing APIs instead of rewriting every system as agent-specific code.
Good schemas are part of prompt engineering for tools. Use precise operation names and descriptions, narrow parameter types, enumerations where possible, clear required fields, and unambiguous error responses. Validate again inside the service; never assume the model-generated arguments are safe because they matched a schema.
Human-in-the-loop: design the pause before the action
Human approval is not a consolation prize for an agent that could not finish the job. It is a boundary we choose. If an action carries legal responsibility, financial impact, security risk, or too much uncertainty, the agent should pause.
For example, an agent can investigate an incident and draft a remediation plan on its own. Changing an IAM policy, refunding a customer, deleting data, sending an external message, or deploying code is different. The reviewer should see the proposed action, target, evidence, expected impact, and rollback plan not a lonely Confirm button.
AgentCore tool patterns support client-side inline functions that can pause for approval, and AgentCore Gateway supports MCP elicitation flows for requesting user input during tool execution. Traditional AWS orchestration can also use Step Functions and Amazon Augmented AI where appropriate.
Amazon Q: enterprise answers and actions
Amazon Q is AWS’s family of generative AI assistants. Q Business connects company data to a conversational experience while respecting identity-aware access, and it can use integrations or plugins to take actions. Its agentic RAG capabilities go beyond a single retrieval step by using specialized agents and tools to build a fuller response.
Amazon Q Developer focuses on software-development and AWS-building workflows. In an agentic architecture discussion, the important distinction is between building a custom agent platform with Bedrock and AgentCore versus adopting a managed assistant experience that already integrates enterprise knowledge or developer workflows.
Amazon Quick: agents for business work
Amazon Quick brings agents closer to everyday business work. A user can analyze data, automate a task, build an application, or conduct research through natural-language interactions. Quick works with connected data and applications and includes Quick Sight for business-intelligence experiences.
Quick can connect knowledge and applications, including Amazon Q Business indexes and supported integrations such as MCP servers. This makes it the business-user layer in the ecosystem: people can use agents, spaces, automations, analytics, and connected knowledge without each team building a custom front end.
The naming is evolving quickly. Current AWS documentation should be treated as authoritative when distinguishing Amazon Q Business, Amazon Quick, and Quick Sight capabilities or planning a migration.
Choosing the right AWS agent path
Need | Recommended starting point | Reason |
|---|---|---|
Custom code-defined agent | Strands Agents or another framework + AgentCore | Flexible authoring with managed runtime, memory, tools, identity, and observability. |
Existing Bedrock Agents deployment | Bedrock Agents Classic | Maintain and govern the existing system while evaluating migration options. |
Flexible multi-agent routing | Strands multi-agent patterns; Agent Squad for relevant existing projects | Use explicit graphs, workflows, swarms, or routing based on control needs. |
Enterprise knowledge assistant | Amazon Q Business / Amazon Quick | Adopt managed connectors, identity-aware knowledge, and business-user experiences. |
Governed tools across agents | AgentCore Gateway with MCP or OpenAPI targets | Centralize discovery, connectivity, authentication, and policy enforcement. |
Putting it together: an incident-response agent team
Here is how the operations-team analogy might look in a real cloud incident, useful enough to speed up the investigation, but deliberately unable to make an uncontrolled production change:
- A supervisor receives the incident goal and creates a bounded investigation plan.
- An observability agent queries metrics and logs through read-only tools.
- A knowledge agent retrieves runbooks and related incident history.
- A security agent reviews IAM exposure and policy constraints.
- AgentCore Memory preserves session evidence and approved long-term preferences.
- AgentCore Gateway exposes internal APIs or MCP tools with identity and access controls.
- A remediation agent drafts commands and a rollback plan but cannot execute them directly.
- A human reviews evidence and approves, modifies, or rejects the proposed action.
- AgentCore Observability records the reasoning and tool path for debugging and evaluation.
Eight failure modes to design against
- Over-autonomy: the agent can take a high-impact action without an approval boundary.
- Tool confusion: vague descriptions cause the wrong API or specialist to be selected.
- Excess privilege: every agent receives the same broad execution role.
- Unbounded loops: no step, time, token, cost, or retry limit stops the reasoning cycle.
- Memory contamination: incorrect or cross-tenant information is retained and recalled.
- Coordination debt: more agents add latency and disagreement without measurable benefit.
- Hidden failures: only the final answer is logged, while tool calls and intermediate states disappear.
- Protocol complacency: MCP or OpenAPI is mistaken for authorization and input validation.
Final takeaway
The jump from generative AI to agentic AI is really a jump from producing an answer to pursuing an outcome. That makes the system more useful, but it also raises the stakes. Identity, permissions, memory, tool design, observability, evaluation, and human accountability can no longer be afterthoughts.
Each AWS offering sits at a different layer. Bedrock Agents Classic teaches the managed agent and action-group model. Strands gives developers a flexible SDK. Agent Squad shows lightweight routing. AgentCore supplies production infrastructure. MCP standardizes tool connectivity, while OpenAPI describes existing HTTP APIs. Amazon Q and Amazon Quick package agentic capabilities for enterprise knowledge, development, analytics, and business work.
My biggest takeaway is that a good agent architecture is rarely the one with the most agents or the most autonomy. It is the smallest system that completes the task reliably, explains what it did, respects permissions, stops safely, and brings in a person exactly where judgment is needed.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article