🎯 Introduction

In Part 1, we explored the challenges facing trade settlement and how Agentic AI can revolutionize this critical financial process. Now, we'll dive deep into the technical implementation using Amazon Bedrock AgentCore, exploring the architecture, components, and step-by-step implementation process.

What You'll Learn:

• Amazon Bedrock AgentCore architecture and capabilities

• Detailed solution design and agent workflows

• Step-by-step implementation procedures

• AWS console configurations and best practices

• Real-world deployment considerations

---

🏗️ Amazon Bedrock AgentCore: The Foundation

What is Amazon Bedrock AgentCore?

Amazon Bedrock AgentCore is a fully managed service that provides the infrastructure and tools needed to build, deploy, and manage agentic AI applications at enterprise scale. It combines the power of foundation models with agent orchestration, tool integration, and enterprise-grade security.

Core Components Architecture

Agent Runtine

%%{init: {
"themeVariables":{"fontFamily":"Inter, Arial, sans-serif","fontSize":"20px"},
"flowchart":{"nodeSpacing":60,"rankSpacing":70,"htmlLabels":true}
}}%%
flowchart LR
subgraph "Agent Runtime"
  A1(Agent Orchestrator):::agent
  A2[Foundation Models]:::ai
  A3[Tool Integration Engine]:::comp
  A4[Memory Management]:::comp
  A5[Context Management]:::comp
  A1 --> A2
  A1 --> A3
  A1 --> A4
  A1 --> A5
end

classDef agent fill:#ffecb3,stroke:#ffa000,stroke-width:2px;
classDef ai fill:#bbdefb,stroke:#1976d2,stroke-width:2px;
classDef comp fill:#f3e5f5,stroke:#8e24aa,stroke-width:2px;

Gateway & Identity

%%{init: {
"themeVariables":{"fontFamily":"Inter, Arial, sans-serif","fontSize":"15px"},
"flowchart":{"nodeSpacing":50,"rankSpacing":60,"htmlLabels":true}
}}%%
flowchart LR
subgraph "Gateway & Identity"
  F1(AgentCore Gateway):::gw
  F2[Authentication]:::infra
  F3[Authorization]:::infra
  F4[MCP Protocol]:::infra
  F1 --> F2
  F1 --> F3
  F1 --> F4
end

classDef gw fill:#ffe0b2,stroke:#f57c00,stroke-width:2px;
classDef infra fill:#e0f2f1,stroke:#00695c,stroke-width:2px;

Infrastructure

%%{init: {
"themeVariables":{"fontFamily":"Inter, Arial, sans-serif","fontSize":"20px"},
"flowchart":{"nodeSpacing":60,"rankSpacing":70,"htmlLabels":true}
}}%%
flowchart LR
subgraph "Infrastructure"
  J1(Container Runtime):::infra
  J2[Auto Scaling]:::infra
  J3[Load Balancing]:::infra
  J4[Health Monitoring]:::infra
  J1 --> J2
  J1 --> J3
  J1 --> J4
end

classDef infra fill:#e0f2f1,stroke:#00695c,stroke-width:2px;

External Integrations for this usecase

%%{init: {
"themeVariables":{"fontFamily":"Inter, Arial, sans-serif","fontSize":"20px"},
"flowchart":{"nodeSpacing":60,"rankSpacing":70,"htmlLabels":true}
}}%%
flowchart LR
subgraph "External Integrations"
  N[AWS Services]:::ext
  O[(DynamoDB)]:::db
  P[CloudWatch]:::ext
  Q[IAM]:::ext
  R[Custom APIs]:::ext
  S[Trading Systems]:::ext
  T[Risk Systems]:::ext
  U[Compliance Systems]:::ext

  N --> O
  N --> P
  N --> Q
  R --> S
  R --> T
  R --> U
end

classDef ext fill:#fff9c4,stroke:#fbc02d,stroke-width:2px;
classDef db fill:#c8e6c9,stroke:#388e3c,stroke-width:2px;

