Kira

What if an autonomous agent ran your YouTube channel? Meet Kira — text through WhatsApp, and it finds what's trending, produces the video, and publishes it to YouTube.

Comment

Inspiration

We’ve always wanted to make really good YouTube videos that people would actually watch, especially around trending topics. But we kept running into two big problems: we didn’t know what videos were worth making, and making them took way too much time.

We would see something trending and wonder, “What angle would actually get people interested? Would this video perform well?” Even when we had an idea, turning it into a good video could take anywhere from a few hours to several days. With busy schedules, it was hard to spend that much time on a video when we didn’t even know if people would watch it.

Because of this, a lot of our ideas never made it past the brainstorming stage. We realized that there are probably many people who want to post on YouTube, have ideas, and see trends they want to jump on, but simply don’t have the time or the tools to act on them quickly.

That’s what inspired Kira. We wanted to remove that barrier. Kira helps creators figure out what videos are worth making and then create them in less than 15 minutes, instead of spending hours or days. Our goal is to make creating timely, high-quality content something people can actually do, even when they don’t have a lot of time.

What it does

Kira is an autonomous AI agent that helps you figure out what to post on YouTube and creates it for you.

You simply message Kira on WhatsApp with a topic, a vibe, or even just ask, “What should I post today?” Kira researches what’s trending, looks at what is already performing, and suggests a video idea with a creative brief. You can approve it or steer it with a simple message.

Once you approve, Kira takes care of the rest. It writes the script, creates the visuals, generates the video, voiceover, music, and captions, puts everything together, and publishes the finished Short to YouTube.

It also remembers your preferences and what you’ve already posted, so it gets better at creating content for you over time.

From a simple WhatsApp message to a published YouTube Short in under 15 minutes.

How we built it

Kira is built as a multi-agent system using Google ADK and Gemini 3.5 Flash, with two cooperating agents: a Planning Agent and an Execution Agent.

The Planning Agent acts as the content strategist. It uses tool calls to query YouTube Trends, Google Trends, and live web search, while also reading Kira’s persistent memory to understand the creator’s preferences and avoid repeating previously published topics. It combines this information into a creative brief and waits for user approval. Once approved, the agent automatically hands off the brief to the Execution Agent.

The Execution Agent is responsible for the complete production workflow. We implemented dedicated tools and LLM-backed skills for script writing and production planning, followed by image generation with Nano Banana Pro, image-to-video generation with Gemini Omni Flash, voiceover using Gemini 3.1 Flash TTS, background music using Stable Audio 3, and caption transcription using Whisper. FFmpeg handles the deterministic post-processing layer, including video concatenation, caption burn-in, audio mixing, and final muxing.

The entire system is exposed through WhatsApp using Twilio's WhatsApp API, with a FastAPI service running on Google Cloud Run. For local development and testing, we also built a browser-based WhatsApp simulator.

For persistence, we use Supabase Postgres for users, sessions, messages, production state, and per-user JSONB memory. Generated assets are copied to Google Cloud Storage, giving us persistent URLs instead of relying on Fal.ai's temporary media URLs. YouTube publishing is handled through the YouTube Data API and OAuth.

We also designed Kira so that external services are optional and degrade gracefully. Postgres, GCS, Twilio, and YouTube can be disconnected during local development, allowing the core agent pipeline to run with just Gemini and Fal.ai credentials.

Finally, we built a content block system that separates the agent and production code from the content niche. A content block defines things like seed keywords, style, duration, voice, music, noise terms, and prompt overrides. This means we can move from our current Space & Cosmos channel to something like technology, history, or cooking without changing the underlying agent architecture.

The key technical idea is orchestration: Kira isn't one model generating a video. It is an agentic system coordinating specialized reasoning, tools, media models, deterministic processing, storage, and publishing into one autonomous pipeline.

Challenges we ran into

