How to Build a Jujutsu Kaisen Domain Expansion AR Game with AWS Bedrock AgentCore & CDK-Driven AI Commentator?

Discover how to synchronize real-time computer vision, serverless robotics, and multimodal AI runtimes on AWS. This deep dive walks through constructing an interactive web-based arena powered by Bedrock AgentCore container runtimes and automated Cloud Development Kit pipelines.

Series: AWS OpenClaw (4 articles)

1
Deep Dive Architectural Design of a Multi-Tenant Serverless OpenClaw Agent Platform Using Amazon Bedrock AgentCore, Lambda MicroVMs, and LiteLLM Budget Gates
…
3
How to Build a Jujutsu Kaisen Domain Expansion AR Game with AWS Bedrock AgentCore & CDK-Driven AI Commentator? This article
4
Architecture Blog: Building an Omnichannel, Multi-Agent Embodied AI Platform with Amazon Bedrock AgentCore and OpenClaw

Cyrus Wong

AWS AI Hero + Microsoft MVP + Google Developer Experts - GCP(AI)

Published Jun 16, 2026

Last modified Jul 17, 2026

Introduction: The Fan-Made Inspiration & Architecture Hype

Imagine striking a physical hand sign in front of your webcam—crossing your index and middle fingers—and watching your screen erupt into Gojo Satoru’s iconic Unlimited Void (無量空處) or Ryomen Sukuna's Malevolent Shrine (伏魔御廚子) with immersive, swirling 3D particle effects. Simultaneously, a physical humanoid robot on your desk (or a serverless 3D simulated robot in a web viewer) executes a choreographed kung-fu stance.

Suddenly, a voice rings out with pure attitude: "唔錯喎！反應好似我去搶購減價化妝品噉快！當堂順眼好多！" (Not bad! Your reaction is almost as fast as me grabbing a limited-edition bag in Shibuya!)

This is the Jujutsu Kaisen Domain Expansion AR Game—a fan-made, non-commercial application that merges real-time browser-based computer vision with fully serverless AWS robotics and generative AI orchestration. At the center of this experience is an AI Commentator based on Kugisaki Nobara (釘崎野薔薇), the brash, fashion-obsessed Grade 3 Jujutsu Sorcerer from Tokyo. Utilizing multimodal AI vision, Nobara doesn't just narrate game events—she literally roasts players' real-world details (facial panic, clothes, posture, messy rooms) in local Hong Kong Cantonese, Taiwanese Mandarin, Japanese, or English.

To bring this high-octane experience to life, we designed and deployed a decoupled, event-driven game architecture entirely on AWS. In this deep-dive technical blog post, we’ll explore how we utilized AWS Bedrock AgentCore, AWS Polly, AWS Lambda, Amazon DynamoDB, Amazon S3, and Google's MediaPipe Hands, with our entire infrastructure modeled natively in AWS Cloud Development Kit (CDK).

📐 Unified Cloud System Architecture

To support low-latency real-time gameplay, high-definition camera rendering, and highly dynamic AI commentary without incurring high idle costs, we implemented a fully decoupled, serverless architecture.

Our architecture partitions workload domains to isolate responsibilities:

Surface	Model Role	Current AWS Model ID / Implementation
AI Commentator (Nobara)	Visual-aware text reasoning & match commentary	`moonshotai.kimi-k2.5` via custom ECR Container / Bedrock
Voice Synthesis (TTS)	High-fidelity neural speech synthesis	`AWS Polly` (Neural Cantonese / Mandarin / Japanese / English)

🔄 End-to-End Execution Flow: From Gesture to Speech

To understand how high-fidelity gesture recognition, cloud-based LLM orchestration, and physical robotics action execution merge, let's trace the complete, secure end-to-end request-response and execution lifecycle of the Jujutsu Kaisen Domain Expansion Game.

1. Unified Execution Flow Diagram

