Skip to main content
In this lesson we introduce Amazon Bedrock Agents and demonstrate how they enable foundation models to move beyond content generation into taking real-world actions — for example, calling external APIs, retrieving data, or orchestrating multi-step workflows. What we’ll cover
  • Why a foundation model by itself cannot perform external actions reliably.
  • How Bedrock Agents solve this by combining models with managed orchestration and tools.
  • How your application interacts with a Bedrock Agent.
  • Expected results, a key takeaway, and the next topic to explore.
Let’s start with the problem statement.

​
Problem: models alone are not enough

Models such as Anthropic Claude and Meta Llama are excellent at generating text, code, and other outputs. However, they do not automatically perform actions against external systems. If your application needs to:
  • Generate an API call,
  • Execute that call,
  • Parse the response, and
  • Iterate with follow-up calls,
you traditionally must write and maintain orchestration code that coordinates the model and each external system. That orchestration quickly becomes repetitive and brittle as integrations grow.
A slide titled "Problem: Models Alone Are Not Enough" showing an illustrated brain on a platform linked through a "Require custom orchestration code" icon to an API gear, then to a computer and server rack. It visually conveys that models need orchestration and infrastructure to be usable.

​
Solution overview: Bedrock Agents

Bedrock Agents combine a foundation model with managed orchestration and pluggable tools (action groups). When your application invokes an agent, you specify:
  • The foundation model to use,
  • The agent to run,
  • The task or instruction to complete.
The agent receives the request and autonomously decides whether to call configured tools (APIs, databases, knowledge bases) and how to use them. It may:
  • Satisfy the request using the model alone, or
  • Call one or more tools, potentially in multiple steps, until the task is complete.
This moves planning, tool selection, execution, response parsing, and iterative reasoning into a managed agent runtime. Your application only issues a single agent invocation and receives a final response.
A slide titled "Solution: Use Bedrock Agents" showing that an agent combines a Foundation Model (reasoning), Instructions (what to do), and Tools/APIs (how to act). The diagram explains the agent then plans, selects the right tool, and executes multi-step workflows so models can call APIs and complete real tasks.

​
Agent anatomy — core elements

An agent consists of three core elements that work together to convert intent into actions:
  • Foundation model — the reasoning engine that decides when and how to use tools.
  • Instructions — preconfigured behavioral guidance that frames the agent’s goals and constraints (for example: “You are a customer-support assistant. Be concise and professional.”).
  • Action groups (tools/APIs) — external services the agent may call. Each group can expose multiple actions (for example, getOrder and updateOrder for an order-management API).
Together the agent builds a plan from the instruction, selects tools, executes actions, parses responses, and iterates until the instruction is satisfied: understanding → decision → action → response. Key components
A slide titled "Solution: Key Components" showing a central "AGENT Orchestrator" circle connected to three surrounding circles labeled "Foundation Model," "Action Groups," and "Instructions," each with short explanatory text. A green bar at the bottom reads "Together: Understanding → Decision → Action → Response."

​
How your application interacts with an agent — typical flow

  1. An end user interacts with your application (where your Bedrock SDK code runs).
  2. Your application calls the Bedrock Agent Runtime — a different endpoint from the standard Bedrock model runtime. See the Amazon Bedrock documentation.
  3. Instead of calling InvokeModel or Converse, your application calls InvokeAgent and passes the prompt/instruction.
  4. The agent uses its configured foundation model, action groups, and an optional knowledge base (RAG — retrieval-augmented generation) to fulfill the instruction.
  5. The agent returns its final response to your application.
  6. Your application renders the result to the end user.
Note that the Agent Runtime handles both the model interactions and the tool executions so your application does not need to orchestrate each API call.
When interacting with an agent, call the Bedrock Agent Runtime using the InvokeAgent method. The agent runtime handles model calls, tool execution, and RAG lookups on your behalf.
Additional details
  • Action groups and actions are configured when you create the agent; you control which external systems the agent may access.
  • A knowledge base (RAG) can be attached to provide context from your private documents; the agent can combine retrieved documents with tool usage during reasoning.
  • During a single invocation the agent may perform multiple API calls or DB operations; the runtime aggregates these steps and returns a consolidated final response.
A colorful flowchart titled "Workflow: How Your Application Interacts With a Bedrock Agent" showing five steps from "User asks" through "App invokes agent," "Agent processes," "Response returns," to "User sees result," with supporting components (Foundation Model, Action Groups, Knowledge Base) beneath the agent.

​
Example: minimal InvokeAgent payload

Below is a conceptual example of an InvokeAgent request payload. Use this only as a high-level guide — exact SDK or HTTP formats depend on the Bedrock client you use.
The runtime receives this request, the agent decides whether to call orders-api.getOrder, parse the result, and potentially call orders-api.updateOrder before returning the final output.

​
Summary — key takeaways

  • Foundation models are excellent at generation but do not inherently perform external actions.
  • Bedrock Agents combine a foundation model, instructions, and action groups into a managed agent runtime that autonomously plans and executes multi-step tasks.
  • Applications should call the Bedrock Agent Runtime with InvokeAgent — the agent handles orchestration, tool calls, and iterative reasoning.
  • This approach shifts integration complexity out of your application code and into a managed agent runtime, simplifying maintenance and scaling of multi-tool workflows.
We will next explore how to configure action groups and actions for an agent, and walk through concrete example invocations using the InvokeAgent API.

Watch Video