Bedrock AgentCore Introduction Part 2

Let’s walk through a design decision for building an AIOps system and why Amazon Bedrock AgentCore is often the right choice for complex orchestration. The application needs to:

Query internal systems
Coordinate multiple workflows and agents
Use external tooling and APIs
Route across different sub-agents
Persist memory and maintain state across model calls
Support approval and retry logic flows

When an application requires the above capabilities, building it with a single Bedrock Agent is unlikely to succeed — Agents excel at simpler interaction patterns but lack the execution control and flexibility required for complex orchestrations. Amazon Bedrock AgentCore, on the other hand, is designed specifically for that level of complexity.

A slide titled "Workflow: Design Decision Example" showing a "Use Case" panel for an "AI Ops Assistant" on the left and a grid of "Application Requirements" tiles on the right. The requirements list includes querying internal systems, coordinating workflows, using external tools/APIs, routing across agents, persistent memory, and approval/retry flows.

How to map application requirements to Bedrock Agents vs AgentCore

Simple conversational workflows: Bedrock Agents are an excellent fit. AgentCore can handle them too, but it is usually more than required.
Basic tool invocation (one or two tools): Bedrock Agents provide moderate support through action groups and Lambda integrations; AgentCore can also do this but may be overkill for trivial cases.
Multi-step orchestration: AgentCore is the stronger fit. It supports complex sequencing, switching between sub-agents (for example, a reasoning agent followed by a lower-latency agent for iterative work), and fine-grained orchestration.
Long-running workflows: AgentCore is a serverless platform built for long-running, managed workflows — Agents are limited here.
Complex routing and execution control: AgentCore allows complete autonomy to implement routing logic, model selection, and tool invocation rules.
Integration with broad external ecosystems and modular architectures (MCP-style — see MCP For Beginners): AgentCore is designed for strong, extensible support.

A comparison table titled "Workflow: Agents vs AgentCore" that lists application requirements (like simple conversational workflows, tool invocation, multi-step orchestration, long-running workflows, etc.) and rates how well "Bedrock Agents" and "Bedrock AgentCore" support each (labels such as "Excellent fit," "Moderate support," "Strong support," and "Limited"). The slide uses blue and gray rating bars to show which option is better suited for each requirement.

Quick decision guide

Are we doing only model inference?
- Yes → Use the InvokeModel and Converse methods of the Bedrock SDK / Runtime.
No → Are we doing managed orchestration with minimal custom logic?
- Yes → Bedrock Agents are an ideal fit.
No → Do we need custom logic, advanced tools, explicit memory management, or complex routing?
- Yes → AgentCore is the right platform.
Do you need a cross-platform open standard (MCP-style)?
- AgentCore can support an MCP architecture; otherwise default to Bedrock Agents for simpler orchestration.

Table of recommendations

Use case	Recommended approach	Notes
Single-turn model inference	`Bedrock Runtime` (`InvokeModel`/`Converse`)	Simple, low-latency calls to models
Conversational flows with limited tools	Bedrock Agents	Use action groups and Lambda integrations
Multi-step, conditional workflows	AgentCore	Supports sequencing, sub-agents, memory and retries
Long-running or stateful processes	AgentCore	Serverless orchestration designed for managed workflows
Integration-heavy architectures (external APIs, complex routing)	AgentCore	Fine-grained execution control and extensibility

If your application requires custom orchestration, persistent state, complex routing between sub-agents, or long-running workflows, AgentCore is usually the better choice. For simple conversational or single-tool tasks, Bedrock Agents are typically sufficient and simpler to adopt.

Architecture overview — AgentCore in an application landscape

Front end / API layer: Your application handles authentication, user interaction, and front-end workflows (for example, using Amazon API Gateway and AWS Lambda).
AgentCore endpoint: AgentCore is a serverless platform exposed as an API endpoint within Amazon Bedrock. Your application calls AgentCore to invoke named workflows.
Inside AgentCore: Workflows orchestrate model calls, sub-agents, tool invocations, memory and context management, external API calls, and any business logic you implement.

This separation keeps UI and authentication concerns in your application while allowing AgentCore to manage orchestration, tool usage, state, and sub-agent coordination. Example: invoking a named workflow from your application

The client in your app calls AgentCore’s SDK endpoint and requests a specific workflow (for example, operations-assistant) with the user’s input.
AgentCore runs the workflow you defined, performs any required queries or tool calls, manages memory/context, and returns the consolidated result.

Example Python snippet showing a conceptual invocation (replace with the actual Bedrock AgentCore SDK usage in your environment):

# User request arrives from application
user_request = "Summarize today's sales issues"

# Application sends request to AgentCore workflow
# (agentcore_client represents the SDK client configured for the AgentCore endpoint)
response = agentcore_client.run_workflow(
    workflow="operations-assistant",
    input=user_request
)

print(response)

Notes on this flow

The workflow parameter is the name of a workflow deployed in Amazon Bedrock AgentCore (here: operations-assistant).
The input contains the user’s request; your workflow can accept structured JSON or a simple text string depending on design choices.
AgentCore is a distinct endpoint/API from Bedrock Agents and Bedrock Runtime; configure the appropriate client and endpoint for AgentCore calls.

Request flow summary

User → Your application (API/Gateway/Lambda) → AgentCore workflow endpoint.
AgentCore coordinates the workflow: it may query databases, fetch incident tickets, call foundation models (possibly multiple models), invoke external tools/APIs, manage memory/context, and return a consolidated response to your application.
The internal implementation of the workflow (tool choices, routing, sub-agents, memory policies, retries, approvals) is under your control.

AgentCore enables powerful orchestration but adds operational complexity. Evaluate trade-offs such as development effort, observability, and potential cost before migrating simple workloads away from Bedrock Agents or direct model invocation.

Conclusion Amazon Bedrock AgentCore provides a serverless, managed platform to express and run complex orchestration patterns—routing across sub-agents, persisting memory, invoking external tools, and managing long-running workflows—while letting your application remain focused on UI, authentication, and business-level concerns. Links and references

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 2

Watch Video