The following sequence diagram details the precise, secure path of a single hand gesture performed in the browser. It shows how it traverses the Cognito-authorized server gateway, invokes the serverless AgentCore Runtime, executes tool-calling via the IAM-authenticated Tool Gateway, and triggers actions across physical devices:

2. Comprehensive Flow Step Walkthrough

Step A: Gesture Detection and Server Signalling (Client JS)

The player strikes Sukuna's Malevolent Shrine (伏魔御廚子) hand sign. MediaPipe Hands detects the 21 3D landmarks on the browser canvas at 60 FPS. hand_tracker.js matches the geometric landmarks against our gesture database. Once verified, battle.js fires a single secure POST call containing the Cognito Bearer JWT token to our Amazon API Gateway:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// From battle.js: Dispatching recognized gesture to API Gateway
async function triggerCursedTechnique(techniqueName) {
    const token = await getCognitoAccessToken(); // High-security Bearer Token
    try {
        const response = await fetch("/api/trigger-technique", {
            method: "POST",
            headers: {
                "Content-Type": "application/json",
                "Authorization": `Bearer ${token}`
            },
            body: JSON.stringify({
                technique: techniqueName, // e.g. "malevolent_shrine"
                robotId: "all",
                sessionId: "mcpserver"
            })
        });
        const result = await response.json();
        playCommentaryAudio(result.audioUrl); // Play the resulting voice track
    } catch (err) {
        console.error("Failed to execute server-side technique orchestration:", err);
    }
}

Step B: Cognito Validation & Server-Side Orchestration (Monolithic Lambda)

API Gateway validates the Cognito access token at the cloud border. If valid, the request is proxy-forwarded to our monolithic Flask-based Lambda backend (lambda_function.py).

The Lambda server acts as our central coordinator. It accesses our internal JJK_ACTION_MAP to translate the gesture to a physical stance, immediately dispatches an asynchronous REST command to trigger the robot simulator stance, and prepares the multi-modal prompt for the commentator. To ensure the player’s webcam snaps survive intermediary proxy gateways, it packages them inside custom text-based XML tags inside commentary.py:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# From commentary.py: Embedding pictures inside prompt XML tags
def generate_ai_commentary(content_block, session_id="mcpserver", image_base64_p1=""):
    # Package snapshots within XML blocks appended to prompt text to prevent stripping
    if image_base64_p1:
        content_block += f"\n<p1_webcam_base64_jpeg>{image_base64_p1}</p1_webcam_base64_jpeg>"
        
    # Instantiate AWS Bedrock AgentCore Client
    agent_client = boto3.client("bedrock-agentcore", region_name="us-east-1")
    
    # Format the payload and execute runtime session
    payload_dict = {
        "prompt": content_block,
        "session_id": session_id
    }
    
    response = agent_client.invoke_agent_runtime(
        agentRuntimeArn=os.environ.get("AGENTCORE_RUNTIME_ARN"),
        runtimeSessionId=session_id,
        payload=json.dumps(payload_dict).encode("utf-8")
    )
    return response.get("response").read().decode("utf-8")

Step C: Serverless Runtime Execution and XML Bypass (AgentCore Runtime)

The serverless AWS Bedrock AgentCore Runtime routes the invocation to our custom commentator container (domain_commentator_agentcore) using IAM SigV4 authorizations. The container's FastAPI service (commentator_agent.py) intercepts the request, uses regex to parse out base64 webcam photos from the prompt XML block, and reconstructs the Bedrock binary multimodal parts:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
# From commentator_agent.py: Extracting snapshots inside the container
@app.post("/invocations")
async def invoke_agent(request: Request):
    body = await request.json()
    prompt_text = body.get("prompt", "")
    
    # Execute Regex parsing to extract embedded webcam base64 images
    p1_pattern = re.compile(r"<p1_webcam_base64_jpeg>(.*?)</p1_webcam_base64_jpeg>", re.DOTALL)
    p1_match = p1_pattern.search(prompt_text)
    
    image_b64_p1 = ""
    if p1_match:
        image_b64_p1 = p1_match.group(1).strip()
        # Completely strip out base64 XML tags from text prompt to keep LLM context clean
        prompt_text = p1_pattern.sub("", prompt_text).strip()
        
    # Convert base64 string to raw binary parts for direct Bedrock Converse multimodal input
    img_bytes_p1 = base64.b64decode(image_b64_p1)
    message_content = [
        {"text": "Player 1 webcam snapshot:"},
        {"image": {"format": "jpeg", "source": {"bytes": img_bytes_p1}}},
        {"text": prompt_text}
    ]
    
    # Execute model (Moonshot kimi-k2.5) via Strands Agent
    response = await strands_agent.invoke_async(message_content)
    return JSONResponse(content={"response": str(response)}, status_code=200)

