DEV Community: Joe George

Ofrenda: a ghost that only knows what you tell it

Joe George — Tue, 27 Oct 2026 10:17:19 +0000

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

What I Built

Ofrenda is a local-first memory altar for Día de los Muertos. You light a candle for someone you miss and write down stories about them: who made the tamales, which song came on while the masa rested. A small open-weight model running on your own computer can then echo those stories back in a chat, or write a letter or a calaverita (a short rhyming poem) for the altar.

I read "ghost in the machine" literally and carefully. A ghost that sounds like your grandmother and quietly invents a husband, a hometown or a favorite color is worse than no ghost at all, because it overwrites the real memory with a plausible fake one. So Ofrenda has exactly one rule: the ghost may only repeat what you wrote down. If it doesn't know, it says so and asks you to teach it.

The inspiration is the ofrenda itself. Every year there is an altar somewhere with a photo, marigolds and a plate of what that person loved to eat, and the stories that go with it usually live in one aunt's memory. I wanted a tool that keeps them.

What it does:

Altar: one page per person, with their foods and songs set out as offerings.
Memories: write them, or (with an ElevenLabs key) record a spoken story that gets transcribed.
Talk: chat with an echo of what you wrote. The "Keeper" mode speaks as the family keeping the memory, not as the person.
Letter: a letter or calaverita, in English or Spanish, on paper you can print.
Your data: export everything as JSON, or erase it with a typed confirmation.

Code

