Creating Seamless Voice Banking Agents with Amazon Nova Sonic + AgentCore

Amazon Nova Sonic is a foundation model from AWS that enables real‑time, natural‑language voice interaction, understanding tone and executing commands.

The article introduces a banking voice assistant use case, showing how a monolithic design leads to long prompts and maintenance difficulty, and proposes a multi‑Agent architecture where each specialized Agent handles a specific domain such as identity verification, account queries, or mortgage assistance.

Integration is achieved by using Nova Sonic as the speech front‑end and Amazon Bedrock AgentCore as the orchestration layer. Sub‑Agents are built with the Strands Agents framework and run on the AgentCore runtime. The GitHub repository https://github.com/aws-samples/amazon-nova-samples/tree/main/speech-to-speech/workshops/agent-core provides the sample code.

Three sub‑Agents are defined:

Identity verification Agent – validates user ID and account information.

Banking services Agent – handles balance checks, statement generation, and other queries.

Mortgage Agent – answers refinancing, interest rate, and repayment questions.

Each Agent runs independently; the identity Agent can return error messages to Nova Sonic, illustrating modular design similar to software engineering principles.

Tool‑call events allow Nova Sonic to trigger a specific sub‑Agent. The article provides a JSON tool specification for a bankAgent that matches queries like “What’s my balance?” and defines the input schema with accountId and query.

[{ "toolSpec": { "name": "bankAgent", "description": `Use this tool whenever the customer asks about their **bank account balance** or **bank statement**.`, "inputSchema": { "json": JSON.stringify({ "type": "object", "properties": { "accountId": { "type": "string", "description": "This is a user input. It is the bank account Id which is a numeric number." }, "query": { "type": "string", "description": "The inquiry to the bank agent such as check account balance, get statement etc." } }, "required": ["accountId","query"] }) } } }]

When a user asks about balance, Nova Sonic emits a toolUse event containing the tool name and payload, which the client forwards to the appropriate sub‑Agent on Bedrock AgentCore. The response is then spoken back to the user.

{ "event": { "toolUse": { "completionId": "UUID", "content": "{\"accountId\":\"one two three four five\",\"query\":\"check account balance\"}", "contentId": "UUID", "promptName": "UUID", "role": "TOOL", "sessionId": "UUID", "toolName": "bankAgent", "toolUseId": "UUID" } } }

The article then presents Python code that creates the banking Agent using Strands, defines two tools ( get_account_balance and get_statement), sets up the Bedrock model amazon.nova-lite-v1:0, and provides a system prompt guiding the Agent’s behavior. The entrypoint banking_agent receives a payload, invokes the Agent, and returns the textual response.

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

app = BedrockAgentCoreApp()

@tool
def get_account_balance(account_id) -> str:
    """Get account balance for given account Id"""
    # implementation...
    return {"result": result}

@tool
def get_statement(account_id: str, year_and_month: str) -> str:
    """Get account statement for a given year and month"""
    # implementation...
    return {"result": result}

bedrock_model = BedrockModel(model_id="amazon.nova-lite-v1:0")
system_prompt = '''
You are a banking agent. You will receive requests that include:
- `account_id`
- `query` (the inquiry type, such as **balance** or **statement**, plus any additional details like month).

## Instructions
1. Use the provided `account_id` and `query` to call the tools.
2. The tool will return a JSON response.
3. Summarize the result in 2–3 sentences.
   - For a **balance inquiry**, give the account balance with currency and date.
   - For a **statement inquiry**, provide opening balance, closing balance, and number of transactions.
4. Do not return raw JSON. Always respond in natural language.
'''

agent = Agent(tools=[get_account_balance, get_statement], model=bedrock_model, system_prompt=system_prompt)

@app.entrypoint
def banking_agent(payload):
    response = agent(json.dumps(payload))
    return response.message['content'][0]['text']

if __name__ == "__main__":
    app.run()

Best‑practice recommendations include balancing flexibility with latency, preferring lightweight models like Amazon Nova Lite for most sub‑Agents, and designing concise voice responses. The article compares stateless versus stateful sub‑Agents, noting that stateless agents are simple and scalable but lack context, whereas stateful agents retain conversation history at the cost of increased complexity and resources.

In conclusion, the multi‑Agent architecture brings flexibility, scalability, and accuracy to AI‑driven workflows. Combining Nova Sonic’s conversational abilities with Bedrock AgentCore’s orchestration lets developers build seamless, modular voice assistants for banking and other domains.