DEV Community: Gowtham M

Building MoneyBuddy: From a Simple Voice Agent to a Multi-Agent AI System in 10 Days

Gowtham M — Sat, 15 Aug 2026 16:53:01 +0000

Hi, I'm Gowtham M.

Over the last 10 days, I participated in the 10 Days of Voice Agents — VoiceForBharat Edition and built MoneyBuddy, an AI-powered voice assistant designed to make financial and government scheme-related information more accessible through natural conversations.

What started as a basic voice interaction gradually evolved into a system involving real-time AI, voice processing, memory, tool usage, human escalation, analytics, and multi-agent handoffs.

The goal was simple:

Can users get help with financial and government scheme-related questions through a natural voice conversation instead of navigating multiple websites and forms?

What started as a basic voice interaction gradually evolved into a system involving real-time AI, voice processing, memory, tool usage, human escalation, analytics, and multi-agent handoffs.

The idea behind MoneyBuddy

Users often need answers to questions like:

Am I eligible for a scheme?
What information do I need?
What should I do next?
Can this be explained in a simpler way?

Instead of searching through multiple sources, MoneyBuddy is designed to let users speak naturally to an AI assistant.

The core flow looks like this:

User Voice
    ↓
Speech-to-Text
    ↓
MoneyBuddy AI Agent
    ↓
Tools / Memory / Agent Routing
    ↓
Response Generation
    ↓
Text-to-Speech
    ↓
User

The 10-day journey

Day 1 — Building the foundation

I started by understanding how a real-time voice agent works.

The basic pipeline was:

Voice Input → AI Processing → Voice Output

This became the foundation for MoneyBuddy.

Day 2 — Designing better conversations

A voice assistant cannot simply read long chatbot-style responses.

I focused on making interactions:

Short
Conversational
Clear
Natural for voice

This made me think more about user experience, not just AI responses.

Day 3 — Defining the agent's role

I worked on giving MoneyBuddy clear instructions.

The agent needed to understand:

What it is responsible for
How it should respond
When to ask follow-up questions
When not to guess
When another action is required

One important lesson: an AI agent performs better when its responsibilities are clearly defined.

Day 4 — Adding tools

Some information should not be generated or guessed by an LLM.

So I explored structured tool usage.

User Request
    ↓
Agent Understands Intent
    ↓
Tool Required?
    ↓
Call Tool
    ↓
Get Result
    ↓
Explain Result to User

This was an important shift from a simple conversational AI system toward an AI agent capable of taking structured actions.

Day 5 — Working with memory

I explored how MoneyBuddy could remember useful conversation context.

The goal was to avoid making returning users repeat the same information.

At the same time, memory requires responsible handling.

The agent should ask for consent before storing relevant information.

This taught me that AI memory is not just a database feature—it is also a user trust feature.

Day 6 — Human escalation

Not every problem should be handled completely by AI.

For situations requiring additional help or manual intervention, I explored human escalation.

A useful AI system should not pretend to know everything.

Sometimes the best response is knowing when to say:

This requires additional assistance.

My key learning:

Good AI systems should understand their limitations.

Day 7 — Thinking beyond a chatbot

At this stage, I started looking at MoneyBuddy as a complete system.

The focus moved toward:

Conversation flows
Agent states
Error handling
Different user paths
System reliability

This was when the project started becoming more than a basic voice demo.

Day 8 — Analytics and outcomes

Building an agent is only the first step.

I also explored tracking what happens during interactions.

Examples of useful metrics include:

Total conversations
Successful outcomes
Escalations
Types of user requests
Agent handoffs

This helped me understand an important engineering principle:

If you cannot observe a system, it becomes difficult to improve it.

Day 9 — Multi-agent architecture

This was one of the biggest upgrades to MoneyBuddy.

Instead of asking one agent to handle everything, I added a dedicated Government Scheme Specialist.