Building Kira wasn't just about connecting a few AI APIs. A lot of the work was making the system reliable when all of these components had to work together autonomously.

  • Getting the agent handoff to actually happen. ADK's multi-agent transfer is model-driven, and Gemini would sometimes describe what the execution agent should do instead of actually transferring control. After several iterations, we used an after_model_callback to explicitly force the handoff once the brief was approved, which made the workflow much more reliable.

  • Deciding between sub-agents and tools. We initially made the script writer and production planner separate ADK sub-agents. This fragmented state and introduced more points where the workflow could fail. We eventually converted them into tool functions that the Execution Agent calls directly. This gave us a much simpler and more reliable execution flow while still keeping the specialized prompts and reasoning.

  • Separating agent reasoning from the user experience. Early versions would sometimes send internal production plans and tool-call chatter directly to WhatsApp. We had to make a clear distinction between what Kira needs to reason about internally and what the user actually needs to see. This led to a cleaner brief-approval step where the user sees the important decision, rather than the entire internal process.

  • Making the system reliable on Cloud Run. We ran into several deployment-specific issues. A blocking database initialization call could prevent the server from starting, while processing full-resolution videos during muxing caused memory spikes and Cloud Run OOM kills. We had to restructure initialization and optimize the video-processing workflow before the deployment became reliable.

  • Privacy and abuse controls. Once we put Kira behind a real WhatsApp number, we had to think beyond the happy path. We removed phone numbers that didn't need to be persisted, prevented them from being stored going forward, and added rate limiting for non-owner users. This was important because an autonomous agent with access to multiple paid APIs can become very expensive if an endpoint is abused.

The biggest lesson was that making an agent autonomous is different from simply making it capable. The individual models and APIs worked well on their own; the hard part was making the entire system predictable, stateful, and reliable from the first WhatsApp message to the final published video.

Accomplishments that we're proud of

We’re most proud that we got a genuinely autonomous, multi-step agent pipeline to work end-to-end from a single WhatsApp message. Kira can go from research → creative brief → script → multimodal generation → video assembly → publishing, without an editing UI or a human stepping in between.

But what makes us even more proud is that Kira isn't just a demo. It has been autonomously running a real YouTube channel, Into the Unknown, entirely through WhatsApp. In the last 7 days, the channel generated 5,265 views, 17.3 hours of watch time, and 18 new subscribers.

Some of the Shorts Kira chose and produced, including The Star Powered by its Own Killer and Can a Planet Survive Its Star's Death?. We're also seeing real viewer comments on videos that Kira researched, wrote, produced, and published on its own.

For us, that is the biggest accomplishment: we didn't just build an autonomous agent—we put it to work in the real world and let the results speak for themselves.

What we learned

We learned that multi-agent orchestration is easy to demo, but much harder to make dependable.

Getting Kira to work once on the happy path was relatively straightforward. Making it reliably go from research → script → multimodal generation → assembly → publish, every time, was a completely different challenge.

We learned that you can't always rely on the model to decide when to hand off control, what information should be shown to the user, or when a task is actually finished. Small changes in the agent's behavior could break an otherwise working pipeline.

The biggest lesson was that good agentic systems need structure around the intelligence. Explicit callbacks for handoffs, tool functions instead of unnecessary sub-agents, clear confirmation points, persistent state, and well-defined boundaries between agents made Kira much more reliable.

We also learned that building for the real world changes the engineering priorities. Things like memory, privacy, rate limiting, graceful failure, deployment constraints, and API costs matter just as much as getting the AI to generate the right output.

Ultimately, we learned that the goal isn't to make the model do everything on its own. The goal is to give the model enough autonomy to be useful, while giving the system enough structure to be reliable.

What's next for Kira

We see Kira becoming a more complete autonomous content partner, not just a tool for creating Shorts.

We want Kira's memory to become much deeper. Instead of only remembering instructions like what topics to avoid, Kira could learn each creator's visual style, tone, pacing, music preferences, and storytelling style over time.

Another major step is longer-form video. Kira currently focuses on Shorts, but we want to extend the same agentic pipeline to longer videos with more complex stories and production.

Most importantly, we want Kira to learn from its own results. Today, Kira uses real-time trends to decide what to make. Next, it will also look at how its published videos actually perform—views, watch time, engagement, and other signals—and use that feedback to make better decisions about future content.

We also want to give creators more control during production. Instead of only approving the brief at the beginning, users could jump in at any point and say things like “make the visuals darker” or “change the ending”, while Kira continues handling the rest autonomously.

The long-term vision is for Kira to become a self-improving content agent: it finds opportunities, creates content, publishes it, learns from the results, and gets better at understanding what works for each creator over time.

Built With

Share this project:

Updates

Submission history