---
title: AgentCore Harness + Strands 1.0: What Actually Ships in August 2026
description: Harness GA Jun 17, 2026 plus Strands 1.0 primitives, and why AWS Context is still Coming soon. Reuse the ~180→95 ms Gateway canary; ship Managed KB today.
url: https://www.joinhorizon.co/blog/production-ai-agents-aws-agentcore-harness-strands-2026/
datePublished: 2026-08-09T00:00:00.000Z
dateModified: 2026-10-28T00:00:00.000Z
author: palaniappan-p
category: AI Agents
tags: bedrock-agentcore, strands, amazon-bedrock, ai-agents, multi-agent, mcp
---

# AgentCore Harness + Strands 1.0: What Actually Ships in August 2026

> Harness GA Jun 17, 2026 plus Strands 1.0 primitives, and why AWS Context is still Coming soon. Reuse the ~180→95 ms Gateway canary; ship Managed KB today.

> **AWS lifecycle notice (June 30, 2026):** Amazon Bedrock Agents Classic is in maintenance for new customers after **July 30, 2026**. Net-new agent builds should use [Bedrock AgentCore](https://www.joinhorizon.co/blog/amazon-bedrock-agentcore-production/). Full matrix: [lifecycle roundup](https://www.joinhorizon.co/blog/aws-service-lifecycle-updates-june-2026/).

**On June 17, 2026**, AgentCore **Harness** reached general availability: create an agent with configuration, invoke it with a streaming API, and stop hand-rolling session stores and tool routers for the default path ([What's New](https://aws.amazon.com/about-aws/whats-new/2026/06/amazon-bedrock-agentcore-harness-generally-available/), [Harness get started](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/harness-get-started.html)). The same Summit week shipped **Managed Knowledge Base** GA and Web Search on Gateway. **Strands Agents 1.0** already gave AWS-endorsed multi-agent primitives (Agents-as-Tools, Graph, Swarm, Workflow) plus A2A.

This post is the August 2026 ship map: what is GA, what is still Coming soon, when to stay on Harness, when to export to Strands, and which comparison tables to use on Monday. Unlike Summit marketing posts, it does not blur AWS Context into “available today.”

> **First-party signals we reuse (not new client outcomes):** Gateway server-side tools cut median tool round-trip **~180 ms → ~95 ms** on a **B2B CRM assistant** (12 tools, ~8k turns/day), per the [Gateway post](https://www.joinhorizon.co/blog/amazon-bedrock-agentcore-gateway-server-side-tool-execution-2026/). Platform TCO silhouette: support-style AgentCore at **50K sessions/mo ~$791/mo** platform + model ([decision guide](https://www.joinhorizon.co/blog/aws-bedrock-agentcore-vs-amazon-q-enterprise-decision-guide-2026/)). Model your mix on the [AgentCore pricing calculator](https://www.joinhorizon.co/tools/amazon-bedrock-agentcore-pricing-calculator/).

> **Reproduce this:** Clone the artifacts under [`examples/architecture-blog-2026/agentcore-harness-strands-1-0/`](https://www.joinhorizon.co/examples/architecture-blog-2026/agentcore-harness-strands-1-0/README.md). `python3 -m py_compile create_harness_stub.py strands_agents_as_tools_stub.py` syntax-checks the stubs. Ship gates live in [`monday-checklist.md`](https://www.joinhorizon.co/examples/architecture-blog-2026/agentcore-harness-strands-1-0/monday-checklist.md).

## Converse, Runtime, and Harness compared

| Layer                 | What it is                                     | You own                                         | AWS owns                                                       |
| --------------------- | ---------------------------------------------- | ----------------------------------------------- | -------------------------------------------------------------- |
| **Bedrock Converse**  | Managed model API                              | Prompts, tool schemas you pass in               | Models, IAM/KMS/CloudTrail on the API                          |
| **AgentCore Runtime** | Firecracker microVM host for custom agent code | Container/CodeZip, loop (Strands, LangGraph, …) | Isolation, session lifecycle, platform telemetry hooks         |
| **AgentCore Harness** | Config-driven managed loop **on** Runtime      | Model, instructions, tools, memory config       | Orchestration loop, streaming, default memory, export scaffold |

**Opinionated take:** treat Harness as the paved road for the first production agent. Treat Runtime + Strands as the paved road once topology, hop caps, or A2A show up. Treat DIY LangGraph on ECS as a keep-existing-investment path, not the greenfield default in August 2026.

## Two API calls: CreateHarness + InvokeHarness

Assumes Python 3.12+, `boto3` ≥ 1.38.0, an IAM execution role, and a [supported region](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/agentcore-regions.html). Default model when omitted: Anthropic Claude Sonnet 4.6 on Bedrock (per AWS get-started docs; pin what your account allows).

```bash
# CLI path (Node 20+)
npm install -g @aws/agentcore
agentcore create --name ops-assistant --model-provider bedrock
agentcore deploy
agentcore invoke --harness ops-assistant --session-id "$(uuidgen)" \
  "How do we handle an ECS service stuck in DRAINING?"
```

```python
# Control plane + data plane sketch — see create_harness_stub.py in the artifact folder
# boto3 >= 1.38.0; runtimeSessionId must be at least 33 characters
import boto3, uuid

control = boto3.client("bedrock-agentcore-control", region_name="us-west-2")
created = control.create_harness(
    harnessName="ops-assistant",
    executionRoleArn="arn:aws:iam::123456789012:role/HarnessExecutionRole",
)
# Poll get_harness until status == READY, then:

client = boto3.client("bedrock-agentcore", region_name="us-west-2")
response = client.invoke_harness(
    harnessArn=created["arn"],  # use the ARN from get_harness
    runtimeSessionId=str(uuid.uuid4()),
    messages=[{"role": "user", "content": [{"text": "Summarize the DRAINING runbook."}]}],
)
for event in response["stream"]:
    if "contentBlockDelta" in event:
        delta = event["contentBlockDelta"].get("delta", {})
        if "text" in delta:
            print(delta["text"], end="")
```

Stream events follow the Converse-shaped sequence (`messageStart` → `contentBlock*` → `messageStop`). Spans land under AgentCore / CloudWatch without a custom APM shim. Still build dashboards before you need them in an incident.

Mid-session **provider switching** (when enabled for your harness/providers) preserves conversation state by rebuilding history into the target provider’s message format. Use it for cost or capability shifts mid-thread, not as an excuse to skip evals when the model family changes.

## Harness vs Runtime vs DIY: how to pick

Full matrix: [`harness-vs-runtime-vs-strands.md`](https://www.joinhorizon.co/examples/architecture-blog-2026/agentcore-harness-strands-1-0/harness-vs-runtime-vs-strands.md).

| Dimension   | Harness                   | Runtime + Strands       | DIY LangGraph / CrewAI                |
| ----------- | ------------------------- | ----------------------- | ------------------------------------- |
| Ownership   | Config                    | Your code + AWS host    | Your loop + usually your host packing |
| Multi-agent | Export when needed        | Native primitives + A2A | Bring your own supervisor             |
| First agent | Minutes                   | Hours to days             | Days to weeks                           |
| When NOT to | Hard DAG / multi-team A2A | Thin FAQ Harness covers | Greenfield with no existing graph     |

> **What broke:** Week of a support-bot pilot (pre-Harness-export discipline). Team enabled Browser on the default tool set “for research.” Conversational turns that only needed CRM Gateway tools still spun Browser sessions. Platform compute tracked roughly **3×** the prior Runtime-shaped baseline until Browser was gated per intent. Detection: CloudWatch tool mix + AgentCore cost lines; fix: default Browser off, Policy on write tools, golden evals that fail if Browser fires on status-only intents.

## Graduating from Harness by exporting to Strands

![Architecture diagram of an AgentCore Harness configuration exported to Strands code on AgentCore Runtime](../../assets/images/blog/production-ai-agents-aws-agentcore-harness-strands-2026-export.webp)

_Figure: graduation in the article. When the topology needs code, export the Harness to Strands and host it on Runtime. Memory, Gateway, and Identity are reused rather than rebuilt. The full request path is the AgentCore production article. The checklist files under the other harness folder were left alone. [Open the draw.io source](https://www.joinhorizon.co/examples/architecture-blog-2026/production-ai-agents-aws-agentcore-harness-strands-2026/export.drawio)._

When configuration cannot express the topology, export Harness to **Strands-based Python** and host on AgentCore Runtime (or elsewhere). AWS positions this as config-to-code translation that reuses the same Memory, Gateway, Identity, and observability primitives. Claude Agent SDK export is on the roadmap; Strands is the supported target today ([export docs](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/harness-export.html)).

**Opinionated take:** export early if you already know you need Graph edges or Agents-as-Tools hop caps. Stay on Harness if you are still discovering tools and prompts; exporting every day is thrash.

## Strands 1.0 primitives compared

Names below match [Strands multi-agent docs](https://strandsagents.com/docs/user-guide/concepts/multi-agent/multi-agent-patterns/) (Agents-as-Tools, Graph, Swarm, Workflow). Third-party posts sometimes invent `PipelineAgent` class names. Prefer the SDK names in code reviews.

| Primitive           | Shape                                   | Determinism | Best for                                                        | When NOT to                        |
| ------------------- | --------------------------------------- | ----------- | --------------------------------------------------------------- | ---------------------------------- |
| **Agents-as-Tools** | Orchestrator calls specialists as tools | Medium      | Hierarchical supervisors; expensive planner + cheap specialists | Fixed audit step order             |
| **Graph**           | DAG/cyclic nodes via `GraphBuilder`     | High        | Compliance, review, nested Swarm-in-Graph                       | Open-ended brainstorming           |
| **Swarm**           | Peer handoffs + shared memory           | Low to medium | Exploration, peer review                                        | Unbounded handoffs; ungated writes |
| **Workflow**        | Code-defined sequential/parallel tasks  | Highest     | Validation chains, batch transforms                             | Free-form chat routing             |

```python
# strands-agents >= 1.x — Agents-as-Tools (see strands_agents_as_tools_stub.py)
from strands import Agent

runbook_agent = Agent(system_prompt="Answer only from ops runbook context.")
triage_agent = Agent(system_prompt="Classify severity; do not invent metrics.")

orchestrator = Agent(
    system_prompt="Route runbook questions to runbook_agent; severity to triage_agent.",
    tools=[
        runbook_agent.as_tool(name="runbook_agent", description="Ops procedures."),
        triage_agent.as_tool(name="triage_agent", description="Incident triage."),
    ],
)
```

For a commerce-shaped supervisor with Gateway Policy on refunds, use the longer sample in [eCommerce AgentCore agents](https://www.joinhorizon.co/blog/ecommerce-ai-agents-amazon-bedrock-agentcore-2026/): same primitives, product-specific tools.

A2A covers cross-team or cross-cloud specialists with signed identity and scoped tools. Prefer in-process Agents-as-Tools when one team owns the Runtime; prefer A2A when ownership is split.

## Loop controls the Strands docs name

The [Strands agent loop](https://strandsagents.com/docs/user-guide/concepts/agents/agent-loop/) caps the turns and tokens one call may use, can be cancelled mid-loop, and reports why the loop stopped. One agent instance handles one invocation at a time and rejects an overlapping call. [Hooks](https://strandsagents.com/docs/user-guide/concepts/agents/hooks/) fire around invocation, model calls, and tool calls. [Interventions](https://strandsagents.com/docs/user-guide/concepts/agents/interventions/) are a typed layer on those hooks: proceed, deny, guide, confirm, and transform. Handlers run in registration order. A deny short-circuits the rest, which is how a cheap authorization check skips a later model check.

A [session manager](https://strandsagents.com/docs/user-guide/concepts/agents/session-management/) restores one conversation, including interrupt state. [Memory](https://strandsagents.com/docs/user-guide/concepts/memory/overview/), when you add a memory manager, is a separate store across sessions. The conversation history the loop accumulates is the working context for that task. It is neither the session checkpoint nor long-term memory.

AgentCore Harness is the managed loop. Strands is the code you export to when the topology needs it. Neither one is a finished commerce agent. Gateway policy, identity, and the evaluation file are still yours. The local `harness.py` beside the store-agent sample is a stand-in for tenancy, budgets, cancellation, and write approval. It is not the Strands intervention runtime, and it does not call AWS.

## Grounding that ships today (AWS Context is not GA)

![Architecture diagram of an agent question answered from Managed Knowledge Base](../../assets/images/blog/production-ai-agents-aws-agentcore-harness-strands-2026-ground.webp)

_Figure: grounding that ships in the article. A question uses Managed Knowledge Base. AWS Context is not drawn because the article still lists it as coming soon. Memory is conversation state, not this document store. The cited gateway timing stays in the other post. [Open the draw.io source](https://www.joinhorizon.co/examples/architecture-blog-2026/production-ai-agents-aws-agentcore-harness-strands-2026/ground.drawio)._

Summit messaging bundled **AWS Context** (org knowledge graph) with Harness. Status check as of **August 2026**: AWS still describes Context as **Coming soon** ([Context intelligence blog](https://aws.amazon.com/blogs/machine-learning/context-intelligence-for-your-data-and-ai-agents-at-scale/)). Do not write production code against APIs that are not public.

What **does** ship for grounding:

| Option                                 | Status              | Use now?                                             |
| -------------------------------------- | ------------------- | ---------------------------------------------------- |
| **Managed Knowledge Base** (AgentCore) | **GA** Jun 17, 2026 | **Yes**: connectors + agentic retriever via Gateway |
| Classic Bedrock Knowledge Bases        | GA                  | Yes if already invested; dual-run carefully          |
| AgentCore Memory                       | GA                  | Yes: conversation/user state, not docs              |
| AgentCore Web Search                   | GA                  | Yes: live public facts inside your boundary         |
| **AWS Context**                        | **Coming soon**     | **No**: roadmap seam only                           |

Full matrix: [`grounding-status-matrix.md`](https://www.joinhorizon.co/examples/architecture-blog-2026/agentcore-harness-strands-1-0/grounding-status-matrix.md).

The agentic retriever on Managed KB decomposes multi-hop questions (runbooks + postmortems + escalation paths) instead of a single vector hit. That is the production substitute for “wait for Context” on unstructured estates.

## Observability and A/B testing: ship with a baseline

Harness and Runtime emit OpenTelemetry-compatible spans into CloudWatch. A/B testing is **GA** and can split traffic across agent versions even outside AgentCore Runtime ([release notes](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/release-notes.html)).

Do not A/B prompt tweaks until you have a golden suite. Statistical winners on a vague `task_completion_rate` are how teams ship polite hallucinations.

## Reference architecture

```text
User / IdP JWT
    → AgentCore Identity
    → Harness  OR  Runtime (Strands orchestrator)
         ├─ Agents-as-Tools / Graph / Swarm (Runtime path)
         ├─ AgentCore Memory (session + long-term)
         └─ AgentCore Gateway
              ├─ MCP / OpenAPI / Lambda tools (+ Policy)
              ├─ Managed Knowledge Base (GA)
              └─ Web Search (optional)
    → Observability (OTEL → CloudWatch) + Evaluations / A/B
```

AWS Context (coming soon) would sit beside Managed KB as an org graph. Design the MCP/tool seam; do not block the diagram on it.

## What to Do This Week

1. Stand up one **Harness** in non-prod (`agentcore create` or CreateHarness); confirm spans.
2. Attach **one** real Gateway tool (read-only first); Identity brokers secrets.
3. Connect **Managed Knowledge Base** to an S3 prefix of runbooks, not AWS Context.
4. Write 10 to 20 golden tasks; fail the suite if Browser fires on status-only intents.
5. If you need multi-agent topology, **export to Strands** and cap specialist hops; see [`monday-checklist.md`](https://www.joinhorizon.co/examples/architecture-blog-2026/agentcore-harness-strands-1-0/monday-checklist.md).
6. Model platform + tokens on the [AgentCore pricing calculator](https://www.joinhorizon.co/tools/amazon-bedrock-agentcore-pricing-calculator/), then [book a Bedrock agent architecture review](https://www.joinhorizon.co/contact-us/).

## Framework primitives are not the harness

Harness, Runtime, and Strands each give you a piece of the loop. None of them is the permission check, the budget, or the evaluation suite. Exporting a Harness config to Strands does not bring Gateway policy or Identity with it. You still attach those.

The application still has to classify the task, assemble the minimum context, keep state outside the transcript, route models by risk, verify with something other than the generator, bound retries, and record the trace. Commerce-specific gates are in the [AWS store-agent architecture](https://www.joinhorizon.co/blog/aws-ai-agents-for-ecommerce-factualminds-2026/) and in [securing store agents](https://www.joinhorizon.co/blog/secure-ai-agents-ecommerce-store-2026/).

## What This Post Doesn't Cover

- Full AgentCore **pricing line items**: [12-components pricing post](https://www.joinhorizon.co/blog/amazon-bedrock-agentcore-pricing-12-components/) and the calculator.
- Classic **supervisor + Lambda** patterns: historical only; [supervisor post](https://www.joinhorizon.co/blog/aws-bedrock-multi-agent-supervisor-pattern/) with lifecycle notice.
- Hands-on **AWS Context** APIs: not GA as of this publish date; re-check docs before you assume launch.
- Region-by-region SKU matrices: verify [AgentCore regions](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/agentcore-regions.html) in your account.
- HIPAA/PCI control mapping for agents: separate compliance engagement; do not treat Gateway Policy alone as a BAA story.
- Domain-specific agent design for retail: the [eCommerce AI Agents series](https://www.joinhorizon.co/resources/ecommerce-ai-agents/) applies this ship map workflow by workflow, from [support](https://www.joinhorizon.co/blog/ai-customer-support-agent-ecommerce-2026/) to a [multi-agent operations team](https://www.joinhorizon.co/blog/multi-agent-ecommerce-operations-team-2026/).

---

Need a Harness → Strands graduation plan for an existing demo agent? Start with [Generative AI on AWS](https://www.joinhorizon.co/services/generative-ai-on-aws/) or [contact us](https://www.joinhorizon.co/contact-us/).

## How the Harness and Strands stays bounded

Separate AgentCore Harness, Runtime, and Strands, and keep policy outside all three.

- **Maturity:** Level 2 — reference architecture
- **Risk:** high
- **Oversight:** approval
- **Starts when:** A team is choosing how to host the loop.
- **Tools:** A write goes through a router, a permission check, a policy check, and a budget check. The model does not commit it. An approval token lives in tool context, not in the user message.
- **Stops for a person:** Exporting to Strands does not bring Gateway policy with it. You still attach policy, identity, and a budget.
- **Checked by:** The page states what is GA and what is not. A framework primitive is not called a complete harness.
- **Untrusted data:** Docs that treat Strands or Harness as a substitute for authorization.
- **If it fails:** If the Harness and Strands stops, name the reason: completed, budget_exceeded, timed_out, cancelled, guardrail_blocked, approval_required, tool_failure, verification_failed, or partial_completion. Retry a timeout at most twice. Back off on rate limits. After repeated verification failure, escalate. Stop when the budget is exhausted or a permission is denied. No unbounded loop. Exporting to Strands does not bring Gateway policy with it. You still attach policy, identity, and a budget.
- **Lifecycle:** Explore, then act, then confirm, then verify. Explore gathers the context for the Harness and Strands. Act stays reversible. Confirm stops before an irreversible step. Verify is a separate check of the outcome.

Reference architecture, not a published production deployment. The shared contract is the [AWS store-agent architecture](https://www.joinhorizon.co/blog/aws-ai-agents-for-ecommerce-factualminds-2026/#operating-contract).

## FAQ

### When should I NOT start on AgentCore Harness?
Skip Harness when you already need a hard audit DAG, multi-team A2A, hop caps in code, or a LangGraph/CrewAI graph you will not rewrite this quarter. Use Runtime + Strands (or keep your framework on Runtime). Also skip AgentCore entirely for single-turn Converse calls or employee-only knowledge work where Quick Suite wins on connectors and seats.

### What could go wrong if we treat AWS Context as GA?
As of August 2026, AWS still lists AWS Context as Coming soon, with no public Create/Invoke path to pin a production design. Teams that sequence roadmaps behind it delay grounding that Managed Knowledge Base already ships. Design a seam for Context later; wire Managed KB + Gateway now.

### Harness or Runtime for a multi-agent supervisor?
Use Runtime + Strands for supervisors with Agents-as-Tools, Graph, Swarm, or Workflow topologies. Stay on Harness for a single-domain agent until config cannot express routing, Policy-scoped writes, or hop limits. Export Harness to Strands when you graduate. Do not rebuild IAM, Memory, or Gateway from scratch.

### Is Managed Knowledge Base the same as AgentCore Memory?
No. Managed Knowledge Base is document/media RAG with connectors and an agentic retriever. Memory is session and long-term conversational state. Most production agents need both: KB for runbooks and policies, Memory for the user notebook.

### Can we A/B test agents that do not run on AgentCore Runtime?
Yes. AgentCore A/B testing (GA) can split live traffic across versions whether agents run on AgentCore Runtime, Lambda, EKS, or non-AWS hosts. You still need a golden eval suite so task_completion_rate means something before you trust the statistical recommendation.

### What could go wrong if Browser or Code Interpreter stays enabled on every turn?
Platform compute can dominate the bill. In support-bot pilots we have seen roughly 3× Runtime-shaped spend when Browser stayed hot on conversational turns that only needed Gateway tools. Default those tools off; enable per skill or per intent.

### How do Strands Graph and Swarm differ?
Graph fixes topology (edges and dependencies) for compliance and review pipelines. Swarm uses peer handoffs and shared working memory for exploration; set max_handoffs and timeouts or cost and latency explode. Prefer Agents-as-Tools for hierarchical supervisors with clear specialists.

### Should net-new agents still use Bedrock Agents Classic?
No. Agents Classic is in maintenance for new customers after July 30, 2026. Net-new builds should use AgentCore Harness or Runtime. Existing Classic deployments keep running; plan a cutover inventory of tools and sessions rather than a one-day flip.

---

*Source: https://www.joinhorizon.co/blog/production-ai-agents-aws-agentcore-harness-strands-2026/*
