DEV Community: Penta Dank

Please Hold: the customer-service call you keep putting off, written by a Gemma that isn't allowed to make things up

Penta Dank — Sun, 25 Oct 2026 18:25:36 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady

What I Built

Everybody has one. The charge you meant to dispute. The subscription that renewed after you cancelled. The bill that went up $30 with no warning. You know exactly what you want. You just don't want to sit through the phone tree, explain it three times, and remember to ask for a reference number.

Before I built anything this week, I had an agent go read what people actually complain about online. The loudest category wasn't sleep or inboxes. It was dealing with companies. A February 2026 Groundwork Collaborative study, reported by Fortune, puts the "annoyance economy" at about $165 billion a year and finds Americans spend 60% more time on customer-service calls than 20 years ago. On Trustpilot, Calm sits at 1.4 out of 5, and the reviews are mostly billing traps: "They charged me $85 for a free trial and then refused a refund."

Then I checked this challenge's tag. Around 545 Week 3 posts: a lot of file sorters, a lot of inbox digests, and four bedtime companions, which was the idea I'd planned to build. Nobody had taken the customer's side of the phone call.

Please Hold does. You type one sentence:

Lumen Fitness charged me $49.99 on Oct 3 even though I cancelled on Sept 28. Member #448210. I want it refunded.

and get back the whole errand:

A phone script in your voice: the first thing to say, the exact ask, three polite lines for when they say no, and how to close (agent's name, reference number, what was agreed).
An email and a chat message, ready to send.
Your leverage. Short, sourced consumer-rights pointers for the US, UK and EU that match the errand. I wrote these by hand. The model never writes them.
Hold mode. A full-screen card with your script, a hold timer, and calm hold music generated on your device. Your hold music, not theirs.
After the call. Type the agent's name and reference number, and it writes the confirmation email and a calendar reminder to check they actually did it. No model in this step, so nothing gets made up.

Gemma runs on your own computer through Ollama. Your account numbers, your address, the money you're owed: none of it leaves your machine. If you just want to try it on a phone, there's an opt-in cloud mode, clearly labeled.

Demo

Live: https://please-hold.dankpenta.workers.dev

To keep everything local, install Ollama, run ollama pull gemma3:4b, and start it with the site allowed:

OLLAMA_ORIGINS=https://please-hold.dankpenta.workers.dev ollama serve

Or pick Gemma 4 26B on Cloudflare to try it on any device right now.

Screenshots from a run on my laptop with gemma3:4b in Ollama. The ledger numbers are from that test run.

Code

5thlegend / please-hold

Please Hold

Type the customer-service errand you've been avoiding. Get everything you need to finish it in one call.

Live: https://please-hold.dankpenta.workers.dev

You write one sentence, like "Lumen Fitness charged me $49.99 on Oct 3 even though I cancelled on Sept 28. Member #448210. I want it refunded." Please Hold gives you back:

A phone script: the first thing to say, the exact ask, three polite lines for when they say no, and how to close the call.
An email and a chat message, ready to send.
Your leverage: hand-written, sourced consumer-rights pointers (US, UK, EU) that match the errand. These are never written by the model.
Hold mode: a full-screen card with your script, a hold timer, and calm hold music generated on your device.
After the call: log the agent's name and reference number, then get a confirmation email and a calendar reminder to check they actually did…

View on GitHub

MIT licensed. Plain HTML, CSS and ES modules, no build step. One small Cloudflare Worker for the opt-in cloud route.

How I Built It

The model writes words, never facts

Small models are helpful in the worst way. Ask one for a cancellation email and it may add a support phone number, a "within 5 business days" promise, or a consumer protection act. None of that came from you, and some of it is invented. On a customer-service call that's not a style problem. Read a made-up policy to an agent and you've lost the call.

So Please Hold never trusts the model's output. It runs two passes, then checks the receipts:

Pass 1, extract. Gemma pulls out the company, the errand type, and the facts, each with a quote from your sentence. A fact survives only if its quote really is your words, or if every number in it matches what you typed and most of its words are yours. Anything else is dropped before a word gets written.
Pass 2, write. Gemma writes the email, chat message and phone script from the surviving facts only, in your voice. Unknowns become [ORDER NUMBER]-style blanks.
The receipts check. Plain JavaScript, no model, finds every checkable claim in the output (phone numbers, URLs, emails, amounts, dates, durations, percentages, account numbers, legal-sounding phrases) and compares each one against your own words.

// public/js/verify.js (trimmed)
for (const c of findClaims(output)) {
  const status = isVerified(c.kind, c.text, idx)
    ? "verified"                       // it's in what you typed
    : c.catchable ? "caught"           // phone/URL/email you never gave: replaced
    : "unverified";                    // number, date, deadline, law: highlighted
  segments.push({ text: status === "caught" ? PLACEHOLDER[c.kind] : c.text, status });
}

On screen, anything from your words gets a dotted underline. An invented phone number is removed and replaced with [COMPANY PHONE — copy it from your bill]. Anything else you didn't say is highlighted yellow so you check it before you read it to a stranger.

Both passes use structured output: the JSON schema goes to the model, so it can only produce the fields the app expects (Ollama's format, Workers AI's response_format).

The parts I wrote by hand

Anything that has to be right isn't generated. That covers the consumer-rights pointers, each checked against an official page (FTC, Your Europe, Citizens Advice). It also covers the "getting to a human" tips, the follow-up email built from your call log, and the .ics reminder. The hold music is four slow major-seventh chords and a soft bell, generated live with the Web Audio API. No audio files.

Where Gemma runs

Option	Model	Where your text goes
Your computer (default when found)	any Gemma in Ollama, e.g. `gemma3:4b`	Nowhere
Cloudflare (opt-in)	Gemma 4 26B A4B on Workers AI	Cloudflare. The app doesn't store or log it

What broke: I tried to put Gemma in the browser

My plan was for Gemma to run inside the tab with nothing to install. I spent most of an afternoon on it, and it didn't ship. Here's what happened on my laptop (RTX 4050 6 GB, 16 GB RAM, Chrome):

Gemma 4 E2B on WebLLM 0.2.86, the first WebLLM release with Gemma 4, lost the WebGPU device on the first token. So did every other model on 0.2.86. 0.2.85 is stable but has no Gemma 4.
Gemma 4 E2B on Transformers.js 4.3.0 downloaded all ~3.3 GB of weights, then the tab crashed loading them.
Gemma 3 1B on WebLLM 0.2.85 runs, but it's too small for this job. Under a JSON grammar it printed whitespace until it hit the token limit. Without one, it echoed my prompt back, or worse: it answered with a refund for "$10.99 on Oct 28." The user had typed $49.99 and Oct 3.

That last one is the whole argument for the receipts check, made by the model itself. It's still in the app behind ?lab=1 if you want to watch it struggle.

Two bugs from that detour that you might hit too:

Hugging Face rejects *.workers.dev referrers. WebLLM said Failed to execute 'open' on 'CacheStorage', then Failed to fetch. Chrome said CORS, and curl said everything was fine. Replaying Chrome's exact request one header at a time showed it: Hugging Face returns 404 with no CORS headers to any model download whose Referer is a *.workers.dev page. The fix is one line, <meta name="referrer" content="no-referrer"> (plus the matching Referrer-Policy header).
WebLLM's prebuilt Gemma 3 1B config rejects itself. It sets both a 4096 context and a 512 sliding window, and WebLLM refuses that combination. chatOpts: { context_window_size: 4096, sliding_window_size: -1 } gets it to load.

So the local path is Ollama. It's one install, and the model then runs on your own GPU with native CUDA.

Does it actually behave?

I wrote 24 realistic errands (refunds, cancellations, a lost suitcase, a pharmacy overcharge, a security deposit, a free trial about to convert, an errand where the person doesn't know their account number), ran each through the full pipeline on both backends, and counted what the receipts check found.

Model	Runs on	Errands	Claims checked	Matched your words	Flagged for you	Invented contact details	Avg time per kit
Gemma 4 26B	Cloudflare Workers AI	24/24	169	165	4	0	12.8 s
Gemma 3 4B	my laptop, via Ollama	24/24	155	151	4	0	16.7 s

All eight flags were Gemma doing arithmetic. "My bill went from $65 to $95" became "the $30 increase," and "$120 for a prescription that's supposed to be $10" became "a $110 refund." The math is right, but you never said $30, so it's highlighted for you to confirm. The check doesn't decide what's true. It shows you what didn't come from you.

Neither model invented a phone number on this set. I'd still never ship without the check, after watching the 1B model invent a whole charge on its first try. The local model also had 6 extracted facts dropped for not matching the user's words, before they could reach the email.

The Lazy Payoff

Across the 24 errands, you type about 19 words and Please Hold writes about 220: an email, a chat message, and a four-part phone script with your facts already in it. Each kit takes 13–17 seconds on average.

The app keeps a lazy ledger in your browser: errands finished, time spent on hold, words you didn't have to write, and money recovered.

Why Does Open Innovation Matter?

The sensitive part is the data. A customer-service errand is account numbers, addresses, and money owed. With open weights on your own machine, that text is never sent anywhere. It isn't a "we don't store it" promise.
No subscription, for an app about subscription traps. The thing people hate most about the incumbents is getting charged. A model on your own GPU costs nothing per errand, forever.
I can hold it to account because I can run it. Open weights plus open runtimes let me force a JSON schema, run the same model family locally or in the cloud, and check every output with my own code. The honesty system is mine, not a vendor setting.
You choose where it runs. The same Gemma family runs on a laptop GPU through Ollama, or on Cloudflare when you're on a phone. Open weights make that a radio button, not a migration.
Where open beat closed, and where it didn't. A frontier API would write smoother emails. It would also send your account details to one company so you can argue with another. And open isn't magic: the in-browser route wasn't ready on my hardware this week. Small, local, and checked was the right trade for this job.

What it doesn't do

It doesn't make the call for you, and it doesn't give legal advice. The rights pointers are general information with links to the official source. The local 4B model writes plainer prose than the cloud one, and that's why the checks exist.

My Agent Session

I built this with an AI agent in one long sitting, from "go research what people actually complain about" to deploy. The session shows the research that killed my first idea, the rule that the model writes words and never facts, the Referer bug, and the in-browser attempts that didn't make it.

Please Hold: from 'what are people complaining about?' to a local Gemma errand kit

You

Bring my Hacktoberfest run up to date for the week of 2026-10-20 and ship this week's entry. Week 3 'Slow and Steady' is open: build something with open-weight models / open-source AI that rewards laziness. Pitch 3 concepts that fit my strengths (local-first open-weight AI like Storyhouse/Lore Walk), let me pick, build it, deploy it, save the session, draft the DEV post. Never publish or register without my yes.

Agent

▸ get_challenges DevRelay

Input

DevRelay

Output

Week 3 'Slow and Steady' (Oct 19-25, due Sat 11:59 PM PDT). Writing quality weighted most. Post must explain why open innovation matters and show the lazy payoff.

▸ search_mlh_events Open-Source AI Challenge

Input

Open-Source AI Challenge

Output

MLH event 'Hacktoberfest Open-Source AI Challenge: Week 3' exists; not registered yet.

Pitched three: an offline wind-down companion that slows down with you, a local file tidier, and fridge-photo-to-grocery-list. Recommended the wind-down companion.

You

Go out on the internet and deep research what people are complaining about in this area or theme and we can come up with ideas to reward their laziness.

Agent

Ran four parallel research tracks (life admin, household/food, sleep and wind-down, developer drudgery plus the competition), then a report writer combined them into one ranked report.

▸ research: life admin HN, r/ADHD snapshots, Trustpilot, surveys

Input

HN, r/ADHD snapshots, Trustpilot, surveys

Output

Top pains: customer-service calls and hold time, insurance/medical paperwork, subscription cancelling. Groundwork Collaborative (Feb 2026): $165B/yr 'annoyance economy', call time up 60% in 20 years.

▸ research: sleep Trustpilot, app stores, AASM, Talker Research

Input

Trustpilot, app stores, AASM, Talker Research

Output

Calm 1.4/5 on Trustpilot (492 reviews, 78% one-star), mostly billing traps: 'They charged me $85 for a free trial and then refused a refund'.

▸ research: competition dev.to #hf26challenge

Input

dev.to #hf26challenge

Output

~545 Week 3 entries. ~119 file sorters, ~80 summarizers, ~48 inbox/chat digests.

▸ search_dev_to_semantic hf26challenge bedtime sleep wind-down offline

Input

hf26challenge bedtime sleep wind-down offline

Output

Sloth Companion, SnoozeScape, Compline, SlumberSafe: the bedtime idea is already taken.

▸ search_dev_to_semantic hf26challenge fridge / timesheet / insurance letter

Input

hf26challenge fridge / timesheet / insurance letter

Output

Fridge: 4+ this week. Timesheet: 'lowkey' did it in Week 2. Letter decoder: Week 2.

▸ search_dev_to_semantic hf26challenge cancel subscription customer service call script

Input

hf26challenge cancel subscription customer service call script

Output

No Week 3 entry on the consumer side of customer-service errands.

My original pick was already taken four times. The most-complained-about pain (calling a company to cancel, refund, or dispute) had no Week 3 entry. New pitch: Please Hold. One sentence in, the whole errand kit out, written on your device.

You

Build Please Hold — the local customer-service errand kit.

Agent

▸ Bash HF API: onnx-community + mlc-ai gemma models; npm view @mlc-ai/web-llm

Input

$ HF API: onnx-community + mlc-ai gemma models; npm view @mlc-ai/web-llm

Output

gemma-4-E2B-it-q4f16_1-MLC (2.8 GB, 3.4 GB VRAM) is in WebLLM 0.2.86 but not 0.2.85. gemma3-1b-it (0.6 GB) in both. Workers AI has @cf/google/gemma-4-26b-a4b-it.

Decision: on-device Gemma 4 E2B through WebLLM as the default (pinned and vendored 0.2.86), Gemma 3 1B as a light option, the user's own Ollama, and an opt-in cloud fallback (Gemma 4 26B on Workers AI) for browsers without WebGPU. Same open model family, the user picks where it runs.

Design rule: the model writes words, never facts. Pass 1 extracts facts and must quote the user word for word. Pass 2 writes the kit only from verified facts. Then a deterministic 'receipts check' scans every phone number, URL, email, amount, date, duration, percentage, account number and legal-sounding phrase, and compares it to the user's own text. Invented contact details get replaced with a placeholder; other unverified claims are highlighted. Consumer-rights pointers, IVR tips, the follow-up email and the calendar reminder are written by hand, with no model involved.

▸ Bash node test/verify.test.mjs

Input

$ node test/verify.test.mjs

Output

verify: all checks passed

▸ Bash Workers AI REST: gemma-4-26b-a4b-it with json_schema response_format

Input

$ Workers AI REST: gemma-4-26b-a4b-it with json_schema response_format

Output

200 in 5.6s. Clean JSON, but facts came back as fragments ('on Oct 3'). Fixed the prompt: each fact is one short third-person sentence.

▸ WebFetch consumer.ftc.gov/articles/using-credit-cards-and-disputing-charges

Input

consumer.ftc.gov/articles/using-credit-cards-and-disputing-charges

Output

'Send your letter so that it reaches the issuer within 60 days after the first bill with the error was sent to you.' Rewrote the US leverage text to match. Two Citizens Advice URLs 404'd; swapped them for a live Citizens Advice page that states the 14-day and 30-day rules.

▸ Bash npx wrangler deploy

Input

$ npx wrangler deploy

Output

https://please-hold.dankpenta.workers.dev

▸ Bash node test/eval-cloud.mjs (24 realistic errands)

Input

$ node test/eval-cloud.mjs (24 realistic errands)

Output

24/24 ok. 178 checkable claims: 174 matched the user's words, 0 invented contact details, 4 flagged ($110, a difference Gemma calculated from $120 and $10, which isn't in the user's words). Avg 17s per kit, ~216 words written per errand.

▸ browser on-device run in the in-app browser

Input

on-device run in the in-app browser

Output

Blocked: the sandboxed browser pane can't reach huggingface.co for the weights. Switched to Playwright driving real Chrome on the RTX 4050.

▸ Playwright CreateMLCEngine('gemma-4-E2B-it-q4f16_1-MLC')

Input

CreateMLCEngine('gemma-4-E2B-it-q4f16_1-MLC')

Output

UnknownError: Failed to execute 'open' on 'CacheStorage'. My IndexedDB fallback used the old option name (useIndexedDBCache); WebLLM 0.2.86 renamed it to cacheBackend: 'indexeddb'. Fixed and redeployed.

▸ Playwright fetch(huggingface.co/.../mlc-chat-config.json) from the app

Input

fetch(huggingface.co/.../mlc-chat-config.json) from the app

Output

Still 'Failed to fetch': CORS, no Access-Control-Allow-Origin. The cache error had been a red herring. Direct navigation to the same URL works.

▸ Bash curl with Chrome's exact headers, varying one at a time

Input

$ curl with Chrome's exact headers, varying one at a time

Output

Referer: https://please-hold.dankpenta.workers.dev/ -> 404 from CloudFront (no CORS headers). No Referer -> 302. Referer: https://example.com/ -> 302. Hugging Face rejects downloads referred by *.workers.dev pages.

Fix: <meta name="referrer" content="no-referrer"> plus a Referrer-Policy: no-referrer header in public/_headers. One line each. Re-probe: all three files 200.

▸ Playwright Gemma 4 E2B on WebLLM 0.2.86, RTX 4050, real Chrome

Input

Gemma 4 E2B on WebLLM 0.2.86, RTX 4050, real Chrome

Output

Model loaded (428s, 2.8 GB). First generated token: 'Failed to execute mapAsync on GPUBuffer: A valid external Instance reference no longer exists.' The WebGPU device was lost. Same with Gemma 3 1B on 0.2.86, even for a 40-token plain-text reply.

▸ Playwright Same Gemma 3 1B on WebLLM 0.2.85

Input

Same Gemma 3 1B on WebLLM 0.2.85

Output

Works: 2.2s plain, 5.3s with a JSON schema. 0.2.86 is the regression, and it's the only version with Gemma 4.

▸ Playwright Gemma 3 1B on the real facts prompt (341 tokens)

Input

Gemma 3 1B on the real facts prompt (341 tokens)

Output

Under the JSON grammar: '{"company"' followed by 1,200 characters of whitespace. Without a grammar: echoes '---' or the prompt. With a system role it answered about a refund 'of $10.99 on Oct 28'. The user typed $49.99 and Oct 3. Too small for this job, so it moved behind ?lab=1.

▸ Playwright Gemma 4 E2B via Transformers.js 4.3.0 (+esm build)

Input

Gemma 4 E2B via Transformers.js 4.3.0 (+esm build)

Output

All weights downloaded (~3.3 GB), then the tab crashed while loading them. 16 GB RAM, 2.5 GB free.

Decision: the local path is Ollama (native CUDA). It's the default whenever the site detects it, the cloud is opt-in, and the in-browser path stays behind a flag with an honest write-up. Added an in-app message for GPU resets and a copyable OLLAMA_ORIGINS command for Mac/Linux and Windows.

▸ Bash node test/eval-ollama.mjs gemma3:4b (first run)

Input

$ node test/eval-ollama.mjs gemma3:4b (first run)

Output

24/24, 110 of 111 claims matched, 0 invented contacts, but 10 facts dropped. They were mostly false positives: the model 'quoted' its own paraphrase ('They were charged $120 for a prescription').

Loosened checkFacts: a fact is kept if its quote really is the user's words, or if every number in it checks out and at least 60% of its content words are the user's. Added unit tests for both, including one where a fact with an invented $140 still gets dropped.

▸ Read docs/shots/02-kit.png

Input

docs/shots/02-kit.png

Output

The phone opener came out in the agent's voice: 'Thank you for contacting Lumen Fitness... I'm here to assist you today.' Fixed the prompt to say everything is in the CUSTOMER's voice, said TO the company. The goal and fallback are now short phrases, and the 'have these ready' items are plain lowercase.

▸ Bash final evals, both backends, final prompts

Input

$ final evals, both backends, final prompts

Output

Gemma 4 26B (Workers AI): 24/24, 165 of 169 claims matched, 4 flagged, 0 invented contacts, 12.8s avg. Gemma 3 4B (Ollama, RTX 4050): 24/24, 151 of 155 matched, 4 flagged, 0 invented contacts, 6 facts dropped, 16.7s avg. All 8 flags were Gemma's own arithmetic ($95 - $65 = '$30', $120 - $10 = '$110'), so they're highlighted for the user to confirm.

Prize Categories

Best Use of Gemma: Gemma is the whole engine. Gemma 3 4B runs locally through Ollama, and Gemma 4 26B on Workers AI is the opt-in fallback. Both are held to the same receipts check, and both are measured on the same 24 errands above.

LORE WALK: I built an app that wants you to put it away

Penta Dank — Sun, 11 Oct 2026 02:57:42 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

What I Built

I run Next Realm Interactive. My friend and creative director, Bully (@BullyStepHarder), is the guy on our team who holds the tablet. I see the blueprint; he translates it into something people can actually see. We call him the Lorekeeper, half as a joke. But most of his lore gets made indoors, under a ceiling, staring at a screen.

So I built him something that argues with that, and gets him curious about what open AI can do in his hands.

LORE WALK is a phone app whose main instruction is put me away. You tap Start a walk, and the screen tells you exactly one thing: find something worth remembering. Then you go. When something stops you, like a tree with a split trunk, a door painted a color nobody would choose, or a rock that looks like it's been waiting, you pull the phone out for about ten seconds and take one photo.

A small open-weight model running on the phone reads the photo. A second small model takes what it saw and writes a title and a few sentences of lore, treating the place as a location in some old world. Mythic, but tied to what's actually there. That's a Lore Shard. Then the phone goes back in your pocket.

When you end the walk, you get the Lore Codex: every shard in the order you found it, with an optional little route line if you turned on location. You can export it as Markdown or as one tall image to share.

The screen should be the shortest part of the walk. That was the whole design brief.

Demo

Live: https://lore-walk-nextrealm.dankpenta.workers.dev (open it on your phone; it installs as a PWA)

Screenshots from a full run on my machine: photo in, caption, tags, lore, Codex.

Code

5thlegend / lore-walk

LORE WALK by Bully · Next Realm Interactive. Turn a walk into world lore with open models running on your phone.

LORE WALK — by Penta Dank · Next Realm Interactive

Walk the world. Write its lore.

LORE WALK is a tiny phone app that wants you to put it away. Start a walk, pocket your phone, and only pull it out when something stops you — a crooked tree, a doorway, a mural, a rock that looks like it has a name. Snap it. An open-weight AI model running entirely on your device reads the place and writes a short piece of world lore about it. That's a Lore Shard. End the walk and you get a Lore Codex: your shards in order, with an optional route line, exportable as Markdown or an image.

Live: https://lore-walk-nextrealm.dankpenta.workers.dev

Built by Penta Dank (General Dank) of Next Realm Interactive for his friend and creative director Bully (@BullyStepHarder), a.k.a. The Lorekeeper, to pull his creativity outside and into open…

View on GitHub

MIT licensed. It's plain HTML, CSS, and one JS module. No build step and no backend.

How I Built It

The whole app is static files. All the intelligence runs in the browser through Transformers.js v3, which uses WebGPU when the phone supports it and falls back to WASM on the CPU when it doesn't.

The pipeline for each shard:

Downscale on device. The photo goes through a canvas and comes out at 512px for the models and 480px as a JPEG thumbnail. The original never gets uploaded anywhere, because there's nowhere to upload it to.
Read the place. Xenova/vit-gpt2-image-captioning (8-bit quantized) gives a plain caption, something like "a large tree in a grassy field."
Name the thing. Xenova/clip-vit-base-patch32 does zero-shot classification against a short list of things worth stopping for (tree, doorway, mural, rock, bridge, stairs, gate…). That gives the lore writer a noun to hold onto.
Write the lore. HuggingFaceTB/SmolLM2-360M-Instruct gets the caption and tags with a tight prompt: a 2–5 word place name, then three sentences of lore, in a fixed TITLE: / LORE: format that I parse and trim.
Never break. If a model fails to load, the phone runs out of memory, or the small model rambles past the format, a seeded template generator builds the shard from the same caption and tags. On a trail, the demo can't be the thing that breaks.

Every shard records which models actually produced it, and the Codex shows that. The ⚙ panel lets you swap models: SmolLM2-135M for older phones, Qwen2.5-0.5B-Instruct if you've got the headroom, or template-only for zero download.

For offline use, a service worker caches the app shell and the library, and Transformers.js keeps the model weights in the browser's Cache API. Load it once on Wi-Fi at home and the walk itself needs no signal. Shards live in localStorage as small thumbnails.

The look comes from our studio: violet-black, galaxy purple, burning gold, fire orange, and white used sparingly. Big condensed type, like the spine of a tome. There's a maple leaf hidden in there too.

Why Does Open Innovation Matter?

Because of where this app is meant to be used: outside, where the signal is bad.

Offline on a trail. A closed API needs a round trip to a datacenter for every photo. Here the model is a file sitting on my phone. Signal bar or no signal bar, it writes.
The data stays on the device. I'm asking people to photograph their neighborhood, their walk home, the tree outside their kid's school. Those photos shouldn't be training data for anyone. With local inference, privacy isn't a promise in a policy. The photos physically never leave.
Swap the model. Open weights mean the app isn't married to one vendor. When a better small vision model ships next month, changing it is one line.
Zero cost. No API key, no per-request bill, no free tier that runs out. It costs nothing to run whether ten people use it or ten thousand.
Where open beat closed. A giant closed model would write prettier sentences. But it would also need a connection, a key, a budget, and trust, and it would make the phone a pipe to somewhere else. The small open models are a little rougher, and honestly that roughness reads like found folklore. For an app whose job is to get you off the screen, small, local, and free beats big and remote.

My Agent Session

This was built with an AI agent working alongside me, start to finish in one evening. Here's the real session: model choices, the first run where the small model ignored my output format, the CORS wall on the live site, the fallback that kept it from breaking, and the final run where all three open models wrote "The Luminous Tree."

LORE WALK: building an on-device open-model app that wants you to put it away

You

Hacktoberfest Open-Source AI Challenge, Week 1: Touch Grass. Build an app for my friend and creative director Bully, the 'Lorekeeper', that gets his creativity outside and into open AI. Use open-weight models running on-device, make it look like Next Realm Interactive, and deploy it to Cloudflare.

Agent

Plan: a phone PWA whose main instruction is 'put me away'. Start a walk, snap one photo when something stops you, and on-device models turn it into a Lore Shard. End the walk to get a Lore Codex. Static files only, no backend, so photos never leave the phone.

Agent

Model stack, all in the browser via Transformers.js v3 (WebGPU if available, else WASM): vit-gpt2 captioning to read the place, CLIP zero-shot to name the thing, SmolLM2-360M-Instruct to write the lore, and a seeded template generator so a shard always gets made.

▸ Write dist/app.js (pipeline excerpt)

Input

dist/app.js (pipeline excerpt)

Output

61: status('Reading the place…'); pipe('image-to-text', v, { device: 'wasm', dtype: 'q8' }) ... max_new_tokens: 30
64: status('Naming what it is…'); pipe('zero-shot-image-classification', c, { device: 'wasm', dtype: 'q8' }) ... LABELS.map(l => `a photo of a ${l}`)
72: function templateLore(caption, tags, n) {
111: return { ...templateLore(caption, tags, n), model: 'template (seeded by vision output)' };

Agent

GPU detection gets a 2.5s timeout so a hanging adapter request can't freeze startup. Model downloads begin as soon as the walk starts.

▸ Write dist/app.js

Input

dist/app.js

Output

4: const hasGPU = !!navigator.gpu && !!(await Promise.race([navigator.gpu.requestAdapter().catch(() => null), new Promise(r => setTimeout(() => r(null), 2500))]));
42: function warm() { /* start downloading while they walk */ ... }

Agent

The lore prompt asks for a strict TITLE: / LORE: format: a 2-5 word place name, then 3 sentences.

▸ Write dist/app.js (prompt)

Input

dist/app.js (prompt)

Output

96: content: `A traveler on foot found this: "${seedText}".\nInvent a short place-name title (2-5 words) and 3 sentences of world lore about it as a location in an ancient world ...

Agent

Headless end-to-end test harness: a 390x844 phone viewport, a real tree photo (test.jpg), a full walk, and screenshots of home, walk and codex.

▸ Write test.py

Input

test.py

Output

pg.goto('http://localhost:8765/'); click #startBtn; set_input_files('#photo','test.jpg'); wait_for_selector('#lastShard .shard', timeout=840000); print RESULT; click #endBtn; screenshots shot-home/shot-walk/shot-codex.png

Agent

First local run with the real models. All three models loaded on CPU (no GPU adapter in the headless box). The caption and CLIP outputs were good, but SmolLM2 drifted off the format and the parser couldn't use it, so the template fallback wrote the shard.

▸ Shell python3 test.py > test.log (v1 commit)

Input

python3 test.py > test.log  (v1 commit)

Output

0s C: No available adapters.
0s C: [status] Reading the place…
14s C: [status] Naming what it is…
21s C: [status] Writing the lore…
   **Lore:** 
Located deep within a lush, earthy grove, The Tree Oak stands tall, its majestic trunk reaching toward the sky like a giant emerald heart. ...
RESULT: SHARD 01 · 7:11 PM
THE WATCH OF ORRIN

Long before the roads had names, the tree at Orrin was where the Realm kept its promises. Travelers describe it plainly — a tree with a large, colorful, and colorful tree trunk — and that is how it hides. ...

seen: a tree with a large, colorful, and colorful tree trunk · tags: tree
models: Xenova/vit-gpt2-image-captioning → Xenova/clip-vit-base-patch32 → template (seeded by vision output) · 97.4s on-device

Agent

Fallback worked as designed: the shard still came out and was honestly labeled 'template (seeded by vision output)'. The model had written a markdown 'Lore:' header instead of the requested format. The shipped parser tolerates TITLE variants and recovers the LORE text:

▸ Edit dist/app.js (parser)

Input

dist/app.js (parser)

Output

101: const t = clean.match(/TITLE[^:\n]{0,12}:\s*([^\n,]+?)(?=\s*(?:,|LORE:|TITLE|\n|$))/i);
103: let rest = clean.match(/LORE:\s*([\s\S]+)/i)?.[1] || (t ? clean.slice(t.index + t[0].length) : clean).replace(/TITLE[^:\n]{0,12}:/gi, '');
109: } catch (e) { console.warn('text model failed', e); }

Agent

Deployed to Cloudflare as a Workers static-assets site. The whole config is one line pointing at ./dist.

▸ Write wrangler.jsonc

Input

wrangler.jsonc

Output

{ "name": "lore-walk-nextrealm", "compatibility_date": "2026-10-01", "assets": { "directory": "./dist" } }

▸ Shell npx wrangler deploy

Input

npx wrangler deploy

Output

(deploy output not preserved; the live URL is the one served in test_live.log: https://lore-walk-nextrealm.dankpenta.workers.dev)

Agent

Ran the same end-to-end test against the live URL.

▸ Shell python3 test_live.py > test_live.log

Input

python3 test_live.py > test_live.log

Output

0s REQ https://lore-walk-nextrealm.dankpenta.workers.dev/
1s REQ .../sw.js
1s C: [status] Reading the place…
1s REQ https://cdn.jsdelivr.net/npm/@huggingface/transformers@3.7.2/dist/transformers.min.js
1s C: Access to fetch at 'https://huggingface.co/Xenova/vit-gpt2-image-captioning/resolve/main/tokenizer_config.json' from origin 'https://lore-walk-nextrealm.dankpenta.workers.dev' has been blocked by CORS policy: No 'Access-Control-Allow-Origin' header is present on the requested resource.
FAIL .../tokenizer_config.json net::ERR_FAILED
... (same CORS failure for CLIP and SmolLM2 config/tokenizer files)

Agent

CORS problem: in the live headless run, every Hugging Face model file was blocked, so all three models failed. The app still didn't break. It fell back to the template and produced a shard in 0.4s.

▸ Read test_live.log (result)

Input

test_live.log (result)

Output

RESULT: SHARD 01 · 7:14 PM
THE THRESHOLD OF EMBERLINE

Long before the roads had names, the stone at Emberline was where the Realm kept its promises. Most walk past it without a second look, which is exactly how it survives. Touch it once and you will remember a place you have never been.

seen: —
models: template (seeded by vision output) · 0.4s on-device

Shard saved. Now put me away again.

Agent

Made the offline story concrete: a service worker caches the app shell and the library, and Transformers.js keeps model weights in the Cache API. Shards go into localStorage as small thumbnails, and if storage fills up the app degrades to keeping only the most recent walks.

▸ Read dist/app.js

Input

dist/app.js

Output

15: const saveWalks = w => { try { localStorage.setItem('lw_walks', JSON.stringify(w.slice(-8))); } catch (e) { localStorage.setItem('lw_walks', JSON.stringify(w.slice(-2))); } };

Agent

Committed v1: app, icons, OG image, manifest, service worker, README, MIT license, DEV post draft, and test logs.

▸ Shell git commit -m 'LORE WALK v1'

Input

git commit -m 'LORE WALK v1'

Output

35c86b7 LORE WALK v1
 23 files changed, 665 insertions(+)
 dist/app.js | 188 +, dist/index.html | 90 +, DEV_POST.md | 66 +, README.md | 35 +, test.py, test_live.py, wrangler.jsonc ...

You

Credit me (Penta Dank) as the maker. It's made for Bully.

Agent

Updated the byline across the page title, OG tags, header, manifest, README and post.

▸ Shell git show 6014c8a -- dist/index.html

Input

git show 6014c8a -- dist/index.html

Output

-<title>LORE WALK — by Bully · Next Realm Interactive</title>
+<title>LORE WALK — by Penta Dank · Next Realm Interactive</title>
-  <div class="by">by Bully · Next Realm Interactive</div>
+  <div class="by">by Penta Dank · Next Realm Interactive · made for Bully</div>

▸ Shell git commit

Input

git commit

Output

6014c8a Credit Penta Dank as maker; made for Bully
 5 files changed, 14 insertions(+), 14 deletions(-)

Agent

Added screenshots to the post and hosted them from the deployed site so DEV can embed them.

▸ Shell git log --oneline (screenshots)

Input

git log --oneline (screenshots)

Output

33193c0 Screenshots + final post
e5cffd5 Add screenshots (docs/shot-*.png)
d6b7445 Host screenshots (dist/shot-*.png, DEV_POST.md)

You

Do a Next Realm signature design pass.

Agent

Design pass: a cinematic violet-black world, galaxy purple, burning gold, fire orange, white used sparingly, condensed tome-spine type, tome-styled shards, new icons and OG image, and polished exports.

▸ Edit dist/style.css, index.html, app.js, icon.svg, sw.js

Input

dist/style.css, index.html, app.js, icon.svg, sw.js

Output

style.css | 126 +++++---  index.html | 27 ++-  app.js | 16 +-  sw.js | 6 +-  icon-192/512.png, og.png regenerated

Agent

Responsive QA script. It forces template-only mode so it runs fast, makes two shards, ends the walk, and checks for horizontal overflow at 390x844, 1280x800 and 320x640.

▸ Write qa.py

Input

qa.py

Output

for w,h,t in [(390,844,'m'),(1280,800,'d'),(320,640,'s')]: run(...)
  visionSel='none'; clipSel='none'; textSel='template'
  2x set_input_files('#photo','test.jpg') -> wait 'SHARD 0n'
  screenshots qa/{tag}-home|walk|shard|codex.png
  print(tag,'scrollWidth',scrollWidth)

Agent

Reran the full real-model test after the design pass. This time SmolLM2-360M's output got through the parser, so all three open models produced the shard (124.4s on CPU). The output is wild, rambling found folklore.

▸ Shell python3 test.py > test.log

Input

python3 test.py > test.log

Output

2s C: [status] Reading the place…
17s C: [status] Naming what it is…
24s C: [status] Writing the lore…
36s C: Unable to add response to browser cache: UnknownError: Failed to execute 'put' on 'Cache': Unexpected internal error..
RESULT:
SHARD 01 · 7:36 PM
PUKUTUKA [BY AETHERE] : THE LUMINOUS TREE

At twilight the Moon-Moon rises against the sky of pukutuckana over Pikinipu’s sacred hui iwi – and to your knowledge that is where you find what was once white from its blossoms all around under great oak... 

seen: a tree with a large, colorful, and colorful tree trunk · tags: tree
models: Xenova/vit-gpt2-image-captioning → Xenova/clip-vit-base-patch32 → HuggingFaceTB/SmolLM2-360M-Instruct · 124.4s on-device

Agent

Committed the design pass with refreshed screenshots for mobile, desktop and small phones.

▸ Shell git commit

Input

git commit

Output

f06f986 Next Realm signature design pass: cinematic world, tome shards, new icons/OG, export polish
 34 files changed, 226 insertions(+), 126 deletions(-)

Agent

Final DEV post is honest about status: the full flow was tested end to end on a real tree photo, a shard takes about 1.5-2 minutes on a laptop CPU, phone WebGPU speed hasn't been measured, and the first real walk is Bully's.

Taking It Outside

Honest status: this one was built against the clock tonight, and the walk hasn't happened yet. I ran the full flow end to end on my machine with a real tree photo. The caption model saw "a tree with a large, colorful… tree trunk," CLIP tagged it as a tree, and SmolLM2 wrote back a few lines about "The Tree Oak" standing tall with its trunk reaching for the sky. That's a little clumsy, a little mythic, and exactly the kind of found folklore I was after.

On a laptop CPU, each shard took about a minute and a half. On a phone with WebGPU it should be faster, but I haven't measured that, so I won't claim it.

The first real walk is Bully's. That was always the point: I build the engine, the Lorekeeper writes the world. When he takes it out, I'll post the Codex in the comments, including whatever the models get wrong.

Storyhouse: I built my grandmother somewhere for her stories to live

Penta Dank — Mon, 05 Oct 2026 02:13:42 +0000

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

What I Built

I built Storyhouse for my grandmother.

She's in her eighties, and she's living with early Alzheimer's. The hardest part isn't only the memories she may lose — it's realizing how many stories she's carrying right now. The Sunday peach pies her mother baked. The dance where she met my grandfather. The old blue Beetle with the heater that never worked. Eighty years of stories, and almost none of them written down. And fewer people around to tell them to than there used to be.

I didn't want to build another chatbot.

I wanted to build somewhere her stories could live.

Storyhouse is a local-first, voice-first AI companion and family memory archive. It sits in the room, listens while she talks, responds warmly, and quietly turns the meaningful moments into a structured, family-owned Memory Vault — connecting people, places, recipes, and decades into something the whole family can keep forever.

It is deliberately not a few things: not an Alzheimer's treatment, not a medical device, not a replacement for family, and never a fake relative pretending to be her granddaughter. It's a companion and a memory-preservation system — and it always nudges her back toward real people.

The interface isn't a chat window. It's a house you walk into: a Living Room to talk, a Library of preserved stories in her own words, a Gallery, a Life Timeline, and a Vault she (and the family) fully own. There's a read-only Family View so relatives can wander the archive, and a printable storybook PDF so her words can live on paper too.

She spent 80 years collecting stories. We built somewhere for them to live.

Demo

The demo runs in Demo Mode with a fictional woman, "Margaret," so no real family memory is ever exposed. Her seeded life is built to show the system actually thinking: ask it about "Grandpa's car" and it retrieves the right memory; it links the blue Chevrolet to teaching their son to drive; it holds an unfinished story to gently return to later; and it keeps a deliberately conflicting date ("1957"… "actually, maybe 1958") as two recollections — because it is not allowed to quietly decide which one is true.

Code

5thlegend / storyhouse

🏠 Storyhouse

A home for the stories that make us who we are.

Storyhouse is a local-first, voice-first AI companion and family memory archive. It listens to an elderly loved one tell the stories of their life, remembers them, connects them across the decades, and preserves them in a structured, family-owned Memory Vault — all powered by an open-weight Gemma model running locally, so the most private memories a family has never leave the device.

She spent 80 years collecting stories. We built somewhere for them to live.

The person I built it for

I built Storyhouse for my grandmother, who is in her eighties and living with early Alzheimer's.

The hardest part isn't only the memories she may lose. It's realizing how many stories she is carrying right now — about her mother's Sunday peach pies, the dance where she met my grandfather, the old blue…

View on GitHub

How I Built It

The intelligence is Google Gemma 3 (open-weight, 4B), running entirely locally via Ollama — no cloud, no API key, no bill. Gemma does the real work:

the warm companion responses (streamed token-by-token, so it feels like talking, not waiting),
memory extraction — turning a spoken passage into structured JSON (title, people, places, dates, emotions, themes),
entity extraction and novelty reasoning,
retrieval synthesis ("what did I tell you about Grandpa's car?").

Semantic memory search uses the open nomic-embed-text model, also local. Everything sits behind a provider abstraction, so the model is swappable and nothing is coupled to a vendor:

AIProvider
  ├── OllamaProvider   (Gemma — the open-source core)
  └── MockProvider     (honest offline fallback: the app still opens, the Vault still works)

It's a real memory system, not a prompt stuffed with history. Her words → embedding → cosine search over the vault → only the relevant memories are assembled into Gemma's context. The whole archive is never dumped into the model.

And the honesty rails are in the data model, not just the vibes:

Immutable originals — her exact words are stored once, never overwritten. A revised detail becomes a new recollection.
Provenance on everything — each fact is tagged DIRECT (her words), APPROXIMATE, FAMILY_REPORTED, DERIVED (AI inference), or GENERATED (AI art). The UI shows it; the AI is told to say "you told me…", never "it is true that…".
Never invent — if nothing relevant is retrieved, it says "I don't have that one yet — I'd love to hear about it," instead of making something up. If she says "1944," it keeps the year; it won't fabricate a day.
Consent — a story is kept only when offered and accepted. The microphone only listens when tapped.

For the whole family. A read-only Family View (passcode-unlocked) lets relatives browse the Library, Gallery, Timeline and Vault — but the Living Room, the microphone, and all editing stay private to her, and anything marked private is never shown. It's enforced on the server, not just hidden in the UI. It runs on the home device; for family far away, a Cloudflare Tunnel keeps the data on that device while making it privately reachable — no cloud database, ever. And the whole archive exports as a storybook PDF (her words, provenance, and the memory art embedded) or as JSON/Markdown — the family owns it, forever.

Memory art uses another open-weight model — Flux.1 schnell — hosted on Cloudflare Workers AI, which turns a scene she described ("an enormous orange tree, the light coming through all gold") into a labeled painting. It runs on Cloudflare's GPUs so it doesn't fight Gemma for the laptop's 6 GB. It's the one piece that calls out — disclosed in the app, and always labeled "AI-generated visual interpretation," never a real photograph.

Stack: React + Vite + Tailwind on the front, Node + Express on the back, and the Memory Vault in SQLite via Node's built-in node:sqlite (which, as a bonus, means zero native build step — a real gift on Windows without a C++ toolchain). A nice detail for small hardware: on a 6 GB laptop GPU, Gemma and the embedder were fighting for VRAM, so I pinned both resident with keep_alive and a boot warmup. Warm turns land in ~2 seconds.

Why Does Open Innovation Matter?

Because these are a dying woman's most intimate memories.

For this project, open-weight, local AI isn't a nice-to-have — it's the only ethically defensible architecture.

🔒 Private by construction. Her stories are processed on the device and stored in a local vault. Nothing is uploaded. A closed API would mean sending my grandmother's life to a company's servers.
✈️ Works offline. It runs on a laptop with no internet — and the roadmap puts it on her own phone, fully on-device, using Gemma 3n via Google AI Edge / MediaPipe.
💸 Free to run, forever. No per-token meter running while a grandchild keeps a grandparent's memory alive.
🔧 Ours to change. We own the weights. We can swap models or fine-tune on the family's own voice, because nothing is locked behind a vendor. Even the image model is open-weight (Flux.1) — the only thing we don't own is the GPU it briefly borrows.
🧭 Provable. Because I control the whole pipeline, I can show that her conversations never leave the device — not just promise it.

A closed API could have produced the conversation. It could not have produced the ownership. That difference is the entire point.

My Agent Session

I built this with Claude Code (and saved the session with DevRelay). Here's the real build — including the honest engineering saves: swapping a native SQLite dependency for Node's built-in node:sqlite when there was no C++ toolchain, pinning both models resident to stop VRAM thrashing on a 6 GB GPU, and catching the moment it fabricated a memory (a stale fallback embedding had broken retrieval) and hardening it so it can never invent her life.

Building Storyhouse: a local-first memory companion on open-weight Gemma

You

For the Hacktoberfest 'Build for a Friend' challenge: build Storyhouse — a local-first, voice-first AI memory companion for my grandmother (80s, early Alzheimer's) to preserve her life stories. Open-source AI must be at the core. Can it run open AI locally, and ideally on-device on her phone?

Agent

Yes — and Gemma is the ideal pick. Gemma 3 runs locally via Ollama now, and Gemma 3n is purpose-built for on-device Android (text + audio) via MediaPipe, so the same open model family can eventually run fully offline on her phone. For a weekend we'll ship a local-first web MVP (installable as a PWA), with on-device Android documented as Phase 2. Let me check the hardware first.

▸ bash nvidia-smi --query-gpu=name,memory.total --format=csv,noheader

Input

$ nvidia-smi --query-gpu=name,memory.total --format=csv,noheader

Output

NVIDIA GeForce RTX 4050 Laptop GPU, 6141 MiB

Agent

6 GB VRAM — enough for gemma3:4b (quality sweet spot) plus a small embedder. Pulling both open models.

▸ bash ollama pull gemma3:4b && ollama pull nomic-embed-text

Input

$ ollama pull gemma3:4b && ollama pull nomic-embed-text

Output

gemma3:4b (3.3 GB) + nomic-embed-text (274 MB) pulled

▸ bash curl ollama /api/chat gemma3:4b 'Reply: ready'

Input

$ curl ollama /api/chat gemma3:4b 'Reply: ready'

Output

reply: 'Ready!'  |  gen ~23 tok/s warm

Agent

Open core confirmed. Architecture: React + Vite + Tailwind client; Node + Express API; a real Memory Vault in SQLite (not chat logs). Every model sits behind an AIProvider abstraction (OllamaProvider for Gemma + an honest MockProvider fallback) so the open model is the core and nothing is coupled to a vendor. Scaffolding the server, DB schema, provider layer, memory store, and the fictional 'Margaret' demo seed.

Agent

First real snag: better-sqlite3 tried to compile from source and failed — no Visual Studio C++ toolchain on this Windows machine.

▸ bash npm install

Input

$ npm install

Output

gyp ERR! find VS — Could not find any Visual Studio installation to use (better-sqlite3 rebuild failed)

Rather than make the user install a multi-GB compiler, I switched to Node's built-in node:sqlite (--experimental-sqlite) — same synchronous API, zero native build. A nice side effect: the project now installs clean on any machine with no toolchain.

Agent

Second snag, specific to small VRAM: the first conversation turn timed out and retrieval came back empty. Gemma (~5 GB) and the embedder were evicting each other between turns. Checked residency:

▸ bash ollama ps

Input

$ ollama ps

Output

gemma3:4b 100% GPU + nomic-embed-text 100% GPU  |  GPU 5.5/6.1 GB — both fit!

They fit together; the models were just unloading on the default keep_alive. Fix: pin both resident with keep_alive:'30m' on every call + a boot warmup. Warm turns now land in ~2–4 s.

Agent

Core loop working end-to-end. The companion is grounded ONLY in retrieved memories (embed the query → cosine search the vault → assemble just the relevant memories → Gemma). Tested:

▸ api POST /conversations/:id/messages { text: "Do you remember what I told you abo...

Input

POST /conversations/:id/messages { text: "Do you remember what I told you about Grandpa's car?" }

Output

Storyhouse: "You mentioned… Harold's blue Chevrolet. Is that what you were thinking of?"  |  grounded on: Teaching their son to drive (0.62), The old blue Chevrolet …

Agent

Memory extraction: Gemma turns a spoken passage into a structured, provenance-tagged memory — never a raw transcript, never inventing facts.

▸ api POST /consolidate { text: "My sister Eleanor and I walked to the schoolhouse ...

Input

POST /consolidate { text: "My sister Eleanor and I walked to the schoolhouse in Cedar Falls every morning in 1944, even in the snow..." }

Output

TITLE: Morning Walks to School | ENTITIES: person:Eleanor, place:Cedar Falls, place:schoolhouse, event:walking to school | THEMES: family, childhood | CONFIDENCE: DIRECT

Agent

Honesty rails are in the data model, not just prompts: immutable originals (a revised date becomes a SECOND recollection — both kept, never silently chosen), provenance tags on every fact (DIRECT / APPROXIMATE / DERIVED / GENERATED), never-invent-date-precision (I clamp year-only dates so '1944' never becomes a fabricated day), consent-to-save, mic-only-on-tap, and AI art always explicitly labeled as an interpretation.

Agent

Verified the UI live in the browser: the warm 'Memory House' renders with a breathing presence orb ('I'm here.'), a Gemma-online indicator, the Living Room conversation, and the Library showing memory cards with 'Her words' provenance badges and entity chips. Then shipped it: wrote the README + docs + MIT license, committed, and pushed a public repo.

▸ bash git commit && gh repo create storyhouse --public --source=. --push

Input

$ git commit && gh repo create storyhouse --public --source=. --push

Output

https://github.com/5thlegend/storyhouse — public, main branch, 54 files

You

Why does the open-source approach matter here, honestly?

Agent

Because these are a dying woman's most intimate memories. Local, open-weight AI is the only architecture that keeps them on the device (nothing uploaded), works offline, costs nothing to run, and lets the family own, swap, or fine-tune the model with nothing locked behind a vendor — and because I control the whole pipeline, I can PROVE nothing leaves the device rather than just promise it. A closed API could produce the conversation; it could not produce the ownership. That difference is the entire point of Storyhouse.

Prize Categories

Gemma — the open-weight Gemma model is genuinely the core intelligence of the app (conversation, memory extraction, entity reasoning, retrieval), run locally. I've deliberately not claimed partner categories for tech I didn't actually use.

Built by Next Realm Interactive. For my grandmother — and for everyone's.