AWS Hong Kong Summit 2026 · Developer Lounge Recap · Article 2 of 6

AWS Magazine · Field Report from Victoria Harbour

High Tech Meets Harbourfront Luxury: The Developer Lounge Vibe

Stepping into the AWS Hong Kong Summit 2026 Developer Lounge, the energy was palpable. Floor-to-ceiling glass walls framed the panoramic skyline of Victoria Harbour, where sleek yachts glided across waters reflecting the midday sun. Inside, the environment seamlessly blended Hong Kong’s signature luxury with hyper-modern cloud innovation. Engineers, founders, and international tech leaders who flew in from San Francisco, Tokyo, London, and Seattle sank into plush velvet lounge chairs, sipping handcrafted local espresso while leaning over glowing screens.

This wasn't just a place to grab stickers or watch pre-recorded demos; it was an epicenter of active business collaboration and intense technical exchange. In private glass-walled VIP booths surrounding the main floor, venture capitalists and startup founders conducted private meetups. The conversation was filled with high-stakes financial dynamics—discussing seed rounds ("money in") alongside production infrastructure burn rates ("money out"). Across whiteboard walls, staff architects and independent builders drew complex system topologies, hashing out how to transform raw model intelligence into enterprise-grade software.

+-----------------------------------------------------------------------------------+
AWS HONG KONG SUMMIT 2026 DEVELOPER LOUNGE

[ Harbour View VIP Corner ]       [ Whiteboard Architecture Zone ]
  - Private meetups and pitching    - Model spend vs harness moats
  - Money in / money out            - Live code and architecture talks

[ Hands-On Lab & Espresso Bar ]   [ Main Stage & Lightning Talks ]
  - Managed memory and CLI setup    - Trista Pan agent harness keynote
  - Hands-on AWS AgentCore GA       - Global speaker panels
+-----------------------------------------------------------------------------------+

Opening: The Lounge Shifts from Demos to Production

If 2025 in the AWS Hong Kong AI scene felt like a constant fireworks display—filled with flashy agent prototypes, weekly demos, and social media screenshots showing off raw model capabilities—then AWS Summit Hong Kong 2026 marked the arrival of operational maturity. The core question echoing across the lounge was no longer "Look what the model can do," but rather the crucial production question: How do you safely get an agent into production?

In the Developer Lounge, that exact question found its focal point when Trista Pan delivered a standing-room-only lightning talk that immediately became the defining topic of conversation. Engineers and consulting partners crowded around whiteboards to debate a central premise: model spend is money out; harness engineering is money that compounds.

Source Essay (builder.aws.com): Agent Harness: Where Engineers Add Value When Models Keep Getting Smarter

Coinciding with the talk, AWS announced the general availability of Amazon Bedrock AgentCore Harness—a managed service providing the production operational layer that models cannot absorb on their own.

GA Announcement: Amazon Bedrock AgentCore harness is now generally available

As AI models mature, engineering leverage is shifting from raw models to agent harnesses—the surrounding scaffolding that directs value to users and builders. In 2025, the industry proved agent capabilities through rapid prototypes. In 2026, the focus has matured to operational control and reliability. As analyst Aakash Gupta summarized, "2025 was agents; 2026 is agent harnesses." True value now comes from making agents work reliably in production.

The Mood Shift: From "Can We?" to "Can We Run It?"

As AI models become increasingly capable, engineering leverage is shifting toward the surrounding scaffolding—directing value either outward toward customers or inward toward builders.

• Last year, agents broke out across every industry, accompanied by new weekly demos.

• The prevailing question in 2025 was "Can we build an agent that does X?", and the answer was almost always yes.

• This year, the question has matured: while spinning up a simple agent is straightforward, transitioning from a weekend prototype to a production system requires reliability and operational control.

As tech analyst Aakash Gupta summarized: "2025 was agents; 2026 is agent harnesses."

The Formula: Agent = Model + Harness

Drawing from Vivek Trivedy’s framing in The Anatomy of an Agent Harness, the core architectural identity of modern AI applications can be expressed through a simple formula:

Agent = Model + Harness

If a component is not the core foundational model itself, it belongs to the harness. Tools, memory, prompt engineering, orchestration, observability, guardrails, routing, and deployment all fall under harness engineering. Systematically designing this harness and turning operational failures into permanent system fixes—a method famously highlighted by Mitchell Hashimoto—defines the discipline of harness engineering.

The Car Analogy That Clicked in the Lounge

To make this concept intuitive for newcomers, speakers in the lounge used a classic automotive analogy:

• The model is the engine: it generates power, reasoning, planning, and raw drive.

• However, you cannot deliver a raw engine sitting on the garage floor to a driver.

