As cloud infrastructure grows more complex, the need for intuitive management interfaces keeps rising. Command-line tools and web consoles are powerful, but they can slow quick decision-making. This post explores an AWS reference project that takes a different approach: talking to cloud infrastructure and getting immediate, intelligent responses. The pattern — a voice interface routed through cooperating AI agents — generalizes well beyond cloud operations to data analytics, customer service and enterprise workflow orchestration.
Architecture deep dive
The system combines Amazon Nova Sonic, AWS’s speech-to-speech model, with the open-source Strands Agents framework to build a multi-agent system that processes voice commands and executes AWS operations in real time.
Main components
The architecture consists of several specialized components. A supervisor agent acts as central coordinator, analyzing incoming voice queries and routing them to the appropriate specialist based on context and intent. Three specialized agents handle the actual work: an EC2 agent for instance management, status monitoring and compute operations; an SSM agent for Systems Manager operations, command execution and patch management; and a backup agent overseeing AWS Backup configuration, job monitoring and restore operations. A voice integration layer uses Amazon Nova Sonic for bidirectional voice processing — converting speech to input for the agents and agent responses back to natural speech.
Solution overview
Instead of navigating consoles or recalling CLI syntax, users state their intent aloud and receive spoken feedback. The design goal is to bridge natural human communication and technical AWS operations, making routine cloud tasks accessible to technical and non-technical team members alike.
Technology stack
The backend runs on Python 3.12+ with the Strands Agents framework for orchestration. The frontend uses React with the AWS Cloudscape Design System. Natural-language understanding runs on Amazon Bedrock with Claude 3 Haiku; Amazon Nova Sonic handles speech recognition and synthesis; and a WebSocket server provides real-time bidirectional communication.
Key features and capabilities
The system converts natural voice queries into AWS API calls — for example, “Show me all EC2 instances running in us-east-1,” “Install the CloudWatch Agent using SSM on my dev instances,” or “Check the status of last night’s backup jobs.” Responses are optimized for voice delivery: concise summaries capped at 800 characters, clearly structured information, and conversational phrasing that sounds natural when spoken aloud.
Implementation overview
Getting started involves three steps. Environment setup: configure AWS credentials with access to Bedrock, Nova Sonic and the target services; set up the Python backend and React frontend; and ensure correct IAM permissions for multi-agent operations. Launching the application: start the Python WebSocket server for voice processing, launch the React frontend, and configure voice settings and the WebSocket connection. Starting a conversation: grant browser microphone permissions and test with commands such as “list my EC2 instances.” Full deployment instructions, code and troubleshooting guides are in the GitHub repository.
Example prompts to test via audio
For EC2 management: “List my dev EC2 instances where tag key is env,” “What is the status of those instances?,” “Start those instances,” “Do these instances have SSM permissions?” For backup management: “Make sure these instances are backed up daily.” For Systems Manager: “Install the CloudWatch Agent using SSM on these instances” and “Scan these instances for patches using SSM.” A demo video in the project repository shows the assistant processing these commands end to end.
Implementation examples
The following code examples demonstrate the key integration patterns: setting up the Strands multi-agent orchestrator and integrating Nova Sonic for real-time voice processing.
AWS Strands agent setup
The implementation uses a multi-agent orchestrator pattern with specialized agents:
from strands import Agent
from config.conversation_config import ConversationConfig
from config.config import create_bedrock_model
class SupervisorAgent(Agent):
def __init__(self, specialized_agents, config=None):
bedrock_model = create_bedrock_model(config)
conversation_manager = ConversationConfig.create_conversation_manager("supervisor")
super().__init__(
model=bedrock_model,
system_prompt=self._get_routing_instructions(),
tools=(), # No tools for pure router
conversation_manager=conversation_manager,
)
self.specialized_agents = specialized_agentsNova Sonic integration
The implementation uses a WebSocket server with session management for real-time audio processing:
class S2sSessionManager:
def __init__(self, model_id='amazon.nova-sonic-v1:0', region='us-east-1', config=None):
self.model_id = model_id
self.region = region
self.audio_input_queue = asyncio.Queue()
self.output_queue = asyncio.Queue()
self.supervisor_agent = SupervisorAgentIntegration(config)
async def processToolUse(self, toolName, toolUseContent):
if toolName == "supervisoragent":
result = await self.supervisor_agent.query(content)
if len(result) > 800:
result = result(:800) + "... (truncated for voice)"
return {"result": result}
Security best practices
The solution is designed for development and testing. Before any production deployment, appropriate controls are essential: authentication and authorization, network security and access restrictions, monitoring and logging for audit compliance, and cost controls. AWS security best practices and the principle of least privilege should govern all IAM configuration — particularly important here, since a misheard voice command in an over-privileged environment could act on real infrastructure.
Production considerations
For production use, AWS points to the Amazon Bedrock AgentCore runtime for enterprise-grade hosting: a serverless runtime purpose-built for dynamic AI agents; full session isolation with dedicated microVMs per user session (critical for agents performing privileged operations); auto-scaling to thousands of sessions with pay-per-use pricing; built-in security integration with identity providers such as Amazon Cognito, Microsoft Entra ID and Okta; distributed tracing and metrics through CloudWatch; and session persistence for long-running interactions.
Conclusion
The project demonstrates what becomes possible when voice interfaces meet intelligent agent orchestration: speech processing through Nova Sonic, multi-agent coordination through Strands, and a modular design that extends to customer service automation, financial analytics, IoT management, healthcare workflows and other domains. It sits within the same enterprise tooling wave as AWS’s managed MLflow expansion — infrastructure vendors racing to make AI operations turnkey.
Limitations and what to watch
Several practical cautions apply. This is an AWS-published sample project, not a supported product: it showcases AWS services by design, and the repository may drift out of date as APIs evolve. Voice control of infrastructure carries inherent risk — speech recognition errors combined with write permissions (“start those instances,” “run this patch scan”) argue for read-only scopes and human confirmation on any mutating action. Latency and per-session costs of always-on speech models deserve measurement before scaling. And the 800-character response cap that makes answers speakable also truncates detail, so complex operational questions will still push users back to the console. Treat the project as a well-documented starting point for experimentation rather than a production blueprint.