Step D: Downstream Tool Execution (AgentCore Tool Gateway)

If the model determines it needs to trigger physical hardware feedback during generation, the agent dispatches a tool call. The AgentCore Runtime routes this tool call via SigV4 directly into our AgentCore Tool Gateway (bedrockagentcore.Gateway).

The gateway resolves the compound tool name (e.g., robot-only-mcp-lambda___robot_wave), verifies that our agent runtime’s execution role has strict bedrock-agentcore:Invoke policies, and triggers the downstream target Lambda (robot_tool_lambda.py):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# From robot_tool_lambda.py: Stripping prefix & executing action via AWS IoT Core
def lambda_handler(event, context):
    full_tool_name = event.get("tool_name", "") # "robot-only-mcp-lambda___robot_wave"
    
    # Extract local tool command
    local_tool_name = full_tool_name.split("___")[-1] if "___" in full_tool_name else full_tool_name
    
    if local_tool_name == "robot_wave":
        iot_client = boto3.client("iot-data")
        # Publish MQTT command to AWS IoT Core topic to synchronize humanoid hardware and simulator
        iot_client.publish(
            topic="arn:aws:iot:us-east-1:123456789012:topic/robot_1/topic",
            qos=1,
            payload=json.dumps({"action": "wave_hand", "timestamp": int(time.time())})
        )
        return {"status": "SUCCESS", "message": "Robot hand wave triggered."}

The tool output travels back up the Tool Gateway into the AgentCore Runtime. The model integrates this result, completes the sassy narration text, and returns it to our monolithic server Lambda. The server strips markdown tags, calls AWS Polly to synthesize a high-fidelity neural Cantonese voice track, uploads the MP3 to Amazon S3, and returns the finished text alongside a presigned S3 audio URL to the browser JS client to play the commentary!

🤖 AWS Bedrock AgentCore & Gateway Patterns (The Key Core Concept)

The absolute centerpiece of our agent execution plane is AWS Bedrock AgentCore. Rather than hosting agents on persistent, expensive virtual machines (EC2) or continuous container tasks (ECS/Fargate) that run up massive idle bills, we leverage AWS Bedrock AgentCore to manage our generative AI orchestrations serverlessly.

Bedrock AgentCore introduces two critical concepts: The Tool Gateway (bedrockagentcore.Gateway) and The Serverless Agent Runtime (agentcore.Runtime).

1. The Centralized Tool Gateway (`bedrockagentcore.Gateway`)

The Tool Gateway serves as our secure action plane. It acts as an IAM-authorized, SigV4-authenticated centralized router. When an agent determines that a physical action is required (e.g., executing a humanoid combat gesture), it sends an execution command into the Tool Gateway. The gateway inspects the tool schemas, validates authorization, and dispatches the execution payload to the targeted serverless Lambda function.

In our codebase, we provision the Tool Gateway inside robot-tool-gateway.ts .

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
import * as bedrockagentcore from "aws-cdk-lib/aws-bedrockagentcore";
import { PythonFunction } from "@aws-cdk/aws-lambda-python-alpha";
import { Construct } from "constructs";
import * as path from "path";

export class RobotToolGatewayConstruct extends Construct {
  public readonly robotToolFunction: PythonFunction;
  public readonly gateway: bedrockagentcore.Gateway;
  public readonly gatewayTarget: bedrockagentcore.GatewayTarget;