• A road-worthy vehicle requires a chassis, steering wheel, brakes, dashboard indicators, seatbelts, and headlights.

• The engine produces power, but the harness converts that power into a safe, reliable vehicle suitable for everyday use.

A high-performing model does not guarantee a successful production agent, just as a powerful engine alone does not guarantee a safe automobile.

The Luxury Hospitality Analogy

Hong Kong's top culinary establishments do not rely solely on high-end stoves; their success depends on reservation management, kitchen coordination, quality control, and guest hospitality. Similarly, in AI architecture, the model represents the flame, while the harness represents the broader operational management.

A Harness Has Two Halves

The responsibilities of an agent harness are evenly split between build-time capabilities and runtime operations:

Martin Fowler’s team formally terms this technical discipline harness engineering. When categorizing application capabilities, only a small fraction belong directly to the model, while the vast majority belong to the harness layer.

Real Evidence: Same Model, Superior Harness

To answer skeptics who suggest waiting for smarter underlying models, presenters shared empirical benchmark cases where the model remained unchanged while only the harness infrastructure was optimized:

1. Vercel’s v0 — Less Context, Higher Efficiency

Large context windows require active management to prevent performance degradation from stale information. The team behind Vercel's v0 reduced their active tool set from 15 down to 2 core primitives (bash and filesystem operations).

• Accuracy: Increased from 80% to 100%.

• Token Spend: Decreased by ~37%.

• Latency: Responses executed 3.5× faster.

2. LangChain on Terminal Bench 2.0

By adding explicit harness components—specifically a self-verification loop, pre-completion checklists, and loop detection logic—LangChain upgraded performance on identical model backends:

• Benchmark Score: Jumped from 52.8% to 66.5%.

• Ranking: Moved from approximately top 30 to the top 5 ranking.

3. Smaller Models Outperforming Flagship Models

• Hebia: Deployed GPT-5.4 mini within a specialized finance and legal harness setup, achieving higher pass rates and cleaner source attribution than un-harnessed flagship models at lower token costs.

• MIT CSAIL’s Recursive Language Models: Wrapped GPT-5-mini in an architecture where the model recursively invokes itself across context segments without fine-tuning, achieving benchmark scores of 64.9% vs 30.3% compared to significantly larger model configurations.

Will the Model Absorb the Harness?

A common developer concern is whether rapid advancements in foundational models will render harness engineering redundant.

What Models Are Absorbing

Certain low-level tasks are increasingly handled natively by newer models:

• Context Handling: Expanding context windows reduce manual chunking overhead.

• Planning: Advanced reasoning models maintain long-horizon coherence without complex manual sprint breakdowns; Addy Osmani noted this significantly reduces context-anxiety failure modes.

• Basic Self-Correction: Refusal patterns and basic output validation are increasingly built into raw models.

Why the Operations Layer Remains Essential

The harness evolves by moving higher up the software stack. Core operational responsibilities—such as model routing, infrastructure scaling, cost tracking, security enforcement, and telemetry—remain distinct from raw model intelligence.

Key Takeaway: A model cannot act as its own multi-provider router, infrastructure scaler, or cost-governance engine.

+-----------------------------------------------------------------------------------+
EVOLUTION OF THE AGENT HARNESS STACK

Operations Layer (grows)
  - Multi-model routing and cost optimization
  - Guardrail enforcement and deterministic permissions
  - Distributed tracing and CloudWatch observability

Model Layer (absorbs low-level tasks)
  - Extended context windows and basic planning
  - Native function calling and basic self-correction
+-----------------------------------------------------------------------------------+

Component Evolution Analysis

Strategic Directions for AI Engineering Teams

Developers and startups are encouraged to commit deliberately to one of two primary strategies:

1. Direction A — Outward Toward Customers: Focus on product design, user experience, and domain problem-solving. By pairing a managed harness with frontier models, small teams can ship sophisticated applications with lower headcount requirements.

2. Direction B — Inward Toward Builders: Build reusable developer tools, custom middleware, evaluation loops, and domain-specific routing infrastructure. This creates long-term value that persists across multiple model generations.

Deep Dive: Amazon Bedrock AgentCore Harness GA

With the general availability of Amazon Bedrock AgentCore Harness, AWS provides a managed infrastructure abstraction designed to streamline agent production deployments.

+-----------------------------------------------------------------------------------+
AMAZON BEDROCK AGENTCORE HARNESS (GA)

API surface: CreateHarness / InvokeHarness

Primitives under the harness
  - Runtime       compute
  - Memory        semantic state
  - Gateway       API / MCP tools
  - Browser       web sandbox
  - Interpreter   Python / Node sandbox
  - Identity      credential vault

Observability: CloudWatch unified harness tracing
+-----------------------------------------------------------------------------------+