Key Capabilities

1. Agent Orchestration

• Multi-Agent Coordination: Seamless collaboration between specialized agents

• Workflow Management: Complex business process automation

• State Management: Persistent agent state across interactions

• Error Handling: Graceful failure recovery and escalation

2. Foundation Model Integration

• Model Selection: Choose optimal models for specific tasks

• Prompt Engineering: Advanced prompt optimization and management

• Response Processing: Intelligent parsing and validation

• Cost Optimization: Efficient model usage and caching

3. Tool Integration

• Native AWS Integration: Direct access to AWS services

• Custom Tool Support: Integration with external systems and APIs

• Security: Secure credential management and access control

• Monitoring: Comprehensive tool usage tracking and analytics

---

🎯 Solution Architecture Deep Dive

High-Level System Architecture

%%{init: {
  "themeVariables":{
    "fontFamily":"Inter, Arial, sans-serif",
    "fontSize":"20px"
  },
  "flowchart": {
    "curve": "basis",
    "padding": 12,
    "nodeSpacing": 70,
    "rankSpacing": 80,
    "htmlLabels": true
  }
}}%%
flowchart LR
  %% =======================
  %% BLOCK DIAGRAM: AGENTCORE
  %% =======================

  %%--- LEFT: Gateway & Identity (Entry) ---
  subgraph G["Gateway & Identity"]
    direction TB
    F1(AgentCore Gateway):::gw
    F2[Authentication]:::infra
    F3[Authorization]:::infra
    F4[MCP Protocol]:::infra
    F1 --> F2
    F1 --> F3
    F1 --> F4
  end

  %%--- CENTER: Agent Runtime (Brain) ---
  subgraph RUNTIME["Agent Runtime"]
    direction TB
    A1(Agent Orchestrator):::agent
    A2[Foundation Models]:::ai
    A3[Tool Integration Engine]:::comp
    A4[Memory Management]:::comp
    A5[Context Management]:::comp
    A1 --> A2
    A1 --> A3
    A1 --> A4
    A1 --> A5
  end

  %%--- RIGHT: External Integrations (World) ---
  subgraph EXT["External Integrations"]
    direction TB
    N[AWS Services]:::ext
    O[(DynamoDB)]:::db
    P[CloudWatch]:::ext
    Q[IAM]:::ext
    R[Custom APIs]:::ext
    S[Trading Systems]:::ext
    T[Risk Systems]:::ext
    U[Compliance Systems]:::ext

    N --> O
    N --> P
    N --> Q
    R --> S
    R --> T
    R --> U
  end

  %%--- BOTTOM: Platform Infrastructure (Ops) ---
  subgraph INFRA["Platform Infrastructure"]
    direction LR
    J1(Container Runtime):::infra
    J2[Auto Scaling]:::infra
    J3[Load Balancing]:::infra
    J4[Health Monitoring]:::infra
    J1 --> J2
    J1 --> J3
    J1 --> J4
  end

  %% =======================
  %% CROSS-BLOCK FLOWS
  %% =======================
  %% Entry into runtime
  F1 ==> A1

  %% Tooling out to services/APIs
  A3 -- Uses --> N
  A3 -- Uses --> R

  %% Control/ops touchpoints (dotted = control/ops)
  A1 -. telemetry .-> J4
  F1 -. routed via .-> J3

  %% =======================
  %% CONTEXT FRAME
  %% =======================
  subgraph FRAME["Amazon Bedrock AgentCore Platform"]
  end
  %% Visually group main blocks within FRAME
  FRAME --- G
  FRAME --- RUNTIME
  FRAME --- EXT
  FRAME --- INFRA

  %% =======================
  %% LEGEND
  %% =======================
  subgraph LEGEND["Legend"]
    direction TB
    L1[[Solid arrow = data/tool call]]
    L2(((Dotted arrow = control/ops)))
  end

  %% =======================
  %% STYLES
  %% =======================
  classDef agent fill:#ffecb3,stroke:#ffa000,stroke-width:2px;
  classDef ai fill:#bbdefb,stroke:#1976d2,stroke-width:2px;
  classDef comp fill:#f3e5f5,stroke:#8e24aa,stroke-width:2px;
  classDef gw fill:#ffe0b2,stroke:#f57c00,stroke-width:2px;
  classDef infra fill:#e0f2f1,stroke:#00695c,stroke-width:2px;
  classDef ext fill:#fff9c4,stroke:#fbc02d,stroke-width:2px;
  classDef db fill:#c8e6c9,stroke:#388e3c,stroke-width:2px;

  class A1 agent
  class A2 ai
  class A3,A4,A5 comp
  class F1 gw
  class F2,F3,F4,J1,J2,J3,J4 infra
  class N,P,Q,R,S,T,U ext
  class O db