The architecture became:

                     User
                       ↓
             MoneyBuddy Main Agent
                       ↓
          Is specialist help needed?
                  ↙          ↘
                No            Yes
                ↓              ↓
        Main Agent       Scheme Specialist
                ↘          ↙
                 Final Response
                       ↓
                     User

The main agent handles:

Greetings
General conversations
Initial request understanding
Basic assistance
Deciding whether a handoff is required

The specialist handles:

Government scheme-related questions
More detailed scheme discussions
Specialized assistance

The important part was context handoff.

The user should not have to explain the entire problem again after being transferred.

This was my biggest takeaway from multi-agent systems:

Specialized agents with clear responsibilities can be easier to manage than one agent trying to do everything.

Day 10 — Bringing everything together

By the end of the challenge, MoneyBuddy had evolved into a system involving:

Voice AI
   +
LLM
   +
Clear Instructions
   +
Structured Tools
   +
Memory
   +
Consent
   +
Human Escalation
   +
Analytics
   +
Specialist Routing
   +
Multi-Agent Handoff

What I learned

Building MoneyBuddy taught me that a voice AI application is much more than:

LLM + Microphone + Speaker

A useful AI agent needs:

Clear objectives
Good prompts
Natural conversation design
Reliable tools
Responsible memory
User consent
Error handling
Real-time performance
Human escalation
Observability and analytics
Clear agent responsibilities
Agent routing
Continuous testing

Challenges I faced

Some of the biggest challenges were:

Real-time latency

A voice pipeline contains multiple stages:

Speech → STT → LLM → Tools → TTS → Audio

A delay at any stage affects the overall user experience.

Agent handoff

Transferring a conversation between agents requires clear routing logic and context management.

Without proper context transfer, users may need to repeat themselves.

Defining agent responsibilities

As the system grew, it became increasingly important to clearly define what each agent should handle.

What's next for MoneyBuddy?

I would like to continue improving the project by exploring:

More specialist agents
Better tool integration
More verified data sources
Improved latency
Better multilingual support
More advanced analytics
Stronger memory management
Better mobile experience
Public deployment

Final thoughts

These 10 days changed the way I think about AI applications.

I started with the idea of building a voice assistant.

I ended up learning about real-time systems, AI agents, tools, memory, user consent, escalation, observability, and multi-agent architectures.

My biggest takeaway:

A useful AI product is not built by choosing only a powerful model. It is built by connecting the right components with clear responsibilities, good user experience, reliable systems, and continuous testing.

MoneyBuddy is still a work in progress, but these 10 days gave me a much stronger foundation for building AI agents that can interact with users in more natural and useful ways.

VoiceForBharat #MurfAI #VoiceAI #AIAgents #MultiAgentAI #LiveKit #Python #GenerativeAI #MoneyBuddy

The Agentic Era Is Here — But Are We Actually Ready?

Gowtham M — Wed, 29 Apr 2026 07:56:57 +0000

This is a submission for the Google Cloud NEXT Writing Challenge

While watching Google Cloud NEXT ’26, I didn’t just feel excited. I felt a bit uncomfortable too.

Because what Google introduced is not just another update in cloud or AI. It’s a shift in how work itself might happen.

The biggest announcement for me was the Gemini Enterprise Agent Platform.

Until now, most of us have been using AI as a tool. We ask questions, get answers, maybe generate code or content. But what Google is pushing is something very different. They are moving towards systems where AI agents can actually take actions, collaborate with each other, and complete tasks end-to-end.

One line from the keynote stayed with me.

The era of the pilot is over. The era of the agent is here.

That sounds powerful. But it also raises important questions.

What really impressed me was how multiple agents can work together from a single prompt. One agent handles research, another analyzes data, another creates content, and another interacts with development tools. This is not just automation. This feels like assigning work to a team.

If this becomes normal, then using software may change completely. Instead of clicking through apps, we might just describe what we want, and a system of agents handles everything.

