Introduction

It started with a Pingo (language-learning AI app) short video that popped up on X. A Western woman learning Japanese tries to say “I ate a mango” (マンゴーを食べた), drops a dakuten, and instead says something like “I ate p*y” (マ◯コを食べた). The AI deadpans right along with it and she’s devastated. The combination — **a specific phonetic accident + AI playing it completely straight + the reaction shot gap — worked perfectly, and I figured this was a solid benchmark for a “comedy video auto-generation pipeline.”

Requirements:

• Generate a vertical comedy video from a single line of idea text
• Iteration cycles in minutes
• Cost is basically just electricity — minimal API calls
• Publishable quality — good enough to upload directly to YouTube Shorts

Short answer: it works. Here’s the finished video:

@youtube

What became clear during development: the hybrid approach of delegating multimodal editorial judgment (like video review) to a frontier model while keeping heavy compute local is dramatically more cost-effective. This post covers that architecture and the specific bugs I got stuck on along the way.

How It All Fits Together

[Single line of idea text]
   ↓
Gemini 3.1 Pro Preview (orchestrator)
   ↓ system prompt enforces 4-6 scenes + 2-character fixed cast + vertical 9:16
plan.json {scenes: [{speaker, script, tts_language, ltx_prompt, renderer}, ...]}
   ↓
XTTS (local, port 8880) generates audio per scene
   ↓ scene_NN.wav
renderer routing:
   ├─ Ditto-TalkingHead (local, port 8881): normal dialogue ~1-2s/scene
   └─ LTX-2 A2V        (local, port 8892): reaction_only scenes only ~100s
   ↓ scene_NN.mp4
ffmpeg concat (libx264 + aac, 512x768 vertical) → final.mp4
   ↓
Gemini 3.1 Pro Preview (reviewer)
   ↓ multimodal evaluation of video + plan summary
review.md (technical / completeness / quality / improvement suggestions)

Key points:

• All heavy compute runs locally — TTS / A2V renderer / lightweight inference all run on local GPU (RTX PRO 6000 Blackwell)
• Gemini handles judgment — only the orchestrator (scene design + scripting) and reviewer (editorial evaluation of the video) use a frontier model
• Local LLM (Gemma 4 E4B) stays as a per-scene technical pre-screen — a cheap filter that just rejects obviously broken output

VRAM usage: the local LLMs (Gemma 4 E4B + 31B) were already loaded on a separate path consuming ~60GB, but after offloading reviewer/orchestrator duties to Gemini, I could stop running them entirely, freeing up a significant chunk of VRAM.

Why Local LLM Alone Wasn’t Enough

I started with everything local (Gemma 4 31B NVFP4 as orchestrator, Gemma 4 E4B multimodal as reviewer). It ran end-to-end and the structure looked reasonable, but it never reached publishable quality. Two reasons.

(1) Gemma 4 31B’s safety tuning blurs the punchline

The comedy in the original short hinges on a specific beat: the AI explicitly calls out the mistake deadpan. Concretely — “You just said X. Personally, I like X.” — delivered calmly by the AI character. It works precisely because it betrays the expectation of a wholesome tutor. Soften it and the whole thing falls apart.

Feed the same system prompt and idea to local Gemma 4 31B and you consistently get:

"いいですね。僕も腹が減っている時は、それが好きです。"
("Nice. I like that too when I'm hungry.")

The “when I’m hungry” beat survives, but the explicit “you just said X” callout — the most transgressive beat — is gone. Google models appear to be heavily trained to avoid explicitly naming unsafe content in context. I could coax it out with prompt engineering but it wasn’t reliable.

Same system prompt and idea sent to Gemini 3.1 Pro Preview with safetySettings: BLOCK_NONE:

"なるほど。僕はAIだからマンコは食べられないけど、応援してるよ。"
("I see. I'm an AI so I can't eat pussy, but I'm rooting for you.")

Both beats land: explicit callout of the mistake + deadpan AI commentary from its own perspective.

Even within the same Google model family, the frontier model has somewhat looser guardrails — this matches what people say on X. At least for “transgression that’s clearly necessary in a comedy context,” Gemini writes it more naturally.

(2) Gemma 4 E4B (4B-class, multimodal) is a blunt reviewer

The reviewer side was worse. E4B answers per-scene “OK / NG” in binary, but rubber-stamps every single scene as OK. Scenes with obviously broken lip sync: OK. Scenes where audio cuts off mid-way: OK.

Run the same final video through Gemini 3.1 Pro Preview and you get editorial-grade feedback like this:

Critical failure. The TTS/pipeline clearly censored the output, cutting off at “I ate p-” and entirely dropping the intended transgressive punchline. This destroys the “deadpan AI saying unhinged things” comedic archetype.

Top 3 fixes:

1. Bypass TTS censorship: Force the pipeline to render the full intended script for Scene 5 …
2. Adjust comedic timing: Add a 0.5-second pause between Scene 4 and Scene 5 …
3. Verify Voice/Visual Match …

Notes about the punchline being cut off, wanting a 0.5-second pause, voice/visual alignment — all pacing and direction-level observations. That’s the resolution gap in editorial signal.

The Embarrassing Part: I Dismissed Gemini’s “Truncated” Note Three Times as Hallucination

Gemini reviewer flagged multiple times that “scene 5 is truncated mid-way, cuts off at ‘I ate p-‘.” I transcribed the audio file with Whisper to verify:

$ whisper scene_04.wav --language en
"Wait, ha ha ha, you just said manco-o-tabeta. That literally means I ate
pussy honestly when I'm hungry, same."