Key Responsibilities:

• Trade data validation and normalization

• Database persistence with audit trails

• Integration with downstream agents

• Error handling and reporting

Matching Agent

flowchart TD
    A[Receive Trade for Matching] --> B[Query Pending Trades]
    B --> C[Apply Deterministic Rules]
    C --> D{Exact Match Found?}
    D -->|Yes| E[Create Match Record]
    D -->|No| F[Apply Fuzzy Matching]
    F --> G[Calculate Confidence Score]
    G --> H{Confidence > 98%?}
    H -->|Yes| E
    H -->|No| I{Confidence > 85%?}
    I -->|Yes| J[Queue for Human Review]
    I -->|No| K[Trigger Exception Agent]
    E --> L[Update Trade Status]
    L --> M[Create Settlement Instructions]

    style A fill:#e3f2fd
    style C fill:#e8f5e8
    style F fill:#fff3e0
    style G fill:#fff3e0
    style E fill:#e8f5e8
    style K fill:#ffebee
    style J fill:#fff8e1

Advanced Matching Logic:

• Deterministic Matching: Exact field matching (price, quantity, instrument)

• Probabilistic Matching: ML-based similarity scoring

• Confidence Thresholds: Risk-based decision making

• Learning Integration: Continuous improvement from outcomes

Exception Resolution Agent

flowchart TD
    A[Receive Exception] --> B[Classify Exception Type]
    B --> C[Analyze Historical Patterns]
    C --> D[Generate Resolution Strategy]
    D --> E{Auto-Resolution Possible?}
    E -->|Yes| F[Execute Resolution]
    E -->|No| G[Escalate to Human]
    F --> H[Validate Resolution]
    H --> I{Resolution Successful?}
    I -->|Yes| J[Update Records]
    I -->|No| G
    G --> K[Create Investigation Task]
    J --> L[Learn from Outcome]

    style A fill:#e3f2fd
    style B fill:#fff3e0
    style C fill:#fff3e0
    style D fill:#fff3e0
    style F fill:#e8f5e8
    style G fill:#fff8e1
    style L fill:#f3e5f5

Exception Types Handled:

• Price Mismatches: Tolerance-based resolution

• Quantity Discrepancies: Partial matching strategies

• Currency Issues: Conversion and validation

• Settlement Date Conflicts: Calendar-aware resolution

• Counterparty Problems: Risk-based escalation

---

🛠️ Implementation Procedure

Phase 1: Infrastructure Setup

Step 1: AWS Account Preparation

Prerequisites:

• AWS Account with appropriate permissions

• AWS CLI configured

• Docker installed (for local development)

Required AWS Services:

• Amazon Bedrock AgentCore

• Amazon DynamoDB

• Amazon Cognito

• AWS IAM

• Amazon CloudWatch

Step 2: DynamoDB Table Creation

