Amazon Bedrock AgentCore v2.0 完全ガイド 2026

概要： Amazon Bedrock AgentCore は、自律 AI エージェント（複雑なマルチステップタスクを自動実行する AI）の実行・管理基盤。メモリ管理・ツール呼び出し・マルチエージェントオーケストレーション・Gateway・Code Interpreter をマネージドで提供し、Bedrock 上で LangChain・LangGraph・Strands Agents などのオープンソース SDK を統合し、エンタープライズグレードのエージェントアーキテクチャを構築・デプロイ・スケールできる。2024 年末 GA・2025-2026 年に急速に進化中。

目次

1. 1. 本質・課題・特徴
2. 2. アーキテクチャ図
3. 3. コアコンポーネント
4. 4. 主要ユースケース（10+）
5. 5. AgentCore Runtime・管理機能
6. 6. Memory & State Management
7. 7. Multi-Agent Orchestration
8. [8. Integrations（LangChain・Strands・LlamaIndex）](#8-integrationslangchainstrlandsllama index)
9. 9. Code Interpreter & Tools
10. 10. Gateway & Observability
11. 11. 設定・操作の具体例
12. 12. 類似サービス比較表
13. 13. ベストプラクティス
14. 14. トラブルシューティング
15. 15. 2025-2026 最新動向
16. 16. 学習リソース・参考文献
17. 17. 実装例・チェックリスト
18. 18. まとめ

1. 本質・課題・特徴

1.1 本質

Amazon Bedrock AgentCore は 「自律 AI エージェントの実行・管理基盤」 です。複雑なマルチステップタスク（例：「顧客の注文を検索→在庫確認→配送スケジュール決定→請求書生成」）を自動実行するカスタム AI エージェントを、ノーコード＋低コードで構築・デプロイ・スケールできます。

従来の Bedrock Agents（GUI でアクション定義）から進化した 次世代基盤 として、LangChain・LangGraph・Strands Agents などのオープンソース SDK をネイティブサポート。メモリ・マルチエージェント・Code Interpreter・永続状態管理をマネージドで提供し、開発者は「エージェントの論理（ロジック）」に集中可能。

1.2 解決する課題

エンタープライズが直面する課題

• 複雑なワークフロー自動化の困難さ：複数のステップ（検索→分析→判定→実行）を含むタスクを自動化する場合、各ステップ間の状態・メモリ管理が複雑。従来の RPA・ワークフロー自動化ツールは拡張性に乏しい
• エージェントのステートフルな対話の実現困難：チャットボットなら簡単だが、「ユーザーとの複数ターンの対話」「会話履歴の参照」「コンテキストの保持」を実現するには、セッション管理・メモリストア・履歴取得が必要
• マルチエージェント協調実行の管理複雑性：専門エージェント（リサーチ・分析・レポート生成）を協調させる場合、エージェント間の通信・タスク委譲・結果統合をハンドコーディングするのは負担
• エージェント実行インフラの自前構築が必要：LangChain・AutoGen でカスタムエージェントを構築すると、コンテナ化・スケーリング・セッション管理・エラー復旧を自前で実装する必要
• 高度な推論・計算実行が必要な場合の処理遅延：エージェントが Python コードを生成・実行してデータ分析・複雑計算をしたい場合、サンドボックス環境が必要（Code Interpreter）
• 信頼度・トレーサビリティの確保困難：エージェントの意思決定プロセス・使用したツール・参照したデータを追跡しにくく、誤った判定の原因特定が困難

1.3 主な特徴

2. アーキテクチャ図

2.1 全体アーキテクチャ

graph TB
    subgraph "User / Application"
        WebApp["Web Application<br/>Chat UI / API Client"]
        ExtSys["External Systems<br/>Salesforce, ServiceNow<br/>Slack, etc."]
    end
    
    subgraph "AgentCore Platform"
        Gateway["Gateway<br/>認証・レート制限<br/>リクエストルーティング"]
        Runtime["Agent Runtime<br/>実行エンジン<br/>マルチテナント"]
        Memory["Memory Store<br/>会話履歴・ユーザーコンテキスト<br/>永続化"]
        Orchestrator["Orchestration Engine<br/>マルチエージェント調整<br/>タスク委譲"]
        CI["Code Interpreter<br/>Python コード実行<br/>サンドボックス"]
    end
    
    subgraph "Agent Framework"
        SuperAgent["Supervisor Agent<br/>タスク分解・調整<br/>Claude ベース"]
        SubAgent1["Sub-Agent 1<br/>Research Agent<br/>Web・DB 検索"]
        SubAgent2["Sub-Agent 2<br/>Analysis Agent<br/>データ分析"]
        SubAgent3["Sub-Agent 3<br/>Writer Agent<br/>レポート生成"]
    end
    
    subgraph "Tools & Integrations"
        Tools["Tool Registry<br/>Lambda・HTTP API<br/>AWS Service API"]
        KnowledgeBase["Knowledge Bases<br/>RAG データソース"]
        ExternalAPIs["External APIs<br/>REST・GraphQL"]
    end
    
    subgraph "Bedrock Layer"
        FM["Foundation Models<br/>Claude 3 series<br/>Llama 2/3<br/>Others"]
    end
    
    subgraph "Monitoring & Storage"
        CloudWatch["CloudWatch<br/>Logs・Metrics<br/>Traces"]
        Audit["Audit Trail<br/>IAM・CloudTrail<br/>コンプライアンス"]
        S3["S3<br/>エージェント生成ファイル<br/>レポート保存"]
    end
    
    WebApp -->|Request| Gateway
    ExtSys -->|Webhook| Gateway
    
    Gateway -->|Route| Runtime
    Runtime -->|Query| Memory
    Runtime -->|Manage| Orchestrator
    
    Orchestrator -->|Supervise| SuperAgent
    SuperAgent -->|Delegate| SubAgent1
    SuperAgent -->|Delegate| SubAgent2
    SuperAgent -->|Delegate| SubAgent3
    
    SubAgent1 -->|Call| Tools
    SubAgent2 -->|Query| KnowledgeBase
    SubAgent3 -->|Integrate| ExternalAPIs
    
    Runtime -->|Execute| CI
    CI -->|Generate Code| FM
    
    SuperAgent -->|Invoke| FM
    SubAgent1 -->|Invoke| FM
    SubAgent2 -->|Invoke| FM
    SubAgent3 -->|Invoke| FM
    
    Runtime -->|Log| CloudWatch
    Orchestrator -->|Audit| Audit
    SubAgent3 -->|Store| S3
    
    style Runtime fill:#146EB4
    style FM fill:#FF9900
    style Memory fill:#90EE90
    style CI fill:#FFB6C1

2.2 エージェント実行フロー

sequenceDiagram
    participant U as ユーザー
    participant G as Gateway
    participant SA as Supervisor Agent
    participant M as Memory
    participant R1 as Research Agent
    participant R2 as Analysis Agent
    participant W as Writer Agent
    participant CI as Code Interpreter
    participant FM as Claude FM
    
    U->>G: "3 月の営業成績を分析して"
    G->>SA: Task Request + User Context
    SA->>M: 過去の分析リクエスト確認
    M-->>SA: "前月は月間 $2.5M"
    
    SA->>R1: "3 月の営業データを収集"
    R1->>FM: 実行計画提案要求
    FM-->>R1: "SalesForce API + S3 から取得"
    R1->>R1: Tool Call: SalesForce API
    R1-->>SA: 売上 $3.2M、件数 450、新規 120
    
    SA->>R2: "データ分析："前年比・前月比・カテゴリ別"
    R2->>FM: 分析アルゴリズム要求
    FM-->>R2: "pandas + matplotlib for visualization"
    R2->>CI: Python コード実行要求
    CI->>CI: exec(data_analysis.py)
    CI-->>R2: グラフ・統計量
    R2-->>SA: 前月比 +28%、新規顧客 +45%
    
    SA->>W: "レポート生成："要点・グラフ・提案"
    W->>FM: レポート構成要求
    FM-->>W: Markdown template
    W->>W: Template fill + S3 アップロード
    W-->>SA: Report URL
    
    SA->>M: "分析結果・メタデータ保存"
    M-->>SA: Stored
    
    SA-->>G: Final Report + Analysis Details
    G-->>U: "3 月営売成績: $3.2M（前月比 +28%）<br/>Report: [link]"
    U->>U: レポート確認
    
    U->>G: "なぜ新規顧客が増えたのか？"
    G->>SA: Follow-up Question
    SA->>M: メモリから前回の分析取得
    M-->>SA: 過去の分析コンテキスト
    SA->>FM: 前回データ + 新質問で推論
    FM-->>SA: 新規営業キャンペーン影響の分析
    SA-->>G: 原因分析・提案
    G-->>U: 回答表示

3. コアコンポーネント

3.1 Agent Runtime（実行エンジン）

定義：エージェントコード（LangChain・Strands）を実行し、ツール呼び出し・メモリ管理・エラー復旧を自動化。

実行フロー

1. User Request → Gateway で受け取り
2. Gateway が Request を AgentCore Runtime へ送付
3. Runtime が Agent Code をロード（Lambda / Container）
4. Agent がツール呼び出し・FM 推論実行
5. Runtime が Tool Results を Agent へフィードバック
6. Agent が推論 → 次アクション決定
7. Loop: Steps 4-6 を反復（ストップ条件まで）
8. Runtime が最終結果を Memory に保存
9. Response を Gateway → User へ返却

特徴

• Stateless 実行：各ステップの実行は異なるコンテナで可能。スケーラビリティ確保
• Fault Tolerance：Agent 実行失敗時は自動リトライ。一時的エラーは無視
• Timeout 管理：タスクが無限ループに陥るのを防止（デフォルト 15 分）
• Token Usage Track：各 FM 呼び出しのトークン使用をカウント・課金

3.2 Agent Memory（永続メモリ）

定義：ユーザー・エージェントの会話履歴・設定・学習情報を永続化。複数セッション間で参照可能。

メモリタイプ

① Episodic Memory（エピソード記憶）
   定義: 過去のやり取り・イベント
   例: "2025-03-15 10:00, ユーザー: '営売レポートして'
         Agent: 生成したレポート..."
   用途: Conversation History, ユーザー質問への cotext

② Semantic Memory（意味記憶）
   定義: ファクト・知識・統計
   例: "Company X: 2024 年売上 $50M, HQ: NY"
   用途: Knowledge Base, RAG ソース

③ Procedural Memory（手続き記憶）
   定義: 習得パターン・ワークフロー
   例: "Customer support → Priority Check → KB Search → Action"
   用途: Agent decision pattern, 推奨アクション

④ User Profile（ユーザープロフィール）
   定義: ユーザー属性・設定・権限
   例: "User: john@acme.com, Dept: Sales, Role: Manager"
   用途: ACL, Personalization, 提案カスタマイズ

Memory Store 実装

DynamoDB（推奨）:
  Partition Key: user_id
  Sort Key: timestamp
  Attributes:
    - conversation_id
    - message_type (user_msg, agent_msg, tool_call)
    - content
    - metadata (tool_name, tokens_used, etc.)
    - ttl (30 days)

RDS（複雑なクエリが必要な場合）:
  Users Table: user_id, profile_json, created_at
  Conversations Table: conv_id, user_id, messages[], metadata
  Index: user_id, timestamp

S3（大容量ファイル）:
  s3://agent-memory/user_{user_id}/conversation_{conv_id}/
    ├── metadata.json
    ├── messages.jsonl
    ├── generated_reports/
    └── artifacts/

Memory の活用例

ユーザー: "前月のレポートをベースに、今月の追加分析をして"
    ↓
AgentCore Runtime:
  1. Memory Store から前月レポート取得
  2. User Profile から権限確認（このユーザーは Dept=Sales?）
  3. Supervisor Agent に「前月データ + 新要求」を渡す
  4. Agent が前月分析と比較分析を実行
  5. 新レポート生成 & Memory に保存

結果: ユーザーは過去のコンテキストなしで最新情報を得られる

3.3 Orchestration Engine（マルチエージェント調整）

定義：複数のエージェントを協調させるスーパーバイザーエージェント。タスク分解・委譲・結果統合を自動化。

構成図

         ┌─────────────────┐
         │ Supervisor Agent│
         │  (Claude 3.5)   │
         └────────┬────────┘
                  │
         Task: Analyze customer churn
            ↓
         分解: 3 つのサブタスク
         ├── Task 1: Customer data extraction
         ├── Task 2: Churn pattern analysis
         └── Task 3: Recommendation generation
            ↓
    ┌──────┴──────┬──────────┐
    ↓             ↓          ↓
┌─────────┐  ┌────────┐ ┌─────────┐
│ Research│  │Analysis │ │ Writer  │
│ Agent   │  │ Agent   │ │  Agent  │
└────┬────┘  └───┬────┘ └────┬────┘
     │           │           │
Research:    Analysis:   Report:
- Fetch data - ML model  - Structure
- Clean     - Stats      - Visualize
- Validate  - Insights   - Publish

     │           │           │
     └──────┬────┴────┬──────┘
            ↓         ↓
     ┌─────────────────────┐
     │ Supervisor Integrate│
     │ Results & Respond   │
     └─────────────────────┘

オーケストレーションパターン

① Sequential（順序実行）
   Task A → Task B → Task C
   例: Data fetch → Analysis → Report

② Parallel（並列実行）
   Task A ┐
   Task B ├─→ Integration
   Task C ┘
   例: Web search, DB query, API call を同時実行

③ Conditional（条件分岐）
   if (データ quality > threshold)
     → Full Analysis
   else
     → Request Data Validation
   
④ Feedback Loop（フィードバックループ）
   Analysis → Result ↓
   ↓─────────Review Agent──→ 修正
              ↑
           修正不要なら出力

3.4 Code Interpreter（Python 実行環境）

定義：エージェントが生成する Python コードを安全なサンドボックスで実行。データ分析・計算・グラフ生成などを AI が自動実施。

実行例

# Agent が自動生成するコード
import pandas as pd
import matplotlib.pyplot as plt
from datetime import datetime, timedelta

# User が指定したクエリ: "過去 3 ヶ月の日別売上トレンド"
# Agent が以下を自動生成して実行:

def analyze_sales_trend():
    # S3 からデータ取得
    df = pd.read_csv('s3://sales-data/transactions.csv')
    
    # フィルタリング: 過去 3 ヶ月
    cutoff_date = datetime.now() - timedelta(days=90)
    df['date'] = pd.to_datetime(df['date'])
    df = df[df['date'] >= cutoff_date]
    
    # 日別集計
    daily_sales = df.groupby('date')['amount'].sum()
    
    # グラフ生成
    plt.figure(figsize=(12, 6))
    plt.plot(daily_sales.index, daily_sales.values, marker='o')
    plt.title('Daily Sales Trend - Last 3 Months')
    plt.xlabel('Date')
    plt.ylabel('Sales ($)')
    plt.grid()
    
    # S3 へ保存
    plt.savefig('s3://agent-outputs/sales_trend.png')
    
    # 統計情報を返却
    return {
        'total_sales': daily_sales.sum(),
        'avg_daily': daily_sales.mean(),
        'trend': 'upward' if daily_sales.iloc[-1] > daily_sales.iloc[0] else 'downward',
        'chart_url': 's3://agent-outputs/sales_trend.png'
    }

result = analyze_sales_trend()
return result  # Agent が次の推論に使用

セキュリティ機構

• コード検証：実行前に危険なオペレーション（os.system, __import__など）をチェック
• リソース制限：CPU（1 vCPU）・メモリ（512MB）・実行時間（5 分）制限
• Network 隔離：VPC 内での実行・外部ネットワークアクセスは明示的ホワイトリスト
• Audit Trail：実行されたすべてのコードを CloudWatch に記録

3.5 Gateway（API ゲートウェイ）

定義：AgentCore Agent API の認証・レート制限・ルーティング・モニタリングを一元管理。

機能

認証層:
  ✅ IAM Authentication（AWS Principal）
  ✅ API Key（発行・ローテーション）
  ✅ SAML 2.0 / OIDC
  ✅ mTLS（相互認証）

レート制限:
  ✅ Per-user limit（1,000 req/hour）
  ✅ Per-agent limit（100 concurrent）
  ✅ Per-model limit（Bedrock の制限）

ルーティング:
  ✅ Request を複数 Agent へ分散
  ✅ Canary deployment（段階的ロールアウト）
  ✅ A/B testing（異なるモデル・プロンプト）

Monitoring:
  ✅ Request/Response latency
  ✅ Error rate
  ✅ Token usage（コスト追跡）
  ✅ Tool call success rate

Gateway の設定例

Gateway Policy:
  {
    "agents": [
      {
        "agent_id": "sales-agent",
        "rate_limit": {
          "requests_per_minute": 10,
          "concurrent": 5
        },
        "auth": "api_key",
        "model": "claude-3-opus",
        "timeout_sec": 300
      }
    ]
  }

3.6 Tool Registry（ツール管理）

定義：Agent が呼び出し可能なツール（Lambda・HTTP API・AWS Service API）を集約管理。

ツール定義形式

Tool: GetCustomerData
  Type: Lambda
  Function: arn:aws:lambda:ap-northeast-1:123456789012:function:customer-lookup
  Input Schema:
    customer_id: string (required)
    fields: array of string (optional)
  Output Schema:
    customer_name: string
    email: string
    phone: string
    account_balance: number
  Description: "Fetch customer information from Salesforce"

Tool: AnalyzeSentiment
  Type: HTTP
  Endpoint: https://api.example.com/v1/sentiment
  Method: POST
  Auth: BearerToken
  Input Schema:
    text: string
    language: string
  Output Schema:
    sentiment: enum [positive, negative, neutral]
    score: number (0-1)
  Description: "Analyze text sentiment using NLP"

Tool: UpdateDynamoDBItem
  Type: AwsService
  Service: DynamoDB
  Operation: UpdateItem
  Table: user_profiles
  Input Schema:
    user_id: string
    attributes: object
  Auth: IAM Role
  Description: "Update user profile in DynamoDB"

4. 主要ユースケース

4.1 Financial Analysis & Report Generation（金融分析・レポート生成）

シナリオ：複数データソースから財務データ収集→分析→レポート自動生成。Supervisor が Research・Analysis・Writer エージェント を協調。

ユーザー: "2025 Q1 財務パフォーマンスレポートを作成"
    ↓
Supervisor Agent:
  分解: 3 タスク
  
① Research Agent:
   - ERP システムから Q1 収益・利益データ取得
   - 銀行口座から キャッシュフロー情報取得
   - S3 から競合企業の公開財務データ取得
   結果: 構造化データセット

② Analysis Agent:
   - Code Interpreter で Python 実行
   - YoY（前年同期比）・QoQ（前四半期比）計算
   - 利益率・ROI・キャッシュ流動性分析
   - 異常値検出（e.g., 突然の売上 50% 増）
   - グラフ・チャート生成
   結果: インサイト・統計量

③ Writer Agent:
   - LLM で Executive Summary 作成
   - Analysis Agent の結果を要点に整形
   - グラフ・テーブルを Markdown に埋め込み
   - Compliance チェック（PII マスキング）
   - PDF エクスポート
   結果: 最終レポート

出力: PDF レポート + JSON 形式のメタデータ
時間: 従来（手動）3-5 日 → AI（AgentCore）15 分

4.2 Customer Support Automation（カスタマーサポート自動化）

シナリオ：顧客問い合わせ→原因診断→ナレッジベース検索→アクション実行→チケット自動生成。

顧客: "Slack で『ログインできません』と報告"
    ↓
AgentCore Support Agent:
  1. Support Agent が問い合わせ受信
  2. Memory から顧客プロフィール取得
  3. 問題を 3 カテゴリに分類：
     - Password Issue?
     - Account Lockout?
     - Service Outage?

  Case: Password Issue → Sub-agents 委譲
  
  ① Diagnosis Agent:
     - ユーザー認証ログ確認（Security Agent）
     - エラーメッセージ解析
     - 結果: "Password incorrect 3 times in 10 min → Account locked"

  ② Knowledge Agent:
     - ナレッジベース検索: "account locked recovery"
     - 手順 3 ステップ提示
     
  ③ Action Agent:
     - ServiceNow で Self-Service Ticket 自動作成
     - パスワードリセットリンク自動生成・メール送信
     - Slack で顧客に直接回答
     
  ④ Follow-up Agent（24 時間後）:
     - 問題が解決したか確認
     - 解決しなければ人間エージェントへエスカレート

結果: 自動対応率 85%, 平均解決時間 5 分（従来 2 時間）

4.3 Data Scientist Assistant（データサイエンティスト補助）

シナリオ：データ分析の自動化。EDA（探索的データ分析）→モデル学習→パフォーマンス検証をエージェント が自動実施。

データサイエンティスト: 
  "Kaggle のチャーン予測データセットで、
   baseline model を作成して、
   ROC AUC 0.85 以上になるように最適化して"

    ↓
AgentCore Data Science Agent:
  
① Data Exploration Agent（EDA 自動化）:
   import pandas as pd, matplotlib.pyplot as plt
   
   # Code Interpreter で以下を自動生成・実行:
   - データサイズ・型・欠損値確認
   - 分布・相関性分析
   - 異常値検出
   - Feature distribution visualization
   
   Report: EDA サマリー + グラフ

② Feature Engineering Agent:
   - 数値特徴のスケーリング
   - カテゴリカル変数のエンコード
   - 複合特徴生成
   - Collinearity チェック
   
   Result: 最適化された Feature Matrix

③ Model Training Agent:
   # Code Interpreter で自動生成・実行:
   from sklearn.ensemble import RandomForestClassifier
   from sklearn.model_selection import cross_val_score
   
   models = [LogisticRegression, RandomForest, XGBoost]
   for model in models:
       train(X_train, y_train)
       score = evaluate(X_test, y_test)
       if score > 0.85:
           save_model(model)
           break
   
   Result: 最高パフォーマンスモデルの自動選択

④ Report Agent:
   - モデルパフォーマンス報告書生成
   - ROC Curve・Confusion Matrix グラフ
   - Feature Importance ランキング
   - 推奨アクション（本番デプロイ or 再学習）

結果: 従来（手動）1-2 週間 → AI（AgentCore）1-2 時間

4.4 Incident Response Automation（インシデント対応自動化）

シナリオ：セキュリティ・システムインシデント検知→診断→対応→通知を自動化。

Security Monitoring: CloudGuard が異常検知
  イベント: "Unauthorized S3 access attempt from unknown IP"

    ↓
AgentCore Security Response Agent:

① Incident Detection & Assessment:
   - CloudTrail ログ取得
   - API 呼び出しパターン分析
   - IP 評判チェック（threat intelligence DB）
   - 影響範囲推定（accessed S3 buckets）
   
   判定: "High severity - Potential data breach"

② Containment Actions:
   - 疑わしい IAM User の一時停止
   - IP からのアクセスをセキュリティグループで即座にブロック
   - 影響を受けたリソースのスナップショット作成
   - CloudTrail ログ保存用の S3 にコピー

③ Investigation:
   - 過去 30 日の同ユーザーアクティビティ検索
   - ダウンロードされたデータ量推定
   - Lateral Movement 試みの有無確認
   
   Report: Timeline + Findings

④ Notification & Escalation:
   - Security Team に Slack 通知
   - CEO に Executive Summary メール
   - Incident ticket 自動作成（ServiceNow）
   - 監査ログ出力（PCI-DSS / SOC 2 対応）

⑤ Automated Remediation（設定可能）:
   - Exposed credential の自動ローテーション
   - Affected user への MFA reset 強制
   - Temporary access token の無効化

結果: 平均検知〜初期対応時間 5 分（従来 2-4 時間）

4.5 Real Estate / Property Management

シナリオ：物件情報検索→適合判定→提案書生成をエージェント が自動化。

顧客（不動産仲介業者）: 
  "都内 3 LDK、予算 8,000 万円以下、駅徒歩 10 分以内の物件を探して、
   適合物件を見つけたら、
   金利・税金・管理費を含めた購入シミュレーション表を作成して"

    ↓
AgentCore Real Estate Agent:

① Search Agent:
   - 複数 DB（Suumo, Homes, 不動産会社 API）から物件検索
   - フィルタリング: 価格・広さ・アクセス
   - 候補 10 件をランク付け
   
   Result: 適合物件 5 件リスト

② Evaluation Agent:
   - 各物件の:
     - 周辺環境評価（学校・病院・商業施設距離）
     - 治安スコア
     - 将来の値上がり予測（AI 分析）
   
   Result: スコア付きランキング Top 3

③ Financial Analysis Agent:
   - Code Interpreter で金融計算:
     ローン返済額（金利 3.5%, 35 年）
     固定資産税計算
     管理費・修繕費推定
     トータルコスト計算
   
   Report: Excel スプレッドシート

④ Proposal Agent:
   - PDF 提案書生成
     - 物件概要（写真・設備）
     - 周辺情報
     - 購入シミュレーション表
     - リスク・リターン分析
   
   Report: PDF + JSON

結果: 従来（営業 3-5 日）→ AI（15 分）

4.6-4.10 その他のユースケース

4.6 E-commerce Product Recommendation
  顧客閲覧履歴 → 推奨エンジン → Personalized offer 生成

4.7 HR / Recruitment Automation
  職務経歴書 → スキルマッチング → インタビュー質問自動生成

4.8 Compliance & Risk Management
  契約書 → Clause 抽出 → リスク評価 → 法務チェック

4.9 Market Research & Competitive Intelligence
  Web crawler → データ集計 → トレンド分析 → Executive Summary

4.10 Manufacturing Quality Control
  IoT sensor data → 異常検知 → Root cause analysis → 修正提案

5. AgentCore Runtime・管理機能

5.1 Agent Deployment（エージェント展開）

デプロイメント方法

① No-Code UI（コンソール）
   AWS Management Console
   → AgentCore → Agents → Create New
   → テンプレート選択（Supervisor, Single-Agent, etc.）
   → GUI で設定
   → Deploy

② Low-Code（AWS CDK）
   from aws_cdk import (
       core,
       bedrock_agentcore as agentcore
   )
   
   class AgentStack(core.Stack):
       def __init__(self, scope: core.Construct, id: str, **kwargs):
           super().__init__(scope, id, **kwargs)
           
           agent = agentcore.Agent(
               self, "MyAgent",
               agent_name="sales-agent",
               model="claude-3-opus",
               tools=[
                   agentcore.LambdaTool("GetCustomerData", ...),
                   agentcore.HTTPTool("SearchProducts", ...)
               ],
               memory_config=agentcore.MemoryConfig(
                   store="dynamodb",
                   retention_days=30
               )
           )

③ Code（SDK / API）
   import boto3
   
   client = boto3.client('bedrock-agentcore')
   
   response = client.create_agent(
       agentName='my-agent',
       foundationModel='anthropic.claude-3-opus-20240229-v1:0',
       tools=[
           {
               'type': 'lambda',
               'name': 'GetData',
               'arn': 'arn:aws:lambda:...'
           }
       ],
       memory={
           'type': 'dynamodb',
           'table': 'agent-memory'
       }
   )

5.2 Agent Monitoring & Observability

CloudWatch Metrics

Agent-Level:
  ✅ requests_per_minute
  ✅ average_latency_ms
  ✅ error_rate（%）
  ✅ tool_call_count
  ✅ tool_success_rate
  ✅ tokens_used（入力・出力・total）
  ✅ cost_usd

Tool-Level:
  ✅ tool_call_count (by tool)
  ✅ tool_average_duration_ms
  ✅ tool_error_rate
  ✅ tool_timeout_count

Model-Level:
  ✅ model_inference_latency_ms
  ✅ prompt_token_count
  ✅ completion_token_count
  ✅ model_output_length_avg

Memory-Level:
  ✅ memory_store_latency_ms
  ✅ memory_read_count
  ✅ memory_write_count
  ✅ memory_storage_size_gb

CloudWatch Logs

ログフォーマット:

{
  "timestamp": "2025-04-26T10:35:20.123Z",
  "request_id": "req-abc123xyz",
  "agent_id": "agent-sales-001",
  "user_id": "user-john@acme.com",
  "event_type": "tool_call",
  "tool_name": "salesforce_api",
  "tool_input": { "query": "customer_id=12345" },
  "tool_output": { "customer_name": "Acme Inc", ... },
  "tool_duration_ms": 450,
  "tokens_used": {
    "input": 250,
    "output": 100
  },
  "status": "success"
}

# ログからのカスタムメトリクス抽出（CloudWatch Insights）
fields @timestamp, agent_id, tool_name, tool_duration_ms
| stats avg(tool_duration_ms) by tool_name
| sort 1

5.3 Cost Management

コスト構成

AgentCore Pricing（2026 年現在）:

1. Model Inference Cost（Bedrock）
   - Input tokens: $0.003 / 1K tokens（Claude 3 Haiku）
   - Output tokens: $0.015 / 1K tokens
   
2. Agent Execution Cost（AgentCore）
   - Agent task: $0.01 per task（max 15 min）
   - Tool invocation: $0.001 per call
   - Memory store: $0.001 per read, $0.0005 per write（DynamoDB）

3. Code Interpreter Cost
   - Execution: $0.10 per execution（max 5 min）
   - Storage (S3): $0.023 per GB/month

例) データ分析エージェント実行コスト:
  - 入力 tokens 2,000: $0.006
  - 出力 tokens 500: $0.0075
  - Agent execution（5 ステップ）: $0.05
  - Tool calls（10 calls）: $0.01
  - Code Interpreter（2 実行）: $0.20
  ─────────────────────
  合計: 約 $0.28 / 1 実行
  
