> ## Documentation Index
> Fetch the complete documentation index at: https://notes.kodekloud.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Bedrock AgentCore Introduction Part 2
> Guide comparing Amazon Bedrock AgentCore and Bedrock Agents for building complex AIOps orchestration, workflow mapping, architecture, and decision criteria
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.
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](https://learn.kodekloud.com/user/courses/mcp-for-beginners)): AgentCore is designed for strong, extensible support.
Quick decision guide
1. Are we doing only model inference?
* Yes → Use the `InvokeModel` and `Converse` methods of the [Bedrock SDK / Runtime](https://docs.aws.amazon.com/bedrock/latest/devguide/).
2. No → Are we doing managed orchestration with minimal custom logic?
* Yes → Bedrock Agents are an ideal fit.
3. No → Do we need custom logic, advanced tools, explicit memory management, or complex routing?
* Yes → AgentCore is the right platform.
4. 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](https://aws.amazon.com/api-gateway/) and [AWS Lambda](https://aws.amazon.com/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):
```python theme={null}
# 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
* [Bedrock SDK / Runtime documentation](https://docs.aws.amazon.com/bedrock/latest/devguide/)
* [Amazon API Gateway](https://aws.amazon.com/api-gateway/)
* [AWS Lambda](https://aws.amazon.com/lambda/)
* [MCP For Beginners](https://learn.kodekloud.com/user/courses/mcp-for-beginners)
This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.