erDiagram
    TRADES {
        string trade_id PK
        string instrument_id
        decimal quantity
        decimal price
        string side
        string account
        string status
        datetime created_at
        datetime updated_at
    }

    MATCHES {
        string match_id PK
        string trade_id_1 FK
        string trade_id_2 FK
        decimal confidence
        string match_type
        string status
        datetime created_at
    }

    EXCEPTIONS {
        string exception_id PK
        string trade_id FK
        string exception_type
        string details
        string status
        string priority
        datetime sla_deadline
        datetime created_at
    }

    AUDIT {
        string audit_id PK
        string trade_id FK
        string action
        string details
        string checksum
        datetime timestamp
    }

    TRADES ||--o{ MATCHES : "participates_in"
    TRADES ||--o{ EXCEPTIONS : "generates"
    TRADES ||--o{ AUDIT : "tracked_by"

AWS Console Steps:

1. Navigate to DynamoDB Console

2. Create tables with the schema above

3. Configure appropriate read/write capacity

4. Set up Global Secondary Indexes (GSIs) for query optimization

Step 3: IAM Role Configuration

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "dynamodb:GetItem",
        "dynamodb:PutItem",
        "dynamodb:UpdateItem",
        "dynamodb:DeleteItem",
        "dynamodb:Query",
        "dynamodb:Scan"
      ],
      "Resource": [
        "arn:aws:dynamodb:*:*:table/TradeSettlement-*"
      ]
    },
    {
      "Effect": "Allow",
      "Action": [
        "bedrock:InvokeModel",
        "bedrock:InvokeModelWithResponseStream"
      ],
      "Resource": "*"
    },
    {
      "Effect": "Allow",
      "Action": [
        "logs:CreateLogGroup",
        "logs:CreateLogStream",
        "logs:PutLogEvents"
      ],
      "Resource": "*"
    }
  ]
}

Phase 2: AgentCore Development

Step 1: Agent Implementation

Core Agent Structure:

from bedrock_agentcore.runtime import BedrockAgentCoreApp
from strands import Agent, tool
from strands.models import BedrockModel

# Initialize AgentCore App
app = BedrockAgentCoreApp()

# Initialize Foundation Model
model = BedrockModel(
    model_id="anthropic.claude-3-7-sonnet-20241022-v1:0",
    region="us-east-1"
)

@tool
def store_trade(trade_data: dict) -> dict:
    """Store trade with validation and normalization"""
    # Implementation details...
    pass

@tool
def find_matches(trade_id: str) -> dict:
    """Find potential matches for a trade"""
    # Implementation details...
    pass

# Agent Definitions
ingestion_agent = Agent(
    name="Trade Ingestion Agent",
    model=model,
    tools=[store_trade],
    instructions="""
    You are a trade ingestion specialist responsible for:
    1. Validating trade data integrity
    2. Normalizing data formats
    3. Storing trades with audit trails
    4. Handling validation errors gracefully
    """
)

matching_agent = Agent(
    name="Trade Matching Agent",
    model=model,
    tools=[find_matches],
    instructions="""
    You are a trade matching specialist using:
    1. Deterministic matching for exact matches
    2. Probabilistic matching for fuzzy matches
    3. Confidence-based decision making
    4. Exception creation for unmatched trades
    """
)

@app.entrypoint
def trade_settlement_handler(payload):
    """Main entrypoint for trade settlement operations"""
    operation = payload.get("operation", "status")

    if operation == "ingest":
        return ingestion_agent(payload)
    elif operation == "match":
        return matching_agent(payload)
    else:
        return {"status": "ready", "available_operations": ["ingest", "match"]}

Step 2: Configuration Setup

AgentCore Configuration (.bedrock_agentcore.yaml):