月単位: 1,000 実行 / 月 = $280 / 月

6. Memory & State Management

6.1 Memory Architecture

3-Tier Memory System:

Tier 1: Session Cache（高速、短期）
  Store: ElastiCache（Redis）
  TTL: 1 時間
  用途: 現在のセッション中の会話履歴
  例: Agent がツール呼び出し中、前の出力をすぐ参照

Tier 2: Persistent Store（中速、中期）
  Store: DynamoDB / RDS
  TTL: 30-90 日
  用途: ユーザー会話履歴・ユーザープロフィール
  例: 「先月質問したコンテキストに基づいて」

Tier 3: Long-term Archive（低速、長期）
  Store: S3 + Glacier
  Retention: 7 年（コンプライアンス）
  用途: 監査ログ・参照用アーカイブ
  例: 規制当局の監査対応

6.2 State Management

Agent State Machine:

┌─────────────────────────────────────┐
│ IDLE                                 │
│ Agent が待機状態                      │
└──────────────┬──────────────────────┘
               │ New Request
               ↓
┌─────────────────────────────────────┐
│ RECEIVED                             │
│ Request を受け取った                  │
└──────────────┬──────────────────────┘
               │ Load context
               ↓
┌─────────────────────────────────────┐
│ REASONING                            │
│ FM に推論させて次アクション決定        │
└──────────────┬──────────────────────┘
               │
        ┌──────┴──────┐
        ↓             ↓
   TOOL_CALL    GENERATE_RESPONSE
        │             │
        ↓             ↓
   Tool        Response Ready
   実行           │
        │         ↓
        └────┬────┘
             ↓