  constructor(scope: Construct, id: string, props: RobotToolGatewayConstructProps) {
    super(scope, id);

    // 1. Define downstream execution Lambdas (e.g., Robot Physical Commands Handler)
    this.robotToolFunction = new PythonFunction(this, "RobotToolFunction", {
      entry: path.join(__dirname, "../../../mcp_server"),
      runtime: SHARED_PYTHON_RUNTIME,
      index: "robot_tool_lambda.py",
      handler: "lambda_handler",
      timeout: Duration.seconds(30),
      environment: {
        SIMULATOR_ENDPOINT: props.simulatorEndpoint || "",
        MEDIA_BUCKET_NAME: props.mediaBucket.bucketName,
      },
    });

    // 2. Define the AgentCore Gateway with strict IAM-based authorization (SigV4)
    this.gateway = new bedrockagentcore.Gateway(this, "RobotToolGateway", {
      description: "AgentCore gateway fronting the robot and digital human Lambda tools",
      authorizerConfiguration: bedrockagentcore.GatewayAuthorizer.usingAwsIam(),
    });

    // 3. Register Lambda Targets & Dynamically Slice local JSON-RPC / MCP schemas
    this.gatewayTarget = this.gateway.addLambdaTarget("RobotToolLambdaTarget", {
      description: "Lambda target exposing only the robot tools through AgentCore",
      gatewayTargetName: "robot-only-mcp-lambda",
      lambdaFunction: this.robotToolFunction,
      toolSchema: bedrockagentcore.ToolSchema.fromLocalAsset(
        materializeRobotToolSchemaAsset() // Slices schema to include only robot locomotion/combat actions
      ),
    });
  }
}

2. The Serverless AgentCore Commentator Runtime (`agentcore.Runtime`)

To execute our custom commentator agent logic, we bundle our commentator code as an ARM64 container and deploy it as a dedicated serverless AgentCore Runtime.

Our CDK implementation is configured in domain-expansion-serverless.ts using the official @aws-cdk/aws-bedrock-agentcore-alpha library:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
import * as agentcore from "@aws-cdk/aws-bedrock-agentcore-alpha";
import { Platform } from "aws-cdk-lib/aws-ecr-assets";
import { Construct } from "constructs";
import * as path from "path";

// From domain-expansion-serverless.ts: Deploying commentator container as a dedicated Bedrock AgentCore Runtime
const observability = createAgentCoreRuntimeObservability(
  this,
  "DomainExpansionObservability",
  "domain_commentator_agentcore"
);

const agentRuntimeArtifact = agentcore.AgentRuntimeArtifact.fromAsset(
  path.join(__dirname, "../../../domain-expansion-commentator-agentcore"),
  {
    platform: Platform.LINUX_ARM64,
  }
);

const runtime = new agentcore.Runtime(this, "Runtime", {
  runtimeName: "domain_commentator_agentcore",
  agentRuntimeArtifact: agentRuntimeArtifact,
  authorizerConfiguration: agentcore.RuntimeAuthorizerConfiguration.usingIAM(),
  lifecycleConfiguration: {
    idleRuntimeSessionTimeout: Duration.seconds(120),
    maxLifetime: Duration.seconds(900),
  },
  tracingEnabled: true,
  loggingConfigs: observability.loggingConfigs,
  environmentVariables: {
    IsInCloud: "yes",
    AWS_BEDROCK_REGION: "us-east-1",
    BEDROCK_MODEL_ID: "moonshotai.kimi-k2.5",
  },
});

🔒 Split-Route Security & Server-Side Orchestration (API Gateway)

When developing the serverless backend of the Domain Expansion Game, we encountered an architectural conflict:

Security Requirement: Critical endpoints that trigger expensive Bedrock LLM processes or update match results must be strictly authorized via Cognito.
Web Browser Capability: Standard HTML <img> elements (e.g., <img src="...">) fetched natively by browsers cannot append custom HTTP headers like Authorization: Bearer <token>.

