Happy New Year all — I spent a bit of time over the holidays building something I’d been meaning to explore for a while, and figured it was worth sharing.
Customer service AI usually shows up in one of two forms:
-
a chatbot that answers questions correctly but with the emotional range of a parking meter, or
-
a demo that works great until someone speaks slightly faster than expected.
The CORA Voice Agent project sits between low-code and pro-code. It’s not trying to replace human agents, and it’s definitely not trying to win a “most autonomous AI” contest. Instead, it explores a more practical question: What if AI could help humans get better at customer conversations, in real time, using voice?
This project was built as a learning journey first, but one that intentionally lands on a real, usable solution — delivered in two parts:
- A six-module training workshop that walks through the architecture and build-out step by step - using easily deployed Azure components.
- A GitHub repository you can fork, break, improve, or deploy using GitHub Actions and Azure Developer CLI
- A six-module training workshop that walks through the architecture and build-out step by step - using easily deployed Azure components.
- A GitHub repository you can fork, break, improve, or deploy using GitHub Actions and Azure Developer CLI
CORA isn't a new industry acronym to learn or standard to follow.
CORA stands for Customer-Oriented Response Agent, she’s the name we gave our AI training application! 🤖
CORA even has personality with over 100 voice tones (in Edge browser) and 6 selectable persona moods to simulate customer emotional state for broad training experiences.
CORA stands for Customer-Oriented Response Agent, she’s the name we gave our AI training application! 🤖
CORA even has personality with over 100 voice tones (in Edge browser) and 6 selectable persona moods to simulate customer emotional state for broad training experiences.
Module 1: Solution Overview
In Module One, we take a step back and compare low-code tools such as Copilot Studio with Azure-based solutions, exploring when it makes sense to reach for more advanced features without making things harder than they need to be. It’s a look at how Azure OpenAI and Microsoft Foundry can be combined to support real-time voice interaction and scoring.
You’ll walk through the core components, how they talk to each other, and why certain architectural choices were made. Think of it as the “map before the hike” — helpful context before you start provisioning things and wondering why nothing works yet.
Module 2: Infrastructure Setup
Here’s where the cloud work begins. This module focuses on standing up the required Azure infrastructure using Azure Developer CLI (azd).
Container Apps, storage, identities, telemetry — the usual cast of characters — but wired together with repeatability in mind. The goal isn’t just to get something running once, it’s to make sure you can tear it down, redeploy it, and still remember how it works the next day.
Module 3: Application Deployment
Now the voice agent starts to feel real.
This module walks through deploying the Flask-based application, containerizing it, and getting it running in Azure Container Apps. It also introduces how real-time voice flows move between the browser, the backend, and Azure services.
At this point, you’re no longer just reading diagrams. You’re deploying something that listens, responds, and occasionally surprises you — usually right before you check the logs.
Module 4: Azure OpenAI and Microsoft Foundry Integration
This is where the intelligence layer comes into focus.
You’ll configure a Microsoft Foundry project, deploy models, and wire them into the conversation flow. The emphasis here isn’t “look how smart the model is,” but rather how it’s used — scoring interactions based on tone, clarity, and empathy rather than just correctness.
It’s less about generating perfect answers and more about evaluating how those answers sound when spoken aloud by a human agent.
Module 5: Analytics Dashboard
Voice interactions are interesting. Metrics make them useful.
This module introduces a lightweight analytics dashboard built with Chart.js and Azure Table Storage. It visualizes conversation scores over time, helping surface patterns that are easy to miss when you’re just listening to recordings.
Nothing flashy. Just enough insight to answer questions like:
-
Are agents improving?
-
Are certain scenarios harder than others?
-
Is the AI being too generous… or too harsh?
Module 6: Advanced Topics (Optional, but Encouraged)
The final module is intentionally open-ended. Monitoring, observability, and production considerations all show up here, along with ideas for extending the system beyond the workshop.
If you’re the kind of person who can’t leave a project alone once it’s “done,” this section will feel very familiar.
The Repository: From Learning Exercise to Something You Can Actually Use
The training workshop is paired with a GitHub repository that mirrors exactly what you build across the modules. This isn’t reference code meant to be admired from a distance. It’s meant to be forked, modified, and occasionally broken while you figure out how the pieces fit together.
At a technical level, the repository brings together a fairly opinionated but approachable stack:
-
Python + Flask for the core web application
-
WebSockets to support real-time voice interaction
Web Speech API for speech recognition and speech synthesis
-
Azure OpenAI for language understanding and response generation
-
Microsoft Foundry for model orchestration and agent configuration
-
Azure Container Apps for scalable, managed runtime
-
Azure Storage (Tables) for lightweight analytics persistence
-
Chart.js for visualizing interaction metrics
-
Azure Developer CLI (azd) to glue infrastructure and app deployment together
The result is a system that feels modern without being overly abstracted. You can see where data flows, where models are called, and where decisions are made — which is exactly what you want when you’re learning or experimenting.
The repo includes:
-
The full Flask application used throughout the training
-
Infrastructure templates aligned with the workshop architecture
-
Predefined SDK usage for Azure OpenAI and Foundry to reduce setup friction
-
GitHub Actions workflows that automate Azure deployment end to end
One of the deliberate design choices here was local development first. You can run the app locally, iterate quickly, and only push to Azure when it’s ready. When you do, azd handles the heavy lifting — provisioning resources, wiring identities, and keeping environments consistent.
From there, GitHub workflows step in to make things repeatable. Whether you’re testing changes, sharing improvements, or just tired of clicking through the portal, the automation is there when you want it — and out of the way when you don’t.
The goal isn’t to enforce a single deployment path. It’s to give you options without adding complexity for complexity’s sake.
Why Share This at All?
This project didn’t start as a demo idea or a “let’s build something cool” exercise. It grew out of real customer conversations — questions around voice AI, agent coaching, and whether modern AI tooling could support human agents without getting in their way.
Voice AI is easy to demo and surprisingly hard to do well. Once you add humans into the loop — especially in customer service — things like tone, pacing, empathy, and consistency matter just as much as accuracy. That’s where the curiosity turned into experimentation, and eventually into something worth sharing.
Rather than keep the learning internal, this felt like a good opportunity to:
-
Document what worked (and what didn’t)
-
Show how Azure OpenAI and Microsoft Foundry behave in a real voice scenario
-
Share an approach that others can adapt, extend, or completely rethink
CORA is an open learning project — part experiment, part reference, and a practical starting point for anyone curious about:
-
Real-time voice agents beyond scripted demos
-
Coaching and scoring human interactions, not replacing them
-
Azure OpenAI and Microsoft Foundry in practical, hands-on scenarios
-
Balancing local development flexibility with cloud-scale automation
If someone forks the repo, learns something new, or walks away with a better mental model of how voice AI can support humans instead of replacing them — then the project has already succeeded.
Wrapping It Up
If you’re curious to see how this all comes together, the full training modules and deployment walkthrough are available on GitHub Pages. You can move through each module at your own pace, save your progress along the way, and if you make it to the end, there’s even a certificate of achievement waiting for you — mostly as proof that you survived a real-world voice AI build without losing your sanity.
👉 https://jbaart37.github.io/Cora-Voice-Agent-Training/
If reading site pages isn’t your thing and you’d rather learn by breaking code, you can jump straight into the repository. Clone it, run it locally, or use the included GitHub workflows to deploy everything into Azure with minimal technical acrobatics.
👉 https://github.com/jbaart37/Cora-Voice-Agent-Training
Whether you follow the training step by step or dive directly into the code, the goal is the same: learn by building, explore what’s possible with voice AI and human-in-the-loop systems, and hopefully come away with a few ideas of your own.
