Skip to main content
This lesson expands on what Bedrock Agents can do and how they integrate foundation models with external systems and knowledge sources. You’ll learn typical runtime flows, real-world use cases, how agents orchestrate multi-step workflows, and the main benefits you can expect when you adopt agents to handle orchestration and tool usage. What Bedrock Agents can do:
  • Retrieve information from a Bedrock Knowledge Base using Retrieval-Augmented Generation (RAG).
  • Ask follow-up questions to gather missing inputs.
  • Request additional input from the user (generate frontend callbacks) when a tool requires more information than is available.
  • Decide when to respond directly versus when to take action by calling a tool.
  • Chain multiple steps together to complete multi-step workflows.
  • Honor explicit instructions that control behavior, tone, and permitted data sources.
For example, you can configure an agent to answer only from a knowledge base or only from external tool results rather than relying on the model’s pre-trained knowledge. Those configuration-level decisions help control hallucination and enforce governance over data sources.
A dark-themed presentation slide titled "Workflow: What Else Can Agents Do?" listing agent capabilities such as retrieving information from knowledge bases, asking follow-up questions, deciding when to respond versus take action, chaining multiple steps to complete tasks, and applying instructions to control behavior and tone, each paired with an icon.
Runtime flow (typical)
  1. The user sends a request to your application.
  2. Your application invokes the agent runtime (for example, via an “invoke agent” API) hosted in Bedrock.
  3. The agent evaluates the request using its configured instructions, model choice, and action groups and selects one or more actions:
    • Answer immediately using available context.
    • Ask clarifying questions to the user.
    • Retrieve documents from a knowledge base (RAG).
    • Call external tools or APIs defined in action groups (for example, order APIs, calendar APIs, or internal microservices).
    • Combine and synthesize results from multiple sources into a single, coherent response.
  4. The agent returns a single response that may include model-generated text, retrieved documents, API results, and any follow-up questions for the user.
The key point: the response can be a combination of model output plus concrete data from APIs and knowledge sources, depending on the agent’s decision-making.
A flowchart titled "Workflow: Multiple Actions" showing a user request routed from Your Application to a Bedrock Agents runtime and Agent. The agent picks one or more actions—Think, Ask, Retrieve, Act, Combine results—and then returns a response to the app.
Real-world examples The following table summarizes common agent-driven use cases, the typical actions an agent will take, and example tools or data sources involved.
A dark blue presentation slide titled "Workflow: Real-World Examples" that outlines a "Knowledge Assistant" flow. It shows a user question ("What is our refund policy?") going to an Agent which queries a Bedrock knowledge base (RAG) and returns an answer.
Multi-step workflows Many user requests require multiple ordered steps. Example: “Book me a meeting with John tomorrow.” Typical sequence:
  1. Check the user’s calendar for conflicts.
  2. Check John’s availability via a directory or calendar API.
  3. Call a scheduling API to create the event.
  4. Send confirmations or follow-ups (email, calendar invites).
Agents orchestrate these steps dynamically, invoking the correct tools at the right time instead of relying on hard-coded orchestration in your application. This makes the integration more maintainable and easier to extend.
A slide titled "Workflow: Real-World Examples" showing a multi-step flowchart where the user request "Book me a meeting with John tomorrow" goes to an "Agent" and then to steps like "Checks calendar," "Calls scheduling API," and "Confirms booking." The design uses rounded blue boxes on a dark blue background.
Chained queries and reasoning Consider: “What were our top-selling products last month, and are any low on stock?” An agent can:
  • Query the sales database to find top-selling products.
  • Query the inventory system to check stock levels.
  • Use the model to combine, compute percentages, rank items, and flag low-stock thresholds.
  • Return a consolidated answer that contains both sales insight and inventory warnings.
This multi-source, multi-step approach leverages tools and RAG to deliver grounded, actionable insights rather than relying solely on model memorized knowledge.
A dark-themed diagram titled "Workflow: One Request, Multiple Actions" showing a user prompt asking about top-selling products routed to an agent icon, which then returns an answer box listing steps like querying the sales database and inventory, combining results, and returning the answer.
Benefits you can expect
  • Less orchestration code: Agents embed decision logic and sequencing, reducing custom glue code.
  • Faster API integration: Define capabilities and action groups once; agents reuse them across requests.
  • Easier development of intelligent assistants: Focus on intent and instructions rather than low-level orchestration.
  • More consistent tool-use patterns: Standardized action groups and agent configs yield predictable behavior.
A presentation slide titled "Results" with four numbered dark-blue panels. Each panel shows an icon and a short benefit: less orchestration code, faster API integration, easier-to-build intelligent assistants, and more consistent tool-use patterns.
Summary Bedrock Agents let you describe API capabilities and high-level intent; the agent then decides when and how to use those capabilities to satisfy a user request. That reduces orchestration code and makes it easier to build scalable, maintainable assistants that combine foundation models with external data sources and APIs.
When designing agents, explicitly specify which data sources the agent may use (for example, the knowledge base or tool results) and whether it should avoid relying on the model’s inherent pre-trained knowledge. This helps reduce hallucinations and ensures answers are grounded in your authoritative sources.
Next steps
  • Try the hands-on lab that walks through building an app that uses the SWAPI example end-to-end.
  • Learn more about integrating serverless actions with agents, e.g., using AWS Lambda for protected API calls and business workflows: https://learn.kodekloud.com/user/courses/aws-lambda
Further reading and references
  • Amazon Bedrock documentation — foundational concepts and agent runtime
  • Retrieval-Augmented Generation (RAG) patterns for grounding model responses
  • Design patterns for agent action groups and tool integration

Watch Video

Practice Lab