DEV Community: Anuj Jain

WAKE.EXE: a horror game where Gemma times your hesitation and writes the next room

Anuj Jain — Sat, 31 Oct 2026 22:08:47 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine

LLM text adventures tend to fail the same way. Ask the model to run the inventory and it hands you a key that was never in the room, or opens a wall because you asked nicely. And when it does behave, you wait several seconds per command, which is fatal for a horror game.

So in WAKE.EXE the model has no power over the rules. Code owns the map, the state, the timer and the distance to the monster. Gemma's whole job is to be the thing that watches you: it reads how long you hesitated, how fast you type and how often you died, and it decides what the next nightmare says to you.

Black Mirror always fascinated me and that's where I took inspiration from (Bandersnatch), I had fun drafting a small story in a limited time while keeping it fun.

TL;DR. WAKE.EXE is a short browser horror game in 1-bit ASCII/pixel style. You wake from a nightmare with something chasing you and answer a series of 15-second A/B dilemmas. A local open-weight Gemma plays "Dr. Vance", a clinical observer who profiles you from real telemetry and generates the next dilemmas a few steps ahead, so you never wait on the model. If the model is slow or wrong, validated fallback dilemmas keep the game going. A full run takes about 40-45 minutes and has two endings.

What I Built

You are Subject 09. You wake in a damp bedroom while a rotary phone rings and something claws at the closet wall. Every sector gives you a short scene and two choices, with a 15-second countdown bar:

Path A leans into instinct (the "beast" path).
Path B leans into doubt and decryption (the "meta" path).
Doing nothing is a choice too: when the timer runs out, the monster closes the distance by 2.

Each choice moves two numbers: Distance (how close the thing is) and Sanity (which drives the screen distortion). Distance also drives the heartbeat: about 50 BPM when you are safe, past 130 BPM when it is one step away.

The part I wanted people to see is the AI. A GHOST // PROCESS panel stays on screen and shows the provider and model, the lookahead queue (which upcoming dilemmas are ready), and what the Director currently thinks of you, with tags like cautious, reckless, fast typist and marked. Those tags come from real numbers: average hesitation before you answer, typing speed in WPM, deaths, and near-misses.

There is also a Safe Mode that removes screen shake, chromatic aberration and loud audio spikes, and at the end you can download your own case file as a .txt.

Spoilers below.

There are two endings, both in the Mirror Vault. In the first, you wipe the glass and the reflection is not human: every door was locked from the inside, and you were the thing in the walls. In the second, if you spent the game doubting the facility, the wallpaper peels into scanlines and the mirror shows the CRT glass from the inside, with your own session ID and keystroke metrics on screen.

Demo

Play it: embed https://wake-9csj.onrender.com

What the live site runs:

Active Model: Google Gemma (gemma2-9b-it)
Inference Provider: Groq LPU Cloud (OpenAI-compatible endpoint)
Live Health Endpoint: Verified at /api/health (providerConnected: true)
Live Performance: ~355ms generation latency per dilemma batch

The deployed build on Render actively queries Groq's hosted Google Gemma 2 model to generate all Bandersnatch dilemmas, player taunts, and Dr. Vance's clinical psychiatric evaluations in real-time. If network connectivity is ever lost, the built-in deterministic fallback engine seamlessly takes over to ensure zero gameplay disruption."

Code

An16og / WAKE

WAKE.EXE 👁️

"I was never running from it. The footsteps behind me were the echoes of my own paws."

WAKE.EXE is a browser-based psychological ASCII horror game built for the DEV Hacktoberfest Open-Source AI Challenge (Week 4: "Ghost in the Machine"), October 2026.

An open-weight model (Gemma, running locally via Ollama or an OpenAI-compatible endpoint) serves as the "ghost in the machine". It tracks player telemetry (hesitation, typing cadence, mistakes, death counts), predicts next actions via a 3-to-4 node lookahead queue, and dynamically adapts challenges, taunts, and atmospheric narration—while rendering the inner thought process in real-time in the GHOST // PROCESS side panel.

📸 Key Features

Retro CRT Experience: Authentic phosphor green / monochrome toggle, scanlines, CRT curvature, and retro bitmap typography (VT323).
Deterministic Game Engine: The model never controls state or rules. Code owns state; deterministic validators guarantee every minigame is…

View on GitHub

How I Built It

The rule: code owns the state, the model owns the dread