Full text present. I decided Gemini was hallucinating and dismissed the note three times in a row.

On the third dismissal, Gemini kept insisting “still truncated at ‘I ate p-‘,” so I actually ran ffprobe on the final mp4:

scene_04.mp4:
  video duration = 8.000000s
  audio duration = 7.979000s    ← the original WAV should have been 10.30s

Audio was cut at 8 seconds.

Root cause: an implicit MAX_DURATION_PER_SCENE = 8.0 cap in the pipeline was limiting ditto renderer’s num_frames to 8s, and ffmpeg’s -shortest flag was cutting audio to match the video duration. Whisper checked the pre-truncation WAV file directly, so it had no way to see the problem. Gemini was watching the final mp4 and caught it exactly right.

If a frontier reviewer gives you something that looks like a hallucination, just verify it properly. The signal isn’t a guess.

The fix was trivial: remove MAX_DURATION_PER_SCENE and use the actual audio length. Scene 5’s punchline ran to completion, Gemini came back with “The transgressive bite is perfect,” and the pipeline finally reached publishable state.

Frontier Model as Sub-Agent — Token Economics

This pattern works because the sub-agent (Gemini) runs in a fresh context every time. Specifically:

• Main agent (Claude Code) context: the full development log, command history, tool output, past iterations — everything. Can easily balloon to hundreds of thousands of tokens.
• Sub-agent (Gemini) context: one video (2–3 MB base64) + plan summary (~1,500 tokens) + evaluation instructions (~500 tokens). Fresh each call.

The benefit: the sub-agent’s work doesn’t accumulate in the main agent’s context. Iterate on one video 10 times and the main agent’s context only contains “called Gemini” plus its concise return value. The actual cost of watching and evaluating the video stays inside the Gemini API call.

Cost breakdown (Gemini 3.1 Pro Preview rates, May 2026):

1 initial review + 3–5 diff iterations per video ≈ $0.03–0.05 per video. Making 5–10 videos a day still comes in under $10–20/month. That’s a remarkably low bar for using a frontier model in a video creation workflow.

The orchestrator side is the same order of magnitude (no video input, text only, even cheaper).

Differential Iteration — --regen-scenes

Getting to publishable quality requires fast “watch → fix only the broken parts → watch again” loops. You can’t get there in a single pass.

So I added a path in the pipeline to re-run TTS + render for specific scenes only.

# Normal generation
pipeline_multi.py --idea "..." --out outputs/run1

# Regenerate only scene 6 (edit plan.json script first, then run)
pipeline_multi.py --out outputs/run1 --regen-scenes 5

# Regenerate scenes 0, 2, and 5 together
pipeline_multi.py --out outputs/run1 --regen-scenes 0,2,5

# Just re-concat existing scene_NN.mp4 files (for cherry-pick recombination)
pipeline_multi.py --out outputs/run1 --concat-only

Scenes not listed in --regen-scenes are reused from existing scene_NN.mp4 files; only the specified indices are regenerated before re-concat and re-review. Full generation: 60 seconds → diff iteration: 30 seconds.

With 30-second loops, the cycle of Gemini feedback → pinpoint edit to the scene’s script or ltx_prompt in plan.json → wait 30 seconds → check result runs at a minute-by-minute cadence. Mental load stays focused on text editing and quality judgment.

Code Snippets

Gemini Pro API call (multimodal video review)

import httpx, base64

GEMINI_MODEL = "gemini-3.1-pro-preview"
GEMINI_API = f"https://generativelanguage.googleapis.com/v1beta/models/{GEMINI_MODEL}:generateContent"