default_agent: trade_settlement_system
agents:
  trade_settlement_system:
    name: trade_settlement_system
    entrypoint: ./agentcore-blog/trade-settlements/fixed_cloud_agentcore.py
    platform: linux/arm64
    container_runtime: docker
    aws:
      execution_role: arn:aws:iam::09**********:role/agentcore-trade-settlement-role
      execution_role_auto_create: false
      account: 09**********
      region: us-east-1
      ecr_repository: 09**********.dkr.ecr.us-east-1.amazonaws.com/bedrock_agentcore-trade_settlement_system
      ecr_auto_create: true
      network_configuration:
        network_mode: PUBLIC
      protocol_configuration:
        server_protocol: HTTP
      observability:
        enabled: true
    bedrock_agentcore:
      agent_id: trade_settlement_system-iQ2FTU7Rbd
      agent_arn: arn:aws:bedrock-agentcore:us-east-1:09**********:runtime/trade_settlement_system-iQ2FTU7Rbd
      agent_session_id: d131fe07-2cda-4521-9f45-987cfea341c6
    codebuild:
      project_name: bedrock-agentcore-trade_settlement_system-builder
      execution_role: arn:aws:iam::09**********:role/AmazonBedrockAgentCoreSDKCodeBuild-us-east-1-6ec1ed5707
      source_bucket: bedrock-agentcore-codebuild-sources-098493093308-us-east-1
    authorizer_configuration: null
    oauth_configuration: null

Phase 3: Gateway and Identity Setup

Step 1: Cognito User Pool Configuration

graph LR
    A[Client Application] --> B[Cognito User Pool]
    B --> C[OAuth2 Token]
    C --> D[AgentCore Gateway]
    D --> E[Agent Runtime]

    style B fill:#ff9800
    style D fill:#ff5722
    style E fill:#2196f3

Cognito Setup Steps:

1. Create User Pool in AWS Console

2. Configure OAuth2 client credentials flow

3. Set up resource server and scopes

4. Generate client credentials

Step 2: AgentCore Gateway Creation

Gateway Configuration:

{
  "gatewayName": "TradeSettlementGateway",
  "description": "Gateway for Trade Settlement AgentCore System",
  "identityConfiguration": {
    "type": "COGNITO_USER_POOL",
    "userPoolId": "us-east-1_XXXXXXXXX",
    "clientId": "your-client-id"
  },
  "targetConfiguration": {
    "type": "AGENT_RUNTIME",
    "agentRuntimeArn": "arn:aws:bedrock-agentcore:us-east-1:ACCOUNT:runtime/trade_settlement_system"
  }
}

[Screenshot Placeholder: AgentCore Console showing gateway creation

]

Phase 4: Deployment and Testing

Step 1: Local Development and Testing

# Install dependencies
pip install bedrock-agentcore strands boto3

# Local testing
python local_agentcore_test.py

# Local container build and test
agentcore launch --local

Step 2: Cloud Deployment

# Build and deploy to cloud
agentcore launch --agent trade_settlement_system

# Check deployment status
agentcore status

# Test cloud deployment
agentcore invoke '{"prompt": "Hello AgentCore"}'

Step 3: Gateway Testing

import requests
import json
import base64

# Get OAuth2 token
def get_access_token():
    credentials = f"{CLIENT_ID}:{CLIENT_SECRET}"
    encoded_credentials = base64.b64encode(credentials.encode()).decode()

    response = requests.post(
        f"{COGNITO_DOMAIN}/oauth2/token",
        headers={
            "Authorization": f"Basic {encoded_credentials}",
            "Content-Type": "application/x-www-form-urlencoded"
        },
        data={
            "grant_type": "client_credentials",
            "scope": "TradeSettlementGateway/invoke"
        }
    )
    return response.json()["access_token"]

# Test gateway
def test_gateway():
    token = get_access_token()

    payload = {
        "jsonrpc": "2.0",
        "id": 1,
        "method": "tools/call",
        "params": {
            "name": "store_trade",
            "arguments": {
                "trade_data": {
                    "trade_id": "TEST_001",
                    "instrument_id": "AAPL",
                    "quantity": 100,
                    "price": 175.50,
                    "side": "BUY",
                    "account": "TEST_ACCOUNT"
                }
            }
        }
    }

    response = requests.post(
        GATEWAY_URL,
        headers={"Authorization": f"Bearer {token}"},
        json=payload
    )

    return response.json()