player choice (or timeout)
  -> code updates distance, sanity, room
  -> telemetry: hesitation ms, WPM, deaths, tags
  -> Director (Gemma via Ollama or an OpenAI-compatible API):
       next 3-4 dilemmas as JSON
  -> zod schema check -> retry once -> fallback dilemma
  -> lookahead queue -> the player never waits on the model

While you are on Room 1, the Director is already generating and validating Rooms 2 to 4. That was the fix for generation latency: horror pacing cannot survive a spinner.

Taunts that can't invent facts about you

Dr. Vance's lines contain placeholders, and the code fills them from real telemetry:

.replace(/\{avg_think_s\}/g, `${avgThinkSec} seconds`)
.replace(/\{deaths\}/g, `${profile.deaths}`)
.replace(/\{typing_wpm\}/g, `${profile.typingSpeedWpm || 45} WPM`)

So when the game tells you that you hesitated for 6 seconds, that number is measured, not guessed. This does not stop the model from writing a flat or off-tone line, and it can't police claims outside the placeholders. In early test runs, the model frequently tried to invent its own horror lore to sound intimidating—generating taunts like "You dropped your flashlight in sector 4 and your hands shook on the mouse." The problem? WAKE.EXE is a pure keyboard-driven terminal game, and the player never had a flashlight. The moment an LLM hallucinates fake actions the player never took, psychological dread evaporates into disbelief. In other runs, it drifted into campy Saturday-morning villain tropes ("Mwahaha, you cannot escape the dark dungeon"), totally destroying Dr. Vance's cold, sterile clinical persona.

To fix this, we took a two-layer defense. First, we strictly locked the prompt contract: Dr. Vance is instructed to evaluate cognitive telemetry only, and taunts must use deterministic interpolation slots ({avg_think_s}, {deaths}, {last_mistake}, {typing_wpm}). Any claim about player performance is populated by ground-truth runtime metrics via regex, making factual hallucinations impossible. Second, we wrapped generation in a strict Zod schema validator: if the model ever outputs malformed JSON, drops tone, or violates schema boundaries, the engine retries once with an error-correction prompt, and seamlessly falls back to our hand-crafted dilemma suite with zero player interruption.

Evaluation

I ran the Director against 25 synthetic player archetypes with gemma3:1b

Measure	Result
Valid against the schema and structure checks	25 of 25
Needed a retry	0 of 25
Replaced by a pre-written fallback	0 of 25
Median / p95 generation time	4.0 s / 4.9 s
Next dilemma already ready when the player needed it	25 of 25 (100% in live play; see note below)

Twenty-five clean runs is a small sample: with no failures in 25, the true failure rate could still be as high as about 12% (the "rule of three": 3 divided by 25). The checks are also structural. They confirm at least two non-empty choices, a bounded 15-second timer, valid branch metadata, and bounded sanity and distance changes. That tells me an output is playable, not that it is good.

Reading through the raw outputs by hand showed the stark difference between syntactically valid and compelling narrative.

When the model locked into Dr. Vance's clinical tone, the generated dilemmas were genuinely unsettling:

The Good (Sector: Server Archive):

Scenario: "A CRT monitor flickers to life, printing your actual keystroke latency in green phosphor. Behind the glass, an audio speaker hums: 'Daniel, stop looking at the prompt. The observer at the keyboard cannot save you.' You have 15 seconds."

Choice A: "SMASH THE MONITOR WITH YOUR BARE HANDS" (Branch: Beast, Distance +1, Sanity -2)

Choice B: "TYPE 'WHO IS RUNNING THE SIMULATION?'" (Branch: Meta, Distance +2, Sanity -3)

It nails the psychological dread, weaves in real player metrics, and creates a legitimate thematic fork between primal violence and 4th-wall realization.

But smaller models (especially at 1B) can also slip into flat, low-stakes repetition where choices become trivial synonyms:

The Weak (Sector: Pulsing Antechamber):

Scenario: "You enter a dark corridor. The walls are red and slimy. You hear a strange noise in the darkness."

Choice A: "Walk quietly forward." (Branch: Beast, Distance +1, Sanity -1)

Choice B: "Move slowly ahead." (Branch: Meta, Distance +1, Sanity -1)