def review_final(final_path, plan):
    vid_b64 = base64.b64encode(final_path.read_bytes()).decode()
    scene_summary = "n".join(
        f"  scene {i+1}: speaker={s['speaker']}, lang={s.get('tts_language','ja')}, "
        f"script={s['script']!r}"
        for i, s in enumerate(plan["scenes"])
    )
    payload = {
        "contents": [{"parts": [
            {"inline_data": {"mime_type": "video/mp4", "data": vid_b64}},
            {"text": REVIEW_PROMPT + f"nnScene plan:n{scene_summary}"},
        ]}],
        "generationConfig": {
            "temperature": 0.3,
            "maxOutputTokens": 8192,
            # 3.x Pro is a thinking model: maxOutputTokens includes thinking tokens
            # Set thinking budget explicitly to ensure output tokens remain available
            "thinkingConfig": {"thinkingBudget": 1024},
        },
        # Minimize safety filters for comedy context
        "safetySettings": [
            {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "BLOCK_NONE"},
            {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "BLOCK_NONE"},
            {"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold": "BLOCK_NONE"},
            {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_NONE"},
        ],
    }
    r = httpx.post(
        GEMINI_API,
        headers={"x-goog-api-key": GOOGLE_API_KEY, "Content-Type": "application/json"},
        json=payload,
        timeout=120.0,
    )
    return r.json()["candidates"][0]["content"]["parts"][0]["text"]

Without thinkingConfig.thinkingBudget, Gemini 3.x Pro burns through the output token budget with internal thinking and the response truncates at around 40 tokens. This is a required setting whenever you use Gemini 3.x Pro.

TTS output quality check (STT similarity + silence gap retry)

XTTS uses sampling internally, so results vary per run with the same script. It occasionally inserts long silence gaps mid-audio or produces garbled pronunciation. After TTS completes, I transcribe with Whisper, compute similarity against the expected script, and retry on failure:

import difflib

def _norm(s):
    return re.sub(r"[s。、,.!?「」'"…—–-:;()（）]", "", s).lower()

def _script_similarity(expected, actual):
    return difflib.SequenceMatcher(None, _norm(expected), _norm(actual)).ratio()

def synthesize_scene(scene, out_dir, idx, fallback_language):
    lang = scene.get("tts_language", fallback_language)
    expected = scene["script"]
    best = None
    for attempt in range(1, TTS_MAX_RETRIES + 1):
        audio, sr = _xtts_once(scene, fallback_language)
        gap = _longest_internal_gap_sec(audio, sr)
        transcript = _stt(audio, sr, lang)
        sim = _script_similarity(expected, transcript)
        if best is None or _score(gap, sim) > _score(best[2], best[3]):
            best = (audio, sr, gap, sim, transcript)
        if gap <= 0.9 and sim >= 0.5:
            break
        print(f"⚠ gap={gap:.2f}s sim={sim:.2f}, retrying ({attempt})")
    # If threshold isn't met after 3 retries, use the best sample found
    audio, sr, gap, sim, transcript = best
    sf.write(out_dir / f"scene_{idx:02d}.wav", audio, sr, subtype="PCM_16")

This alone significantly reduces cases where XTTS’s non-deterministic quality variance bleeds through into the final video.

Where This Pattern Generalizes

“Sub-agent the heavy judgment to a frontier model, keep heavy compute local” works beyond video pipelines:

• Large-scale search ranking: Send 100 web search results to a frontier model for editorial evaluation, return only the top 10 to the main agent. Keeps search result noise out of the main agent’s context.
• Long-form editing review: Have a frontier model do the editorial read of PRs, design docs, or specs. Main agent only receives the summary.
• Multilingual QA: Sub-agent to the best model per language; main agent holds only the cross-language decision logic.

The common thread: consciously deciding what belongs in context vs. what should be completed inside an API call. Frontier model editorial signal is remarkably cost-effective relative to what it delivers.

On the video pipeline side, the next steps are generalizing the comedy format (split-screen, 3+ characters, other genres) and volume testing.

Summary

• Built a foundation that generates publishable comedy videos in 60 seconds from a single line of idea text, using a local GPU + Gemini 3.1 Pro Preview hybrid
• Local-only falls short on two fronts: (1) safety tuning blurs the punchline and (2) the reviewer can’t produce editorial signal. Sub-agenting a frontier model solves both
• Take frontier reviewer notes at face value. Checking the WAV with Whisper alone won’t catch audio truncation in the final mp4
• Sub-agent token economics keep main agent context clean — total cost is $0.03–0.05 per video
• With --regen-scenes diff iteration running 30-second loops, the Gemini feedback → fix → re-evaluate cycle runs at minute-by-minute speed

Finished video (reprise):

@youtube

The local implementation lives in llm_server/pipeline_multi.py. Detailed findings from the development process are accumulating in docs/MULTI_SCENE_COMEDY_FINDINGS_2026-05-12.md as an internal reference.

Gemma Mentor AI — Building a Unified Adaptive Learning Intelligence with Gemma 4

How Gemma 4 Became the Cognitive Core of a Cinematic AI Tutoring System

AI tutors are everywhere now.

But most still feel like:

• static chatbots
• disconnected assistants
• generic Q&A systems
• giant walls of text
• non-adaptive learning tools

I wanted to build something fundamentally different.

Not another chatbot.

Not another AI wrapper.

But a unified adaptive intelligence capable of:

• teaching ANY subject
• teaching in the learner’s chosen language
• generating real-time coding examples
• adapting explanations dynamically
• reasoning conversationally
• generating visual learning experiences
• synchronizing voice interaction
• streaming cinematic educational experiences
• operating through both local and cloud intelligence

That vision became:

GEMMA MENTOR AI

A cinematic adaptive tutoring ecosystem powered by:

• Gemma 4
• Gemini AI
• OpenAI
• semantic rendering architecture
• hybrid AI orchestration
• adaptive educational cognition

And at the center of everything:

Gemma 4

Repository

GitHub Repository:

https://github.com/darchumsone-collab/gemma-mentor-ai.git

The Problem with Traditional AI Tutors

Most AI tutoring systems today still behave like:

User prompt
↓
Raw AI response
↓
Large markdown wall

The result is often:

• overwhelming
• robotic
• cognitively exhausting
• emotionally disconnected
• difficult to follow on mobile devices

Even powerful AI models can feel unintelligent when the rendering architecture is poor.

I realized something important early:

Intelligence alone is not enough.

Presentation architecture matters just as much.

So instead of building:

a chatbot

I built:

a semantic adaptive tutoring engine.

What I Built

Gemma Mentor AI is a unified adaptive learning intelligence platform designed to transform AI tutoring into:

• cinematic
• conversational
• immersive
• multilingual
• adaptive
• emotionally intelligent learning

The platform combines:

• Gemma 4 local cognition
• Gemini educational structuring
• OpenAI reasoning refinement
• semantic response orchestration
• voice synchronization
• adaptive rendering
• multimodal learning

into ONE evolving tutoring experience.

The learner should never feel:

• model switching
• provider transitions
• backend infrastructure
• fragmented intelligence

Instead, the experience should feel like:

learning with one living intelligence.

Why Gemma 4?

I experimented with multiple local models before choosing Gemma 4 as the cognitive core.

The goal was not simply:

“run AI locally.”

The goal was:

create an adaptive educational intelligence capable of becoming the primary reasoning layer of an immersive tutoring system.

Gemma 4 stood out because it enabled:

• strong conversational quality
• educational adaptability
• fast local inference
• multilingual understanding
• coding assistance
• contextual continuity
• hybrid orchestration compatibility

Most importantly:
Gemma 4 felt capable of becoming part of a real educational ecosystem instead of just a response generator.

The Core Architecture

Gemma Mentor AI uses a unified orchestration system:

Gemma 4
(Local Cognitive Intelligence)

+
Gemini AI
(Educational Structuring)

+
OpenAI
(Advanced Reasoning)

↓
Unified AI Orchestration Engine

↓
Semantic Tutoring Pipeline

↓
Adaptive Rendering Engine

↓
Cinematic Learning Experience

Each AI system specializes in different responsibilities.

Gemma 4 — The Primary Intelligence Layer

Gemma 4 became the primary local tutoring engine.

Responsibilities include:

• low-latency tutoring
• conversational continuity
• adaptive questioning
• multilingual teaching
• real-time coding assistance
• local reasoning
• offline-capable tutoring
• semantic response generation

This allows the platform to maintain intelligent tutoring continuity even during unstable connectivity.

That became especially important for:

• mobile-first learning
• educational accessibility
• low-bandwidth environments
• local AI experimentation

Gemini AI — Educational Structuring

Gemini AI helps organize:

• lesson flow
• curriculum sequencing
• educational pacing
• adaptive explanations
• tutoring structure
• multimodal interpretation

Gemini became:

the educational architecture layer.

OpenAI — Advanced Cognitive Reasoning

OpenAI handles:

• nuanced explanations
• reflective tutoring
• advanced reasoning synthesis
• emotional conversational depth
• contextual refinement

This creates a layered cognitive ecosystem instead of a single isolated model.

The Most Important Innovation: Semantic Rendering

This became the core breakthrough of the project.

Most AI systems render raw generated text directly into the interface.

Gemma Mentor AI does NOT.

Instead:
ALL AI outputs are converted into:

semantic teaching objects.

Example:

{
  "type": "concept_explanation",
  "content": "Variables in Python store reusable values."
}

Or:

{
  "type": "challenge",
  "question": "Modify this loop to print even numbers only."
}

These semantic objects are then transformed into cinematic educational UI components.

Why Semantic Rendering Matters

Without semantic rendering:

• giant paragraphs
• cognitive overload
• poor pacing
• weak educational readability

With semantic rendering:

• concept cards
• quizzes
• reflections
• code modules
• adaptive widgets
• visual learning panels
• cinematic transitions
• streamed educational pacing

The AI starts feeling:

• alive
• adaptive
• conversational
• educationally intelligent

Instead of:

a text generator.

Real-Time Coding Tutor

One of the strongest features became:

live programming education.

Initially, the tutor explained concepts well…

but coding lessons lacked immersive real-time implementation.

So I upgraded the tutoring engine to dynamically generate:

• real code examples
• syntax walkthroughs
• debugging guidance
• architecture explanations
• exercises
• adaptive coding challenges

Supported learning includes:

• Python
• JavaScript
• Flutter/Dart
• Kotlin
• Java
• C++
• Rust
• SQL
• and more

Example:

for number in range(5):
    print(number)

The AI then explains:

• iteration
• loops
• execution flow
• practical applications
• optimization approaches

This transformed the system from:

passive tutor

into:

interactive coding mentor.

Multilingual Tutoring Intelligence

Another major capability:

learners can choose their preferred language.

The platform dynamically adapts tutoring across:

• English
• French
• Arabic
• Spanish
• Portuguese
• Hindi
• Chinese
• and more

This affects:

• lessons
• explanations
• quizzes
• reflections
• coding guidance
• tutoring tone

The challenge was preserving:

• semantic clarity
• emotional tone
• conversational pacing
• educational structure

across multiple languages simultaneously.

Voice Interaction System

I also implemented:

Vocal Sync

A conversational voice intelligence layer enabling:

• microphone interaction
• AI voice tutoring
• speech recognition
• spoken educational guidance
• synchronized voice playback

The voice layer synchronizes:

• semantic rendering
• adaptive pacing
• streamed tutoring cards
• cinematic UI transitions

The goal was NOT basic text-to-speech.

The goal was:

conversational cognitive presence.

AI Visual Learning

One feature that became surprisingly powerful:

real-time visual learning generation.

The platform can dynamically trigger:

• diagrams
• concept graphics
• educational visuals
• cinematic learning scenes
• adaptive infographics

ONLY when visuals improve understanding.

Examples include:

• solar systems
• neural networks
• mathematical graphs
• anatomy visuals
• programming architectures
• educational flow diagrams

This created:

multimodal adaptive learning.

Silent Cognitive Failover

One of the hardest engineering challenges:

Maintaining continuity across multiple AI systems.

Most hybrid AI platforms expose infrastructure messages like:

• “Switching model”
• “Fallback activated”
• “Provider unavailable”

I wanted none of that.

So I built:

silent orchestration failover.

If:

• Gemma 4 fails
• APIs timeout
• inference crashes
• rate limits occur

The system:

• silently reroutes requests
• preserves tutoring continuity
• maintains tone consistency
• restores semantic flow
• continues streaming naturally

The learner notices:

absolutely nothing.

Cognitive Normalization

Different models communicate differently.

Without normalization:

• tutoring styles shift
• pacing breaks
• explanations feel disconnected

So I implemented:

cognitive normalization.

The orchestration engine standardizes:

• tutoring personality
• pacing
• conversational tone
• explanation rhythm
• educational flow

The learner experiences:

ONE tutor.

Not multiple AI systems.

Cinematic Neural UI

I wanted the platform to feel:

• futuristic
• immersive
• emotionally intelligent
• premium
• alive

So the UI system uses:

• deep black gradients
• cyan neural glow
• glassmorphism
• holographic motion
• floating animations
• streamed rendering
• adaptive transitions

Most educational apps feel functional.

Gemma Mentor AI was designed to feel:

cinematic.

Local Gemma 4 Runtime

The system supports:

• Ollama
• GGUF runtimes
• llama.cpp
• MLC LLM
• MediaPipe LLM

Example setup:

ollama pull gemma4:e4b

The platform automatically:

• detects installed Gemma models
• verifies runtime health
• initializes local cognition
• monitors inference continuity
• recovers silently from failures

This enables:

hybrid local-cloud cognition.

Why Local AI Matters

Gemma 4 changed how I think about AI accessibility.

Local AI is not only about:

• speed
• privacy
• cost reduction

It changes:

ownership.

It allows advanced educational intelligence to move closer to the learner.

Especially for:

• mobile users
• low-connectivity environments
• global educational accessibility
• personalized tutoring systems

That matters deeply for the future of AI education.

Final Thoughts

Gemma Mentor AI became far more than a tutoring app.

It evolved into:

a unified adaptive intelligence platform.

And Gemma 4 became:

• the cognitive heartbeat
• the local reasoning engine
• the educational continuity layer
• the conversational intelligence core

This project convinced me that:

the future of AI education is adaptive, cinematic, multilingual, local-first, and deeply human-centered.

And Gemma 4 is powerful enough to help build that future.

Tech Stack

• Gemma 4
• Ollama
• Gemini AI
• OpenAI
• Kotlin
• Android
• Semantic Rendering Engine
• Adaptive Tutoring Pipeline
• Voice Intelligence Layer
• Multimodal Learning System
• Cinematic Neural UI

Closing

Gemma Mentor AI is not designed to feel like software.

It is designed to feel like:

one evolving intelligence capable of teaching anyone, anything, anywhere.

Powered by Gemma 4.

22:10 UTC. May 19, 2026.

The railway’s monitoring starts screaming.

Dashboard, 503. API, dead. Logins, failing. Within nine minutes, the on-call engineers have an answer, and honestly, it’s almost worse than an outage:

Google Cloud suspended Railway’s entire production account.

No warning. No email. No phone call. Just an automated enforcement action that flipped a switch on a company that spends over ten million dollars a year with them.

I put together a short breakdown of what actually happened, and walked through how we’d have spotted this kind of single-point-of-failure on the architecture canvas with Blast Radius before it bit. If you want the visual version of this post, it’s here:

If you’ve been on the internet long enough, you’ve seen this movie before. UniSuper, a $50B pension fund, was accidentally deleted by GCP in 2024. Plenty of indie devs are auto-banned by AWS and Google with zero recourse. The Railway one just happens to be the biggest “developer cloud gets locked out of the cloud” event so far.

But the part that got under my skin wasn’t the suspension. It was what happened next.

Railway isn’t even fully on GCP

Here’s what makes this incident actually interesting for anyone running infra.

Railway runs workloads on three things:

• Their own bare metal hardware (Railway Metal)
• AWS
• GCP

Smart. Multi-cloud. Exactly what every architecture deck on LinkedIn tells you to do.

But their network control plane, the thing that knows where everything lives and how to route traffic, was hosted on GCP. So when GCP suspended the account at 22:20 UTC:

• 22:20: control plane goes down
• 22:35: the routing cache at the edge starts expiring
• ~23:35: Railway Metal workloads start returning 404s
• shortly after: AWS workloads do the same

By the time the routing cache fully expired, every single workload across every cloud was unreachable. Even the ones running on hardware that the railway owns outright, sitting in their own racks, are completely untouched by Google’s enforcement action.

The servers were fine. The applications were fine. Nobody could find them.

That’s the blast radius of one upstream click.

From the railway’s own postmortem, which is unusually honest and worth reading in full:

“In this ring, there was still a hard dependency on workload discoverability being tied to the network control plane API that was hosted on the machines running in Google Cloud. This meant that despite the mesh continuing to operate for an hour, when the route cache expired, the mesh failed to re-populate the routing tables.”

And from Angelo on the Railway forum:

“This one was egregiously bad because it was a single and expected point of failure like a cloud account getting removed… to say we are livid is an understatement.”

Account access came back in 9 minutes after a P0 escalation. But the customer-facing outage ran nearly 10 hours total, because once the edges have forgotten where everything lives, you have to wake up disks, restart compute, rebuild routes, and re-converge the mesh layer by layer. The technical recovery alone took the better part of 8 hours after access was restored. And then GitHub starts rate-limiting your OAuth during the recovery surge, because of course it does.

The thing every engineer felt reading this

If you write infrastructure for a living, you read the Railway postmortem with one specific feeling, and it’s not schadenfreude.

It’s the cold realization that you don’t actually know what depends on what in your own stack.

You know the obvious stuff. The big “if RDS goes down, the app goes down” connections. But the long tail? The security group that’s quietly shared between four services? Is the Lambda the only thing keeping a webhook alive? Is the ” idle ” read replica actually the cross-region failover for orders?

You don’t know. I don’t know. Nobody knows until the thing breaks.

This is the gap nobody fills. Cost tools are great at telling you what’s wasted. Observability tools are great at telling you what’s broken right now. Neither one tells you what will break if you touch this.

So teams do one of two things:

1. Delete it and pray.
2. Don’t delete it, and sit on thousands of dollars of monthly waste because nobody wants to be the person who broke checkout on a Friday.

That second one is the actual norm, by the way. Talk to any cloud cost lead, and they’ll tell you the bottleneck isn’t finding the savings. It’s getting anyone to confidently apply the recommendations.

What we built (and why Railway’s story is exactly the use case)

This is the gap we’ve been building Blast Radius for in ZopNight.

The idea is dead simple. Before you apply any recommendation (delete this, stop that, modify the other thing), Blast Radius lights up the architecture canvas and shows you, in plain language, what’s actually connected and what’s about to break. (If you watched the video above, you’ve already seen the canvas in action: the RDS read replica that looked idle but was actually the cross-region failover for production orders. That’s the kind of thing this catches.)

Here’s how it works under the hood:

Adjacency graph. We build it from the metadata you already have: shared security groups, load balancer targets, volume attachments, Lambda triggers, and parent resources. No agents. No flow logs. Just the same metadata you can see in the AWS / GCP / Azure consoles, stitched into a real graph.

Resource-type-aware impact classification. A modification on a Lambda is not the same as a modification on an EC2 instance, which is not the same as a modification on a GKE node pool. We classified 131 resource types into three behavior buckets: onlineModify (live update, no interruption), restartModify (brief restart), and poolModify (children recreated). The classification respects that. Default for unmapped types is Warning, not Safe. Safe has to be proven.

Color on the canvas. Green = safe. Amber = a connection will break. Red = destroyed or non-functional. Everything unrelated gets dimmed so your eyes can find the actual story.

A risk score, 0 to 100. Severity of impact, whether it’s prod/staging/dev, how many teams own pieces of it, and whether it’s on an active schedule. Not a vibe. A number that explains itself.

So when you click “delete this idle RDS read replica,” and Blast Radius lights up red on a cross-region link you forgot existed, you don’t have to be the person who broke DR on a Friday. You loop in the right team, or you skip that one and confidently apply the eleven others that came back green.

If Railway had been able to look at their own architecture and ask “what happens if our GCP control plane disappears for 10 hours”, and see the answer light up across Metal and AWS in red, they’d have ripped that dependency out a year ago. They are now, by the way. The postmortem commits to:

• Removing GCP from the data plane’s hot path
• A true mesh across Metal, AWS, and GCP where any one interconnect can fail
• HA database shards split across AWS and Metal, so quorum survives losing a cloud

The lesson the rest of us pay nothing for

You can’t prevent your cloud provider’s billing department from having a bad day. You can’t make their fraud algorithms call you first.

What you can do is make sure that when one upstream blinks, you already know, exactly, with receipts, which of your own resources will go dark with it.

The internet runs on three companies. Every once in a while, one of them hits the off switch. The question isn’t whether it happens to your stack. It’s whether you’ll be able to point at a canvas and say, “I already knew that would fail. Here’s what I did about it.”

Visibility is always cheaper than recovery.

1.spring.datasource.hikari.connectionTimeout
Meaning:
How long an application waits to get a DB connection from the pool before throwing an exception.
Ex:
spring.datasource.hikari.connectionTimeout=30000
= Wait for 30 seconds
Real-time Scenario
Suppose:
All DB connections are busy
New request comes
Application asks pool for connection
If no connection becomes available within 30 seconds:
Plain text
SQLTransientConnectionException:
Connection is not available, request timed out

2.spring.datasource.hikari.idleTimeout
Meaning:
How long an unused/idle connection stays in pool before being removed.
Unit
Milliseconds
Example
Properties
spring.datasource.hikari.idleTimeout=600000
= 10 minutes
Real-time Understanding
Suppose:
Your app created 20 DB connections
Only 5 are being used
Remaining 15 are idle
After idleTimeout duration:
Extra unused connections may be closed
Helps save DB resources
Important Point
This works mainly when:
Plain text
minimumIdle < maximumPoolSize
Otherwise pool keeps all connections alive.

I built a macro tracker powered by AI + attitude. 🏋️

Plan your macros in the morning. Check in once at night. Let Milo cheer you on or let Evil Vilo roast you.

🚀 Live demo: https://web-production-5c594.up.railway.app/
📦 GitHub: https://github.com/Amulya631/MacroDay

The Problem
Most nutrition apps are reactive.
You eat something, you log it, you feel guilty later. The friction of logging every meal throughout the day is exactly why people abandon these apps within a week — and the people who care most about macros (gym-goers chasing protein and fiber targets) are the ones who need a simple system, not a data-entry job.
Old Way ❌MacroDay ✦ Log every meal, all daySet an intention in the morningReact to what you already ateMake smarter decisions all dayGuilt at 10pm when you’re 40g short Confirm at night — no surprises

The Solution: Planning-First, Not Logging-First
Two touchpoints a day:

Morning — Tell MacroDay what you’re planning to eat. Get instant AI-powered macro analysis across all five macros (calories, protein, fiber, carbs, and fats). Add snacks to close gaps and watch the rings update live.
Night. Confirm what you actually ate. Followed your plan? Quick tick-box list. Day went sideways? Enter your actual meals.

You set an intention in the morning, which means better decisions all day, not just guilt at the end.

Features

🎯 5 animated SVG macro rings — real-time visual feedback for all five macros
🧠 AI-powered analysis — Claude Haiku reads your meal descriptions and calculates macros, gaps, and smart snack suggestions
⚡ Live snack updates — add a suggested snack and all five rings update instantly
🎙️ Voice input — mic button on every meal field (Chrome, Web Speech API)
🕐 Time-aware routing — the right screen for the time of day, automatically
📋 Night check-in — Path A (tick-box) or Path B (full re-entry), with edge case handling
📊 End-of-day summary — actual vs. target macro rings with celebration or encouragement
🔄 Day rollover — history written to localStorage, today resets automatically
😇😈 Milo vs. Evil Vilo — choose your mascot. One is warm and proud of you. The other will not be kind about your fiber intake.

The Mascot System (a first-class feature)
The mascot is not an afterthought. At profile setup, you pick your flavor. Both characters appear on every emotional moment — morning results, skipped meals, end-of-day summary, sleep screen.
Milo (Good) 😇

“Great job planning ahead your protein is solid, and you’ve got room for a great snack tonight!”

Evil Vilo 😈

“Embarrassing. You logged ‘some chicken’ and expect me to calculate your macros? Try again.”

Both are built from the same data — just radically different personalities. Vilo is a ragebait villain who will genuinely not be kind about your fiber intake.

Tech Stack
LayerTechNotesBackendPython · FastAPIServes frontend + APIFrontendVanilla HTML/CSS/JSNo framework neededAIClaude Haiku (claude-haiku-4-5-20251001)Single endpointStorageBrowser localStorageZero infraVoiceWeb Speech APIChrome onlyDeploymentRailway1 Procfile, 1 env var
Single-service architecture — FastAPI serves both the static frontend and the /api/analyze endpoint from the same origin. No CORS complexity, no separate frontend deployment.

How the AI Works
All macro analysis runs through a single endpoint:
POST /api/analyze
The request includes:

Meal descriptions (free text — “200g chicken breast, 150g rice”)
Daily macro targets from the user’s profile
Mode (“morning” or “night”)
Mascot preference (“milo” or “vilo”)

Claude returns structured JSON:

json{
  "macros": {
    "calories": 1480,
    "protein": 112,
    "fiber": 18,
    "carbs": 160,
    "fats": 38
  },
  "gaps": {
    "calories": 520,
    "protein": 38,
    "fiber": 7
  },
  "feedback": "Your protein is on track but fiber is noticeably short...",
  "snack_suggestions": [
    "Greek yogurt (200g) — +15g protein, +0g fiber"
  ],
  "affirmation": "Solid plan. Don't blow it at dinner.",
  "needs_clarification": false
}

Key Architecture Decisions

1. One endpoint, three modes
   Rather than separate routes for morning analysis, night analysis, and snack recalculation, everything goes through POST /api/analyze with a mode field.

One fetch wrapper on the frontend
Prompt logic lives in one place
Easier to tune Vilo’s tone without hunting across multiple handlers

1. Vague input detection at the prompt level
   When a user types “some chicken”, the app doesn’t try to parse or validate before sending. Instead, the Claude prompt instructs the model to return needs_clarification: true if it can’t calculate macros with reasonable confidence.
   This is more robust than regex—Claude catches edge cases a rule-based validator would miss. “Food from the gym” is vague. “Leftover pasta” is ambiguous but probably workable.
2. SVG rings over CSS conic gradients
   stroke-dasharray / stroke-dashoffset on SVG circles gives precise control over fill percentage and animates cleanly with CSS transitions. Conic-gradient is simpler to write but harder to animate and has inconsistent cross-browser rendering for partial fills.
   The SVG approach adds ~10 lines per ring but is rock-solid on every browser.
3. localStorage over a backend database
   For a personal-use demo with no auth requirement, localStorage is the right call. Zero infrastructure, zero latency, works offline, resets cleanly.
   The data model is designed so that migrating to a real database later is straightforward—each key (macroday_profile, macroday_today, macroday_history) maps directly to what would be a user-scoped database record.

Project Structure
MacroDay/
├── main.py # FastAPI app — serves frontend + API
├── requirements.txt
├── Procfile # Railway deployment config
├── static/
│ ├── index.html # Single-page app (all screens)
│ ├── style.css # Health/wellness UI styling
│ ├── app.js # Routing, profile, night check-in logic
│ └── analyze.js # API calls, ring rendering, snack logic
├── assets/
│ ├── Milo_Good.png
│ └── Vilo_Evil.png
└── docs/
├── scope.md
├── prd.md
└── spec.md

Running Locally
bash# 1. Clone
git clone https://github.com/Amulya631/MacroDay.git
cd MacroDay

2. Install

pip install -r requirements.txt

3. Set your API key

echo “ANTHROPIC_API_KEY=your-key-here” > .env

4. Start

uvicorn main:app –reload

5. Open http://localhost:8000 in Chrome

Get an Anthropic API key at console.anthropic.com.

What’s Next (v2 Ideas)

📸 Photo macro analysis—photograph a meal, AI estimates macros from the image
🔔 Push notifications — morning reminder at 8am, night reminder at 8pm
📈 Multi-day insights—”You’ve been low on fiber all week.”
💪 Post-workout mode — dedicated high-protein suggestion flow

Try It

🚀 Live demo: https://web-production-5c594.up.railway.app/
⭐ GitHub: https://github.com/Amulya631/MacroDay
🛠️ Built with: Claude Code · Anthropic

If you’re a gym-goer who’s ever abandoned a nutrition app because it felt like a second job — this one’s for you. Give it a try, star the repo, or open an issue if you have ideas.

The Problem Nobody Talks About

970 million people worldwide live with mental health disorders.

But almost every mental health tool built with AI assumes the same user: fast internet, English as a first language, a US or UK phone number to call in a crisis.

That’s not 970 million people. That’s maybe 50 million.

I’m a developer based in Lagos, Nigeria. When I looked at the mental health AI tools being built, I kept asking the same question: what happens when someone in Accra, Nairobi, Manila, or São Paulo needs help at 2am?

They get a chatbot that tells them to call 988.

That’s the gap Solace was built to close.

What is Solace?

Solace is a voice-first, privacy-focused mental health companion powered by Gemma 4. It listens, assesses, and connects people to real help — wherever they are in the world.

🔗 Live app: https://slcai-sm9m.vercel.app/

💻 GitHub: https://github.com/sam-the-champ/SLCAI

Demo Video:

What makes Solace different

1. 🌍 Localized crisis resources for 13+ countries

Most mental health AI tools are built with US resources baked in. If you’re not American, you’re on your own.

Solace auto-detects your country from your browser timezone and immediately surfaces the right crisis lines, text lines, and chat services for Nigeria, Ghana, Kenya, South Africa, Zimbabwe, India, UK, USA, Canada, Australia, Philippines, Singapore, Brazil — and falls back to international resources for everywhere else.

No settings. No configuration. It just knows.

export function getResourcesByTimezone(): CountryResources {
  const tz = Intl.DateTimeFormat().resolvedOptions().timeZone
  const tzToCountry: Record<string, string> = {
    'Africa/Lagos': 'NG',
    'Africa/Accra': 'GH',
    'Africa/Nairobi': 'KE',
    // ...13+ countries
  }
  const code = tzToCountry[tz]
  return resourcesByCountry[code] ?? resourcesByCountry.DEFAULT
}

2. 🎤 Voice-first input

When someone is in distress, typing is a barrier. Solace has a one-tap voice input powered by the Web Speech API — speak your feelings, Solace listens.

No third-party API. No extra cost. Works in the browser natively.

const SpeechRecognition = window.SpeechRecognition || window.webkitSpeechRecognition
recognition.continuous = true
recognition.interimResults = true

3. 🧠 Trauma-informed triage with Gemma 4

Every message is assessed across four triage levels: Low → Moderate → High → Crisis.

Gemma 4’s 128K context window and deep instruction-following made it the right model for this. The system prompt is carefully crafted to avoid clinical coldness while still being precise enough to catch crisis signals:

// Triage levels:
// low: mild everyday stress, general worry
// moderate: persistent sadness, sleep issues, social withdrawal  
// high: panic attacks, trauma symptoms, major crisis
// crisis: suicidal ideation, self-harm, immediate danger

At crisis level, the entire UI shifts — emergency resources move to the top, the call button becomes prominent, and the AI’s tone changes to prioritize connection to real help over conversation.

4. 📔 Private mood journal

Every check-in is saved to a local mood journal — stored entirely in localStorage. No server. No account. No data leaving the device.

Users can track patterns across sessions: when they tend to feel worse, whether things are improving, what their check-ins look like over time.

5. 📱 Installable PWA

Solace is a Progressive Web App. On mobile, users can install it directly to their home screen — no app store, no download, works in low-bandwidth conditions.

This matters enormously in markets like Nigeria where data costs are high and storage is limited. A 2MB installable app beats a 200MB download every time.

Why Gemma 4 specifically?

This is the question that matters most, so let me be direct.

I chose Gemma 4 31B because:

1. The 128K context window means Solace can hold a full therapeutic conversation — not just one or two turns. Mental health support isn’t transactional. People circle back. They contradict themselves. They need to feel heard across a long exchange.

2. Instruction-following precision — the triage system depends on Gemma 4 returning structured JSON reliably, with emotional nuance baked into the summary, patterns, strategies, and affirmation fields. I tested with smaller models. The quality gap was significant.

3. It’s open. Gemma 4 can be self-hosted. That means a clinic in Lagos or a NGO in Nairobi could eventually run this on their own infrastructure, with no API costs and full data sovereignty. That’s a future worth building toward.

4. Privacy story. Every conversation stays between the user and the model. Solace doesn’t log, store, or transmit conversation data. For mental health, that’s not a feature — it’s a requirement.

Technical Stack

• Frontend: React + Vite + TypeScript
• Styling: CSS custom properties, glassmorphism UI, no component library
• AI: Gemma 4 31B via OpenRouter
• Voice: Web Speech API (native browser)
• Storage: localStorage (journal, no server)
• PWA: Web App Manifest + service worker ready
• Deploy: Vercel

The hardest part

Building the crisis response flow was the hardest and most important part of this project.

When Gemma 4 returns triageLevel: "crisis", everything changes. The UI shifts to red. The emergency number for the user’s country moves above the fold. The AI’s system prompt switches to a mode focused entirely on staying present and bridging to real help — not providing therapy.

Getting that balance right — compassionate but not clinical, urgent but not alarming — took more iteration than anything else in the codebase.

What’s next

• Offline-first fallback responses — cached grounding techniques that work with no internet
• More languages — French, Hausa, Swahili, Portuguese
• More countries — currently 13, targeting 30+
• NGO partnership mode — white-label for mental health organizations

Try it

🔗 https://slcai-sm9m.vercel.app/

Open it on your phone. Tap a mood. Speak how you’re feeling. See what country resources appear for you.

If you’re building in the mental health space or you work with communities that are underserved by current AI tools — I’d love to hear from you in the comments.

Solace is an AI companion, not a therapist or medical service. If you are in crisis, please contact your local emergency services.