AyoChat

An autonomous multi-agent AI swarm that polls YouTube comments and deploys culturally fluent, verified replies in your authentic voice—governed entirely from the terminal or your phone.

Comment 1

Inspiration

Over the summer, my dance channel on YouTube hit a massive viral growth point—pulling in millions of views and thousands of comments in under 28 days. It exposed me to incredible scale, but with that scale came a global deluge of comments, hype, and inevitably, hate, spanning multiple languages. I realized a massive bottleneck in the attention economy: creators can get 20 million Shorts views, but if the global operating system of life (classes, research, sleep) keeps your phone on "Do Not Disturb," you lose the engagement. I needed a bridge to funnel fleeting attention into a regulated, governed space.

But the true inspiration for this specific iteration came from a dinner at St. James with industry-leading AI researchers from Howard University and beyond. Sitting at that table, listening to architects of the field discuss the future of AI governance and cross-cultural semantic datasets, I experienced a profound shift from operator to architect. I realized that a single, monolithic LLM couldn't safely govern a diverse global community. I needed a digital "council" to mirror the human one I was sitting with. Thus, Lumi was brought to life.

What it does

AyoChat is an autonomous multi-agent swarm that acts as a sovereign digital guardian for creator communities. Instead of relying on generic "smart replies," Lumi actively governs the space:

  • The Supervisor Node calibrates the "room temperature" based on video metadata.
  • The Perception Node scores inbound semiotic intent, detects language, and dynamically routes the comment.
  • The Autonomous Hive Node deploys a strictly 1-sentence, culturally fluent, unbothered reply.
  • The Mobile HITL Companion PWA allows the creator to monitor 4D semiotic telemetry and approve, skip, or edit agent drafts directly from their phone before dispatching them to the YouTube API.

How I Built It

Under the hood, this engine orchestrates Gemini 3.5 Flash through an ADK BuiltInPlanner, ChromaDB vector retrieval, an LLM Council for multi-lingual synthesis, and an asynchronous FastAPI + SQLite mobile HITL pipeline.

  • The Memory: I used ChromaDB and engineered Atomic Dialogue-Pair Chunking (.jsonl). Each 60-90 token chunk binds the inbound fan intent, the factual context, and the calibrated response into a single, indivisible vector.
  • The Brain & Advanced Reasoning: I implemented the ADK BuiltInPlanner into our Hive Node, allocating a 1024-token thinking budget to Gemini 3.5 Flash. Before generating a reply, the model explicitly reasons through the cultural nuance and mathematically weighs our 4D semiotic vectors ($\alpha_{cs}$, $\beta_{sf}$, $\gamma_{fr}$, $\tau_{max}$). Non-English queries route to our LLM Council (BETO, CamelBERT, Llama-3) for authentic regional consensus.
  • The Interface: I decoupled the swarm from the terminal by building a Next.js Progressive Web App featuring Material 3 Expressive "liquid glass" design, turning raw agent orchestration into an accessible, mobile-first creator product.

Challenges I Ran Into

The most humbling initial challenge was a state-leakage bug we dubbed "The Repeating Lamp Cache String." During batch-polling, the agent began deploying the exact same hardcoded string to every user by failing to clear its memory state. We architected a swift fix using explicit reset_state() lifecycle hooks.

However, the final challenge was purely architectural restraint. Building the terminal script took five days, but wiring the Telegram automation and abstracting that power into a mobile PWA made me realize who I was actually engineering for: everyday creators. There were so many moments where I convinced myself to push just one "LAST" feature. The build never truly feels finished, but I had to learn when the system was powerful enough to stand on its own, and stop the build.

Accomplishments and Wins

I built a verifiable, production-ready creator infrastructure. I am incredibly proud of the 89/89 passing test suite, which rigorously evaluates the RAG Triad. My biggest technical accomplishments\ was gaining hands on experience learning to coordinate agents in Agent Development Kit (ADK) and applying the content I started learning from GEAR modules on Google Skills directly to my personal build. My most impactful accomplishment was the evolution of the solution itself. My first real win was simply watching the agent successfully reply to every unresponded comment on a single video. My second win was scaling that across the entire channel. However, that scale terrified me—it immediately exposed the danger of automation without guardrails (which led to a repeating cache bug). That scare forced me to build the Human-in-the-Loop (HITL) Terminal UI. When I finished the terminal view, I thought, "Oh my gosh, it's done. We finished."

But then I thought: if my laptop is in my bag, and comments are flooding in, a terminal isn't enough. That pushed me to completely abstract the architecture into a mobile companion app. By the end of the sprint, we had arrived at a completely different island from where we started.

The true win wasn't just writing the code; it was the journey from conception to a fully delivered, viable solution. I got to experience the very essence of computer science—spending hours agonizing over how to package raw compute and make it genuinely easy for humans to interact with. That question of how to make things easier never stops, but I am incredibly proud of the solution I delivered with the time allocated for the build.

What I Learned

I learned that fixed-size document chunking is fundamentally flawed for social dialogue. I learned that global language parity cannot be solved efficiently by a single model. Most importantly, I learned that AI engineering isn't just about scaling live telemetry or wiring multi-agent systems—it is about embedding cultural fidelity directly into the infrastructure to protect your community's joy.

What's next for AyoChat

The immediate next phase is building a Stateful Thread Tree Memory Layer using Redis session caching to maintain deep conversational memory with fans across multi-turn reply threads without exceeding API quotas. The ultimate goal is to package this swarm into a plug-and-play architecture, allowing any creator to spin up their own culturally sovereign AI guardian.

Built With

Share this project:

Updates