Architectural Overview & Key Capabilities

Building on Simon Willison's fundamental definition—"An LLM agent runs tools in a loop to achieve a goal"—AgentCore Harness simplifies the surrounding operational overhead. While prototyping local agent loops is straightforward, deploying production environments traditionally requires managing sandboxed compute, network isolation, identity vaulting, session persistence, and distributed tracing. AgentCore Harness replaces custom infrastructure setup with a managed abstraction driven by two central API calls: CreateHarness and InvokeHarness.

1. Multi-Model Flexibility & Provider Switching

AgentCore Harness decouples agent configurations from single model vendors. Developers can define a default model configuration and dynamically override it per invocation or switch model providers mid-session while preserving conversational state.

Model provider support includes:

• bedrock: Native access to models hosted on Amazon Bedrock, including Anthropic Claude, Amazon Nova, Meta Llama, DeepSeek, Qwen, Kimi, MiniMax, Cohere, Mistral, as well as OpenAI GPT-5.5 and GPT-5.4 endpoints on Bedrock.

• openAi: Direct connectivity to OpenAI API endpoints (api.openai.com).

• gemini: Direct Google Gemini API integration.

• liteLlm: Universal integration for third-party endpoints, including Azure OpenAI, Vertex AI, Cohere, and custom self-hosted endpoints.

API keys used for external model providers are managed via AgentCore Identity’s token vault, ensuring credentials remain protected from raw model context exposure.

2. Declarative Tool Integration

Tools are defined via structured declarations within the tools array during harness creation:

"tools": [
  { "type": "agentcore_browser" },
  { "type": "agentcore_code_interpreter" },
  { 
    "type": "remote_mcp",
    "name": "X_tool",
    "config": { "remoteMcp": { "url": "https://mcp.X_tool/mcp" } } 
  },
  { 
    "type": "agentcore_gateway",
    "name": "Y_tool",
    "config": { "agentCoreGateway": { "arn": "arn:aws:bedrock-agentcore:us-west-2:123456789012:gateway/gw-xyz" } } 
  }
]

Every execution session includes automated access to native shell and file_operations capabilities without requiring manual tool wrapping. Specific tools can be selectively allowed or restricted at runtime using the allowed_tools override parameter on InvokeHarness.

3. Managed Session Memory

Omitting explicit memory flags during CreateHarness automatically provisions managed memory with enterprise defaults:

• Strategies: Combined SEMANTIC index and SUMMARIZATION processing.

• Data Retention: Configurable 30-day default event expiration.

• Security: AWS-managed encryption with tenant isolation scoped by actorId.

// Example: Managed Memory Configuration
"memory": {
  "managedMemoryConfiguration": {
    "strategies": ["SEMANTIC", "SUMMARIZATION"],
    "eventExpiryDuration": 30
  }
}

// Example: Bring Your Own Memory ARN
"memory": { 
  "agentCoreMemoryConfiguration": { 
    "arn": "arn:aws:bedrock-agentcore:us-west-2:123456789012:memory/mem-abc" 
  } 
}

// Example: Stateless Execution
"memory": { "disabled": {} }

4. Modular Skill Integration

Skills represent modular bundles containing code scripts, reference files, and domain instructions. Metadata is indexed upfront, and full contents are loaded dynamically when required by the task execution plan.

The HarnessSkill schema supports four distinct ingestion sources:

• awsSkills: Pre-curated AWS domain skill bundles covering SDK usage, IaC, security, serverless, databases, and operations.

• git: HTTPS repositories pinned to specific branches or commit hashes.

• s3: Direct skill package deployment from Amazon S3 buckets.

• path: Local container filesystem references.

5. Sandboxed Runtime & Persistent Storage

Custom dependencies can be deployed by linking container images stored in Amazon ECR. Developers can execute setup scripts without incurring model token costs using the InvokeAgentRuntimeCommand API.

Storage options accommodate varied persistence requirements:

6. Observability, Evaluation & Optimization Loop

CloudWatch GenAI Observability features a dedicated Harnesses dashboard view. Operations teams can trace execution paths down to individual spans across memory lookups, browser sessions, code executions, and tool calls.

Built-in evaluation components support automated quality control:

• AgentCore Evaluations: Runs LLM-as-a-judge metrics assessing faithfulness, helpfulness, and safety across batch datasets or live traffic.

• AgentCore Optimization: Analyzes evaluation scores to suggest optimized system prompts and tool descriptions, validating changes via live A/B routing through AgentCore Gateway.

7. Environment Versioning & Code Export

Updating a harness configuration creates an immutable version record. Production deployment endpoints can be pinned to explicit versions to ensure reliable rollbacks:

