Multi-Agent Quant Backtesting on AgentCore

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

AWS Magazine · Field Report from Victoria Harbour

The Vibe: Where High Capital Meets High Tech

If you stood by the glass curtain walls of the AWS Hong Kong Summit 2026 Developer Lounge, you felt a distinct energy. Floor-to-ceiling windows framed the gleaming towers of Central and the tugboats carving through Victoria Harbour. Inside, the lounge felt like a hybrid of a Silicon Valley hacker space and a private Hong Kong wealth management suite—sleek ergonomic furniture, artisan espresso machines, glowing dual monitors, and the rhythmic sound of mechanical keyboards mixing with low-frequency dealmaking.

In this room, "money in / money out" isn’t a abstract concept; it is the ultimate metric. Between formal talks, private startup meetups were popping up across lounge corners. Founders in hoodies sat with VC partners in tailored suits, scribbling business models on napkin sketches while watching live telemetry on AWS dashboards.

Nowhere did this pulse hit harder than around Haowen Huang’s hands-on workshop track. Hong Kong understands capital risk intrinsically: you measure it, you stress-test it, and you never deploy blindly. Quants, senior architects, and curious startup builders crowded into the lounge session to see how generative AI is completely rewriting quantitative backtesting.

The Core Demo: Three AI agents collaborating seamlessly to turn a plain-language trading idea into an automated, full-scale quantitative backtesting report.

+-----------------------------------------------------------------------------------+
DEVELOPER LOUNGE HIGH-TECH ARCHITECTURE

[ User Natural Language ]
          v
[ Quant Orchestrator (Claude Sonnet 4) ]
          v
   --> [ Strategy Generator ]   Claude Opus 4 code generation
   --> [ MCP Gateway ]          S3 Tables market data
   --> [ Result Summarizer ]    Nova Lite 2.0 report
+-----------------------------------------------------------------------------------+

• Builder Resource: Amazon Bedrock AgentCore + Strands quant backtesting

• Hands-on Catalog: Agentic Backtesting for Quants by Bedrock AgentCore and Strands Agents

Mandatory Summit Disclaimer: This workshop track is designed strictly for learning and architectural discussion. It does not constitute investment advice. Participants are solely responsible for their own investment decisions and any financial outcomes. Market data is sourced via Yahoo Finance for educational demonstration purposes only.

At AWS Hong Kong Summit 2026, Haowen Huang’s Developer Lounge workshop showed how three Amazon Bedrock AgentCore agents—powered by Claude Opus 4, Claude Sonnet 4, and Amazon Nova Lite 2.0—turn natural-language trading ideas into full Backtrader backtests. Using Strands Agent-as-Tools, MCP Gateway market data from S3 Tables, Cognito identity, memory, and CloudWatch observability, builders learned cost-aware multi-agent design, hands-on lab progression, and production patterns for quant workflows—without real investment advice.

1. Quantitative Backtesting 101 — Why We Need Agents

In quantitative trading, backtesting is the process of testing a trading strategy against historical market data to evaluate its performance before risking real capital.

Why Backtesting Matters

Before deploying real capital into live markets, quants must rigorously evaluate risk and performance metrics:

The Traditional Workflow vs. The Challenge

1. Define Strategy Rules: Entry/exit signals, position sizing, risk controls.

2. Collect Historical Data: Clean OHLCV (Open, High, Low, Close, Volume) price/time series data.

3. Write Code: Implement strategy rules using frameworks like Backtrader, Zipline, or custom scripts.

4. Run Simulation: Execute trades across historical timelines.

5. Analyze Analytics: Generate equity curves, drawdown maps, and risk ratios.

The Gap: Success requires four distinct skill sets: domain trading knowledge, data engineering, specialized Python coding, and statistical analysis. In traditional setups, a single developer rarely excels at all four. Multi-agent systems bridge this gap by delegating each specialized domain to a dedicated AI agent.