┌─────────────────────────────────────┐
│ COMPLETE                             │
│ レスポンス返却・状態保存               │
└──────────────┬──────────────────────┘
               │
               ↓
         IDLE（戻る）

7. Multi-Agent Orchestration

7.1 Orchestration Patterns

Pattern 1: Sequential（順序実行）

Task A → Task B → Task C → Complete

用途: ETL パイプライン、データ処理フロー
例:
  1. Extract（データ取得）
  2. Transform（加工）
  3. Load（保存）

Pattern 2: Parallel（並列実行）

    ┌─ Task A ─┐
Start ─ Task B ─ Integration
    └─ Task C ─┘

用途: 複数ソースからのデータ取得・キャッシュ更新
例:
  - Web API, DB query, File system を同時アクセス
  - 時間短縮（順序実行なら 3 秒 × 3 = 9 秒 → 並列なら 3 秒）

Pattern 3: Tree（階層的）

         Supervisor
           /  |  \
        Sub1 Sub2 Sub3
        / \   |   / \
      T1  T2  T3 T4 T5

用途: 複雑なタスク分解（大タスク → 中タスク → 小タスク）

Pattern 4: Feedback Loop（反復）

       ┌─── Review ───┐
       ↑              ↓ 修正必要?
  Analysis → Result ─┤
       ↑              ↓ OK
       └─ Complete ───┘