---

📊 Monitoring and Observability

CloudWatch Integration

graph TB
    subgraph "AgentCore Runtime"
        A[Agent Execution] --> B[Metrics Collection]
        A --> C[Log Generation]
        A --> D[Trace Creation]
    end

    subgraph "CloudWatch"
        E[CloudWatch Metrics] --> F[Custom Dashboards]
        G[CloudWatch Logs] --> H[Log Insights]
        I[X-Ray Traces] --> J[Service Map]
    end

    subgraph "Alerting"
        K[CloudWatch Alarms] --> L[SNS Notifications]
        L --> M[Email/SMS Alerts]
        L --> N[Lambda Functions]
    end

    B --> E
    C --> G
    D --> I
    F --> K
    H --> K
    J --> K

    style A fill:#2196f3
    style E fill:#ff9800
    style G fill:#ff9800
    style I fill:#ff9800
    style K fill:#f44336

Key Metrics to Monitor:

• Agent Performance: Execution time, success rate, error rate

• Trade Processing: Throughput, latency, match rate

• Exception Handling: Exception volume, resolution time, escalation rate

• 

Custom Dashboards

Dashboard Components:

1. Real-time Trade Volume: Live trade ingestion rates

2. Match Rate Trends: Historical matching performance

3. Exception Analytics: Exception types and resolution patterns

4. Agent Performance: Individual agent execution metrics

5. System Health: Infrastructure and resource utilization

🎯 Performance Optimization

Scaling Strategies

Horizontal Scaling

• Auto Scaling: Automatic container scaling based on demand

• Load Distribution: Intelligent request routing

• Resource Optimization: Dynamic resource allocation

Vertical Scaling

• Memory Optimization: Right-sizing based on workload

• CPU Allocation: Performance tuning for compute-intensive tasks

• Storage Optimization: Efficient data access patterns

Cost Optimization

pie title Cost Distribution
    "Foundation Model Usage" : 45
    "Container Runtime" : 25
    "Data Storage" : 15
    "Network Transfer" : 10
    "Monitoring & Logging" : 5

Cost Optimization Strategies:

• Model Selection: Choose cost-effective models for specific tasks

• Caching: Reduce redundant model calls

• Batch Processing: Optimize for throughput vs. latency

• Resource Scheduling: Scale down during low-activity periods

---

🎯 What's Next?

In Part 3 of this series, we'll cover:

Testing and Validation

• Comprehensive testing strategies and frameworks

• Performance benchmarking and load testing

• Integration testing with existing systems

• User acceptance testing procedures

Deployment Considerations

• Production deployment best practices

• Blue-green deployment strategies

• Rollback procedures and disaster recovery

• Change management and version control

Real-World Challenges

• Common implementation issues and solutions

• Performance tuning and optimization

• Troubleshooting and debugging techniques

• Lessons learned and best practices

---

📝 Key Takeaways

1. Amazon Bedrock AgentCore provides a comprehensive platform for agentic AI applications

2. Proper architecture design is crucial for scalable and maintainable solutions

3. Security and compliance must be built-in from the ground up

4. Monitoring and observability are essential for production operations

5. Performance optimization requires continuous tuning and optimization

---

🔗 Series Navigation

• Part 1: Problem Statement and Agentic AI Solution

• Part 2: Bedrock AgentCore Deep Dive and Implementation ← You are here

• Part 3: Testing, Deployment, and Real-World Considerations ← Soon will be created

---

Ready to deploy your agentic AI solution? Join us in Part 3 where we'll explore testing strategies, deployment best practices, and real-world implementation challenges.