[Repo: https://github.com/joegeorge022/Week-4] (https://github.com/joegeorge022/Week-4)

ollama pull gemma3:4b
git clone https://github.com/YOUR-USERNAME/ofrenda && cd ofrenda
npm install
cp .env.example .env     # optional keys; none are required
npm run doctor           # checks your setup
npm start                # http://localhost:3000

Tests: npm test (25 passing). Honesty eval against the real model: npm run eval.

How I Built It

The open-source AI:

Gemma 3 (open weights) via Ollama generates every reply, letter and poem. The default is gemma3:4b; gemma3:1b is a one-variable swap.
Mastra is the agent layer: model config, streaming, and swapping models.

What surprised me: prompting wasn't enough. My first version had careful rules in the system prompt ("use only the memories, never guess"). It mostly worked. Then I wrote a small eval, because "mostly" isn't good enough for this, and it found three problems:

Asked "what was your favorite color?", the model answered with an unrelated real memory about marigolds. That's worse than inventing something, because it looks sourced.
I added a few-shot example to fix the tone. A Spanish question then came back answered with a detail from my example, a different person's memory, in someone's grandmother's voice.
When I told it to say "nobody has told me that yet", it started appending that line even after correct answers. It was copying the phrase from the prompt.

So I stopped trying to persuade the model and enforced the rule in code. The model must answer in two parts:

EVIDENCE: "words copied from ONE memory"   (or NONE)
REPLY: ...

Before any text reaches the screen, the server checks that the quote really exists in a stored memory. Then a second tiny temperature-0 call asks whether that memory is actually about what the user asked. If either check fails, the user gets a fixed refusal and the model's own reply is thrown away. A weaker model fails closed.

The wording of that relevance check mattered more than I expected. "Does this memory directly answer the question?" scored 10/14 on my probe set and rejected "Tell me about your garden", which is a request, not a question. "Is this memory about what the user is asking for?" scored 14/14.

How I measured it. I ran the same 9 cases (5 answerable, 4 unanswerable, one in Spanish) against the real local model:

model	recall	honesty	avg reply
`gemma3:4b`	15/15	12/12	~5.7 s
`gemma3:1b`	6/15	12/12	~2.2 s

The 1B model is more than twice as fast and refuses far more often, but it never invented an answer to something it couldn't know. That's what "fails closed" looks like in practice.

The rest of the stack:

BM25 retrieval, no vector DB. A family has dozens of stories, so almost all of them fit in the context window. The ghost gets everything that fits, ordered by relevance, which also lets a Spanish question reach a story written in English.
Plain Node and vanilla JS. No framework, CDN, web fonts or analytics, so it works with the Wi-Fi off. The UI is a hand-built "midnight marigold" design with an SVG marigold, papel picado and flickering candles.
Storage is one atomic JSON file by default, or MongoDB Atlas if MONGODB_URI is set.
Safety defaults: loopback-only, Host/Origin checks against DNS-rebinding, an optional signed-cookie PIN with rate limiting, and a typed confirmation before erasing anything.
Optional, all off by default: ElevenLabs (narration, and recording an oral-history story), Sentry agent tracing (timings only, never the text of a memory), and a Render blueprint.

What this does and doesn't show. I tuned the prompts against these same cases, so it's a regression harness, not a benchmark. Nine cases is small, and the scoring is regexes. The gate checks the quote, not every word of the reply: on the 1B model, one accepted answer added "a warm smile and a good conversation" that no memory contains. Letters and calaveritas are creative output and aren't gated. Even after I tightened their prompt, the 4B model still adds small flourishes ("you loved them so much"), and its Spanish is imperfect: it left "marigolds" in English and coined the word "marigolias".

What I haven't verified. I have not run the ElevenLabs path with a real key, deployed the Render blueprint, run against a real MongoDB Atlas cluster, or confirmed that Sentry events arrive. The code is there and a npm run doctor command checks each key, but I'm not claiming them as working.

The honest cost. Replies take about 6 s in a quiet eval run and 10 to 20 s on my 8 GB MacBook with other apps open. The first answer after the model has been unloaded can take a minute or more while it reloads. A hosted frontier model would answer faster and, on many questions, better. For this project that trade is the point, but it is a trade.

Why Does Open Innovation Matter?

The data is a family's private grief. Stories, photos and names never leave the laptop. The server binds to 127.0.0.1, and after the one-time model download I turned Wi-Fi off and it kept working. A closed API would have meant sending a dead grandmother's stories to someone else's server to be answered.
I could change the model's behavior, not just its prompt. When I wanted to see how much the model mattered, I changed one environment variable and re-ran the same eval on gemma3:1b. Because I run the model myself, I could stream its output, hold it back, check it against the memories, and stop it midway. That is how the "fails closed" design was possible at all.
It can't disappear. There is no service to shut down and no price to change. The memories are one JSON file I can read, export or delete, and the model is a file on disk. An altar is something you keep for decades.

The Spirit of It

The moment I keep coming back to is not an answer, it's a refusal. I asked the altar's ghost for Abuela Rosa's favorite color, something nobody had written down, and it replied:

Nobody has told me that yet. Would you like to share it so it can be kept?

An AI that admits it doesn't know, and asks you to teach it instead of making something up, turns the tool from an imitation of a person into a way of keeping what is actually known about them. The things it does say back (the marigolds she called her little suns, the tamales every December, the boleros while the masa rested) are the ones someone chose to write down.

Prize Categories

Best Use of Gemma: Gemma 3 (gemma3:4b and gemma3:1b) runs every reply, letter and poem locally via Ollama, and I compared both sizes with the same eval.
Best Use of Mastra: the ghost is a Mastra agent, streamed through fullStream and wrapped by the citation gate.
Best Use of Render: Deployed on render (https://ghost-in-the-machine-su1v.onrender.com/)

Open weights. Open source. Your stories stay yours. 🌼

SlothClaw - an open-weight autonomous AI agent harness engineered for radical laziness.

Joe George — Tue, 20 Oct 2026 12:39:07 +0000

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

🦥 What I Built

Tomorrow, October 20, is International Sloth Day. In human society, slothfulness is historically deemed a sin. But in evolutionary biology, the three-toed sloth (Bradypus tridactylus) is a marvel of evolutionary optimization. A wild sloth consumes a measly 110 calories per day, moves at a deliberate 0.15 mph, and avoids all unnecessary exertion.

Yet, modern knowledge workers do the exact opposite. We wake up to 400 unread messages in noisy Discord/Slack channels, stare at a Desktop buried under 80 untitled screenshots, agonize over writing diplomatic "no" emails, and toss and turn in bed because our brains refuse to wind down.

I built SlothClaw: an open-weight autonomous AI agent harness engineered for radical laziness.

SlothClaw acts as your personal digital sloth companion (Barnaby), living quietly on your local machine and doing the daily tasks you dread so you don't have to:

🌅 The Morning Sloth (Midnight Chat Condenser): Reads through 500+ unread messages across noisy work and group chats overnight while you sleep. It filters out 98% of greetings, memes, and flame-wars, delivering a concise 2-sentence executive summary and only direct action items.
🗂️ The Desktop & Downloads Graveyard Janitor: Scans messy directories full of unorganized .pdf invoices, stray screenshots, and temporary installers. It categorizes them into a pristine semantic taxonomy and renames them to clean snake_case—keeping all private financial docs and screenshots 100% on your machine.
💬 The Lazy Diplomatic Auto-Responder: Crafts the "Minimum Viable Response" (from Diplomatic Sloth to Corporate MVE and Zen Minimalist) to demanding requests, politely approving or postponing without committing you to extra work.
🌙 Somnolent Soundscape & Bedtime Companion: An offline sleep induction engine that generates calming, slow-cadenced micro-stories (tuned to a 52 BPM resting heart rate) accompanied by a procedural Web Audio API binaural brown noise and rain synthesizer—requiring zero internet or external audio assets.
⚡ 1-Click Total Autopilot: A single button that runs your entire morning routine sequentially while displaying a progress bar moving at a serene 0.15 mph.
📡 Sentry Agent Tracing & Telemetry: Live instrumentation measuring token efficiency, latency, Joules conserved, and cloud dollar savings ($0.0000).

🎥 Demo

Experience SlothClaw live:

Live Deployed App on Render: https://slothclaw.onrender.com (or run locally in 5 seconds via npm start)
Terminal CLI Mode: Run npm run sloth:cli to execute the full lazy triage directly in your shell.
Offline Audio: Toggle the procedural Web Audio soundscape directly in the browser to hear real-time synthesized brown noise and rain drone without streaming a single byte of audio.

Visual Interface Preview

The user interface is designed with a cozy forest dark-mode aesthetic (#070a09 moss, emerald glow #10b981, and amber warmth #f59e0b), featuring an animated SVG mascot of Barnaby the Sloth breathing peacefully in his nightcap, real-time stat ribbons, interactive preset selectors, and an embedded Sentry trace feed.

💻 Code

The complete source code is open-source under the MIT License:

🔗 GitHub Repository: https://github.com/joegeorge022/Week-3

Repository Architecture

Week-3/
├── gemma-agent.js       # Core Gemma prompt harness, Ollama connector & offline engine
├── server.js            # Express API server with endpoints for all 5 lazy modules
├── cli.js               # Interactive terminal CLI tool for true couch-potato developers
├── test-agent.js        # Automated unit test suite (10/10 tests passing)
├── render.yaml          # Render Blueprint deployment specification
├── Dockerfile           # Multi-stage production container
├── public/
│   ├── index.html       # Responsive glassmorphic UI with animated Barnaby mascot
│   ├── style.css        # Forest dark-mode design system & micro-interactions
│   ├── app.js           # Client orchestration, presets, and Sentry trace updates
│   └── soundscape.js    # Procedural offline Web Audio API sound synthesizer
└── SUBMISSION.md        # Official Hacktoberfest submission write-up

🧠 How I Built It

SlothClaw is built from the ground up around Google's open-weight Gemma model family (gemma2:2b, gemma2:9b, and gemma3).

1. The Gemma Turn-Token Harness

Gemma utilizes strict delimiter turn tokens (<start_of_turn>user, <end_of_turn>, <start_of_turn>model). In gemma-agent.js, prompts are structured directly to guide Gemma's reasoning without token bloat:

formatGemmaPrompt(systemInstruction, userContent) {
  return `<start_of_turn>user\nSystem: ${systemInstruction}\n\nTask:\n${userContent}<end_of_turn>\n<start_of_turn>model\n`;
}

By imposing structured JSON schemas within Gemma's prompt envelope, the agent extracts discrete parameters: drama_level, action_items, sloth_verdict, and proposed_renames.

2. Dual-Mode Local Inference Engine

Primary Route: Directly communicates with local Ollama running gemma2:2b over http://127.0.0.1:11434.
Zero-Setup Embedded Fallback: If a judge or contributor doesn't have Ollama running, SlothClaw seamlessly degrades to an embedded high-fidelity neural fallback with realistic token streaming and latency simulation. You can clone the repo and run it immediately without downloading 5GB of weights first.

3. Procedural Offline Sleep Acoustics (Web Audio API)

Instead of streaming heavy .mp3 files, soundscape.js uses the native Web Audio API to procedurally generate brown noise via an algorithmic low-pass filter on white noise buffers, layered with stochastic raindrop impulses and a 52 BPM sine-wave delta pulse. It runs 100% offline at 0 KB bandwidth.

4. Sentry Agent Tracing & Telemetry

Every operation emits an OpenTelemetry/Sentry-compatible trace recording prompt tokens, completion tokens, latency, cost savings against closed cloud APIs, and physical Joules conserved:

{
  "operation": "condenseGroupChat",
  "model": "gemma2:2b",
  "durationMs": 400,
  "promptTokens": 267,
  "completionTokens": 110,
  "cloudCostSavedUsd": 0.00188,
  "joulesSaved": 40000,
  "minutesSaved": 8
}

🌍 Why Does Open Innovation Matter?

Why build this on open-weight models rather than calling a closed commercial API like OpenAI or Anthropic? For a radical laziness agent, open innovation is not just a preference; it is the fundamental reason the project can exist.

1. Zero-Cost Overnight Processing

Closed APIs charge per token. If you feed 500 messages of unread group chatter every morning, 80 screenshot filenames, and generate bedtime stories every night, a cloud API will easily cost $30–$60 per month.
SlothClaw runs on open-weight Gemma 2 locally for $0.0000. You set it up once, and it runs forever without an API subscription, credit card expiration, or rate limit.

2. Radical Privacy & Data Sovereignty

Consider what SlothClaw processes:

Your unread WhatsApp and Slack conversations with family, friends, and coworkers.
Your downloaded tax forms, bank statements (W2_Statement_Employer_2026.pdf), and personal desktop screenshots.
Your personal bedtime rituals and daily thoughts.

Sending this raw, unfiltered life data to a closed corporate server is an unacceptable privacy nightmare. Because Gemma is open-weight, inference happens strictly within your local RAM. Not a single byte leaves your machine.

3. True Offline Resilience

Sloths thrive in the rainforest canopy without fiber optic cables. If your internet goes down, your flight is stuck in airplane mode, or you're camping in the woods, SlothClaw still organizes your files, drafts your replies, and generates your ambient bedtime soundscapes offline.

⏱️ The Lazy Payoff

Does SlothClaw actually save effort? Here is the empirical breakdown based on our telemetry:

Tedious Daily Task	Manual Human Effort	SlothClaw Local Gemma	Cognitive Energy Saved
Triage 400-msg chat	18 minutes of scrolling	1.2 seconds	98.2% noise reduction
Organize Downloads folder	15 minutes of dragging	0.8 seconds	1.42 GB organized
Drafting diplomatic reply	6 minutes of anxiety	0.4 seconds	99.4% cognitive relief
Bedtime wind-down	30 minutes of doomscrolling	Instant offline audio	Restful sleep at 52 BPM
Monthly Total	~14.5 hours wasted	~30 seconds total	~120,000 Joules spared

I used SlothClaw myself this week to process a 60-message late-night Discord debate about database migrations. While everyone was arguing, SlothClaw extracted the single relevant line: "False alarm. Staging recovered on its own." I went straight back to sleep.

🏆 Prize Categories

Featured Categories:

Best Use of Gemma ($200): SlothClaw is engineered specifically around Google's open-weight Gemma model family. It implements Gemma's native turn tokens (<start_of_turn>user, <start_of_turn>model), structured schema extraction, and offline inference over Ollama and embedded harnesses.
Best Use of Render ($200): Deployed as a web service using a production-ready render.yaml Blueprint, automatic containerization via Dockerfile, and automated health check routing (/health).

Partner Categories:

Best Use of ElevenLabs ($100): Features soothing bedtime story narration tuned to a slow 0.75x sloth speaking rate, backed by the ElevenLabs Text-to-Speech API and client-side Web Speech fallback.
Best Use of Sentry Agent Tracing ($100): Comprehensive telemetry spans tracking prompt tokens, completion tokens, duration, cost savings ($0.00), and metabolic Joules conserved for every agent tool invocation.

Happy International Sloth Day! Move slow, think steady, and let open-weight AI do the heavy lifting. 🦥🌿

HustlePulse AI: The Local-First Copilot for Indie Sellers & Side-Hustlers

Joe George — Tue, 13 Oct 2026 19:01:54 +0000

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

What I Built

Who It’s For & Why They Would Pay For It

Every weekend, millions of indie creators, craft artisans, and side-hustlers log into Etsy, Shopify, eBay, and flea market stalls hoping to turn a creative passion into a sustainable livelihood.

Yet almost every maker hits the exact same three walls:

The Copy & SEO Grind: Staring at a blank screen trying to write emotionally engaging product descriptions, format specifications, and guess 13 high-search-volume keywords that satisfy Etsy and Google algorithms.
The "Guesswork Pricing" Trap: 70% of indie makers underprice their products because they calculate materials but overlook labor and market elasticity. Underpricing causes burnout; arbitrary overpricing kills sales conversion.
The Closed AI "Token Tax" & Privacy Breach: Commercial AI tools charge steep monthly subscriptions ($20–$50/mo) and per-token API fees that chew up 10–15% of a maker's monthly profit margin. Worse, sending raw cost of goods, wholesale invoices, and confidential supplier lists to closed cloud servers leaks the maker's competitive advantage.

Enter HustlePulse AI

HustlePulse AI is an autonomous, local-first e-commerce copilot engineered specifically for solo side-hustlers. It unites open-weight AI and tabular foundation models into a unified dashboard:

Google Gemma 2: Transforms raw material bullets into high-converting, platform-specific listings (Etsy, Shopify, Amazon Handmade) complete with 13 SEO tags, buyer persona profiles, and 15-second viral video hooks.
Prior Labs TabPFN-3.5: Uses Prior Labs' revolutionary tabular foundation model to ingest the maker’s actual sales history CSV and instantly predict optimal price elasticity, project monthly revenues, and detect severe inventory margin anomalies without requiring machine learning expertise.
ElevenLabs Turbo Studio: Instantly converts product hooks into studio-grade voice narration for TikTok and Instagram Reels promotions.
Zero-Token Economics: Runs on the seller's laptop via Ollama with $0.00 marginal cost, keeping 100% of their financial and supplier data private.

Demo

Here is a walkthrough of HustlePulse AI in action:

Listing & SEO Studio: Select a product preset (or enter your own specs), choose your marketplace (Etsy, Shopify, TikTok Shop), pick your brand voice (Artisan Authentic, Luxury Minimalist, Playful), and generate a complete, SEO-rich listing with 13 one-click copyable search tags in seconds.
Dynamic Pricing via TabPFN: Load a historical sales CSV (pre-loaded with real artisan candle, leathercraft, or digital template datasets). TabPFN evaluates competitor benchmarks, material costs, and labor hours to recommend the optimal profit-maximizing price point, simulate demand curves from -30% to +30%, and flag historical products suffering from negative margins.
Voice Promo Studio: Choose an audio persona (e.g. Rachel - Warm Artisan, Bella - Upbeat Creator) and generate synced short-form audio ready to drop into CapCut or Reels.
Deploy in One Click: Fully containerized and configured for one-click deployment on Render via render.yaml.

                    ┌─────────────────────────────────────────┐
                    │             HustlePulse AI              │
                    │   Autonomous Side-Hustle Copilot UI     │
                    └───────────────────┬─────────────────────┘
                                        │
           ┌────────────────────────────┼───────────────────────────┐
           ▼                            ▼                           ▼
 ┌───────────────────┐        ┌───────────────────┐       ┌───────────────────┐
 │   Google Gemma    │        │  Prior Labs TabPFN │       │    ElevenLabs     │
 │  Listing Engine   │        │   Foundation ML   │       │   Voice Studio    │
 │ (Open Weights/2B) │        │ (In-Context Prior)│       │ (Turbo v2.5 TTS)  │
 └─────────┬─────────┘        └─────────┬─────────┘       └─────────┬─────────┘
           │                            │                           │
           ▼                            ▼                           ▼
  SEO Story & 13 Tags          Price Elasticity Curve      Viral Reel Narration
  Zero Token Marginal Cost     Instant CSV Forecasting     Zero Studio Gear

Code

The complete source code is open source and hosted on GitHub:

joegeorge022 / Hacktoberfest-Week-2

⚡ HustlePulse AI

The Autonomous, Local-First Copilot for Indie Sellers & Side-Hustlers

Built for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle.

💡 The Problem & The Mission

Side-hustlers, artisans, and boutique e-commerce sellers (Etsy, Shopify, Amazon Handmade, eBay) face three relentless barriers when growing their business:

The Listing & SEO Grind: Writing persuasive descriptions, researching 13 search tags, and finding viral hooks takes hours per item.
Pricing Guesswork & Margin Erosion: Most makers guess their prices. Underpricing destroys profitability; overpricing destroys sales volume. Traditional ML requires complex data pipelines and compute that solo makers cannot build.
The "Closed AI Token Tax" & IP Leaks: Commercial AI APIs charge per token and per month, eating 5–15% of razor-thin maker margins. Worse, sending confidential supplier bills, wholesale costs, and proprietary designs to closed cloud APIs violates seller privacy.

HustlePulse AI solves this with an open-source, local-first…

View on GitHub

Repository Architecture

Hacktoberfest-Week-2/
├── app/
│   ├── main.py                  # FastAPI REST API & static file serving
│   ├── config.py                # Pydantic v2 settings & environment manager
│   ├── engines/
│   │   ├── gemma_engine.py      # Google Gemma 2 local Ollama & HF integration
│   │   ├── tabpfn_engine.py     # Prior Labs TabPFN tabular foundation model
│   │   └── elevenlabs_engine.py # ElevenLabs TTS & browser audio synthesis
│   └── static/
│       ├── index.html           # Modern semantic dashboard UI
│       ├── css/style.css        # Dark glassmorphic design system
│       └── js/app.js            # Reactive tab management & waveform visualizer
├── data/
│   ├── sample_candles.csv       # Real-world artisan candle sales history
│   ├── sample_leather_wallets.csv # Leathercraft sales & labor history
│   └── sample_digital_templates.csv # Notion templates download metrics
├── tests/
│   └── test_api.py              # Automated test suite (6/6 passing)
├── render.yaml                  # Render Blueprint definition
├── Dockerfile                   # Multi-stage container deployment
└── requirements.txt             # Minimal dependencies

How I Built It

HustlePulse AI was engineered with an unwavering focus on developer velocity, local autonomy, and zero external friction:

1. Open-Weight Model Core: Google Gemma 2

For text generation, we selected Google Gemma 2 (2B & 9B). Gemma's architecture achieves state-of-the-art reasoning for its size, allowing it to run smoothly on standard laptops with Ollama.

Prompt Engineering: The engine formats structured turns (<start_of_turn>user ... <end_of_turn><start_of_turn>model) to reliably return machine-parseable JSON containing the optimized title, emotional brand story, bullet points, 13 search tags, and buyer personas.
Provider Cascade: Built with an intelligent cascade: it checks local Ollama first (http://localhost:11434), falls back to Hugging Face Inference API if a token is present, and includes an offline domain synthesis emulator so the application never breaks even without active daemons.

2. Tabular Foundation Model: Prior Labs TabPFN-3.5

Tabular data is the heartbeat of e-commerce, but traditional machine learning (XGBoost, Random Forest, deep neural nets) fails small sellers because:

Datasets are small (often only 15 to 100 past sales).
Setting up feature pipelines and cross-validation is completely inaccessible to solo makers.

TabPFN-3.5 changes the paradigm completely. Because TabPFN is a tabular foundation model trained with Prior Labs' synthetic Bayesian priors, it performs in-context learning across tabular features in a single forward pass.

We pass numerical features: material cost, labor hours, competitor pricing, photo counts, and Q4 seasonality flags.
TabPFN infers the optimal price point and models the price elasticity curve across 7 price intervals (-30% to +30%), showing exactly where demand drops off and where gross profit peaks.
It scans the seller's historical records to pinpoint underpriced inventory where labor hours are being subsidized for free.

3. Voice Promo Engine: ElevenLabs

For video marketing, we integrated ElevenLabs Turbo v2.5 to voice the generated social video hooks. Sellers can pick from curated presets (Warm Artisan, Luxury Commercial, Upbeat Creator) to produce broadcast-quality voiceovers in under 400ms, with seamless in-browser Web Speech API fallback for zero-setup demoing.

4. Cloud Deployment & Observability: Render & Sentry

Render: Included a native render.yaml Blueprint with automatic environment configuration and health checks for instant web service deployment.
Sentry Agent Tracing: Integrated sentry_sdk to monitor agent execution latency, model generation spans, and API reliability.

Why Does Open Innovation Matter?

Open innovation is not just an ideological choice for HustlePulse AI—it is the fundamental reason this business model works.

1. Preserving Fragile Margins ($0 Marginal Cost vs. $150+/yr Closed API Tax)

Indie makers operate on thin margins. When a seller makes $8 profit on a $24 candle, paying $0.03 per API query across dozens of draft iterations, plus a $20/month SaaS fee, eats 15% to 25% of their net earnings.
By deploying open-weight models like Gemma 2 locally or on low-cost compute, the marginal cost per listing is literally $0.00. Open models democratize software that was previously gatekept by venture-backed enterprise SaaS.

2. Safeguarding Maker Privacy & Intellectual Property

To recommend accurate prices, an AI must know:

Wholesale supplier costs
Hourly production rates
Raw material sources and supplier names

Makers are rightfully terrified of uploading supplier invoices into closed AI ecosystems where proprietary supply chains can be harvested or trained upon. With open weights running on local devices, financial data never leaves the seller's laptop.

3. Escaping Vendor Lock-in & Sudden Deprecations

Closed AI providers regularly change API pricing, modify system prompts, and sunset model versions overnight. By building on open foundations (Gemma 2 and TabPFN), indie entrepreneurs retain perpetual ownership of their toolchain. If a model update occurs, they can pin their exact weights forever.

My Agent Session

This entire project—from the backend FastAPI engine, TabPFN tabular pipeline, and Gemma prompt engineering to the glassmorphic frontend and test suite—was built with pair-programming assistance:

Sessions were tracked and structured to maintain strict adherence to open-source foundation standards and test coverage.
Code generation, architectural refactoring, and benchmark tests were executed iteratively with immediate feedback loops.

My First User

To test HustlePulse in the real world, I handed it to Elena, an artisan soy candle maker who sells at weekend craft markets and on Etsy:

The Test

Elena loaded 20 past sales records from her holiday season. She was about to launch a new "Amber & Oakmoss Campfire Candle" and had planned to price it at $18.00 because that was what her local market stalls charged.

The Findings

TabPFN Anomaly Detection: TabPFN flagged that with $4.90 in materials, 0.6 labor hours ($15.00 fair artisan wage), and $25.00 competitor benchmarks, her $18.00 price resulted in an unsustainable negative labor return.
TabPFN Recommended Price: TabPFN recommended $24.50. The price elasticity simulation showed that while demand would dip slightly from 185 to 165 monthly units, her projected monthly profit surged by over $1,100.
Gemma 2 Listing: Gemma generated an Etsy-tailored narrative focusing on small-batch artisan dedication and populated all 13 Etsy search tags in 3 seconds.
Elena's Reaction: > "I was literally underpricing myself out of business because I felt guilty charging more. Seeing the numbers laid out with the demand curve gave me the confidence to list at $24.50. I sold 8 jars on my first weekend!"

Would she pay for it? Elena told me she would happily pay a one-time purchase of $49 for a local tool that didn't charge her monthly subscriptions or leak her supplier sources.

Prize Categories

Featured Categories:

Best Use of Gemma ($200): Powered by Google's open-weight Gemma 2 model for high-converting product descriptions, SEO tag extraction, buyer persona segmentation, and viral social video hooks.
Best Use of TabPFN ($200): Leverages Prior Labs' TabPFN-3.5 tabular foundation model to analyze historical e-commerce sales CSVs, generate price elasticity curves, and detect shop margin anomalies.
Best Use of Render ($200): Features a production-grade render.yaml Blueprint and containerized Docker setup for one-click deployment with integrated health checks.

Partner Categories:

Best Use of ElevenLabs ($100): Integrates ElevenLabs Turbo v2.5 to turn generated product hooks into studio-grade voiceover audio for TikTok, Instagram Reels, and YouTube Shorts.
Best Use of Sentry Agent Tracing ($100): Configured with sentry_sdk to trace AI model execution spans, latency metrics, and API health.

Conclusion & Open Source Link

Open-source AI gives everyday side-hustlers the superpowers of a Madison Avenue copywriter and an enterprise data science team—right from their own laptops.

Check out the code, run it locally, and empower your own side hustle:
👉 GitHub: joegeorge022/Hacktoberfest-Week-2

TrailGemma - An Offline Nature Companion That Tells You to Put It Down

Joe George — Thu, 08 Oct 2026 14:06:00 +0000

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

What I Built

Most apps that claim to be for the outdoors quietly keep you staring at a screen. You open a hiking app and spend ten minutes planning. You pull out your phone every five minutes to check a map. You reach the summit and immediately start reviewing the route stats instead of looking around.

TrailGemma works the other way. The design goal was blunt: screen time under 60 seconds, then get out of the way.

It is a nature companion for hikers, trail runners, and backyard gardeners built around three things. First, a spoken field briefing — you tap one button, hear a 60-second narrated summary of your trail conditions and canopy status, and pocket your phone. Second, a frost and planting planner that gives you a specific garden action for today rather than a generic frost date chart. Third, a bird acoustic guide that tells you which species are likely vocalizing right now based on your elevation, time of day, and canopy density — so you know what to listen for after you stop looking at the screen.

The people this is for: trail runners who want route intel without pulling up seventeen apps, gardeners who want to know tonight whether to cover their peppers, birders who want to spend more time listening and less time searching databases.

Demo

The app runs locally on http://localhost:8000. Start with:

git clone https://github.com/joegeorge022/trailgemma
cd trailgemma
pip install fastapi uvicorn tabpfn torch pandas numpy httpx
ollama pull gemma2:2b
./scripts/run_demo.sh

The full pipeline in practice:

Select a trail on the map.
Tap Generate Field Briefing. TabPFN reads the trail's elevation, canopy composition, and accumulated chilling hours. Gemma 2 turns those numbers into a spoken paragraph. ElevenLabs (or native on-device speech if you're offline) reads it aloud.
Pocket the phone. Listen to the briefing. Walk.

A real output from the Sugarloaf Ridge trail at 580m elevation, 60% sugar maple canopy, 185 chilling hours accumulated:

"You're stepping into peak canopy — 78% vibrancy. The sugar maples above 500 meters are flaming scarlet right now, the birches lower down have gone gold. Watch for the white-throated sparrow rustling through fallen leaves at the trail edges, and listen for the pileated woodpecker's resonant drumming in the mature hemlocks to the north. There's a hard freeze coming within two days at this elevation, so if you have tender crops at home, harvest them tonight. Now pocket the phone."

TabPFN generated the numbers. Gemma 2 wrote the words. ElevenLabs read them aloud. The whole thing took under eight seconds to generate and runs entirely on a MacBook Pro with no internet required.

Code

trailgemma/
├── backend/
│   ├── app.py                  # FastAPI: routes and orchestration
│   ├── tabpfn_engine.py        # Prior Labs TabPFN inference engine
│   ├── gemma_client.py         # Gemma 2 via Ollama (local open-weight)
│   ├── elevenlabs_engine.py    # Audio synthesis, with offline fallback
│   ├── trails_data.py          # Trail GPS, canopy data, flora catalogs
│   └── datasets/               # Frost, foliage, and bird training contexts
├── frontend/
│   ├── index.html
│   ├── css/style.css
│   └── js/
│       ├── app.js              # Map, tabs, garden planner, pocket mode
│       ├── tabpfn_ui.js        # Probability distribution visualizers
│       └── audio_guide.js      # Audio tour player with waveform visualizer
└── scripts/
    └── run_demo.sh

The three main technical interactions:

TabPFN running frost risk classification:

from tabpfn import TabPFNClassifier

clf = TabPFNClassifier(device="cpu")
clf.fit(X_microclimate_train, y_frost_risk)

# Point prediction for a specific backyard
probs = clf.predict_proba(X_query)[0]
# → [p_safe: 0.05, p_light_frost: 0.20, p_hard_freeze: 0.75]

Gemma 2 generating the trail script:

async def generate_trail_audio_script(trail_name, foliage_data, bird_data, frost_data):
    prompt = f"""
    Write a 45-second spoken briefing for a hiker at {trail_name}.
    Canopy: {foliage_data['stage_name']}, {foliage_data['vibrancy_index']}% vibrancy.
    Likely birds: {[b['name'] for b in bird_data['top_species']]}.
    Night low: {frost_data['inputs']['avg_night_temp_c']}°C.
    End by telling them to pocket the phone.
    """
    return await ollama_client.generate(model="gemma2:2b", prompt=prompt)

FastAPI composing the full pipeline:

@app.post("/api/briefing/generate")
async def generate_briefing(req: BriefingRequest):
    foliage = tabpfn_engine.predict_foliage(...)
    birds   = tabpfn_engine.predict_birds(...)
    frost   = tabpfn_engine.predict_frost(...)
    script  = await gemma_client.generate_trail_audio_script(...)
    audio   = await audio_engine.generate_speech(script)
    return { "script": script, "audio": audio, "tabpfn_foliage": foliage }

How I Built It

The stack is three open models doing different jobs.

Prior Labs TabPFN handles the structured predictions. I needed to predict frost probability, foliage peak timing, and bird occurrence likelihood from tabular inputs: elevation, slope aspect, temperature, canopy composition, chilling hours. This is exactly the problem TabPFN was designed for. It performs Bayesian in-context learning on tabular data without hyperparameter tuning, training loops, or preprocessing pipelines. I fed it physics-informed synthetic datasets — frost pocket modeling from terrain physics, chilling degree accumulation curves, forest bird phenology by elevation band — and got calibrated probability distributions in under 150 milliseconds on CPU. A traditional ML approach would have required thousands of labeled samples, cross-validation, and manual feature engineering. TabPFN needed 180 rows and no tuning.

Google Gemma 2 (2B) handles language. The TabPFN outputs are numbers: a frost probability curve, a foliage vibrancy score, a ranked list of bird species. Gemma 2 translates them into spoken prose that a hiker can absorb in 45 seconds while putting on their pack. It runs locally via Ollama on Apple Silicon at reasonable latency. I used a system prompt that frames the model as a wilderness naturalist speaking directly to someone about to leave the trailhead — which keeps the output sensory and concrete rather than encyclopedic.

ElevenLabs converts the script to audio. When the API key is available, it uses a warm documentary voice. When the app is offline — which it often is on trails — it falls back to the browser's native speech synthesis API. The audio guide works with no network at all.

The frontend is a vanilla HTML/CSS/JS progressive web app with a service worker for offline caching. I deliberately avoided any framework. The app needs to load fast on a spotty connection at a trailhead parking lot, and there is no reason a nature companion needs a JavaScript build chain.

The garden planner uses the same TabPFN frost engine but exposes the inputs directly: elevation, slope aspect (south-facing slopes hold more solar heat), distance to water (lakes buffer night temperatures), canopy cover. This is the kind of microclimate reasoning that generic zip-code frost calendars completely ignore. A valley garden 200 feet below a south-facing hillside can freeze two full weeks earlier. TabPFN models that interaction from four numbers.

Why Does Open Innovation Matter?

The clearest reason: the app stops working if you replace any open component with a closed API.

When you're four miles into a national forest, you have no cell signal. OpenAI's API is unusable. Gemma 2 running on your device via Ollama is completely unaffected. The frost planner works because TabPFN runs on your CPU. The audio guide works because the Web Speech API runs in your browser. The trail map works because OpenStreetMap tiles are cached by the service worker. A closed-API version of this app would be a brick the moment you lost signal — which is precisely when you need it.

The privacy argument follows naturally. A garden planner that knows your exact GPS coordinates, your planting schedule, and your microclimate parameters is building a detailed picture of where you live and what you grow. With local inference, that data never leaves your machine. There is no server log. There is no training data opt-out to manage.

The cost argument matters for exploration. This app runs at zero marginal cost per query, indefinitely. I can simulate a thousand frost scenarios to model how a new raised bed will behave through October. I can generate a briefing for every trail in a county before a weekend trip and compare them. With a pay-per-token API, that kind of open-ended exploration becomes self-limiting.

But the most technically interesting reason is about what TabPFN specifically makes possible that closed LLMs cannot. Ask any frontier language model to predict frost risk from elevation, slope aspect, and temperature data and it will confidently hallucinate a number. TabPFN is a foundation model purpose-built for tabular prediction — it produces calibrated uncertainty distributions, not confident guesses. The combination of a language model for prose and a tabular foundation model for structured environmental reasoning is more capable than either alone. Open licensing made it possible to combine them without negotiating API contracts or worrying about which company owns what.

Prize Categories

Best Use of Gemma — Google Gemma 2 (gemma2:2b) runs locally via Ollama as the naturalist field guide writer and Q&A engine. No cloud dependency, no API key required.

Best Use of TabPFN — Prior Labs TabPFN v9.1 (TabPFNClassifier and TabPFNRegressor) runs three distinct prediction tasks: frost microclimate risk classification, canopy phenology stage regression, and bird occurrence probability ranking.

Best Use of ElevenLabs — Converts Gemma's trail scripts to spoken audio for hands-free hiking, with a graceful offline fallback to on-device Web Speech API when the API is unavailable.