# Pin PROD Endpoint to Harness Version 2
aws bedrock-agentcore-control create-harness-endpoint \
  --harness-id harness-xyz123 \
  --endpoint-name PROD \
  --harness-version 2

# Promote Version 5 to PROD
aws bedrock-agentcore-control update-harness-endpoint \
  --harness-id harness-xyz123 \
  --endpoint-name PROD \
  --harness-version 5

If an application outgrows declarative configuration, developers can export the harness into code:

agentcore export harness --name myHarness-xyz123 --output ./my-agent

This exports code built on the open-source Strands framework, preserving prompt definitions, memory structures, and tool bindings.

Three Production Agent Configurations

The versatility of AgentCore Harness is demonstrated through three standard production deployment patterns:

Pattern 1: Automated Research & Content Synthesis Agent

• Tools: agentcore_browser paired with AgentCore Gateway pointing to web search endpoints.

• Skills: Connected via git to document processing skill repositories.

• Memory: Default managed memory enabled to retain context across multi-step research sessions.

Pattern 2: Enterprise Cloud Analytics Agent

• Skills: Ingests the complete awsSkills bundle.

• Permissions: Scoped IAM execution roles providing access to Athena, Glue, Redshift, and CloudWatch.

• Tools: Includes agentcore_code_interpreter for running Python data visualizations inside secure sandboxes.

Pattern 3: Automated Software Development Agent

• Runtime: Custom ECR container pre-loaded with development toolchains.

• Tools: AgentCore Gateway connected to GitHub/GitLab repositories.

• Execution: Uses InvokeAgentRuntimeCommand for deterministic Git operations (cloning, branching, committing) alongside model reasoning.

Consumption-Based Pricing Structure

Amazon Bedrock AgentCore Harness operates without fixed base subscription fees. Billing is calculated strictly on active resource consumption:

Global Customer Implementations

Enterprise leaders highlighted their production implementations during Summit panels:

• Omar Paul (VP of Product, Twilio): "AgentCore Harness combined with Twilio Conversations allows our global customer base to deploy contextual voice and messaging agents rapidly without rebuilding core underlying infrastructure."

• Dr. Lukas Schack (Principal ML Engineer, TUI GROUP): "AgentCore serves as a foundational building block across our organization. During internal hackathons with 500+ developers, teams routinely transition concepts into working prototypes within minutes."

• Rodrigo Moreira (VP of Engineering, VTEX): "By shifting from manual orchestration code to declarative harness configuration, our teams validate new e-commerce customer journeys in minutes rather than days."

• Kazumi Matsuda (Senior Manager, FUJISOFT): "We leverage AgentCore versioning and A/B optimization loops to run live evaluations on production traffic before fully rolling out updates."

Getting Started: Hands-On Quickstart

Option A: Command Line Interface (CLI)

# 1. Install global AgentCore CLI tool
npm install -g @aws/agentcore@preview

# 2. Initialize harness project definition
agentcore create --name research-agent --model-provider bedrock

# 3. Deploy infrastructure to AWS
agentcore deploy

# 4. Invoke agent endpoint
agentcore invoke "Plan a 5-day Tokyo itinerary with daily budgets and reservation links."

Option B: Python SDK (boto3)

import boto3
import uuid

# Initialize control and data clients
control = boto3.client("bedrock-agentcore-control", region_name="us-west-2")
data    = boto3.client("bedrock-agentcore",         region_name="us-west-2")

# Step 1: Create the Agent Harness definition
harness = control.create_harness(
    harnessName="FinancialAnalysisAgent",
    executionRoleArn="arn:aws:iam::123456789012:role/AgentCoreExecutionRole"
)

# Step 2: Invoke the Harness endpoint with session tracking
session_id = str(uuid.uuid4()).ljust(33, "0")  # Minimum required length: 33 characters

response = data.invoke_harness(
    harnessArn=harness["harnessArn"],
    runtimeSessionId=session_id,
    messages=[{
        "role": "user",
        "content": [{"text": "Summarize Q3 financial highlights from uploaded reports."}]
    }]
)

# Step 3: Stream responses in real time
for event in response["stream"]:
    print(event)

Veteran's Verdict: The Engine and the Vehicle

Reflecting on decades of watching technology cycles unfold—from early mainframe architectures to client-server paradigms and modern cloud setups—the evolution of AI engineering follows a familiar pattern. Raw computational capability eventually yields to operational management and enterprise harness systems.

Foundational models will continue to evolve rapidly. However, the durable value built by engineering teams lies in the surrounding infrastructure: operational guardrails, memory strategies, evaluation loops, and system routing.

The model provides the engine, but the harness creates the complete vehicle. Choose your architecture intentionally, and build for long-term scalability.