Structurally, this passed all 5 Zod checks—two choices, valid timers, within delta bounds. But narratively, it’s dead on arrival. "Walk quietly" versus "move slowly" is a false dilemma with zero dramatic stakes. This qualitative gap is why automated schema validation alone isn't enough: it guarantees the game engine won't crash, but strong persona prompt constraints and our pre-authored fallback suites are what keep the psychological tension alive when a generation runs flat.
Rather than subjecting players to generative wait times, WAKE.EXE implements an asynchronous 3-node predictive lookahead queue. In our live playthrough, Google Gemma (gemma2-9b-it on Groq) generated each decision batch in ~355ms, while the human player averaged 2,000ms evaluating choices. This delivered a 100% lookahead hit rate with all three queue slots consistently primed in [READY] state, eliminating gameplay latency entirely.

The look and the sound

The game renders on a 320x180 1-bit canvas scaled up with image-rendering: pixelated. Shading uses hand-made stipple and checker patterns in the style of early Macintosh graphics, rooms change with a 4-frame stepped zoom, and low Sanity adds warping and scanline jitter.

For audio I used ElevenLabs' Sound Generation API once, offline, to make eight clips (ambient loop, whisper, monster growl, mirror crack, door creak, footsteps, breath, death sting). The game plays those files, and if one is missing or you are offline it falls back to a small Web Audio synthesizer.

Stack

TypeScript monorepo (npm workspaces): Vite client, Fastify server, shared Zod schemas, MongoDB Atlas for runs and telemetry, Sentry for tracing. One Node web service on Render serves both the API and the built client.

What broke

CI on Linux: TypeScript complained (TS5011) until I set an explicit rootDir, and the typecheck failed on clean runners because downstream packages need the declaration files that build emits. GitHub Copilot found the ordering problem and fixed the workflow in PR #1.
Render build: NODE_ENV=production made npm skip dev dependencies, so the build died with vite: not found. I moved Vite and TypeScript into dependencies and used --include=dev.
MongoDB Atlas: the server got an SSL alert 80 until my IP was allowed in Atlas. The game falls back to an in-memory store when the database is unreachable, so it never crashes.
Model Prompting: the model was running but it's interference was useless. Fixed the game mechanics to actually be affected by outputs of models

Why Does Open Innovation Matter?

The data is about you. The Director runs on how long you hesitate and how you type. With Gemma running locally through Ollama, that profile never leaves your machine. The hosted version sends telemetry anywhere, you can play the game online, save the gameplay and even download the dossier.

Retries cost nothing. A bad generation just gets validated, retried or replaced, and I can be as strict as I like about it. With a metered API every retry would be a bill.

I could swap the brain. The provider is one environment variable: Ollama locally or any OpenAI-compatible endpoint. Tuning the Director was a loop of changing the prompt and re-running the same evaluation.

Offline: The system runs locally without Wi-Fi using local models (Used Gemma gemma3: 1b) and with minimal latency as it predicts next 3 results while the user makes the choice.

Where a closed model would be better: the writing. A small model model of 1-4b parameters like gemma3: 1b writes flatter dread than a frontier model would, and some lines read like a template. A bigger model would still need the same schema checks and fallbacks, because the point is that the game should not break whatever the model does.

The Spirit of It

The moment it landed. My friend chilli played it first as the story was his idea. He agreed hard on the choice of making game in retro CRT style, "Made my Halloween happy, I'd rate it 2 full size snicker bars and a Twix Right"

I added Safe Mode because the whole game is built around loud sounds and distortion, and I wanted people who can't take that to still be able to finish it.

Prize Categories

Best Use of Gemma: Gemma is the Director. It turns a measured player profile into schema-validated dilemmas and narration, generated ahead of time through a lookahead queue, with a local Ollama provider and an OpenAI-compatible one.
Best Use of Render: one Node 22 web service from a render.yaml serves the Fastify API and the built Vite client.
Best Use of MongoDB Atlas: Atlas stores player runs (state snapshots and checkpoints) and a stream of telemetry events, with an in-memory fallback if it's unreachable.
Best Use of Sentry Agent Tracing: every Director batch is a gen_ai.director span with model, latency, retry count, fallback count and player tags.
Best Use of ElevenLabs: the Sound Generation API produced the game's eight horror sound effects, played from static files with a procedural fallback.
Best Use of GitHub Copilot: Copilot diagnosed and fixed the monorepo CI build-order failure in PR #1.

Built solo by Anuj Jain. MIT licensed.