1. The Split-Routing REST Model

To solve this, we configured a split-routing model on our Amazon API Gateway REST API inside domain-expansion-serverless.ts :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
const restApi = new apigateway.RestApi(this, "DomainExpansionRestApi", {
  restApiName: "Domain Expansion Serverless REST API",
});

const restAuthorizer = new apigateway.CognitoUserPoolsAuthorizer(this, "DomainExpansionRestApiAuthorizer", {
  cognitoUserPools: [props.userPool],
});

const lambdaIntegration = new apigateway.LambdaIntegration(lambdaFunction);
const apiResource = restApi.root.addResource("api");

// 🔓 PUBLIC READ-ONLY MEDIA ENDPOINTS (Protected solely by high-entropy Session IDs)
const getSnapshotResource = apiResource.addResource("get-snapshot");
getSnapshotResource.addMethod("GET", lambdaIntegration, {
  authorizationType: apigateway.AuthorizationType.NONE, // No Cognito Bearer token required
});

const lastImageResource = apiResource.addResource("last-image");
lastImageResource.addMethod("GET", lambdaIntegration, {
  authorizationType: apigateway.AuthorizationType.NONE,
});

// 🔒 COGNITO PROTECTED OPERATION ENDPOINTS
const triggerTechniqueResource = apiResource.addResource("trigger-technique");
triggerTechniqueResource.addMethod("POST", lambdaIntegration, {
  authorizationType: apigateway.AuthorizationType.COGNITO, // Validated instantly at the edge
  authorizer: restAuthorizer,
});

const battleResultResource = apiResource.addResource("battle-result");
battleResultResource.addMethod("POST", lambdaIntegration, {
  authorizationType: apigateway.AuthorizationType.COGNITO,
  authorizer: restAuthorizer,
});

📈 Distributed Tracing & CloudWatch Vended Logs (Observability Construct)

To monitor our LLM container performance and troubleshoot distributed tool routing in real time, we built a dedicated observability construct (agentcore-observability.ts ).

This construct provisions custom CloudWatch Log Groups under the vended logs namespace, configures delivery channels, and connects AWS X-Ray for end-to-end distributed tracing across the agent boundary:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
import * as logs from "aws-cdk-lib/aws-logs";
import { Construct } from "constructs";

export function applyAgentCoreGatewayObservability(
  scope: Construct,
  id: string,
  gateway: IGateway
): void {
  // 1. Create a log group within the strict vended logs namespace
  const applicationLogGroup = new logs.LogGroup(scope, `${id}ApplicationLogGroup`, {
    logGroupName: `/aws/vendedlogs/bedrock-agentcore/gateway/APPLICATION_LOGS/${gateway.gatewayId}`,
    retention: logs.RetentionDays.THREE_DAYS,
  });

  // 2. Provision the AWS Logs Delivery Source pointing to the Gateway resource
  const deliverySource = new logs.CfnDeliverySource(scope, `${id}ApplicationDeliverySource`, {
    name: Names.uniqueResourceName(scope, { maxLength: 60 }),
    logType: "APPLICATION_LOGS",
    resourceArn: gateway.gatewayArn,
  });

  // 3. Provision the AWS Logs Delivery Destination pointing to the CloudWatch Log Group
  const deliveryDestination = new logs.CfnDeliveryDestination(scope, `${id}ApplicationDeliveryDestination`, {
    name: Names.uniqueResourceName(scope, { maxLength: 60 }),
    deliveryDestinationType: "CWL",
    destinationResourceArn: applicationLogGroup.logGroupArn,
  });

  // 4. Bind the delivery link
  const delivery = new logs.CfnDelivery(scope, `${id}ApplicationDelivery`, {
    deliverySourceName: deliverySource.deliverySourceRef.deliverySourceName,
    deliveryDestinationArn: deliveryDestination.attrArn,
  });
}

