ZICQ
中 Log in / Sign up
Newsroom Agentic #Amazon Bedrock AgentCore #Strands Harness #Agent Governance #Context Management #Lifecycle Hooks

Amazon Bedrock AgentCore Harness Adds Strands Defaults and Deterministic Lifecycle Hooks

Avatar of Mr.Xu

By Mr.Xu Compiled & Reviewed by Editorial

Published:

中文阅读 (Chinese) English Version
Co-reading Select any sentence in the article to highlight, annotate, or copy a quote card. Join discussion ↓

Summary:Amazon Bedrock AgentCore harness has adopted the open-source Strands harness as its managed agent foundation. Existing and new harnesses automatically receive an evolving recommended model, task-oriented system instructions, prompt caching, proactive summarization, context offloading, and built-in tools for planning, web retrieval, granular file access, and subagent delegation. The more consequential change is deterministic lifecycle governance. AWS Lambda can synchronously allow or deny invoca


Amazon Web Services has moved Amazon Bedrock AgentCore harness onto the open-source Strands harness foundation and begun rolling the experience out to both new and existing harnesses as of November 11, 2026. No resource migration, new integration, or agent-loop rebuild is required. The upgrade changes four important layers: model and prompt defaults, context management, tool execution, and deterministic governance.

Upgrade boundary: no migration, but mutable defaults

| Setting | When omitted | When configured explicitly | | --- | --- | --- | | Model | Uses the current AgentCore-recommended model and evolves with new releases | A fixed model ID takes precedence | | System prompt | Uses the managed task-oriented instructions | systemPrompt replaces the managed prompt entirely | | Context policy | Automatically summarizes older turns after reaching a threshold | truncation selects a fixed policy | | Tool surface | Receives the current recommended tools when omitted or configured with a wildcard | An explicit allowedTools list fixes the capability boundary |

This lowers the effort required to establish a production agent, but it also changes determinism. Applications that omit configuration may receive a different model, prompt, or tool set as AWS updates its defaults. Security-sensitive deployments should not rely on an expanding wildcard tool set; they should enumerate every capability they intend to expose.

Runtime architecture: Strands supplies the loop, AgentCore operates it

Strands provides the assembled agent foundation, including instructions, tools, and context management. AgentCore runs that foundation as a managed AWS service. At a practical level, requests enter the AgentCore control plane, are assigned to kernel-isolated microVM sessions, and execute a Strands agent loop that calls Amazon Bedrock Converse, managed tools, and delegated workers.

The managed layer connects session persistence, streaming responses, usage metadata, observability, AgentCore Memory, Identity, Gateway, Browser, Code Interpreter, and customer-provided containers. Teams no longer need to host the agent loop, operate session scaling, or maintain tool-execution infrastructure, while retaining control over models, instructions, tools, permissions, and lifecycle policies. Kernel isolation strengthens the execution boundary, but this update does not quantify isolation startup overhead, cold-start latency, or resource consumption under sustained load.

Context management: lower token usage is not the same as lower latency

The managed defaults combine prompt caching, proactive summarization, and context offloading. Caching initially targets Anthropic models on Amazon Bedrock, with the system prompt, tool definitions, and conversation history serving as a reusable prefix that can qualify for lower-priced cache-read tokens. This is most effective when an application repeatedly invokes the same harness with a stable tool surface. Changes to the prefix or tool definitions can reduce cache reuse, so enabling the feature does not imply a fixed cost reduction.

Proactive summarization compresses older turns after a configurable threshold while preserving recent messages. The todo_write tool stores a structured task plan within the session, allowing that plan to survive summarization and later invocations. Context offloading removes large tool results from the immediate model context, supplies a preview, and lets the agent retrieve the full result when needed.

An effective input can be viewed as a combination of cached prefix, uncached history, tool definitions, tool output, and any retrieved offloaded content. Summarization and offloading reduce resident context and repeated transfer volume, but they can add retrieval calls, model turns, and state-reconstruction latency. Amounts, object identifiers, and authorization scopes should not be treated as facts preserved reliably by a summary; critical state still belongs in a database or a purpose-built state store.

Built-in tools and delegation: broader capability, broader permission surface

The recommended tool set now includes todo_write for planning, subagent for delegation, web_fetch for web retrieval, and separate read, write, and edit operations for granular filesystem access. Splitting filesystem operations makes it possible to grant read-only or write-only capabilities instead of exposing an unrestricted shell or filesystem interface.