用途: 品質保証（生成 → 検証 → 修正 ループ）

8. Integrations（LangChain・Strands・LlamaIndex）

8.1 LangChain Integration

from langchain.agents import AgentExecutor, create_tool_calling_agent
from langchain_anthropic import ChatAnthropic
from langchain_aws import AmazonBedrockAgentCore
from langchain.tools import Tool
import json

# Define Tools
tools = [
    Tool(
        name="SearchSalesData",
        func=lambda query: {"sales": 500000},
        description="Search sales from CRM"
    ),
    Tool(
        name="AnalyzeMetrics",
        func=lambda data: {"trend": "upward"},
        description="Analyze metrics"
    )
]

# Create Agent with AgentCore
model = ChatAnthropic(model="claude-3-opus")

agent = create_tool_calling_agent(
    llm=model,
    tools=tools,
    prompt=hub.pull("hwchase17/openai-functions-agent")
)

# Deploy to AgentCore
agentcore_executor = AmazonBedrockAgentCore.from_agent(
    agent=agent,
    memory_store="dynamodb",
    region="ap-northeast-1"
)

# Execute
response = agentcore_executor.invoke({
    "input": "What are the sales trends for Q1?"
})
print(response["output"])

8.2 Strands Agents Integration

from strands import Agent
from strands_tools import (
    web_search,
    calculator,
    file_read,
    api_call
)
from aws_bedrock_agentcore import AgentCoreRuntime

