What's changed: Initial: 5 sections for Domain 2 (implementation and integration)
2.1Agentic AI Solutions and Tool Integrations
Learn to implement agents that reason and use tools autonomously: multi-agent with Strands Agents/Agent Squad, tool integration via MCP (Model Context Protocol), Bedrock AgentCore, ReAct/stopping conditions with Step Functions, and MCP servers on Lambda/ECS.
Agents solve complex tasks autonomously via a loop of reason → use tool → observe → decide next. At the professional level, you must run agents safely and at production quality.
2.1.1Agent building blocks
- Strands Agents: a model-driven open-source agent SDK with a built-in agent loop, tools (MCP), multi-agent, and streaming; Bedrock is the default provider.
- Agent Squad: multi-agent orchestration that routes via a Classifier, with a SupervisorAgent for parallel coordination.
- Bedrock AgentCore: a platform to run production agents with any framework/model (Runtime, Memory, Gateway, Identity, Code Interpreter, Browser, Observability).
- MCP: a protocol that exposes APIs/Lambda/existing services to agents as standardized tools; AgentCore Gateway turns existing assets into MCP tools.
- Safe control: ReAct/stopping conditions with Step Functions, timeouts with Lambda, resource boundaries with IAM, and circuit breakers to prevent runaway behavior.
Common: OSS model-driven agent SDK = Strands, route among agents = Agent Squad Classifier, run any framework in production = AgentCore, turn existing APIs into tools = MCP (AgentCore Gateway), prevent runaway = stopping conditions/timeouts/IAM boundaries.
Agent design splits into single-agent robustness and coordination. For single agents, use the Strands Agents agent loop to call tools (@tool/MCP), and impose ReAct (alternating reason/act), explicit stopping conditions with Step Functions, timeouts with Lambda, and least-privilege resource boundaries with IAM. Use circuit breakers to halt cascading failures, and insert approval steps (human-in-the-loop) with Step Functions where review is needed. For coordination, use Agent Squad (a Classifier picks the best agent from input + history; SupervisorAgent runs them in parallel). Expose tools as MCP servers—lightweight on Lambda, heavy/stateful on ECS. Run in production on Bedrock AgentCore (Runtime for serverless session isolation, Memory for short/long-term memory, Gateway for MCP, Identity for agent auth, Observability for OTEL traces) to get scale, monitoring, and governance without managing infrastructure.
| Goal | Use | Point |
|---|---|---|
| Build a single agent | Strands Agents | Agent loop + MCP tools |
| Route among agents | Agent Squad | Classifier/SupervisorAgent |
| Production platform | Bedrock AgentCore | Runtime/Memory/Gateway/Identity |
| Prevent runaway/cascades | Stopping conditions, timeouts, IAM | Circuit breaker |
Trap: “the more freely an agent calls tools without limits, the better it performs” is wrong—production needs stopping conditions, timeouts, IAM boundaries, and circuit breakers. Also “Strands = an AWS managed service” is wrong (it is an OSS SDK; the managed platform is AgentCore).
2.1.2Section summary
- Single = Strands / coordinate = Agent Squad / platform = AgentCore / tools = MCP
- Safety = stopping conditions, timeouts, IAM boundaries, circuit breakers
Sign in to track progress — Log in.
Quick check
(just a quick review)Q1. You want agents to call existing internal REST APIs and Lambda as tools in a standardized way. Best approach?
Q2. You want to dynamically route user queries to multiple specialized agents (billing, technical, sales). Best option?
Q3. You must prevent a production agent from runaway cost due to infinite loops or excessive tool calls. Which controls fit?