DEV Community: hongpengtan0-max

An AI invented half the memories on an ofrenda card. Ofrenda Keeper writes down only what you said, and asks about the rest

hongpengtan0-max — Wed, 28 Oct 2026 07:43:02 +0000

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

Prize categories: Best Use of Gemma, Best Use of Mastra

What I Built

I asked Gemma 3 to make a Día de los Muertos ofrenda card for "Grandpa Hiro", a made-up grandfather from my test set. All I told it was that he taught me chess on a board with a missing knight replaced by a bottle cap, and that he liked jazz, "but I can't remember which records."

The card came back with:

a surname I never gave him (Tanaka)
favorite foods: mochi, sushi, tempura, green tea ice cream
favorite artists: Miles Davis and Ella Fitzgerald
three wise sayings he never said
"the scent of his pipe tobacco"

That last one is the ghost in the machine: a voice that sounds like memory but belongs to nobody.

On an ofrenda, a made-up detail is worse than a blank line. So I built Ofrenda Keeper, a local app that turns what you tell it about someone you miss into an altar card. Its one rule: if you didn't say it, it doesn't go on the card. If you weren't sure, it asks you instead of guessing.

Every detail on the card carries the exact words it came from (hover to see them).
When you hedge ("I think the green tamales, but maybe that was my mom"), the detail is held back and becomes a question.
Missing pieces (a song, a saying, the years) become gentle follow-ups, not filler.
A button shows what the same model would have written without the guard, so you can see the difference.

All the memories in this post, the demo and the test set are fictional samples I wrote for testing. I didn't want to put a real person's story into a project I was still debugging.

Demo

▶️ Video (about 2 min, recorded on a CPU-only box, real model latency): docs/demo.mp4

In the demo I type a fictional memory: "My grandmother Lucía made pan de muerto with orange zest… She liked boleros, I think, but I'm not sure which ones."

Pan de muerto and orange zest go on the card.
Boleros do not. They show up under "I'd like to ask you" instead.
When I add "She always said 'Ya llegará.' She kept her rosary in a cookie tin", the saying and the rosary appear, each with its quote.

The "What would an unguarded AI write?" button asks the same Gemma model with a plain "fill every field" prompt. It immediately adds "a picture of Lucía wearing a bolero", "orange blossoms representing her love of orange zest", and more.

Code

hongpengtan0-max / ofrenda-keeper

Turn memories of someone you miss into a Día de los Muertos ofrenda card, locally, without the AI inventing a single detail. Mastra + Gemma 3 via Ollama.

🕯️ Ofrenda Keeper 🌼

Tell it about someone you miss, and it builds a Día de los Muertos ofrenda card from only the things you actually said. Anything it is unsure about becomes a gentle question, not a made-up detail.

It runs entirely on your own machine: Gemma 3 4B (open weights) served by Ollama, orchestrated by Mastra (agent + memory + tools + workflow). There are no API keys, and your family's stories never leave your computer.

Demo video (about 2 min): docs/demo.mp4. The sample memory in the demo is fictional.

Why

If you ask an LLM to "make an ofrenda card for my grandmother", it will happily give her favorite songs, sayings and foods she never had. On our fictional test set, 49.7% of the claims an unguarded Gemma 3 4B made about the person were invented. On a remembrance card, an invented memory…

View on GitHub

How I Built It

Stack, all open and all local:

Gemma 3 4B (Q4_K_M GGUF) running in Ollama on CPU, about 9 tokens/s on the 8-core box I built it on.
Mastra: an Agent with Memory (LibSQL file), two createTool tools, and a two-step createWorkflow.
Express plus one HTML file for the altar card.

The pipeline, run every time you share a memory:

Remember. The Mastra agent replies in a sentence or two and asks one question. Mastra Memory stores the thread, so the card is always rebuilt from everything you've said, not from the model's last reply.
Extract (workflow step 1). Gemma gets only your own messages and must return each detail with a verbatim quote.
Verify (workflow step 2). The verify-quote tool checks, in plain code:
- the quote really exists in your words;
- the detail doesn't go beyond the quote;
- the sentence wasn't hedged ("I think", "maybe", "I can't remember").