Another part that stood out was Workspace Intelligence. Anyone who uses productivity tools knows how much time is wasted searching for information. Emails, documents, chats, spreadsheets — everything is scattered. Google is trying to solve that by creating a system that understands context across all of them and gives you exactly what you need.

If it works as shown, it could remove a lot of friction from daily work.

The Agentic Data Cloud idea also felt very practical. In real-world scenarios, data is never clean or centralized. It lives in different formats and platforms. Instead of forcing everything into one place, Google is allowing AI to understand data where it already exists. That approach feels more realistic than traditional pipelines.

But this is where my concerns begin.

If organizations start using hundreds or even thousands of agents, how do we manage them? Even today, debugging distributed systems is difficult. Now imagine debugging autonomous agents making decisions.

There is also the question of trust. When agents move from assisting to acting, we are giving them more responsibility. In critical systems, even small mistakes can have serious consequences.

And from a learner’s perspective, I’m still thinking about accessibility. These tools are described as low-code, but understanding how to design and control agent-based systems may still require strong fundamentals in cloud, data, and AI.

Personally, this event changed how I look at my future in tech.

Earlier, I thought learning tools and frameworks was enough. Now it feels like the real skill will be designing systems where multiple intelligent components work together. The role of a developer might shift from writing everything manually to orchestrating how things work.

Google Cloud NEXT ’26 didn’t just introduce new features. It introduced a new way of thinking.

We are moving from using software to describing outcomes, and letting systems figure out how to get there.

That is powerful.

But it also means we need to think carefully about control, reliability, and responsibility.

So I’m curious.

Are we ready for this shift, or are we still underestimating how complex it could become?

EcoTrack AI — Carbon Footprint Tracker & Dashboard

Gowtham M — Fri, 17 Apr 2026 18:18:55 +0000

This is a submission for Weekend Challenge: Earth Day Edition

EcoTrack AI — Track, Visualize & Reduce Your Carbon Footprint
This is my individual work, built entirely from scratch for the #weekendchallenge.

🔗 Links
🚀 Live Demo: ecotrack-ai-317275340485.asia-south1.run.app
💻 GitHub Repo: github.com/Gowtham280103/greenprint
💡 What is EcoTrack AI?
EcoTrack AI is a full-stack web application that helps users track, visualize, and reduce their daily carbon footprint using AI-powered suggestions, interactive charts, and gamification.

You enter your daily habits — travel, electricity, food, and shopping — and the app instantly calculates your CO₂ emissions, gives you an Eco Score, and generates personalized tips to help you live greener.

✨ Features
🎯 Daily Tracker — Log travel, electricity, food & shopping habits
📊 Eco Score (0–100) — Animated SVG ring showing your green rating
🟢 Impact Level — Low / Medium / High with color coding
🌳 CO₂ Equivalents — See your footprint as trees, flights, phone charges
🤖 AI Suggestions — Powered by Google Gemini API with smart local fallback
📉 7-Day Trend Chart — Line chart with global average reference line
🥧 Category Breakdown — Doughnut & pie charts via Chart.js
🏆 Badges & Gamification — Earn badges like "Green Warrior", "EV Rider", "Cyclist"
🎮 Daily Challenges — 9 eco challenges with XP rewards
🌙 Dark Mode — Full dark/light theme toggle with persistence
📱 Fully Responsive — Works on mobile, tablet, and desktop
📋 History Log — All past entries with Eco Score column
🛠️ Tech Stack
Layer Technology
Backend Python, Flask, Flask-CORS
Frontend HTML5, CSS3, Vanilla JavaScript
Charts Chart.js 4
AI Google Gemini API
Storage JSON file-based (no database needed)
Deployment Google Cloud Run + Docker
Font Inter (Google Fonts)
🏗️ Architecture
greenprint/
├── Dockerfile
├── .dockerignore
└── ecotrack/
├── backend/
│ ├── app.py # Flask API + static file serving
│ ├── calculator.py # Emission logic + AI suggestions + Eco Score
│ ├── storage.py # JSON persistence
│ └── requirements.txt
└── frontend/
├── index.html # 4-page SPA (Tracker, Dashboard, History, Challenges)
├── style.css # 700-line modern dashboard CSS with dark mode
└── app.js # 600-line frontend logic + Gemini integration
🚀 How to Run Locally