# Define Agent with Strands
agent = Agent(
    tools=[
        web_search,  # Web 検索
        calculator,  # 計算
        file_read,   # ファイル読み込み
        api_call     # REST API 呼び出し
    ],
    model="claude-3-opus",
    system_prompt="You are a data analysis expert"
)

# Deploy to AgentCore
runtime = AgentCoreRuntime(
    region="ap-northeast-1",
    memory_config={
        "type": "dynamodb",
        "table": "agent-memory"
    }
)

# Execute
result = runtime.run_agent(
    agent=agent,
    user_message="Analyze the latest stock market trends"
)

9. Code Interpreter & Tools

9.1 Code Interpreter Usage

# Agent が自動生成するコード例:

# ユーザー質問: "上位 10% の売上パフォーマーを特定して"

# Agent が以下のコードを自動生成・Code Interpreter で実行:

import pandas as pd
import numpy as np

# S3 からデータ読み込み
df = pd.read_csv('s3://sales-data/2025-q1.csv')

# 売上額でランク付け
df['rank'] = df['sales_amount'].rank(method='dense', ascending=False)

# 上位 10% を抽出
top_10_percent_threshold = df['sales_amount'].quantile(0.90)
top_performers = df[df['sales_amount'] >= top_10_percent_threshold]

# 結果の整形
result = top_performers[['employee_name', 'sales_amount', 'rank']].sort_values('rank')

