What's New

AWS Step Functions now integrates with the Amazon Bedrock AgentCore managed harness (currently in preview), enabling developers to embed AI agent reasoning steps directly into visual workflows. This integration allows teams to declare an agent via configuration—specifying the model, tools, and behavior—while AgentCore handles the full agent loop execution, including compute, memory, tooling, and observability. The result is a seamless way to combine deterministic workflow orchestration with dynamic, multi-turn AI reasoning without building custom agent infrastructure.

How It Works

• AgentCore Harness as a Task State: In Workflow Studio, developers search for the AgentCore InvokeHarness state, drag it into the workflow, and either select an existing harness ARN or use "Quick Create Harness" to provision one on the spot.
• Declarative Agent Configuration: The harness is defined through configuration (model, tools, system prompt, behavior) rather than code; AgentCore provisions the managed microVM environment, networking, memory, and observability automatically.
• Per-Invocation Overrides: Each Task state can override harness defaults—such as the model ID, system prompt, or available tools—allowing the same harness to behave differently at different workflow decision points without duplicating configurations.
• Session Persistence: A session ID can be passed to persist agent context (short-term and long-term memory, filesystem state) across multiple invocations, either within a single workflow execution or across separate executions.
• Response Transformation: The integration returns a Converse-shaped JSON structure containing only the final assistant message and aggregated token usage metrics (InputTokens, OutputTokens, TotalTokens); intermediate turns and tool-use blocks are omitted from the output.
• Observability via CloudWatch: The Step Functions execution history records agent input, output, token usage, and duration, with a direct CloudWatch link for turn-by-turn trace details via CloudWatch Transaction Search.
• Integration Pattern: Only the Request-Response pattern is supported; the maximum Task state execution time is 15 minutes (900 seconds), after which Step Functions times out even if the harness is still running.
• Parallel and Sequential Execution: Multiple AgentCore harness steps can be composed in parallel branches or sequential chains within a single state machine, enabling complex multi-agent workflows.

Why It's Important

• Eliminates Agent Infrastructure Plumbing: Teams no longer need to build and maintain the orchestration loop, compute environment, tool wiring, memory management, and authentication for each agent—AgentCore handles all of it, reducing days of setup to a configuration change.
• Bridges Deterministic and AI-Driven Logic: Step Functions' reliable, auditable workflow engine can now incorporate non-deterministic AI reasoning steps, enabling hybrid workflows that combine rule-based automation with adaptive agent decision-making.
• Enterprise-Grade Auditability: Every agent decision is traceable through Step Functions execution history and CloudWatch turn-by-turn logs, which is critical for compliance, debugging, and governance in production environments.
• Human-in-the-Loop for High-Stakes Actions: Built-in Step Functions human approval steps can gate critical agent-driven actions, providing a safety mechanism before consequential operations are executed.
• Reusability and Flexibility: A single harness configuration can be reused across multiple workflows with per-invocation overrides, reducing duplication and making it easier to maintain consistent agent behavior at scale.
• Accelerates Agentic Use Cases: Common enterprise tasks like document classification, unstructured form extraction, and multi-step data enrichment can now be automated end-to-end within existing workflow infrastructure.

How It's Different

• Managed vs. DIY Agent Loop: Unlike custom Lambda-based agent implementations where developers must write and maintain the model-call/tool-invoke loop, AgentCore manages the entire agent loop in a secure, isolated microVM—no orchestration code required.
• Configuration Over Code: Traditional Step Functions integrations with Bedrock (e.g., InvokeModel) require developers to handle multi-turn logic, tool routing, and context management in custom code; the AgentCore harness replaces all of that with a declarative config.
• Stateful Sessions Across Executions: Unlike stateless Lambda invocations or basic Bedrock model calls, AgentCore harness sessions maintain persistent memory and filesystem state across invocations, even spanning multiple Step Functions executions via a shared session ID.
• Multi-Provider Model Flexibility: The AgentCore harness supports models from Amazon Bedrock, OpenAI, and Google Gemini, and can switch providers mid-session—broader than a direct Bedrock InvokeModel call which is limited to Bedrock-hosted models.
• Integrated Observability Without Extra Instrumentation: Turn-by-turn agent traces are automatically captured and linked from the Step Functions console, whereas custom agent implementations require manual logging and tracing setup.
• No Additional Integration Charges: Standard Step Functions pricing applies with no surcharge for the AgentCore integration itself, unlike some third-party agentic orchestration platforms that charge for orchestration overhead.

When to Prefer It

• Document Processing Pipelines: Use this integration when a workflow needs to classify documents, extract fields from unstructured forms, or summarize content as one step in a larger automated pipeline (e.g., invoice processing, contract review).
• Multi-Agent Decision Workflows: When a business process requires different specialized agents at different decision points—such as a triage agent followed by a resolution agent—use parallel or sequential harness steps within a single state machine.
• Regulated or Auditable Processes: When compliance requirements demand a full audit trail of every AI decision, the combination of Step Functions execution history and CloudWatch turn-level traces provides the necessary evidence without custom logging.
• Human-Gated AI Actions: When an AI agent's output must be reviewed by a human before triggering a consequential downstream action (e.g., sending a financial transaction or modifying infrastructure), pair the harness step with a Step Functions wait-for-approval state.
• Iterative Agent Tasks with Context Continuity: When an agent needs to maintain context across multiple workflow invocations—such as a multi-day research task or a stateful customer interaction—use session IDs to persist memory across executions.
• Rapid Prototyping of Agentic Workflows: When a team wants to experiment with different models or tool configurations without rewriting code, the per-invocation override capability and Quick Create Harness in Workflow Studio enable fast iteration.
• Replacing Custom Lambda Orchestration: When existing workflows use complex Lambda functions to manage Bedrock multi-turn conversations, migrating to the AgentCore harness step reduces code maintenance and improves reliability.

Availability

• Preview Status: The AgentCore harness integration is currently in public preview; it is not yet generally available (GA).
• Supported Regions: Available in US East (N. Virginia), US West (Oregon), Europe (Frankfurt), and Asia Pacific (Sydney)—the same regions where the AgentCore harness preview is active.
• Step Functions Pricing: Standard AWS Step Functions pricing applies for workflow execution (state transitions); there are no additional charges for the AgentCore integration itself.
• Bedrock and AgentCore Pricing: Standard Amazon Bedrock pricing applies for model inference; standard AgentCore pricing applies for associated resources (compute, memory, tooling); there is no separate harness charge.
• Integration Pattern Limitation: Only the Request-Response pattern is supported; Run a Job (.sync) and Wait for a Callback with Task Token patterns are not available.
• Execution Time Limit: The InvokeHarness Task state has a hard maximum execution time of 15 minutes (900 seconds), regardless of the TimeoutSeconds value set; users should configure harness timeouts accordingly to avoid unexpected costs.
• Output Constraints: Only the final assistant message is returned; intermediate turns, tool-use blocks, and reasoning blocks are omitted. Output size is subject to the standard Step Functions Task state output limit.

Related Resources

• https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/harness.html
• https://docs.aws.amazon.com/step-functions/latest/dg/connect-bedrockagentcore.html