This setup enables us to trace a single user hand gesture starting in the browser, traversing through our API Gateway, striking the AWS Lambda router, invoking the Bedrock AgentCore container, executing the Strands LLM completion, and hitting the AWS Polly voice synthesis—all visualized on a single, continuous AWS X-Ray service map.

🎮 Interactive Battle Mode & Cost-Saving Session Guards

To build a game that feels responsive, highly synchronized, and cheap to run, we implemented several performance-oriented client-side systems.

1. Cost-Saving Session Guards

Because serverless WebSockets and AgentCore sessions accrue costs when left open, the game client (auth-check.js) implements an active session guard. Every 30 seconds, it decodes the Cognito JWT token on-device to inspect the expiration claim (exp):

$$\text{Session Expired} = \text{currentTime} \ge \text{jwt.exp}$$

If expired, the client instantly triggers a local logout sequence and forces a .close() event on all active WebSockets:

1
2
3
4
5
6
7
8
9
10
11
12
// From auth-check.js: Force WebSocket closures on idle/expired tokens
function checkSessionGuard() {
    const token = getCognitoToken();
    if (isTokenExpired(token)) {
        console.warn("Cognito session expired! Closing active WebSockets to prevent serverless billing leaks.");
        if (webSocketConnection) {
            webSocketConnection.close();
        }
        triggerLocalLogout();
    }
}
setInterval(checkSessionGuard, 30000); // Polling on-device uses 0 cloud compute resource

This guarantees that dormant browser tabs do not hold expensive AgentCore socket pipelines open.

2. High-Performance Battle Mode Sync

WebRTC Peer-to-Peer: During battles, browsers stream players' high-definition camera feeds and Canvas overlay animations directly peer-to-peer using WebRTC.
WebSocket Signaling: The Amazon API Gateway WebSocket acts purely as a lightweight signaling server for game coordinates, technique triggers, and scores. This avoids routing high-bandwidth video data through our AWS servers, reducing cloud bandwidth charges to absolute zero.

3. Intelligent TTS Markdown Sanitization