Anything that fails goes to the ask-follow-up tool and becomes a question.

One honest design note: Gemma 3 through Ollama doesn't do reliable native tool calling. So the Mastra tools are executed by the workflow steps, not picked by the model. I ended up liking that. The guard is code the model can't talk its way around, not a polite request in a prompt.

Does the guard actually work? I measured it.

I wrote 12 short fictional memories with a few certain details each, and hedges in some ("I don't remember what music she liked"). Each one went through both the plain prompt and Ofrenda Keeper, once each, on the same model. Then an AI coding assistant labeled every detail against the source text, using a fixed rubric in the repo: grounded, embellished, invented, or generic decoration. I reviewed every label and the underlying result files before publishing the numbers.

	Unguarded prompt	Ofrenda Keeper
Claims about the person	167	61
Invented claims	83 (49.7%)	0
Cards with ≥1 invented claim	11 of 11 that parsed	0 of 12
Misattributed (right words, wrong person)	–	2 (3.3%)
Key details captured	87.5%	91.7%
Follow-up questions per card	0	4.5
Seconds per card on CPU	26.1	12.6

The unguarded cards also had 110 generic decorations (candles, marigolds, "Unknown"). I didn't count those as lies.

Where it still fails:

Two misattributions got through. In one memory, "I always carried books" became the neighbor carrying books. In another, Lucía carrying "my mother" became "her mother". Word overlap can't tell who did what, so the card still needs a human read-through. I say so in the UI.
It is sometimes too strict. "He liked jazz, but I can't remember which records" got the jazz held back entirely, because the sentence contains a hedge. That costs you one extra question, not a false memory, which is the trade-off I want here.
The first version was useless. It captured only 37.5% of key details, because Gemma invented its own field names ("activities") and my code silently dropped them. Mapping field names fixed that. Better stemming then cut over-strict rejections from 9 to 3. All three result files are in the repo.

Twelve memories is a small test. The assistant applied the rubric to every detail; I reviewed those labels and am responsible for the numbers. The rubric, the raw outputs, and every label are in eval/ for anyone who wants to check the work.

Why Does Open Innovation Matter?

The stories stay home. Memories of someone who died are the most private data I can think of. Here they go into a SQLite file on your own disk and a model running on your own CPU. Nothing is uploaded, and nothing becomes training data for someone else.
It works with the lights off. Once the GGUF is downloaded, the whole thing runs offline. That suits sitting with a grandparent who has no Wi-Fi, or an altar that should outlast any startup's free tier.
I could put the guard in the right place. Because the model and the orchestration are open, the fabrication check lives in my code, between the model and the card. With a closed chat product, I could only ask nicely in a prompt, and the unguarded column above shows how that goes.
It costs nothing to run. That matters for something you might open once a year, every November.
It's swappable. Change OFRENDA_MODEL to a bigger Gemma when you have the RAM. The eval tells you whether it got better or just more confident.

AI assistance disclosure

I built this with an AI coding assistant. It wrote most of the code, the eval scripts, the demo recording script, and the first draft of this post. It also applied the eval rubric in the repo to label every unguarded and guarded detail against the source text (277 unguarded details; 61 guarded details plus verifier rejections). I directed the project, reviewed every label and the result files against that rubric, and am responsible for what is published here. All test memories are fictional, and no real person's story was used.

GigPitch: I lost 15 logo contests in a row, so I built a local AI that writes my bids

hongpengtan0-max — Thu, 15 Oct 2026 08:06:49 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

Since October 4, I've been trying to earn my first money as a freelance logo designer on 猪八戒 (Zhubajie), China's largest gig marketplace. I entered 15 logo design contests (比稿) and won zero of them. Total earnings: ¥0.

Looking back, the designs weren't the main problem. The problem was everything around them: reading vague briefs, guessing a price, and writing the same bid again and again in Chinese and English, often at 2 a.m. Every losing contest cost me an hour of unpaid admin work.

GigPitch is the tool I wish I'd had from day one. You paste a gig brief from 猪八戒, Upwork, Fiverr, or anywhere else, and about 20 seconds later you get:

Brief analysis: brand, industry, style keywords, whether VI or packaging is needed, urgency, and budget
A quote suggestion: calculated by transparent rules, with every line of the reasoning shown, and a warning when the client's budget is below it
Bilingual bid text in 中文 and English, citing my own most relevant portfolio cases
A deliverables checklist (formats and versions), so scope is clear before the client says yes
Three logo concept prompts to kick off the actual design

Who would pay for it? Solo designers and small studios who bid on many small jobs. Saving 30 to 45 minutes per bid is worth far more than a small monthly fee, and because the tool runs locally, it costs almost nothing to operate.

Demo

Code

hongpengtan0-max / gigpitch

Local open-source AI bid assistant for freelance designers (Mastra + Gemma)

GigPitch 🎯

A local bid assistant for freelance designers. Paste a gig brief from 猪八戒, Upwork, Fiverr, or anywhere else. GigPitch returns:

Brief analysis: brand, industry, style keywords, whether VI is needed, urgency, budget
Quote suggestion: computed by transparent pricing rules (not invented by the model), with the reasoning shown
Bilingual bid text: one Chinese and one English draft, citing your own matched portfolio cases
Deliverables checklist: file formats and versions
Logo prompt ideas: three concepts for an image generator

Everything runs on your own machine: Gemma 3 (open weights) served by Ollama, orchestrated by a Mastra workflow. No API keys, no per-token bills, and client briefs never leave the machine.

Built for the DEV × Hacktoberfest 2026 Open-Source AI Challenge, Week 2 ("Side Hustle").

Architecture

brief ─▶ [Mastra step: analyze]  Gemma 3 → JSON (tolerant parser + rule guards)
      ─▶ [Mastra step:

…

View on GitHub

MIT licensed. Run it with ollama pull gemma3:1b && npm install && npm start.

How I Built It

Model: Gemma 3 (open weights), run locally with Ollama. I used gemma3:1b because my box only had about 3 GB of free RAM, and it runs CPU-only at roughly 44 tokens per second. With more memory, switching to gemma3:4b is a single environment variable.
Orchestration: Mastra. GigPitch is a Mastra createWorkflow with three createSteps around a Mastra Agent backed by Gemma (via ollama-ai-provider-v2):
1. analyze: Gemma extracts structured JSON from the brief.
2. quote: a deterministic pricing function plus retrieval from my portfolio file (cases.md). I deliberately kept money out of the model's hands.
3. write: four Gemma calls in parallel (Chinese bid, English bid, checklist, prompts).
Making a 1B model reliable. Small models return almost-valid JSON (I got a stray curly quote ” that broke JSON.parse) and sometimes miss obvious facts. The fixes:
- a tolerant, field-by-field JSON recovery parser
- rule-based guards for VI, urgency, budget (including $ budgets converted to ¥), and brand names in 「」 or quotes
- prompt rules plus post-filters: no self-praise like "经验丰富" or "experienced", no Chinese characters in the English bid, prices in the right currency, one - [ ] checklist format, no [Client Name] placeholders, and no claims that drafts already exist
UI: one HTML file and a small Express endpoint. npm test runs the whole workflow end to end.

Why Does Open Innovation Matter?

Cost decides whether the business works. My actual revenue so far is ¥0. A side hustle that loses money on API calls before it lands its first client is not a side hustle. With open weights on my own CPU, each extra bid costs nothing.
Client data stays private. Briefs include unreleased brand names and business plans. Nothing leaves the machine, which I can tell clients truthfully.
No lock-in, works across borders. I'm moving between China and the US, and not every closed API works or bills smoothly in both places. Ollama + Gemma + Mastra works the same anywhere and keeps working even if a vendor changes its pricing.
Small models are good enough when the system is designed well. With deterministic pricing and rule guards, a 1B open model handles a real niche task, and I can fine-tune it later on my own winning bids.

Prize Categories

Best Use of Mastra: the whole pipeline is a Mastra workflow (createWorkflow / createStep) around a Mastra Agent on an open model.
Best Use of Gemma: Gemma 3 runs locally through Ollama and handles every language task.

Built with help from an AI coding assistant; I directed the design and tested the outputs.