Popo's notebooks only ever listened. So I built him a journal that writes back, on Gemma, offline.

Anuj Jain — Sun, 04 Oct 2026 21:47:32 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

Popo wrote his journal in notebooks for years. Then he stopped.

It wasn't that he had nothing to say. Journaling felt one-sided. He logged his thoughts every night and never really sat with them. The page took everything in and never said a word back. And when he wanted to look back at old entries, the only option was flipping through months of his own handwriting.

I wanted to fix that without losing the one thing a notebook gets right: nobody else reads it.

Pepal (Your Penpal) is a journal that writes back. It looks like a physical notebook, and it does three things:

It asks, so the page isn't silent. Each day you get three reflection questions tailored to your recent mood, so you sit with your thoughts instead of only dumping them.
It stays on your own machine. No account, no cloud, no API key. The entries, the database, and the AI all run locally on Popo's system. Not even I can read it.
You can talk to your past instead of scrolling it. Ask "when did I last feel like this?" and it answers from your own entries, and only your own entries.

When I showed it to Popo, I asked what he thought. He said he wouldn't tell me, he'd write it in the journal. LOL

I took that as the review.

Demo

Screenshot uses sample text. Popo's real journal stays on his machine.

Pepal is local-first, so there's no public link to click. With Docker, it runs in three commands:

git clone https://github.com/An16og/pepal-Your-Pen-Pal
cd pepal-Your-Pen-Pal
docker compose up -d --build

Open http://localhost:8080. The app, Postgres with pgvector, and Ollama all start automatically. On Windows, double-click start.bat.

Code

An16og / pepal-Your-Pen-Pal

Pepal: Your Penpal - 100% offline, local-first AI physical journal companion. Built with Spring Boot 3, Spring AI, PostgreSQL (pgvector), Ollama, and Docker.

Pepal: Your Penpal

A 100% local, offline, physical-style AI journal web app. Built with Spring Boot 3, Spring AI, PostgreSQL (pgvector), Flyway, and vanilla HTML/CSS/JS.

Features

2-Table Architecture: Normalized PostgreSQL storage separating journal_entry metadata from dense entry_embedding 768-dimensional vectors.
Personality System & Settings: Persona presets (GENTLE, PLAYFUL, BLUNT, COACH, CUSTOM) and language options (EN, HINGLISH) composed dynamically with a strict, non-negotiable Safety Layer.
Dynamic Mood-Aware Daily Prompts: 3 AI-tailored reflection questions with deterministic static fallback and per-date reshuffling.
Full Entry Lifecycle: Create, edit (PUT /api/entries/{id}), soft-delete (DELETE /api/entries/{id}), trash listing (GET /api/trash), conflict-aware restore (POST /api/entries/{id}/restore), permanent delete, and daily automated purge job.
Max 1 Daily Reflection per Day: Prompted with 3 questions. Enforced via partial unique index and Spring Boot service validation.
Freeform Journaling: Add unlimited…

View on GitHub

How I Built It

Browser (vanilla HTML/CSS/JS)
        │
Spring Boot 3 ──► Spring AI ──► Ollama: gemma3:1b (chat) + nomic-embed-text (768-dim embeddings)
        │
PostgreSQL 16 + pgvector (HNSW, cosine similarity)
   ├─ journal_entry     (text, mood, energy, date, trash state)
   └─ entry_embedding   (768-dim vector)

The models. Chat runs on Gemma 3 1B through Ollama. Embeddings come from nomic-embed-text, which turns each entry into a 768-dimensional vector. Both run locally.

The database. Entry metadata lives in journal_entry, and the vectors live in a separate entry_embedding table. Listing your history never drags vectors around, and similarity search runs against an HNSW cosine index (<=>) without touching the rest of the row.

Mood is part of the memory. The Energy (High/Low) and Mood (Good/Bad) you pick are embedded along with the text, not just shown as badges. So when you ask the penpal about a feeling, it can find entries by how the day felt, not only by what you wrote.

The frontend. Plain HTML, CSS, and JavaScript with the Fetch API. No framework, because a journal should open fast and have nothing to learn.

Decisions I made for Popo

One reflection a day, enforced twice. Popo wanted to sit with his thoughts, not drown in a to-do list. So there's a single daily reflection (three questions), and every other entry is freeform and unlimited. The rule is checked in the service layer and again by a partial unique index in Postgres, so no double-click or future bug can slip in a second one.