2. Hands-On: What Builders Assembled in the Lounge

The 90-minute, 300-level workshop gave attendees immediate hands-on access to build a complete multi-agent workflow.

• No Local Setup Required: Developers opened browser-based Code-OSS (open-source VS Code) environments pre-provisioned on AWS.

• Skill Prerequisites: Basic Python knowledge and a conceptual understanding of trading rules (e.g., buy/sell signals, moving averages).

• Core Goal: Build, deploy, and trace three specialized AI agents hosted on Amazon Bedrock AgentCore, tied together using the Strands Agents SDK.

+-----------------------------------------------------------------------------------+
DEVELOPER LOUNGE IDE ENVIRONMENT (CODE-OSS)

File Explorer                 Editor: quant_agent.py
  - agents/                     import agentcore
  - tools/                      @agentcore.orchestrator
  - requirements.txt            def run_pipeline():
                                  # Strands multi-agent loop

Terminal
  $ agentcore launch --auto-update-on-conflict
+-----------------------------------------------------------------------------------+

3. Foundation Models: Matching the Model to the Task

A key takeaway from Haowen’s workshop was model cost and latency optimization: never force a single giant model to handle every sub-task. Instead, match models to specific agent roles:

This approach provides high code accuracy where execution matters (Opus 4) while keeping summarization fast and cost-effective (Nova Lite 2.0).

4. Backtrader: The Engine Under the Hood

The system relies on Backtrader, a popular open-source Python backtesting framework. It features:

• Event-driven backtesting execution engine.

• Built-in technical indicators (SMA, EMA, RSI, MACD, etc.).

• Native position sizing and order management.

• Automated performance analysis (Sharpe ratio, max drawdown, trade statistics).

The Strategy Generator Agent dynamically writes Backtrader Python scripts, which are then safely executed by the Quant Agent against real historical market data.

5. Multi-Agent Architecture & Strands Patterns

The Four Key Benefits of Multi-Agent Systems

1. Specialization: Specialized prompts and models increase task precision.

2. Scalability: Sub-agents scale independently based on invocation load.

3. Cost Efficiency: High-capability FMs are used only for complex reasoning tasks.

4. Maintainability: Isolated agents allow granular updates and testing.

Four Multi-Agent Patterns (Strands Agents Framework)

The "Agent as Tools" Flow in Action

+-----------------------------------------------------------------------------------+
AGENT AS TOOLS FLOW

[ User Prompt: "Test a 20/50 SMA Crossover on AAPL" ]
          v
[ Quant Agent Orchestrator ]
          v
   (1) --> Strategy Generator (Claude Opus 4)
           returns Backtrader Python code
   (2) --> Market Data MCP Tool
           returns historical OHLCV
   (3) --> Result Summarizer (Amazon Nova Lite 2.0)
           returns performance analysis report
+-----------------------------------------------------------------------------------+

1. Quant Agent receives user intent.

2. Calls Strategy Generator to turn text into valid Python Backtrader code.

3. Calls Market Data MCP Tool to fetch daily OHLCV prices.

4. Executes the Backtrader simulation locally.

5. Passes raw results to Result Summarizer to generate the final analytical report.

6. Amazon Bedrock AgentCore Services Deep Dive

Amazon Bedrock AgentCore provides fully managed infrastructure for building, deploying, and governing production AI agents.

+-----------------------------------------------------------------------------------+
BEDROCK AGENTCORE SUITE

AgentCore Runtime          AgentCore Gateway           AgentCore Memory
  Serverless hosting         MCP tool routing            State and context

AgentCore Identity         Observability               Policy and Guard
  Cognito OAuth auth         OpenTelemetry tracing       Cedar controls
+-----------------------------------------------------------------------------------+

Full AgentCore Catalogue

Deployment Commands in the Lounge

Developers deployed their orchestrator straight to AgentCore Runtime with simple CLI calls:

# Configure the AgentCore Runtime entry point
agentcore configure --entrypoint quant_agent.py --name quant_agent \
  --requirements-file requirements.txt --idle-timeout 900

# Launch and update environment variables dynamically
agentcore launch --auto-update-on-conflict \
  --env AWS_REGION=$WORKSHOP_REGION \
  --env STRATEGY_GENERATOR_RUNTIME_ARN=arn:aws:bedrock:us-east-1:123456789012:agent/strat_gen \
  --env AGENTCORE_GATEWAY_URL=https://gateway.bedrock.us-east-1.amazonaws.com/mcp

7. The Three-Layer System Architecture

+-----------------------------------------------------------------------------------+
SYSTEM ARCHITECTURE

[ Layer 1: Frontend ]
  Next.js interactive dashboard (strategy form, real-time charts)
          v
[ Layer 2: Orchestration Layer ]
  Bedrock AgentCore Runtime (Quant Agent Orchestrator)
    --> Strategy Generator (Claude Opus 4)
    --> Result Summarizer (Amazon Nova Lite 2.0)
    --> Execute Backtrader simulation engine
          v
[ Layer 3: Enterprise Data Layer ]
  AgentCore MCP Gateway (Cognito OAuth)
          v
  PyIceberg Query Lambda
          v
  Amazon S3 Tables (Apache Iceberg market data)
+-----------------------------------------------------------------------------------+

1. Frontend Layer: Next.js dashboard providing interactive forms, real-time agent execution traces, and performance visualizers.

2. Orchestration Layer: AgentCore Runtime hosting the multi-agent system.

3. Data Layer: Amazon S3 Tables storing historical stock market price data formatted with Apache Iceberg. A Lambda function powered by PyIceberg reads this data and exposes a standard get_market_data tool via AgentCore MCP Gateway.

8. Step-by-Step Lab Progression

The workshop was structured across eight progressive hands-on modules:

+-----------------------------------------------------------------------------------+
LAB PROGRESSION

[ Lab 1: Deploy ] --> [ Lab 2: Memory ] --> [ Lab 3: Gateway ] --> [ Lab 4: Multi-Agent ]
[ Lab 8: A2A ]   <-- [ Lab 7: Sandbox ] <-- [ Lab 6: Policy ]  <-- [ Lab 5: Tracing ]
+-----------------------------------------------------------------------------------+

• Lab 1: Deploy Strategy Generator: Deploy a basic prompt agent on AgentCore Runtime.

• Lab 2: Add AgentCore Memory: Attach short-term memory to handle multi-turn conversational follow-ups.

• Lab 3: Build Quant Agent with Market Data: Connect the agent to external tool endpoints using Gateway & Identity.

• Lab 4: Multi-Agent Orchestration: Combine Strategy Generator, Result Summarizer, and Gateway into an orchestrator flow.

• Lab 5: Observability & Tracing: Trace agent execution paths, tool calls, and performance bottlenecks in CloudWatch.

• Lab 6 (Bonus): AgentCore Policy: Apply Cedar-based policy controls to govern model interactions.

• Lab 7 (Bonus): Sandbox Execution: Move code execution into the secure AgentCore Code Interpreter sandbox.

• Lab 8 (Bonus): Agent-to-Agent (A2A): Replace custom APIs with standardized open A2A protocol interactions.

9. Key Concepts Summary

Closing Remarks from the Developer Lounge

As the afternoon sun dipped behind Victoria Harbour, casting a golden hue over the glass towers, the Developer Lounge remained packed. Builders were still experimenting with new prompts, tuning Backtrader strategy outputs, and comparing CloudWatch trace latencies.

What makes this system compelling isn't just that it writes code—it's that it structures complex human workflows into modular, scalable serverless components. By pairing specialized AI models with managed infrastructure like Amazon Bedrock AgentCore, developers can build reliable agent workflows ready for real-world testing.