# グラフ生成
import matplotlib.pyplot as plt
plt.figure(figsize=(10, 6))
plt.barh(result['employee_name'], result['sales_amount'])
plt.title('Top 10% Performers by Sales')
plt.xlabel('Sales Amount ($)')
plt.savefig('s3://agent-outputs/top_performers.png')

# 返却
return {
    'top_performers': result.to_dict(orient='records'),
    'chart_url': 's3://agent-outputs/top_performers.png',
    'total_count': len(top_performers)
}

9.2 Tool Definition & Registration

Tool Registry Entry:

Name: UpdateCustomerRecord
Type: AWS Service（DynamoDB）
Description: Update customer information in DynamoDB
Input Schema:
  customer_id:
    type: string
    required: true
    example: "CUST-12345"
  attributes:
    type: object
    properties:
      email:
        type: string
      phone:
        type: string
      status:
        type: enum
        values: [active, inactive, suspended]
Output Schema:
  success:
    type: boolean
  updated_fields:
    type: array
  timestamp:
    type: string

Permissions:
  - dynamodb:UpdateItem
  - dynamodb:GetItem
  
Timeout: 10 seconds
Rate Limit: 100 calls per minute

10. Gateway & Observability

10.1 Gateway Configuration

Gateway Settings:

API Endpoint: https://api.agentcore.aws/agents/{agent_id}/invoke