Clone

git clone https://github.com/Gowtham280103/greenprint.git
cd greenprint

Install dependencies

pip install -r ecotrack/backend/requirements.txt

Start server

python ecotrack/backend/app.py
Then open http://localhost:5000

☁️ Deployment
Deployed on Google Cloud Run using Docker. The container auto-scales to zero when idle (free tier friendly).

gcloud run deploy ecotrack-ai \
--source . \
--region asia-south1 \
--allow-unauthenticated
🧠 How the AI Works
The app uses rule-based logic with real emission factors from EPA & IPCC to calculate CO₂, then calls the Google Gemini API to generate personalized, context-aware suggestions like:

"Your 20 km petrol car trip contributes 3.84 kg CO₂. Switching to public transport 2 days/week saves ~1.1 kg CO₂/day — that's 286 kg/year!"

If no Gemini API key is set, a smart local fallback generates equally personalized insights.

📸 Screenshots

Built and Deployed a Smart Stadium Dashboard using Google Cloud Run

Gowtham M — Wed, 15 Apr 2026 10:08:16 +0000

I recently built and deployed a Smart Stadium Dashboard that simulates real-time crowd management inside a large venue.

This project focuses on improving the physical event experience by monitoring crowd density, waiting times, and operational alerts in real-time.

🔹 Key Features
• Live stadium map with crowd density visualization
• Waiting time tracking for gates and facilities
• Priority alert system for critical situations
• Staff allocation monitoring
• AI-based crowd suggestions for better management

🔹 Tech Stack
• Frontend: HTML, CSS, JavaScript (Vite)
• Backend: Node.js (Express)
• Deployment: Google Cloud Run

🔹 What I Learned
• How to deploy full-stack applications on cloud platforms
• Handling frontend and backend integration in production
• Understanding real-world scalability concepts
• Debugging cloud deployment issues

🔹 Challenges Faced
Initially faced multiple deployment errors while configuring Cloud Run, especially with build and server setup. After debugging logs and fixing the server configuration, I successfully deployed the application.

🌐 Live Demo: https://smart-stadium-dashboard-317275340485.us-central1.run.app

This project gave me a strong understanding of cloud deployment and real-time system design.

I built an app that forces you to procrastinate (and it actually works)

Gowtham M — Wed, 08 Apr 2026 18:41:21 +0000

This is a submission for the DEV April Fools Challenge

A chaotic funny scene of a person trying to work on a laptop while popups, alerts, and distractions explode everywhere, colorful, meme style, modern UI elements

What I Built

I built a web app that finally solves productivity…

By completely destroying it.

Introducing Procrastination-as-a-Service (PaaS) — an app designed to make sure you never finish your work.

Instead of helping you focus, it actively distracts you with:

Fake urgent alerts 🚨
Random useless tasks
Sudden redirects to YouTube
Annoying popups that question your life choices

It doesn’t improve your productivity.
It makes sure you avoid it entirely.

Demo

Try to be productive here (good luck 😈):

👉 https://remarkable-starship-ffc0ec.netlify.app/

Code

Check out the chaos behind the scenes:

👉 https://github.com/Gowtham280103/CHAOS_APP.git

How I Built It

HTML, CSS, JavaScript
Used setInterval() to trigger random distractions
Created fake notifications and alerts
Random actions like opening tabs, changing UI, and interrupting users
Deployed using Netlify

The logic is simple:
User tries to work → App interrupts → Productivity destroyed

Prize Category

Community Favorite

Because this is something everyone relates to…

Even if they didn’t ask for it 😄

Final Thoughts

We spend so much time building tools to improve productivity.

So I built one that does the opposite.

And honestly… it works too well.

Thanks for reading 🚀