Build highly scalable serverless LangGraph multi-agent systems in AWS with Amazon Bedrock AgentCore Amazon Web Services announced a new solution for building highly scalable, serverless multi-agent generative AI systems using LangGraph agents integrated with Amazon Bedrock AgentCore Memory and Observability. The approach combines AWS Lambda and Step Functions to orchestrate complex multi-tool agent workflows with automatic scaling, durable state management, and fine-grained cost control. This enables organizations to deploy production-grade AI agents that maintain context across interactions and provide deep observability into agent reasoning and behavior. Artificial Intelligence https://aws.amazon.com/blogs/machine-learning/ Build highly scalable serverless LangGraph multi-agent systems in AWS with Amazon Bedrock AgentCore Generative AI has rapidly evolved from experimental prototypes into systems that are expected to operate reliably in production, at scale, and under real-world performance constraints. As organizations move beyond demos and proofs of concept, they increasingly encounter challenges related to inference latency, scalability, state management, and operational visibility. Building high-performance AI agents today requires more than powerful models and demands an implementation that can deliver consistent performance, preserve context across interactions, and provide deep observability into how agents reason and behave in production. In this post, we provide a solution to build highly scalable, serverless multi-agent generative AI systems on AWS using LangGraph Agents https://www.langchain.com/langgraph as orchestrators integrated with Amazon Bedrock AgentCore Memory https://aws.amazon.com/bedrock/agentcore/ and Amazon Bedrock AgentCore Observability. https://aws.amazon.com/bedrock/agentcore/ Our approach for building highly scalable serverless multi-agent orchestrations combines serverless technologies such as AWS Lambda https://aws.amazon.com/lambda/ and AWS Step Functions https://aws.amazon.com/step-functions/ . These services can be used by developers to build LangGraph agents that scale automatically, respond to events in real time, and remove infrastructure management. This makes them ideal for dynamic, bursty agent workloads. By combining these services, you can orchestrate complex multi-tool agent workflows with durable state management, retries, and fine-grained cost control. LangGraph’s explicit graph-based execution model enables deterministic coordination, parallelism, and conditional routing between agents, making complex multi-agent workflows more straightforward to reason and debug. By separating orchestration logic from agent behavior, you can use LangGraph to add, remove, or evolve specialized agents independently while maintaining a clear, auditable execution path. This is especially valuable for production systems that require predictable behavior, extensibility, and structured control over multi-agent reasoning. AgentCore Observability extends these capabilities by providing detailed visibility into each invocation, capturing model inputs/outputs, latency, and tool-chain metrics across distributed serverless components. Integrated memory services from AgentCore Memory enable agents to maintain short-term conversational context and long-term knowledge across sessions. Solution overview Our serverless LangGraph and AgentCore based multi-agent orchestration system solution is a generative AI-powered multi-agent campaign review system that orchestrates human reviews using diverse personas that enable marketing campaigns to resonate authentically with target audiences while maintaining legal alignment and brand standards. It consists of three specialized AI agents that analyze the marketing campaign in parallel – a persona reviewer agent reviews content from diverse demographic perspectives and provides resonance scoring, a validator agent verifies legal alignment and brand guideline adherence, while a finalizer agent then synthesizes feedback into actionable recommendations. Users upload campaign documents through a React https://react.dev/ frontend that also polls for results and displays reviews as they become available. We use LangGraph to implement the orchestrator and specialized agents by modeling the system as a stateful execution graph. Each node represents a discrete agent function specifically persona review, compliance validation, and feedback synthesis—and edges define the control flow between these steps. The orchestrator is implemented as the supervising graph that routes execution, triggers parallel branches for specialized agents, and collects their outputs for final aggregation.The LangGraph orchestrator and specialized agents are together packaged as a Docker container. We use AWS Lambda as the serverless managed runtime in AWS for our Strands agents to scale automatically, respond to events in real time, and remove infrastructure management. Our orchestrator agent displays its functionality as REST interfaces provided by Amazon API Gateway https://aws.amazon.com/api-gateway/ . Our Agent implementation uses AgentCore Observability to provide detailed visualizations of each step in the agent workflow, enabling developers to inspect execution paths, audit intermediate outputs, and debug performance bottlenecks. Within AgentCore Observability, we provide real-time visibility within Amazon CloudWatch into operational performance dashboards and telemetry for key metrics such as traces, session count, latency, duration, token usage, and error rates. We use AgentCore Memory for two key use cases within our Agent implementation specifically for multi-agent shared memory to provide both context and shared memory across independent agent runs and to provide support for multi-turn conversations. You can extend this implementation to provide an AI assistant natural language interface as our implementation using AgentCore Memory provides built-in support for storing conversational state and history. The following architecture diagram illustrates the various components of our solution. Prerequisites Complete the following prerequisites: - Verify model access in Amazon Bedrock. https://docs.aws.amazon.com/bedrock/latest/userguide/model-access.html In this solution, we use Anthropic’s Claude 4.5 Sonnet on Amazon Bedrock. - Install the AWS Command Line Interface https://aws.amazon.com/cli AWS CLI . - Install the AWS SAM CLI v1.100.0+ https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/install-sam-cli.html - Install Docker v20.x+ https://docs.docker.com/engine/install/ . - Install Node.js v18.x+ https://nodejs.org/ - Install Docker v20.x+ https://docs.docker.com/get-docker/ - Install Python v3.11+ https://www.python.org/downloads/ Dependencies Our Strands Agents implementation has the following dependencies that are packaged in the Dockerfile: - langchain =0.2.0 - langgraph==0.3.31 - langgraph-prebuilt~=0.1.8 - langgraph-sdk~=0.1.61 - langchain-aws =0.2.18 - langchain tavily - requests - bedrock-agentcore - boto3 Deploy the solution You can download the solution from our GitHub repo https://github.com/aws-samples/sample-agentic-genai-agentcore/tree/main . Use the following step-by-step guidance also outlined exactly in the README of the GitHub repo to deploy and access the solution in your AWS environment: Step 1: Clone the repository git clone