Authentication:
  - Method: API Key + IAM
  - Key Rotation: 90 days
  - Signature Version: SigV4

Rate Limiting:
  - Global: 10,000 req/min
  - Per-Agent: 1,000 req/min
  - Per-User: 100 req/min
  - Burst: 500 req / 1 sec

Timeouts:
  - Request Acceptance: 30 sec
  - Tool Call: 5 min per tool
  - Total Agent Execution: 15 min

Response Format:
  {
    "request_id": "req-abc123",
    "status": "completed",
    "result": {...},
    "metadata": {
      "agent_id": "...",
      "tokens_used": 1250,
      "execution_time_ms": 2340
    }
  }

10.2 Observability Dashboard

CloudWatch Dashboard:

Tier 1: System Health
  - Agent uptime（%）
  - Average latency（ms）
  - Error rate（%）
  - Active agents（count）

Tier 2: Agent Performance
  - Requests per minute（by agent）
  - Success rate（%）
  - Tool call distribution
  - Memory usage（GB）

Tier 3: Cost & Usage
  - Total tokens used（daily）
  - Estimated cost（$）
  - Model breakdown（by FM）
  - Top agents by cost

11. 設定・操作の具体例

11.1 AWS Management Console での操作

1. AgentCore Console を開く
   AWS Console → Bedrock → AgentCore → Agents

2. Create Agent
   Name: "customer-support-agent"
   Description: "Automate customer support with multi-agent"
   
3. Configure Base Model
   Model: "Claude 3 Opus"（最高精度）
   
4. Add Tools
   ├─ Tool 1: Salesforce API
   │  └─ Function: GetCustomerData(customer_id)
   ├─ Tool 2: ServiceNow API
   │  └─ Function: CreateTicket(title, description)
   └─ Tool 3: Knowledge Base
      └─ Function: Search(query)

5. Configure Memory
   Store Type: DynamoDB
   Table: "agent-memory"
   Retention: 30 days

6. Set Orchestration
   Pattern: Tree
   ├─ Supervisor Agent
   │  ├─ Sub-Agent 1: Diagnosis
   │  ├─ Sub-Agent 2: Resolution
   │  └─ Sub-Agent 3: Escalation

7. Gateway Settings
   Rate Limit: 100 req/min
   Auth: API Key
   
8. Deploy
   → Review & Deploy
   → Status: RUNNING
   → Endpoint: https://api.agentcore.aws/...

11.2 AWS CDK での構築

import * as cdk from 'aws-cdk-lib';
import * as bedrock from 'aws-cdk-lib/aws-bedrock';
import * as lambda from 'aws-cdk-lib/aws-lambda';
import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';

export class AgentCoreStack extends cdk.Stack {
  constructor(scope: cdk.App, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    // Memory Store
    const memoryTable = new dynamodb.Table(this, 'AgentMemory', {
      partitionKey: { name: 'user_id', type: dynamodb.AttributeType.STRING },
      sortKey: { name: 'timestamp', type: dynamodb.AttributeType.NUMBER },
      billingMode: dynamodb.BillingMode.PAY_PER_REQUEST,
      ttl: {
        attributeName: 'ttl',
        enabled: true,
      },
    });

    // Tool Lambdas
    const getCustomerToolLambda = new lambda.Function(this, 'GetCustomerTool', {
      runtime: lambda.Runtime.PYTHON_3_11,
      handler: 'index.handler',
      code: lambda.Code.fromAsset('lambda/get_customer'),
    });

    // Agent
    const agent = new bedrock.CfnAgent(this, 'SupportAgent', {
      agentName: 'customer-support-agent',
      agentRoleArn: this.getAgentRole().roleArn,
      foundationModel: 'anthropic.claude-3-opus-20240229-v1:0',
      instruction: 'You are a customer support specialist...',
      
      agentResourceRoleArn: this.getAgentResourceRole().roleArn,
      
      memoryConfiguration: {
        type: 'DYNAMODB',
        dynamodbTableArn: memoryTable.tableArn,
      },

      actionGroups: [
        {
          actionGroupName: 'CustomerTools',
          actionGroupExecutor: {
            lambda: getCustomerToolLambda.functionArn,
          },
          apiSchema: {
            s3: {
              s3BucketName: 'my-api-schemas',
              s3ObjectKey: 'customer-schema.json',
            },
          },
        },
      ],
    });

    // Gateway
    const gateway = agent.gateway!;
    gateway.rateLimitConfig = {
      rateLimit: 100,
    };

    // Output
    new cdk.CfnOutput(this, 'AgentEndpoint', {
      value: `https://api.agentcore.aws/agents/${agent.ref}/invoke`,
    });
  }
}

12. 類似サービス比較表

選択ガイド

• AgentCore を選ぶべき：AWS エコシステム・マルチエージェント・メモリ管理・完全マネージド
• OpenAI Assistants を選ぶべき：シンプル単一エージェント・OpenAI エコシステム
• Vertex AI Agent Builder を選ぶべき：GCP 統合・Vertex AI 他サービスとの連携
• LangGraph を選ぶべき：フルコントロール・複雑なロジック・オープンソース志向
• AutoGen を選ぶべき：研究・プロトタイピング・複雑なマルチエージェント論理

13. ベストプラクティス

13.1 ✅ 推奨

13.2 ❌ 非推奨

14. トラブルシューティング

15. 2025-2026 最新動向

15.1 Native Multi-Cloud Support

動向：AWS のみから複数クラウド対応へ。

2026 年対応予定:
  ✅ AWS（Bedrock FM）
  ✅ Azure（OpenAI / Azure AI）
  ✅ Google Cloud（Vertex AI）
  ✅ Open Source（Llama, Mistral デプロイ）

Agent が複数クラウドの Tool を統合:
  Supervisor: Azure Cognitive Services で分析
  Research: GCP BigQuery で Data fetch
  Writer: AWS Bedrock で Report 生成
  → 最適クラウド・最適モデルを自動選択

15.2 Autonomous Agent Evolution

動向：ユーザー指示 → 完全自動実行 への進化。

