AWS for Industries
How to make four specialist AI agents act as one trusted financial advisor
Split a banking assistant into specialist agents and you get clean ownership: lending owns affordability, wealth owns risk tolerance, payments owns money movement, and insurance owns cover. But that same split introduces a new failure mode: Put each specialist on its own runtime, for fault isolation and independent deployment, and the shared state they used to get for free disappears.
Take a customer buying a home. The lending agent establishes the facts that matter: a $1,200,000 property, a $240,000 deposit, and $960,000 of borrowing. Those same numbers must reach the insurance agent, which should size cover (set the amount of insurance coverage) for the $1,200,000 property. They must also reach the wealth agent, which should plan around the funds the customer just moved into the deposit. When the agents run in separate runtimes, nothing carries those figures between them by default. The insurance agent sizes cover against a value it inferred on its own, the wealth agent models a deposit that no longer matches, and the customer hears different versions of the same purchase. In financial services, that isn’t a glitch. It’s a trust problem and, after those numbers feed a recommendation, a compliance problem. Suitability obligations (the rules that require recommendations to fit a customer’s financial situation) assume a customer gets one consistent answer from the institution, not a different one from each agent.
This post is for architects designing multi-agent systems on AWS. As soon as agents run in separate runtimes, three problems appear, and we walk through the decisions we made to solve each one. The first is keeping specialists consistent on the facts, which we handle with shared context that travels with every invocation. The second is letting the orchestrator find specialists without hand-coding them. The third is applying the same guardrails to voice and text without duplicating logic. For banking and digital leaders, these same decisions help an AI-led experience feel more trustworthy in front of customers. They support one consistent answer across lines of business and options that match the customer’s life stage instead of product pushes.
Our proof point is Connected Finance, an Agentic Bank demo in the AWS Industry Zone at re:Invent 2026.
We built the demo with four principles in mind. First, the financial institution should understand the customer’s needs and life stage and suggest the options that fit, not offer a menu of products. Second, context should carry forward so the customer doesn’t need to start over. Third, the conversation should happen in natural voice. Fourth, the experience should cross segment boundaries without the customer noticing the hand-offs.
Architecture overview
The simplicity of the Agentic Bank concept is the product of architecture decisions. The driving idea is that the customer talks to one AI Personal Banker, while four specialist agents (Wealth, Lending, Payments, and Insurance) do the domain work. Amazon Bedrock AgentCore is a platform to build, connect, and optimize agents at scale, with a wide range of frameworks and models. The Personal Banker is an orchestrator that runs on its own Amazon Bedrock AgentCore runtime, a capability of Amazon Bedrock AgentCore, and calls Anthropic’s Claude Sonnet 4.6 (primary) and Claude Haiku 4.5 (fast path) on Amazon Bedrock. For availability, see supported models by AWS Region. The entire solution has 20 independent AWS CloudFormation stacks and eight AgentCore runtimes: the Personal Banker, the voice agent, the Lending, Wealth, and Payments specialists, and three Insurance specialists (home, renters, and cargo). Each specialist runs on its own Amazon Bedrock AgentCore runtime, with its own reasoning, tools, and guardrails. The result behaves like one banker to the customer and four self-contained teams to the developers maintaining it.
Figure 1 shows the conceptual flow: a single voice-and-touch entry point flows into the Personal Banker, which draws on deterministic tools, discovers its specialists, and routes each question to the agent that owns it. Shared context, session state, guardrails, and observability run across each runtime.
Figure 2 follows a single turn through the architecture. The React app is served from an Amazon Simple Storage Service (Amazon S3) bucket through an Amazon CloudFront distribution, and visitors sign in with Amazon Cognito. Chat travels over Amazon API Gateway (HTTP or WebSocket) to an AWS Lambda function handler. It then checks the guardrail on the way in, advances the journey, builds the shared context, and checks the guardrail on the way out. Voice connects to a voice agent on Amazon Bedrock AgentCore runtime. The agent streams audio to Amazon Nova 2.5 Sonic through Amazon Bedrock bidirectional streaming and routes each spoken request into that same turn handler.
The Personal Banker calls tools over the Model Context Protocol (MCP) through Amazon Bedrock AgentCore Gateway, a capability of Amazon Bedrock AgentCore. It hands out questions to the four specialist agents discovered through the AWS Systems Manager Parameter Store. Session and customer state lives in six Amazon DynamoDB tables. Amazon Bedrock AgentCore memory is wired in for cross-session memory but switched off in the demo. Amazon Bedrock Guardrails applies the same input and output guardrails to text per message and to voice per sentence. Amazon Elastic Container Registry (Amazon ECR) stores the runtime container images, and Amazon CloudWatch provides one dashboard, five alarms, and one log line per turn.
Why we designed it this way
The first decision was where to draw the line between a tool and a sub-agent, and we followed the AWS guidance: Use a sub-agent when a capability needs its own reasoning and context, or independent failure isolation. Use a tool when the capability is deterministic, stateless, and fast. The capabilities the Personal Banker uses are deterministic, so they live as eight deterministic tools behind an Amazon Bedrock AgentCore Gateway: open banking, readiness, affordability, life profile, suburbs, properties, search, and session. The four specialists each reason in their own domain, so they are sub-agents, invoked directly and presented to the orchestrator as tools to choose from. It is the supervisor-and-specialist pattern that makes the system coherent.
We developed four rules to support this pattern:
- One runtime per segment (Lending, Wealth, Payments, and Insurance).
- The orchestrator never reaches into a segment’s tools. It asks that segment’s agent, which decides for itself.
- Each specialist calls its own tools over the Gateway.
- The segments never call each other. The orchestrator is the only caller across the segments.
Specialist discovery
Adding a line of business should be a deployment, not a code change, so the Personal Banker has no hard-coded specialists. When a segment deploys, it registers itself in the AWS Systems Manager Parameter Store under a /shared/specialists/ path. It publishes its AgentCore runtime Amazon Resource Name (ARN) and a plain-language description of what it handles. At startup, the orchestrator reads that path and builds one tool per entry.
The description does the real routing work, as the model reads it when deciding whether a question belongs to Lending, Wealth, Payments, or Insurance. Writing a good description is therefore as important as writing good code. A fifth segment, such as Commercial Lending, appears in the conversation after it deploys its stack. Because the orchestrator discovers its specialists at runtime, a bank doesn’t need to build every line of business at once. It can start with two specialists, say lending and payments, and add wealth or insurance later without changing the orchestrator.
Here’s what a registration looks like. Each segment stack writes one parameter, so a new segment needs no change to the orchestrator:
At startup, the orchestrator reads the path and turns each entry into a tool. The following is a simplified version of that loop. The complete code is in the IND329 workshop, Building a multi-agent AI personal banker, linked under Learn more.
Sharing context across runtimes
Running each specialist on its own runtime means shared state is no longer free, and agents quoting different numbers for the same customer isn’t acceptable. The answer is that context travels with the question. On every turn, the Personal Banker sends the specialist a shared_context JSON payload in the invocation itself, holding the facts it has established, such as the property value, deposit, and loan amount. The specialist must adopt that payload before it reasons, and it treats the payload as the current record, because it was assembled for this turn. Current is not the same as correct, which is why only the orchestrator’s tools can change a figure. The same payload doubles as an audit trail. Keep each turn’s shared_context, with its schema_version and assembled_at time, next to the answer it produced. You can show a model risk or supervisory reviewer exactly which facts every specialist reasoned from.
In the demo, the payload wins: A specialist that would value the property differently says so in its answer rather than substituting its own number. For example, insurance might need a replacement-cost valuation rather than the purchase price that lending used. A production system should let specialists return a flagged disagreement for the orchestrator to resolve, by adding a separate fact such as rebuild_value or by asking the customer.
For the home purchase described at the start of this post, the payload the insurance specialist receives looks like this:
The contract each specialist follows:
adopt() loads the canonical facts. context_block() puts them in the specialist’s system prompt. remember() saves a conclusion so that later steps inherit it instead of working it out again. If a number the specialist needs is missing, it says so rather than assuming one.
The return path is straightforward: Specialists never write facts back. The orchestrator’s deterministic tools compute every figure in shared_context and save it with the session in DynamoDB so that the next turn’s payload is rebuilt from that record. A specialist’s answer comes back as text for the orchestrator to phrase. remember() is built to also write a conclusion to AgentCore memory, so it would carry into a later session, but we switched that off for the demo. In production, return conclusions in the specialist’s response and let the orchestrator decide what to add to the record.
In code, the orchestrator’s side of every turn looks like this:
The demo gives some segments their own narrowly scoped role and shares one role across others. For production, give every runtime its own role: The orchestrator can invoke only the registered specialists, and no specialist can invoke another, which enforces the “segments never call each other” rule in policy and code. Keep personally identifiable information (PII) out of shared_context: pass a pseudonymous customer ID and financial facts, and let each specialist look up identity data with its own scoped permissions. Open banking data needs two more controls. Record the customer’s consent for each connected account and check it before any tool reads that data. Keep aggregated account data in the AWS Region your data-residency rules require.
Identity needs to line up too. Amazon Bedrock AgentCore gives each session its own isolated microVM and memory namespace. Every runtime serving one customer derives the same session ID from a single shared function, build_runtime_session_id(). Session state that outlives a turn, such as journey state and history, sits in an Amazon DynamoDB table, and that table, not AgentCore memory, carries continuity in the demo. The principle is to adopt the context and never re-derive it.
The voice layer
Voice is the primary interface, and we gave Amazon Nova 2.5 Sonic one job: transport. It turns speech into text and text back into speech, and nothing else. It holds no financial facts, makes no routing decisions, and never calls a specialist. The browser opens a SigV4-presigned WebSocket directly to the AgentCore runtime hosting the voice agent. The agent streams the audio to Amazon Nova 2.5 Sonic and hands every spoken question to the same run_turn handler as a typed one.
Voice therefore gets the same journey logic, specialists, and guardrails as chat. Swapping or upgrading the speech model touches none of the banking logic. The journey lives in the application layer, not inside the agent. The agent reasons and phrases, while the surrounding logic decides where the conversation is and what appears on the screen. That separation keeps the experience feeling natural and conversational.
The same separation means the voice layer can evolve independently, which is what makes the pattern reusable beyond this demo, in contact-center, advisor-assist, and branch scenarios.
Guardrails
Every turn passes Amazon Bedrock Guardrails twice: an input guardrail on the customer’s message and an output guardrail on the answer. Both modalities use the same pair. They check text per message and voice per sentence, so the system holds audio until each sentence passes, which helps keep non-compliant phrases from being spoken. The specialist that owns each domain rule, such as debt-to-income (DTI) ceilings and lender minimum cover, enforces it in code instead of leaving it to the model’s judgment. The Personal Banker is designed to surface options and explain the trade-offs of each one, not to give regulated advice.
For production, add the two controls that risk and compliance teams ask about first. Route any request that crosses into regulated advice to a licensed human advisor, passing the conversation and its shared_context along so the customer doesn’t start over. And add Automated Reasoning checks in Amazon Bedrock Guardrails, which validate an answer against business rules or regulations written as formal logic. The checks report findings rather than block content, so the application decides whether to serve the answer, rewrite it, or hand off.
Observability
With eight runtimes behind one conversation, operators need to see whether the system is working. We built one Amazon CloudWatch dashboard and ordered it by the questions an operator asks: Is the conversation down or only degraded (orchestrator invocations versus errors)? Which step broke (all four specialists’ errors on one graph)? Is a specialist stalling (p99 latency against the 45-second timeout)? Is it the agent or the tool it called (Lambda and MCP server errors)?
Every turn emits one structured log line. Five alarms cover the failure modes that matter, and we also charted guardrail interventions. For traces, Amazon Bedrock AgentCore Observability, a capability of Amazon Bedrock AgentCore, adds the per-request view: Runtimes instrumented with OpenTelemetry send their spans to it, so one trace can follow a turn from the orchestrator into each specialist. Instrument every runtime so no hop is missing.
What we learned
- Always give the conversation a way to work: Chat has a main path and a backup. The main path runs through Amazon Bedrock AgentCore, which gives each session an isolated runtime and automatic tool discovery. The backup path is an Amazon Bedrock Converse tool loop that runs inside the API’s Lambda function. If an AgentCore call fails, the Lambda function answers the same turn with the same tool definitions, and labels the reply with the path that served it. Building that backup from the start meant the experience never relied on everything being perfect at once. Apply it: Design the degraded path on day one and label every response with the path that served it.
- Ready isn’t the same as working: Early on, the orchestrator reported a healthy status while failing each invocation, and we only caught it by exercising it. With multi-agent systems, you must verify on the actual path, not by trusting a green light. It was a lesson that shaped how we monitor the entire estate today, with one dashboard, a small set of alarms we trust, and a trace line for every turn. Apply it: Health checks should run a real turn end to end, not only confirm the container is up.
- Make the hand-offs observable: In our experience, the hand-offs are where multi-agent systems fail. Tracing every hand-off turned debugging from guesswork into a glance and became a talking point for the demo itself. Apply it: Emit a trace event at every agent-to-agent and agent-to-tool boundary.
- Let the data, not the model, carry the numbers: When a specialist returns numbers (a payment breakdown, coverage tiers), those numbers are computed in code and passed through as-is. We don’t ask the model to reproduce them, which helps keep the chart and the prose consistent with each other. Apply it: Any agent that presents numbers, such as credit decisions or claims settlements, should compute them in code and let the model only phrase them.
- Deploy and verify like production: We pinned container images by their digest instead of a moving tag, and tested the application through its real deployed front door rather than a local stand-in. Together, those decisions caught a costly class of bugs: the kind that reports success while shipping nothing. Treating a demo with production discipline was worth the effort. Apply it: Pin images by digest and gate deployments on a scripted journey test.
The takeaway is that the same architecture that makes the customer experience feel unified also helps make the system resilient and extensible for developers. Get the structure right, and the same decisions serve both audiences at once.
The same orchestrator-and-specialist pattern fits other financial services journeys, such as commercial relationship management, claims, wealth advice, and know your customer (KYC), wherever several specialists must work from the same customer facts.
For production, we would add three things. First, an evaluation suite that scores answers for accuracy and suitability against known customer scenarios on every release, which Amazon Bedrock AgentCore Evaluations, a capability of Amazon Bedrock AgentCore, can run with built-in and custom evaluators. Second, governance over which agents, tools, and models are approved and who signs off on changes. Third, cost tracking per conversation, because every cross-segment hop adds a model call.
When not to use this pattern
Bring in the orchestrator-and-specialist split when a question genuinely spans domains that need their own reasoning, rules, or owners. It’s likely the wrong choice when:
- One domain covers the job – If a mortgage-only assistant hands questions to a lending specialist, you pay for a second model call and a second runtime, and the answer is no better because there is nothing to coordinate. One agent with deterministic tools gives the same answer faster and is easier to test, which matches the AWS guidance to use a tool rather than a sub-agent when the capability is deterministic.
- The latency budget is tight – Each cross-segment hop adds a model call, which is why a chat turn in the demo took about 10 seconds at the median. A voice flow with a sub-second target, such as an interactive voice response (IVR) system, would likely miss its target, so those flows are better served by a single agent.
- Volume is low – Separate runtimes pay off by letting busy segments scale on their own and keeping one failure from reaching many customers. At low volume, neither happens, so you take on the work of running eight runtimes and get nothing back for it. Start in one runtime and split it out as traffic grows, since the
shared_contextcontract carries over unchanged.
Conclusion
Connected Finance began with a belief that customers facing the biggest financial decision of their lives deserve a bank that acts like one partner, not multiple disconnected departments. We built the Agentic Bank to make this possible: one AI Personal Banker and four specialist agents, designed so that a single conversation spans lending, wealth, payments, and insurance without the customer noticing the boundaries.
Visit the Financial Services Expo between November 30 and December 3 at the AWS Industry Zone, Booth 111, Venetian Hall B, Las Vegas, NV, and have the conversation with the AI Personal Banker.
You can start building with the same patterns today: Explore Amazon Bedrock AgentCore for running multi-agent systems, and the Agentic Value Accelerator (AVA) for planning, securing, and governing AI agents in financial services.
Learn more
- Explore the demo described in this post in a hands-on AWS workshop at re:Invent 2026, Building a multi-agent AI personal banker (IND329), where builders can walk through the agent orchestration and tooling.
- Explore the Financial Services re:Invent 2026 Expo kiosk demo packages, including one-pagers, demo videos, and reference architectures for Banking, Wealth Management, Insurance, Payments, and the AVA.
- Visit the Generative AI for Financial Services webpage or get in touch with an AWS Financial Services expert.
- Follow us on LinkedIn.