AI models frequently output Markdown syntax (like **bold text** or headings #). If sent directly to AWS Polly, it will pronounce these symbols literally.

In commentary_tts.py, we sanitize text before synthesis by parsing it through Markdown and BeautifulSoup:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# From commentary_tts.py: Markdown-cleansing filter
import markdown
from bs4 import BeautifulSoup

def sanitize_text_for_tts(raw_text):
    try:
        # Convert markdown formatting to HTML structure
        html_formatted = markdown.markdown(raw_text)
        # Strip all HTML tags to leave purely clean plain text
        clean_text = BeautifulSoup(html_formatted, "html.parser").get_text()
        return clean_text
    except Exception as e:
        logger.error(f"TTS Sanitization failed: {e}")
        return raw_text

🎭 Engineering Nobara's Soul: Character Configuration

To make Kugisaki Nobara feel like her actual anime counterpart, we decoupled her character identity from our codebase. We created two markdown files: IDENTITY.md (defining her sassy demeanor and styling preferences) and SOUL.md (defining her opinions on characters and combat situations). These are loaded dynamically during our container startup:

1
2
3
4
# Extract from SOUL.md: Guidance on Gojo Satoru
- Gojo Satoru is an absolute show-off. He is handsome but deeply annoying. 
- If a player selects Gojo Satoru and performs a perfect block, Nobara should say: 
  "Not bad, but don't get too smug! You're still a million years away from matching my fashion taste!"

💸 Cost Estimation & Pay-As-You-Go Efficiency

By choosing a serverless, event-driven architecture, we optimized our deployment costs to align directly with user traffic:

Zero Idle Costs: When no matches are played and the commentary agents are idle, you are billed $0.00. There are no continuous hourly provisioned instance fees.
Automatic S3 Lifecycles: Webcam snapshots and Polly MP3 streams are saved with a 7-day automatic deletion policy, preventing S3 storage charges from accumulating over time.
On-Demand Billing: Utilizing Pay-Per-Request (On-Demand) billing modes ensures that database and API costs scale linearly with actual tournament games played.

🎯 Summary of Accomplishments

By combining Google's MediaPipe on-device tracking, a serverless AWS API Gateway signaling switchboard, containerized AWS Bedrock AgentCore Runtimes, and a custom CDK observability framework, we successfully built a highly immersive fan game that is:

Engaging: Features a highly expressive, multi-lingual, visual-aware AI Commentator (Kugisaki Nobara) who brings professional JJK anime-lore directly to the battle arena.
Cost-Efficient: Leverages Pay-As-You-Go serverless technologies, automatic S3 lifecycle policies, and WebRTC P2P streams to keep running fees at practically zero when idle.
Resilient: Integrates client-side fallback state machines, HTML-cleansing filters for speech, and XML image wrappers to bypass enterprise proxy limitations natively.
Observable & Traceable: Features full CloudWatch Log Group vending and AWS X-Ray distributed tracing integrated directly within our CDK deployment scripts.

Curious to try it out? Light up your webcam, gather your cursed energy, and check out the live demo!

[!NOTE]
Copyright Disclaimer: This project is a non-commercial, fan-made application created for educational purposes. All rights to "Jujutsu Kaisen" (characters, logos, terminology) belong to Gege Akutami, Shueisha, and MAPPA. No copyright infringement is intended.

By IT114115 - Higher Diploma in Cloud and Data Centre Administration students and special thanks Ester Cheung AWS Student Builder Groups Leader of Hong Kong Institute of Information Technology

# amazon-bedrock # amazon-bedrock-agentcore # amazon-bedrock-agents # serverless

Series: AWS OpenClaw (4 articles)

1
Deep Dive Architectural Design of a Multi-Tenant Serverless OpenClaw Agent Platform Using Amazon Bedrock AgentCore, Lambda MicroVMs, and LiteLLM Budget Gates
…
3
How to Build a Jujutsu Kaisen Domain Expansion AR Game with AWS Bedrock AgentCore & CDK-Driven AI Commentator? This article
4
Architecture Blog: Building an Omnichannel, Multi-Agent Embodied AI Platform with Amazon Bedrock AgentCore and OpenClaw

Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.

Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article

Builder Center

How to Build a Jujutsu Kaisen Domain Expansion AR Game with AWS Bedrock AgentCore & CDK-Driven AI Commentator?

Series: AWS OpenClaw (4 articles)

Cyrus Wong

Introduction: The Fan-Made Inspiration & Architecture Hype

📐 Unified Cloud System Architecture

🔄 End-to-End Execution Flow: From Gesture to Speech

1. Unified Execution Flow Diagram

2. Comprehensive Flow Step Walkthrough

Step A: Gesture Detection and Server Signalling (Client JS)

Step B: Cognito Validation & Server-Side Orchestration (Monolithic Lambda)

Step C: Serverless Runtime Execution and XML Bypass (AgentCore Runtime)

Step D: Downstream Tool Execution (AgentCore Tool Gateway)

🤖 AWS Bedrock AgentCore & Gateway Patterns (The Key Core Concept)

1. The Centralized Tool Gateway (bedrockagentcore.Gateway)

2. The Serverless AgentCore Commentator Runtime (agentcore.Runtime)

🔒 Split-Route Security & Server-Side Orchestration (API Gateway)

1. The Split-Routing REST Model

📈 Distributed Tracing & CloudWatch Vended Logs (Observability Construct)

🎮 Interactive Battle Mode & Cost-Saving Session Guards

1. Cost-Saving Session Guards

2. High-Performance Battle Mode Sync

3. Intelligent TTS Markdown Sanitization

🎭 Engineering Nobara's Soul: Character Configuration

💸 Cost Estimation & Pay-As-You-Go Efficiency

🎯 Summary of Accomplishments

Series: AWS OpenClaw (4 articles)

1. The Centralized Tool Gateway (`bedrockagentcore.Gateway`)

2. The Serverless AgentCore Commentator Runtime (`agentcore.Runtime`)