現在（2024）:
  ユーザー: "売上レポート作成"
  → Agent: 確認・質問して実行

2026 年:
  ユーザー: "売上レポート作成"
  → Agent: 前月履歴から理解
  → 必要なデータ・グラフ・形式を自動判定
  → 関連ステークホルダーを自動特定
  → メール配信 / Slack 通知も自動化
  → 月次スケジュールに自動登録

15.3 Agent Marketplace

動向：AWS が「事前構築エージェント」マーケットプレイス提供開始。

AWS Agent Marketplace:
  - HR Onboarding Agent
  - Financial Analysis Agent
  - Customer Support Agent
  - Sales Pipeline Management Agent
  
ユーザー: マーケットプレイスからエージェント選択 → AWS Account に自動デプロイ

15.4 Real-Time Human-in-the-Loop

動向：Agent → 不確実性高い判定で人間 review → 承認後自動実行。

フロー:
  Agent が判定: "このクライアントのクレジットスコア 60% → リスク HIGH"
    ↓
  System: クレジットチェック Agent の判断確度が低い
    ↓
  Human Review Request: Finance Manager に Slack
    ↓
  Manager が Review: "クライアント歴 5 年 → Risk LOW に調整"
    ↓
  Agent が Learning: 次回から同パターンは低リスク判定

15.5 Federated Agent Networks

動向：組織内・組織間の複数 Agent が協調。

例: 複数部門の Agent が協調
  - Sales Agent（機会認識）
  - Finance Agent（可能性評価）
  - Fulfillment Agent（実行可能性チェック）
  - Customer Success Agent（顧客満足度予測）
  → 4 Agent が Decision を統合して最終判定

16. 学習リソース・参考文献

16.1 公式ドキュメント（AWS）

1. Amazon Bedrock AgentCore Documentation
2. Bedrock Agent Developer Guide
3. Amazon Bedrock Pricing
4. CloudWatch Observability Guide
5. AWS IAM Documentation
6. DynamoDB Documentation
7. AWS SDK for Python (boto3)
8. AWS CDK Documentation

16.2 AWS ブログ・トレーニング

9. AWS Machine Learning Blog - AgentCore
10. AWS DevOps Blog - Agent Implementation
11. AWS Skill Builder - Bedrock Course
12. AWS re:Invent 2025 Sessions

16.3 オープンソース・SDK

13. LangChain Official Documentation
14. LangGraph by LangChain
15. Strands Agents GitHub
16. LlamaIndex Documentation
17. AutoGen by Microsoft

16.4 コミュニティ・チュートリアル

18. AWS Samples - AgentCore Examples
19. Stack Overflow - amazon-bedrock-agentcore tag
20. Reddit - r/aws Agent discussions

17. 実装例・チェックリスト

17.1 初期デプロイメントチェックリスト（2-4 週間）

準備フェーズ（1 週間）
  □ ユースケース定義（検索・分析・レポート生成など）
  □ Agent の役割分離設計（Supervisor + Sub-agents）
  □ Tool 必要リスト作成（API・Lambda・AWS Service）
  □ Memory ストレージ決定（DynamoDB vs RDS）
  □ セキュリティ・ガバナンス要件確認

セットアップ フェーズ（1 週間）
  □ AgentCore Application 作成
  □ DynamoDB Memory table 作成
  □ IAM Role・Policy 設定
  □ Tool Lambda / HTTP endpoint 実装
  □ Gateway 設定（認証・レート制限）

テスト フェーズ（1 週間）
  □ 単体テスト（各 Agent）
  □ 統合テスト（Multi-Agent 協調）
  □ Load test（レイテンシー・スループット）
  □ セキュリティテスト（権限・PII）
  □ Cost estimate（月額想定コスト計算）

デプロイ フェーズ（1 週間）
  □ 本番 Gateway 設定
  □ CloudWatch ダッシュボード構築
  □ アラート・通知設定
  □ Documentation 完成
  □ Team training 実施
  □ Go-live

17.2 本番運用チェックリスト（継続）

日次
  □ CloudWatch Alert 確認（エラー・タイムアウト）
  □ Agent 実行ログレビュー（異常パターン検出）

週次
  □ Cost 確認（予算内か）
  □ Token usage トレンド分析
  □ User feedback 収集・分析

月次
  □ Agent パフォーマンス分析
  □ Memory cleanup（DynamoDB TTL 確認）
  □ Security audit（IAM Policy review）
  □ Capacity planning（スケール必要性判定）
  □ Tool 更新・API Version 確認

18. まとめ

Amazon Bedrock AgentCore は 「自律 AI エージェントの実行・管理基盤」 です。

主な価値

• マネージド実行基盤：Lambda・コンテナ管理不要。AWS が インフラ・スケーリング・監視を完全管理
• 永続メモリ：複数セッション間でコンテキスト保持。ステートフルな継続対話が可能
• マルチエージェント協調：Supervisor agent がサブエージェントを調整。複雑タスクを自動分解・実行
• Code Interpreter：エージェントが Python コード自動生成・実行。データ分析・計算をセルフサービス化
• SDK 統合：LangChain・LangGraph・Strands をネイティブサポート。オープンソース エコシステム活用
• Gateway & Observability：認証・レート制限・CloudWatch で完全監視可能
• エンタープライズ対応：VPC 統合・IAM・監査ログで規制業界対応

2025-2026 年のトレンド

• Multi-Cloud Support（AWS・Azure・GCP 統合）
• Agent Marketplace（事前構築エージェント）
• Autonomous Execution（完全自動化）
• Human-in-the-Loop Review（AI + 人間）
• Federated Agent Networks（複数 Agent 協調）

導入時の注意点

• Memory 設定は 必須（セッションレスでは会話継続不可）
• Supervisor Pattern を活用（複雑タスクは必ずタスク分解）
• Tool の事前検証・エラーハンドリング必須
• CloudWatch でコスト・パフォーマンス常時監視
• IAM は最小権限原則を厳守

Bedrock AgentCore は、エンタープライズグレードの自律 AI エージェント実装を民主化するサービスです。2026 年も急速な進化を続け、複雑なビジネスプロセスの自動化を加速させます。

最終更新：2026-04-26

バージョン：v2.0