The app has to work when the model doesn't. Daily prompts are AI-generated and mood-aware, but there's a deterministic fallback with per-date reshuffling. If Ollama is still loading or busy, Popo still gets three good questions. A journal that opens empty at night is worse than a plain one.

A personality, under a fixed safety layer. The penpal can be GENTLE, PLAYFUL, BLUNT, COACH, or CUSTOM, in English or Hinglish. Whatever is chosen is composed on top of a non-negotiable Safety Layer that no preset can override. A journal is where people write their worst nights, and a persona should change the tone, never the care.

Deleting is reversible. Entries go to a trash with a "days remaining" counter and a daily purge job. Because you can backfill past dates, restoring an old reflection can clash with one you've since written for that day. Restore is conflict-aware and returns a 409 instead of silently breaking the one-a-day rule.

Swapping to Gemma

The app started on llama3.2. I switched the chat model to gemma3:1b, and because the model is configuration and not architecture, the app didn't need to be redesigned around it. Swapping models meant changing one environment variable, proving that the local-first architecture is truly model-agnostic.

Why Does Open Innovation Matter?

Because Popo's journal never leaves his system. A hosted model would need every entry sent to someone else's server to be embedded and answered. Here the entry goes from the browser to Postgres on his own machine, and the vector is computed on his own CPU. For something he writes at his most honest, that was the whole point. He was never going to tell me what he'd write. Now there is genuinely no server I could read it from, even if I wanted to.

Because it costs nothing, forever. No API key, no per-token bill, no subscription. A journal is a daily habit for years, and metered pricing punishes exactly that.

Because I could swap the model. Moving from Llama to Gemma changed one piece of the stack, not the product. If Popo gets a stronger laptop, a bigger open model is a config change away.

Because I can see where the model ends and my rules begin. The persona text, the safety layer, and the retrieval query are code and config I can read and edit, and GET /api/settings/preview returns the exact system prompt before the penpal ever speaks.

Because his entries can't be taken away. The models, the vectors, and the entries all live in Docker volumes (pepal_data, pepal_ollama) on his machine. If a company deprecates a model or changes its pricing, years of his writing keep working.

Where it lost. A 1B model is small, and a hosted frontier model will write more eloquent replies. Sometimes the model relies on repetitive phrasing, ending replies with 'That sounds difficult' instead of digging into the specific nuance of the entry. For a journal opened once a day, I'll take a plainer reply and total privacy.

Handing It Over

Popo uses Pepal on his own system, every day. When I first showed it to him, he said he wouldn't tell me what he'd write. He'd write it in the journal.

That sentence is the reason it runs entirely on his machine. He trusts a journal more than a friend, and a hosted app could never have earned that trust. He immediately disconnected his laptop from the Wi-Fi to prove to himself it still worked, then smiled and started typing.

My Agent Session

I used GitHub Copilot to scaffold the Spring Boot boilerplate and pgvector queries. The most critical decision we worked through was enforcing the Safety Layer at the service level, ensuring no user-defined CUSTOM persona could ever override the core safety constraints.

Prize Categories

Best Use of Gemma. Pepal runs Gemma 3 1B locally through Ollama as its chat model, powering the daily reflection questions, the persona-driven replies, and the retrieval-grounded penpal.

Built for Popo. If you've stopped journaling because the page never answers back, or because you don't trust where the words go, the code is yours. Clone it, run it, and let it write back.

USHER-Know before you watch

Anuj Jain — Fri, 02 Oct 2026 23:20:22 +0000

This is a submission for the Sanity Challenge, Path One: Ship an Agent That Queries Real Content

What I Built

USHER is a statutory and medical compliance gatekeeper for films and TV series.

A streaming catalog's age rating tells you who a title is legally suitable for. It doesn't tell you that a "U" rated family film contains a flashing-screen sequence that can trigger seizures. Disney issued theatrical seizure notices for Incredibles 2 in 2018 over exactly this. Real viewers also don't ask single-field questions. They say things like:

"I'm 14, have photosensitive epilepsy and auditory hyperacusis, and want a thriller."

USHER doesn't just fetch rows. Once the Sanity graph is loaded, the agent:

Resolves multiple constraints at once. Age, medical hazards, and genre are checked together. In this example it disqualifies Oppenheimer and Euphoria on statutory age (CBFC A, 18+). It disqualifies Inception because, although it is UA 13+, its 18-24Hz strobe sequence violates ITU-R BT.1702 photic limits. It recommends The Dark Knight, which is UA 13+ compliant with no photic warnings on record.
Overrides misleading ratings with clinical evidence. Incredibles 2 is rated U (all ages), but the retrieved trigger data records the 6Hz Screenslaver sequence, so the verdict moves from safe to PROHIBITED for photosensitive viewers.
Turns clinical data into practical directives. Instead of "118.5 dB surge at 20ms transition," the viewer gets a plain instruction with exact runtime windows, such as mute or look away between 01:54:30 and 01:56:00.
Cites its legal and clinical authority. Verdicts reference the Cinematograph Act 1952, CBFC Guidelines 2023, ITU-R BT.1702-2, and the WHO 85 dB listening standard, and resolve to one of [SAFE], [RESTRICTED], [PROHIBITED], or [DATA UNAVAILABLE].
Refuses to guess. If a title or hazard isn't certified in Sanity, USHER returns [VERDICT: DATA UNAVAILABLE] and advises withholding viewing until it's certified, instead of improvising safety advice from model memory.

The catalog covers 42 titles across 8 genres, with a dual-theme UI (Space Black & Metallic Slate, or Warm Coffee & Mocha Beige).

Data transparency: While film classifications and hazard designations reflect real statutory records and documented public media advisories (e.g., Disney's theatrical seizure notices for Incredibles 2), specific scene timestamps and decibel measurements are curated demonstration models created for this challenge rather than laboratory-certified clinical datasets. USHER is a demonstration of the architecture, not medical advice.

Demo

Live project: https://usher-liart.vercel.app/

Code

GitHub repository: https://github.com/An16og/usher

studio/: Sanity Studio schemas and the seeding script
web/: Next.js app, /api/chat route, and the Sanity query client (mcp-client.ts)

How I Used Sanity

Sanity is the only source of truth for every safety claim USHER makes. I modeled compliance data as typed, connected documents:

Movie: the title being audited (42)
CBFC Rating: its statutory classification (5)
Trigger Warning: hazard, severity (Mild / Severe / Critical), clinical description, timestamps, and affected demographics (13)
Accessibility Rule: governing standards, with restriction level and trigger condition (7)

Retrieval. I used GROQ over the Sanity Content Lake HTTP Query API as the primary retrieval engine, exposed to the model as a custom Vercel AI SDK tool named search_knowledge_base. One query dereferences the full relational path, Movie → CBFC Rating → Trigger Warnings → Accessibility Rules, in a single round trip:

*[_type == "movie"]{
  _id, title, releaseYear, synopsis,
  cbfcRating->{ ratingCode, minimumAge, description },
  triggerWarnings[]->{
    hazard, severity, category, clinicalDescription,
    timestamps, affectedDemographics
  },
  "applicableRules": *[_type == "accessibilityRule"
    && references(^.triggerWarnings[]._ref)]{
    ruleCode, title, targetDemographic, restrictionLevel,
    triggerCondition, restrictionDetails, source
  }
}

I chose structured GROQ traversal over vector search deliberately. Embeddings are known to blur negation ("contains strobe" vs. "does not contain strobe"), which is unacceptable for a safety use case. GROQ returns verified, typed entities with exact timestamps and statutory clauses, with no chunking or similarity guesswork.

What the agent does with the content. The retrieved graph is the only context the model reasons over. It performs the constraint resolution, rating-versus-clinical-evidence overrides, scene-skip directives, and verdict synthesis described above. If nothing certified comes back, it refuses.

Sanity Context MCP. The codebase also includes a JSON-RPC 2.0 adapter (callSanityContextMcp) for Sanity's MCP endpoint, kept behind a fallback condition. The live app currently retrieves through the direct GROQ path.

Reliability. The gateway uses Gemini with multi-key failover, plus a deterministic fallback engine, so users still get a grounded answer from Sanity data if the model is unavailable.

Sanity Project Details

Project ID: ntxlr356
Dataset: production

Contains 42 titles, 13 trigger warnings, 7 accessibility rules, and 5 CBFC ratings.

Agent Session

USHER was built iteratively in Google Antigravity as the AI-native development environment, covering schema design, the seeding script, the GROQ query layer, the agent's guardrails, and the UI. A transcript isn't included because Antigravity isn't currently supported by the DEV Agent Sessions uploader.