Bedrock AgentCore Introduction Part 3

When you design an AgentCore workflow, you coordinate foundation models, integrated tools (APIs, databases, enterprise systems), memory/state, and orchestration logic to meet your AI application’s goals. AgentCore is intended for agentic architectures that require explicit control over which models and tools run, how context is managed, and how multi-step flows are orchestrated. Key responsibilities inside an AgentCore workflow:

Select foundation models for specific tasks (a core differentiator for agentic systems).
Choose and expose tools, external APIs, and enterprise services.
Store and retrieve conversational or workflow context, controlling the context size passed into each model.
Maintain multi-step orchestration logic for sequential or iterative execution.
Define routing rules to determine which models or tools handle particular requests.

A presentation slide titled "Workflow: What Is an AgentCore Workflow?" describing how an AgentCore coordinates models, tools, memory, workflow logic, and routing rules. The slide shows five labeled cards with icons explaining each component's role in supporting advanced AI applications.

Overview: simple sequential example Below is an intentionally minimal, sequential example using the AgentCore runtime. It shows how a client invokes a workflow, how the workflow fetches data from tools, and how it calls a Bedrock model. Real-world agentic systems commonly use conditional logic, iterative loops, or multiple model calls; this example focuses on the basic flow so you can see the runtime pattern clearly.

from bedrock_agentcore.runtime import BedrockAgentCoreApp

app = BedrockAgentCoreApp()

@app.entrypoint
def operations_assistant(request):
    # Extract the user's prompt from the incoming request
    user_input = request["prompt"]

    # Tool calls / data fetches (these functions would be defined elsewhere
    # and exposed to the AgentCore runtime)
    tickets = get_open_incident_tickets()
    sales = get_sales_metrics()

    # Call a Bedrock model with the assembled context
    response = call_bedrock_model(
        prompt=f"""
        User request: {user_input}

        Open tickets:
        {tickets}

        Sales metrics:
        {sales}

        Summarize today's operational issues.
        """
    )

    # Return the model response back to the calling application
    return {"response": response}

Practical notes on the example

This code is intended to run on the AgentCore serverless platform.
The functions get_open_incident_tickets, get_sales_metrics, and call_bedrock_model are examples of tools/integrations you implement and register with the AgentCore runtime.
Orchestration code controls when and how tools and models are invoked. You can orchestrate:
- Single- or multi-model flows
- Conditional tool calls
- Iterative loops to converge on a result
- Multi-agent interactions

AgentCore components and use cases

Component	Responsibility	Example
Models	Choose which foundation model(s) run for each task	`call_bedrock_model(prompt, model="my-bedrock-model")`
Tools	External APIs, databases, and enterprise services used by the workflow	`get_open_incident_tickets()`
Memory & state	Store conversational context, session state, or intermediate data	`store_memory(user_id, summary)`
Orchestration logic	Define sequencing, conditional branches, retries, and error handling	Application code that calls tools and models in order
Routing rules	Decide which model/tool handles a request based on rules or context	`if request['type']=='billing': use_billing_tool()`

You explicitly define what resources the orchestration can use:

What tools and resources are available.
How those tools are exposed and what interfaces they present.
Any constraints, guardrails, or workflow boundaries the agent must follow.
Sequencing rules that order steps where applicable.

A dark-themed presentation slide titled "Workflow: What the Orchestration Code Defines" showing four labeled panels: "Available Tools and Resources," "How They Are Exposed," "Constraints and Workflow Boundaries," and "Sequencing Rules." Each panel briefly describes aspects of what an orchestration agent can use, see, and must follow.

Should orchestration be predefined or dynamic? You can choose whether orchestration is:

Predefined: the serverless workflow logic controls the exact sequence and tool usage (deterministic).
Dynamic: the model/agent decides at runtime which tools to use, when to call them, and whether to iterate.

Questions the agent may decide at runtime:

Should a tool be used at all?
Which tool should be chosen?
How often and in what order should tools be invoked?
Should the agent retrieve additional data, ask clarifying questions, or iterate with another model call?

These decisions are made when the foundation model has access to the relevant tools and context required to achieve the outcome.

A presentation slide titled "Workflow: What the Model/Agent Decides" showing five numbered panels that list decisions: whether to use a tool, which tool to use, how often to use it, in what order, and whether to retrieve more. The slide has a dark blue background with orange-accented headers.

What you can achieve with Amazon Bedrock AgentCore

Build advanced, flexible AI systems beyond SDK-only or basic agent patterns.
Integrate enterprise tools and services that expose nonstandard interfaces.
Author multi-step, multi-agent processes and iterative loops (for example, while-type loops to converge on a goal).
Maintain a modular, extensible architecture that makes adding new tools and behaviors straightforward by updating serverless workflow code.

When to choose AgentCore

Start with Bedrock Agents for simpler agentic tasks. Choose AgentCore when you need deeper orchestration control, multi-tool coordination, tighter guardrails, or custom sequencing that requires serverless workflow logic and explicit resource management.

Summary AgentCore provides the building blocks—models, tools, memory, and workflow logic—that you wire together in code. You control orchestration and sequencing rules: either predefine the flow or give the agent decision-making privileges. AgentCore is the right choice when you need flexibility, control, and extensibility for agentic AI architectures. Further reading and references

This concludes the introduction to Amazon Bedrock AgentCore. The course finishes with a final lesson that presents a capstone lab project.

Introduction to Gen AI and LLMs

Introduction to Amazon Bedrock

Getting Started With Amazon Bedrock

Foundation Models in Amazon Bedrock

Basic Concepts of Prompt Engineering

Introduction to Text Generation With Amazon Bedrock

How Foundation Models Process Input

Extract Insights Using Prompt Engineering

Working With Different Task Types

Integrating Amazon Bedrock With Other AWS Services

Build a Marketing Email Generation Application

Introduction to Retrieval Augmentation With Bedrock Knowledge Bases

Best Practices and Optimization

Governance, Safety in Responsible AI

Security

Monitoring and Logging

Taking action with Bedrock Agents

Advanced Topics (Optional)

Final Project

Wrap Up

Bedrock AgentCore Introduction Part 3

Watch Video