The subagent tool sends a self-contained task to a fresh worker and returns the result to the parent agent. The worker remains internal to the invocation rather than becoming a separately managed harness resource, but it shares invocation limits and tool-call lifecycle hooks. Delegation can reduce context contamination in the parent loop, yet it adds model calls, data transfer, and failure-handling overhead. In a research, synthesis, and review pipeline, these stages are commonly serialized, so end-to-end latency grows with the number of stages.

Customer-provided MCP servers, AgentCore Gateway, Browser, Code Interpreter, inline functions, skills, memory, and customer containers continue to work through existing interfaces. The expanded tool surface nevertheless increases the possible combinations for prompt injection, data exfiltration, and privilege escalation. When read and web_fetch are both enabled, file boundaries, network egress, and argument-level controls should be enforced outside the model prompt.

Four lifecycle hooks: deterministic gates between models and side effects

| Lifecycle event | When it runs | Effect of a Lambda denial | | --- | --- | --- | | before_invocation | Before the agent processes the request | Stops the invocation with hook_stopped | | before_tool_call | After the model proposes a tool call but before execution | Skips the tool call and continues the loop | | after_tool_call | After a tool result exists | Retains the result and stops before further inference | | after_invocation | After the invocation completes | Reports the decision, but streamed output cannot be retracted |

Only Lambda hooks can alter the agent loop. Lambda runs synchronously and returns an allow or deny decision with an optional reason. SNS and EventBridge targets are notifications for auditing, alerting, or asynchronous workflows and cannot block execution. Hooks are configured through CreateHarness or UpdateHarness. If Lambda times out or fails, the configured failureMode applies, with denial as the default.

Tool-level hooks are inherited by subagents, so delegated refunds, file writes, or network requests still pass through the same policy. Invocation-level hooks run once for the entire invocation. This closes a common delegation-bypass path, but denying before_tool_call leaves the loop running, allowing the model to choose another tool. Business authorization should therefore be enforced again inside the tool service rather than relying exclusively on the agent-side policy.

Hooks do not make the entire agent deterministic; model inference remains stochastic. Their value is the ability to run deterministic code at defined lifecycle checkpoints. For refunds, deletions, or payments, before_tool_call is the critical pre-execution gate. after_invocation is better suited to auditing because content already streamed to the client cannot be genuinely retracted.

Engineering trade-offs: the 34% token claim needs independent validation

AWS cites a Strands study claiming that managed context management can reduce token usage by about 34% compared with other leading harnesses. The post does not disclose the task set, model combinations, cache-hit rate, summary ratio, end-to-end latency, or variance. The figure is best treated as a hypothesis to reproduce rather than a universal saving. Highly repetitive workloads with stable prefixes may gain substantially from caching, while short tasks, large tool outputs, or multi-stage delegation can offset some token savings with retrieval and additional inference turns.

The CLI research-coordinator example runs a researcher, synthesizer, and reviewer, permits one revision cycle, and takes approximately 10 to 15 minutes. This architecture favors long-running autonomous work rather than optimizing a single low-latency turn.

Production rollout checklist

  1. Pin the model ID, system prompt, truncation policy, and tool allowlist for applications that require stable behavior.
  2. Review file reads, file writes, shell access, web retrieval, and MCP tools individually, then constrain network egress and accessible paths.
  3. Use a low-timeout Lambda at before_tool_call for amount, permission, and argument validation, while retaining independent authorization and idempotency controls in the tool service.
  4. Record tool calls and denial reasons through EventBridge or SNS; these notifications support auditing but do not replace synchronous blocking.
  5. Evaluate prompt-cache savings, post-summary fact fidelity, offloaded-content retrieval latency, and total multi-agent cost as separate metrics.
  6. Test hook inheritance in subagents, fail-closed behavior after Lambda timeouts, and whether notification failures affect the main loop.
  7. Monitor cache-read tokens, context length, tool latency, hook latency, and denial rates through AgentCore usage metadata and observability rather than watching only output quality.
  8. A temporary execution role created by the CLI remains in the AWS account after harness deletion and should be removed from IAM when no longer needed.

Source: AWS Machine Learning Blog (2026-11-19)

— END —

Tags: #Amazon Bedrock AgentCore #Strands Harness #Agent Governance #Context Management #Lifecycle Hooks

Editorial & Fact-Checking Note: This article is compiled from primary research, official release documentation, and source papers by the ZICQ Newsroom pipeline with automated entity verification and human editorial review. If you notice any technical inaccuracy, please submit a correction via our corrections policy or email our editorial desk directly.

What's your take on this story?
🚀 Explore & Submit Works

Community Comments

Loading live comments and annotations…