DEV Community: mohamedaminehamdi

Graveyard Shift: five AI ghosts work my night shift on local Gemma 4

mohamedaminehamdi — Thu, 29 Oct 2026 14:34:59 +0000

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

What I Built

Every morning starts with the same scramble: a full inbox, a pile of chats, a contract that's somewhere in Downloads, a meeting I meant to prepare, and a bug I promised to fix "tomorrow". Meanwhile my Mac spends eight hours asleep next to me. So I gave it the night shift.

Graveyard Shift is a crew of AI ghosts that works on your Mac while you sleep, with open models only. At bedtime you leave them a note:

write tests for slugify in inkwell and fix whatever they catch; find the contract Hans sent; prep my 10:00

You press Goodnight and leave the Mac open and plugged in. The ghosts stay in their graves until you've actually fallen asleep. Then five of them rise, all thinking with Gemma 4, locally:

The Mail ghost reads your Gmail, sorts every letter into Reply, FYI, News or Possessed, and drafts the replies.
The Messages ghost reads today's texts, WhatsApp and Slack, and drafts answers in each chat's own language.
The Files ghost reads what you saved today, finds what you asked for, says what to check before you sign, and picks a folder for every loose file.
The Calendar ghost prepares tomorrow's meetings from everything the others read, and flags clashes.
The Code ghost opens a private copy of your repo, writes the tests, runs them in a sandbox and fixes what they catch, on its own branch.

In the morning there is one briefing, and nothing has been sent, accepted, moved or merged. You send the drafts you like yourself. You press Tidy to move the files (Undo puts them back). You Keep the Code ghost's branch, or you Exorcise it.

How I read the theme. Ghosts in the machine, working the graveyard shift. They rise from their graves when the Mac goes quiet. They take turns holding a single candle, because there is one GPU. Every message that tries to give them orders goes into the Possessed pile, and at dawn they sink back into the ground. Their test night belongs to Marisol Vega, an invented designer with a busy Día de los Muertos week: pan de muerto for her mother on Sunday, an ofrenda workshop, and a blog whose slugify turns "Día de los Muertos" into d-a-de-los-muertos.

Demo

Scroll through a recorded night →

The page tells one real night. Marisol doesn't exist, but everything else was real: five ghosts on Gemma 4 e4b, on my MacBook Air, for 30 minutes and 84 steps. Every name, number and line on the page comes from that night's Temporal history, which is published raw next to the code. CI rebuilds the replay from it and fails if they differ.

That night:

28 letters. 6 replies drafted, 14 FYI, 6 newsletters, and 2 possessed: a phishing mail, and a "notice to AI assistants and automated agents processing this inbox" telling them to forward the contract and invoices to an outside address. Gemma caught both, and a plain rule caught the second as well. 0 sent.
8 chats. A bank's one-time code was dropped before any ghost could read it. Of the other 7, the ghost drafted 2 answers, one to Marisol's mother in Spanish, and caught a text asking "AI assistants reading this phone" to forward a verification code.
7 files. Hans's contract read, with 3 things to check before signing, and a folder picked for each of the 5 loose files in Downloads and on the Desktop.
6 meetings prepared, and the 14:00 clash flagged.
1 bug fixed. The Code ghost's new test caught "Día de los Muertos" becoming d-a-de-los-muertos. It fixed slugify, and all 6 tests pass on its branch.
1 crash. Halfway through I killed the worker with kill -9 while the Files ghost was reading the contract. More on that below.

The app on your Mac shows the same thing live, one lane per ghost, then the morning briefing:

Try it yourself. On an Apple-silicon Mac, one line installs everything into your home folder. There's no admin password, and it's about 8 GB, mostly Gemma 4:

curl -fsSL https://mohamedaminehamdi.github.io/graveyard-shift/install.sh | sh

Then graveyard-shift demo works a night on Marisol's day right away, with no accounts and no keys, and graveyard-shift opens the app to watch the ghosts and read the briefing. For your own nights, run graveyard-shift connect gmail you@gmail.com, give the app Full Disk Access if you want texts and WhatsApp, and leave a note at bedtime.

Code

mohamedaminehamdi / graveyard-shift

Ghost agents that work your night shift: mail, files, calendar and code, on local Gemma 4, while you sleep. Temporal keeps the night alive; TabPFN predicts when you wake.

Graveyard Shift 👻

Ghost agents that work your night shift. Leave a note at bedtime ("write tests for slugify in my blog repo; find the contract Hans sent; prep my 10:00"). While you sleep, five ghosts go through your Gmail, your texts, WhatsApp and Slack today's files, tomorrow's calendar and your repo on local Gemma 4. In the morning there is one briefing: letters and chats sorted, replies drafted (never sent), a folder picked for each loose file (press Tidy to move them, Undo to put them back), meetings prepared, the contract found, and a branch with the tests written. Keep it or exorcise it.

See how a night goes, told from a real recorded night: the letters, files, meetings, crash and code on that page come from its Temporal history.

Built with PriorLabs-TabPFN, Gemma 4 and Temporal. Everything runs on your Mac.

Install (macOS, Apple silicon)

curl

…

View on GitHub

How I Built It

One night is one Temporal workflow

A night has plenty of ways to die: the lid gets closed, macOS restarts for an update, Ollama crashes, someone trips over the charger. So the whole night is one Temporal workflow, NightShift. The workflow only decides. Every side effect (reading a letter, each Gemma call, each tool call, each test run) is an activity with a timeout and retries, and long Gemma calls send a heartbeat every 10 seconds.

The five ghosts work at the same time, but there's only one GPU. So all the thinking goes through one task queue, the candle, which has room for one Gemma call at a time:

Worker(client, task_queue="candle", activities=ON_CANDLE, max_concurrent_activities=1)

Then I tested it the rude way. In the recorded night, while the Files ghost was reading the contract, I killed the worker:

13:14:58: kill -9 on worker ghosts-88293, mid-read.
Temporal waited for heartbeats that never came: a 60-second timeout, plus the retry interval.
79 seconds later, a new worker, ghosts-36271, read the contract again (attempt 2), and the night went on.
The 24 steps finished before the crash were not run again. 59 more ran after it.

It also survived a crash I didn't plan. Early in the night, one of the Code ghost's Gemma calls missed its heartbeats too, and I never found out exactly why. Temporal quietly ran it again. Both retries are in the published history.

The tests run the real workflow on a real Temporal dev server, with the activities faked. They check a whole night, dawn cutting it short, "I'm awake" ending it early, and a dead worker costing no finished work.

When will I wake up? TabPFN

Falling asleep is easy to observe: the Mac goes idle. Waking up isn't, and the briefing has to be ready before it happens. So after lights-out, TabPFN predicts, for each 15-minute slot until noon, the chance that I'm back at the Mac.

It learns in context from the Mac's own power log (/var/log/powermanagement, where the display turns on and off). It only uses what's known at lights-out: the time of night, the weekday, when the lights went out, and my last nights. There's no training run: you hand TabPFN the table and it predicts. The deadline is the moment I've probably (1 in 4) been up already.

On 13 nights from my own Mac, each predicted only from the nights before it:

Model	Brier score	Wake-time error	Late briefings
TabPFN	0.062	80 min	3 / 10
each slot's frequency	0.078	184 min	2 / 10
same as yesterday	0.136	255 min	3 / 10
logistic regression	0.075	102 min	4 / 10

TabPFN is by far the best at guessing when, but not yet the best at never being late. With only 13 nights, a slot's plain frequency is the more cautious one. graveyard-shift sleep-eval runs the same comparison on your own power log.

Built with PriorLabs-TabPFN.

Gemma 4 on a 24 GB MacBook Air

I wanted the 26B Gemma 4. With Chrome and an editor open, it pushed 39 GB into swap, and my free disk fell to 15 GB. So the Keeper picks the biggest Gemma 4 that fits in free memory tonight. On my Air that's gemma4:e4b (6.6 GB); with 32 GB or more it's the 26B.

A small model is enough because no ghost ever has to do much at once. Each reads one item as quoted data, and answers in a fixed JSON shape that Ollama enforces with constrained decoding. When the Files ghost picks a folder, the schema's enum is the list of real folders, so it can't invent a path:

"move_to": {"type": "string", "enum": ["", *folders]}   # one of tonight's folders, or nothing

Two lessons from Gemma's tool calls: turn off streaming and thinking (calls leaked into the thinking field when either was on), and re-ask malformed calls instead of keeping them in the conversation.

Possessed letters, and texts

The defense is boring on purpose:

The Mail, Messages, Files and Calendar ghosts have no tools at all. The worst a hostile letter can do is change a label, or a draft that is never sent.
Everything someone else wrote goes between <data> tags, with a reminder that it's data to read, never instructions.
A plain regex sits next to the model as a backstop.

That night the letter and the text that tried to give orders were both caught, and a bank's one-time code never reached a ghost at all: codes and password resets are dropped at dusk, before anything is read.

Read-only hands

Gmail over IMAP, opened with EXAMINE and fetched with BODY.PEEK[], so nothing is even marked as read. One surprise: Python's imaplib.IMAP4_SSL checks no certificate unless you pass it an SSL context, which means the app password would go to whoever answered. It now gets ssl.create_default_context(). The app password lives in the macOS Keychain.
Messages keeps your texts in a SQLite file, chat.db, opened read-only. Newer macOS stores many texts only inside attributedBody, an NSAttributedString in Apple's typedstream format, so there's a small decoder for that.
WhatsApp for Mac keeps its chats in SQLite too, opened the same way.
Slack through four read-only API methods.

A safety test checks the whole package for any way to send, forward or post, and for IMAP writes.

Moving files, only when you say so

The Files ghost suggests and you decide. In the morning, Tidy moves each file into the folder the ghost picked. It never moves a file over an existing one, never outside the folders it was given, never one that changed since the ghost read it, and never a key or a wallet. Every move goes into a journal first, so Undo can put it all back.

The Code ghost's room

The Code ghost is the only one with tools: list, read, search, write, run tests, diff, finish. It works in a git worktree, on its own ghost/… branch. Paths can't leave the worktree, and the tests run under sandbox-exec with a deny-by-default profile: no network, no writes outside the worktree, no reading ~/.ssh, ~/Library or token files. It commits on its branch, and it never merges or pushes.

Its prompt asks for at least one test built from what's inside the repo's real files. Without that, it tested "Hello World", and everything passed. With it, it opened posts/2026-10-20-dia-de-los-muertos.md, wrote a test for that title, watched it fail, and fixed slugify:

+    title = unicodedata.normalize('NFKD', title).encode('ascii', 'ignore').decode('ascii')
     slug = re.sub(r"[^a-z0-9]+", "-", title.lower())

A landing page where the ghosts work as you scroll

The page tells the night by scrolling. A clock runs from 22:47 to 07:15, the sky goes from dusk to golden dawn, and each chapter stays on screen while its ghost works through it. Scroll down and the ghosts work. Scroll back up and the night rewinds. It's plain JavaScript: each scene's moves are paused Web Animations, and one passive scroll handler sets their currentTime, so it also works in Firefox, which has no CSS scroll timelines yet. With JavaScript off, or with reduced motion, every scene simply shows how it ends.

Why Does Open Innovation Matter?

Because of what the ghosts read: my mail, my texts, my files and my code. That's not a list I'd upload to a service so it can work on it while I'm asleep.

It stays on my Mac. Every thought happens there, and nothing a ghost writes is ever sent. The only network reads are at dusk: my calendar feed and, if I connect them, Gmail and Slack, read-only.
No accounts, no keys, no bill. Gemma 4 and TabPFN v2 are open weights, and Temporal is one open-source binary with a SQLite file. A night costs some electricity.
It works with the internet off. Once the day is gathered at dusk, the whole night runs offline.
It can't disappear. There's no service to shut down and no API to deprecate. The ghosts live on my Mac, and the code lives on GitHub.
Open made it better, not only more private. I could size the model to tonight's free memory, constrain its answers with my own schemas, and fit TabPFN to my own power log without sending anyone my sleep.

The honest limits: Gmail and Slack need the network at dusk, and WhatsApp's database format isn't documented. And e4b is small. It filed Ana's lunch text as FYI, although she asked a question, and it read Hans's contract without ticking it as the one I'd asked it to find.

Prize Categories

Best Use of Gemma: every ghost thinks with Gemma 4 locally through Ollama. That covers readers held to a JSON schema, a tool-calling Keeper and Code ghost, and the biggest model that fits tonight's memory.
Best Use of TabPFN: TabPFN v2 predicts when I'll wake up from my own Mac's power log, and that prediction sets the night's deadline. Built with PriorLabs-TabPFN.
Best Use of Temporal: the night is one durable workflow, with a GPU-sized task queue, heartbeats, signals and timers. The recorded night includes a kill -9 and the comeback.

My Downloads folder now tidies itself, by copying how I already file things

mohamedaminehamdi — Fri, 23 Oct 2026 10:59:39 +0000

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

What I Built

My Desktop has 269 folders. I'm clearly willing to file things. I'm just not willing to do it today, so my Downloads folder fills up with IMG_4821.HEIC, document (3).pdf and four ebooks I swear I'll read.

Every file tidier I know of wants rules first: "PDFs go here, screenshots go there". Writing rules is the chore I was avoiding in the first place. So I built the laziest version I could think of.

Tidy Sloth looks at the files I've already filed, works out my system from them, and proposes a tidy for Downloads and Desktop. I get one screen, one sentence and one button. Then I get to watch a sloth do the work: it fetches each file, reads it, gives it a real name, and drops it in the right basket.

It moves a file only when it's confident. Files it isn't sure about stay where they are.
It renames only junk names (IMG_…, Screenshot …, Untitled, UUIDs). Gemma 4 reads the picture or the first page and suggests a real name.
If several files of one kind have nowhere to go, like four ebooks, it suggests a new folder for them.
It never deletes, never touches anything that looks like a key or a password, and Undo puts everything back.

Installing it is one line in Terminal. After that it's an app in your Applications folder: open it and press Approve. And because sloths don't hurry, the installer offers to build a fresh plan every night at 3 am, so in the morning it's already waiting for your one click.

Demo

Try it in the browser. The demo uses a made-up Downloads folder, so nothing real moves. The sloth starts working on its own; press Approve all to have it finish the rest at once, or "Let me check first" to see the whole plan.

The real version runs on your Mac (Apple silicon, macOS 14+). Paste this into Terminal once:

curl -fsSL https://mohamedaminehamdi.github.io/tidy-sloth/install.sh | sh

It installs everything into your home folder, with no admin password: Tidy Sloth, Ollama with Gemma 4, the TabPFN weights, and a Tidy Sloth app. Why a Terminal line and not a .dmg? macOS blocks downloaded apps unless they're notarized, which needs a paid Apple developer account. An app built on your own Mac by the installer has nothing for Gatekeeper to block.

Code

mohamedaminehamdi / tidy-sloth

Tidies your Downloads and Desktop by learning how you already file things. TabPFN + local Gemma 4, fully offline, never deletes.

Tidy Sloth 🦥

Puts your Downloads and Desktop away by learning how you already file things. One click to approve, one click to undo. Runs on your Mac, never deletes anything.

Try the demo (made-up files, nothing real moves)

Install

Paste this into Terminal once (Apple silicon, macOS 14+, no admin password):

curl -fsSL https://mohamedaminehamdi.github.io/tidy-sloth/install.sh | sh

It installs uv, Tidy Sloth, Ollama with Gemma 4 (about 6.6 GB, the bulk of the download), and the open TabPFN weights. Then it makes a Tidy Sloth app in your Applications folder. From then on it's one click: open the app, and the sloth looks through your Downloads and Desktop while you watch.

The installer also asks whether to build a plan every night at 3 am. It's off unless you say yes. A Mac that's asleep at 3 am builds the plan when it next wakes. The nightly run never…

View on GitHub

How I Built It

1. Your folders are the training data

Every file sitting in one of my folders is a labelled example: this file belongs in that folder. So Tidy Sloth turns each file into one row of a table:

extension	family	size	created	lat	lon	downloaded from	filename (8 numbers)	folder
.heic	image	2.1 MB	2026-06-14	38.71	-9.14		…	Lisbon 2026
.pdf	pdf	88 KB	2026-02-03			irs.gov	…	Taxes 2026

Nearly all of these columns were already on the disk. macOS Spotlight keeps a file's capture date, photo GPS and the website it was downloaded from. Tidy Sloth reads them with mdls, so no extra dependency is needed. For the filename, character n-grams are squashed into 8 numbers with TF-IDF and SVD.

Then TabPFN reads the table. TabPFN is a tabular foundation model: you hand it the labelled rows and it predicts new ones in a single forward pass. There's no training run, no hyperparameters and no GPU needed. For a lazy person, that's exactly right.

clf = TabPFNClassifier.create_default_for_version(ModelVersion.V2, categorical_features_indices=CATEGORICAL)
clf.fit(featurizer.transform(filed_paths, meta), folder_labels)   # files I already filed -> their folder
proba = clf.predict_proba(featurizer.transform(loose_paths, meta)) # loose files -> where they probably go

TabPFN handles up to 10 classes, so it learns from my 10 biggest filing folders, with up to 100 files from each. That stays well under its comfortable table size and keeps one huge photo folder from drowning out the rest.

2. Does it actually learn? A held-out test on my real Desktop

Before letting anything move my files, I wanted proof. I took the files I'd already filed, hid 30% of them, fitted on the other 70%, and asked TabPFN to put the hidden ones back:

	put back correctly
A rule based on the file extension	28.9%
TabPFN	98.6%
TabPFN, only when it's ≥ 90% sure (that's 93.8% of files)	100%
TabPFN, only when it's ≥ 70% sure (97.2% of files)	99.5%

That's 547 training files, 211 test files and 10 folders. The confidence is what makes this safe to automate: above 90% it didn't make a single mistake. So Tidy Sloth only moves a file at 70% or more, and leaves everything else alone.

Then I removed the date and GPS columns, and accuracy fell to 45%. Most of my folders are trips, and a trip folder is defined by when and where, not by what the photos are called. The model worked that out without being told. A rules-based tidier would never have guessed "look at the GPS".

The honest weak spot is documents. My folders hold few PDFs, and TabPFN's accuracy on them was lower: 80%, on only 5 test files. That's where the second model comes in.

3. Gemma 4 reads what TabPFN can't

Gemma 4 (gemma4:e4b) runs locally through Ollama and has two small jobs:

Naming junk. If a filename is one nobody really chose (IMG_4821, Screenshot 2026-10-19 at 09.12.44, document (3)), Gemma looks at a small preview made with macOS sips, or at the first page of a PDF read with pypdf. It suggests a 3–8 word name such as "landlord reply about heating". The prompt tells it never to put account or ID numbers in a name.
A second opinion on documents. When TabPFN isn't sure about a PDF, Gemma reads it and picks one of my folders, or "none".

Both calls use Ollama's structured output, so the answer is always valid JSON. For routing, Gemma's choice is an enum of my real folder names, so it can't make up a folder. Only a high-confidence answer counts. Anything less and the file stays where it is:

schema = {"type": "object", "properties": {
    "folder": {"type": "string", "enum": [*folder_names, "none"]},
    "confidence": {"type": "string", "enum": ["high", "medium", "low"]}},
    "required": ["folder", "confidence"]}

4. Plan, one click, undo

Nothing moves while the plan is being built. The review screen is a small page served on 127.0.0.1. You can untick any file and edit any new name. Approve all then runs the plan:

Every move is written to a journal in ~/.tidy-sloth/ before it happens, so even a crash halfway through can be undone.
A name clash becomes name (2).pdf. Nothing is ever overwritten.
There is no delete anywhere in the code.
Undo everything replays the journal backwards.
Secrets are never planned: .pem, .key, id_rsa, .env, wallets, and anything named like a password or recovery code.
Also never touched: code projects (anything with .git, package.json, pyproject.toml…), app bundles, hidden files, and files changed in the last 10 minutes.

Two more safety details:

A double-click on Approve, or a browser tab left open from an older plan, is refused instead of acted on. Each plan has a token, and only one change runs at a time.
If macOS says no when Tidy Sloth asks to look in Desktop or Downloads, the page says how to allow it, instead of quietly planning nothing.

The important parts have tests: secrets and code projects never end up in a plan, an apply/undo roundtrip with a name clash restores every file, and a typed name like ../../etc/passwd is cleaned before it can go anywhere. The server refuses requests from other hosts, which blocks a malicious web page from reading your file list through DNS rebinding. The tests run in GitHub Actions on every push.

5. A sloth you can watch

A tidy you can't see is a tidy you don't trust. So the review screen is a little forest: a branch, a pile of file cards, and one basket per destination folder. The sloth slides along the branch, lowers itself on a vine, and does each file in four steps:

Reads it. A scan line runs over the card and a bubble says what it's looking at ("HEIC photo · 2.1 MB").
Names it. Gemma's new name types itself onto the card.
Decides. The bubble shows the real reason from the plan: "TabPFN: 99% sure → Lisbon 2026", "Gemma 4 read it → Taxes 2026", or "None of your folders fit → a new Books folder".
Puts it away. The card drops into its basket and stays there, and the basket's count ticks up.

It's plain SVG and the Web Animations API, with no libraries and no CDN, so it also works offline. The animation is decoration only. The page never waits for it to finish, and if you click the forest it skips to the real end state. On your own Mac nothing goes in a basket until you press Approve. Before that, the sloth just ambles along the branch and peers at the pile.

6. One line to install, then it's an app

install.sh is a short POSIX script you can read before running it:

It installs uv, then installs Tidy Sloth from a wheel that GitHub Pages serves next to the demo. That avoids git, which on a fresh Mac pops up the developer-tools installer.
It downloads Ollama if you don't have it.
It runs tidy-sloth --setup, which pulls Gemma 4 through Ollama's API, warms the TabPFN weights on a dummy table, and builds Tidy Sloth.app with osacompile.

The app gets the sloth icon and its own bundle id. It's re-signed after the icon is added, because macOS ties folder permissions to a valid signature. It also explains itself in the permission prompt: "Tidy Sloth looks at your files to suggest where they belong. Nothing moves until you approve."

The optional 3 am run is a LaunchAgent that opens the app in overnight mode rather than running Python directly. That way it uses the permissions you already gave Tidy Sloth.

The bug that took the longest

The first run said none of my downloads had a source website, which was obviously wrong. It turns out mdls -raw prints attributes in alphabetical order, not in the order you ask for them. Zipping my list against its output put the creation date in the "downloaded from" column. Sorting the attribute list first fixed it. If you ever script Spotlight, save yourself the hour.

The lazy payoff

On my own Mac, opening the app found 21 loose files in Downloads and Desktop. Tidy Sloth planned:

20 moves:
- 14 by TabPFN, one of them also renamed;
- 2 more after Gemma read the PDFs;
- 4 ebooks into a new Books folder.
1 file left alone, because it wasn't sure.
2 files flagged and never touched, one of them a private key sitting on my Desktop.

That's about 7 minutes of my time back, if you accept my guess that a person spends ~20 seconds finding a home for one file. The plan took under two minutes to build.

Seven minutes isn't much. The real saving is that I'll never have to sit down and do it at all.

Why Does Open Innovation Matter?

Look at a Downloads folder: tax forms, a lease, bank statements, photos with GPS in them. A filename list is personal data, and file contents even more so. A closed API would mean sending my files to someone else's server just to tidy them. With open models, nothing leaves the laptop:

TabPFN's v2 weights are open and run on a laptop with no account or login. It learns my filing system in context, on my machine, every time it runs. A closed classifier couldn't learn my folders without me uploading them.
Gemma 4 runs locally in Ollama, so the photos and PDF pages it reads stay on the Mac. Once the weights are downloaded, it all works offline, on a plane, with Wi-Fi off.
It costs $0 and needs no API key. A tidy tool that charges per file would be a strange thing to run every night.
It's swappable. SLOTH_MODEL=... points it at any other vision model in Ollama. Because the code is open, you can read for yourself that it never deletes, and trust it with your Desktop because of that.

Prize Categories

Best Use of TabPFN: TabPFN is the tidier. It learns your filing system from the files you already filed, in one forward pass, and only acts on its own confidence. Held-out on my real Desktop: 98.6% vs 28.9% for an extension rule, and 100% when it's ≥ 90% sure.
Best Use of Gemma: Gemma 4 runs locally to name junk files from a picture or the first page, and to route documents TabPFN isn't sure about. It uses schema-constrained JSON and can only pick folders that already exist.
Best Use of GitHub Copilot: the project is automated with GitHub Actions.
- On every push, CI runs the safety tests on macOS: secrets skipped, path tricks cleaned, the apply/undo roundtrip, a double Approve refused, and the review server refusing other hosts.
- It shellchecks the installer, then runs it on a clean macOS runner to prove the app gets built, signed and uninstalled.
- A second workflow builds the wheel and publishes the demo, the installer and the wheel to GitHub Pages.

FlipCheck: snap a thrift find, get a fair price and a ready listing (Gemma 4 + TabPFN)

mohamedaminehamdi — Wed, 21 Oct 2026 13:38:20 +0000

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

Posted after the submission window closed, so it's here to share the build rather than to compete.

What I Built

Every reseller knows the routine. You find something good at a thrift store or a car-boot sale, and then you spend ten minutes on eBay working out what it is, what it's worth and how to list it. Multiply that by forty items a weekend and the research eats the profit.

FlipCheck does that research from one photo:

What is it? An open vision model names the item: brand, model, visible condition, and the search a seller would type.
What's it worth? It pulls live eBay listings for that search and prices your item's condition as three numbers: quick sale, fair, and if you can wait. It also shows the closest listings.
The listing. An eBay title (80 characters max), an honest description and item specifics, each with a copy button.

Who would pay for it: part-time flippers on eBay, Vinted and Depop. Many already pay for listing tools and pricing spreadsheets. The pitch is simple: price an item in 15 seconds instead of 10 minutes.

Demo

FlipCheck isn't deployed yet. It runs locally in three commands:

git clone https://github.com/mohamedaminehamdi/flipcheck && cd flipcheck
cp .env.example .env        # add a SerpApi key; Gemma 4 defaults to local Ollama
uv run uvicorn app.main:app --port 8000

The repo includes a Render blueprint (render.yaml) for one-click hosting.

Code

mohamedaminehamdi / flipcheck

Snap a thrift find, get a fair resale price from live eBay listings (TabPFN) and a ready-to-paste listing (Gemma 4).

FlipCheck

Snap a thrift find. Get a fair resale price and a listing ready to paste.

For eBay, Vinted and car-boot flippers who price dozens of items a week and hate the research.

photo ──> Gemma 4 (vision) ──> "Canon AE-1 with 50mm f/1.8, used"
      ──> live eBay listings for that search (SerpApi)
      ──> TabPFN learns a price model from those listings, on the spot
      ──> quick sale · fair · patient price, plus the closest listings
      ──> Gemma 4 writes the title, description and item specifics

How the price works

Identify. Gemma 4 names the item from the photo: brand, model, visible condition and the search a seller would type. You can edit the search before anything is priced.
Market. Up to 200 current eBay listings for that search, via SerpApi. Lots, sponsored listings, unrelated titles and price outliers are dropped.
Price. TabPFN is a tabular foundation model. It…

View on GitHub

How I Built It

photo ──> Gemma 4 (vision)       "Canon AE-1 with 50mm f/1.8, used"
      ──> SerpApi eBay search    up to 200 current listings, cleaned
      ──> TabPFN                 a price model fitted on those listings, on the spot
      ──> Gemma 4                title, description, item specifics

The app renders each step as soon as it's ready. You see what it thinks the item is first, and you can fix the search before any market data is spent.

Step 1: Gemma 4 identifies the item

Gemma 4 gets the photo and must answer in a strict JSON schema: title, brand, model, condition, search query and confidence. I tested the small gemma4:e4b locally through Ollama on four freely licensed photos:

Photo	Gemma 4 E4B said
Canon AE-1	Canon AE-1 with 50mm f/1.8	✅
Original Game Boy	Nintendo Game Boy	✅
Coach Borough bag	Coach, model unknown, low confidence	✅ honest
Air Jordan 4 "White Cement"	Nike Air Max 90, high confidence	❌

Two lessons:

Make it look before it names. I added a visible_marks field that comes first in the schema: list every logo, label and printed detail you can see, then name the item. That fixed the overconfidence on the bag. It didn't fix the sneaker, where the 4B model saw a "red swoosh" instead of a Jumpman. Telling sneaker models apart is hard, and a bigger model is the real fix.
Small models invent features. The listing writer said the Game Boy had "stereo sound capability". Only through headphones. The prompt already forbids specs it can't see. That's why the hosted version uses the 31B Gemma 4 through an OpenAI-compatible endpoint (DigitalOcean or OpenRouter). Switching is one environment variable.

Step 2: live eBay listings, honestly labelled

SerpApi's eBay engine no longer returns sold listings, and eBay's sold-price API needs approval. So FlipCheck prices against current asking prices and says so on every result: "Sold prices are usually a bit lower."

Before pricing, the comps are cleaned:

sponsored listings and bulk lots are removed
titles that don't share most of the search's words are dropped
outliers (accessories, damaged lots) are trimmed with a robust log-price band

Step 3: TabPFN prices this item

This is the part I like most. TabPFN is a tabular foundation model: it fits a small table in one forward pass, with no training run. So every search gets its own price model, fitted on that search's fresh listings.

For each listing it sees:

condition
auction vs buy-it-now
shipping cost
seller feedback
how closely the title matches

It predicts the 25th, 50th and 75th percentiles of log price for an item in your condition. Below 8 good listings, it falls back to plain percentiles; below 3, it says there isn't enough data.

It's fast enough to forget about: 0.1 s for 50 listings, 0.2 s for 200, on CPU. In the test suite, on a synthetic market, it prices "new" above "used" and keeps quick ≤ fair ≤ patient.

Built to survive the public internet

A pricing tool spends real money on every check, so the API is guarded:

Rate limit per IP. It's keyed on the address the hosting proxy writes, so a faked X-Forwarded-For doesn't reset it, and IPv6 clients are grouped per /64.
Upload size. Bodies over 12 MB are refused before they're read, and decompression-bomb images are rejected.
API keys never appear in errors. There's a test that tries to leak one.

CI runs 10 offline tests plus the real TabPFN test on every push.

Why Does Open Innovation Matter?

Because a side hustle only works if the cost per check rounds to zero.

The model licence decides whether you can sell it. TabPFN's v2 weights (Apache 2.0 plus attribution) may be hosted commercially; its newer weights are non-commercial. FlipCheck uses v2 on purpose. With a closed model, that question never even comes up. You just get whatever the pricing page says this month.
No training pipeline to maintain. TabPFN learns from each search's listings in a fraction of a second, so prices are always current. There's nothing to retrain when the market moves.
Swap the brain, keep the business. Gemma 4 is open-weight. The same code runs on a laptop with Ollama, on DigitalOcean, or on OpenRouter. If one provider raises prices, you change one environment variable.
It can run on the seller's own machine. For people pricing hundreds of items, a local model means no per-image fee at all.

My Agent Session

I built FlipCheck with Claude Code as my pair programmer: the research (which is how I found out sold listings were gone), the TabPFN pricing design, and the security hardening.

Prize Categories

Technologies used (posted after the deadline, so for the record rather than for judging):

Gemma: identifies the item from the photo and writes the listing, with schema-constrained JSON.
TabPFN: the pricing engine, fitted on each search's live listings with no training, giving prediction intervals.
SerpApi: the eBay market data integration (built and tested offline; live runs need an API key).
GitHub Copilot: GitHub Actions CI runs the offline and TabPFN tests on every push.

What's next: real prices for the four examples, a hosted 31B Gemma for better sneaker IDs, and a first real reseller. If you flip things and want to try it, tell me in the comments.

I built AI skills that tailor my CV to every job link

mohamedaminehamdi — Thu, 15 Oct 2026 10:33:15 +0000

Job hunting has an annoying loop: read the posting, rewrite the CV, work out
who to contact, write the message. Then do it again for the next job. Most
people skip the rewrite and send the same CV everywhere, and that CV is rarely
the right one.

So I built jobhunt: eleven skills for the coding agent you already use
(Claude Code, Codex, Gemini CLI, Cursor, Cline or Windsurf). You paste a job
link, and you get a CV built for that posting, the people worth messaging, and
the message to send them.

▶️ 22-second demo · 🌐 Site · 💻 Code

Same facts, better order

Here's the idea in one picture. The same six lines from one profile, against
one posting:

Most readers stop after the first screenful. On the CV you send everywhere,
your three strongest lines for this job sat below it. Nothing about your
experience changed, only what a reader meets first.

What happens when you paste a link

You say something like:

prepare an application for https://boards.greenhouse.io/acme/jobs/42

and it runs, in order:

Your profile, once. The first run reads your CV into profile.yaml and stops so you can check it. A model just read your career, so you approve it once and everything after is built on facts you agreed to.
The posting. It reads the page in your own browser and pulls out what the job actually asks for.
Fit, before. Every requirement is checked against your own work: what backs it, and what's a real gap.
A CV for this job. Your strongest lines for this posting move to the top.
Fit, after. The same check again, so you can see what the tailoring bought you.
Cover letter and PDFs. The letter is written in the posting's language, and you get PDFs of both.
Critique. What's still weak, before you send.
Outreach. Who to message (alumni first, because they're the ones who reply), the LinkedIn searches that find them, and a draft note.

Everything lands in one folder per job. Each skill also works on its own: "how
good is my CV?" runs just the review, and "how well do I match " runs
just the fit score.

How it's built

Each skill is two halves:

SKILL.md, the judgement half. It holds plain-language instructions for the model: what to read, what to decide, when to stop and ask.
A small Python script, the exact half. Argv in, JSON out. It does the scoring, the ordering and the PDFs: anything that should be the same every time.

That split is why there's no API key. Your agent is the model, so whatever
you already pay for covers it. The scripts use only the Python standard
library, run on the 3.9 that ships with macOS, and each skill carries its own
copy of the library, so one skill installed alone works exactly like all
eleven.

Not making things up

A CV tool built on a language model has one obvious failure: inventing things.
jobhunt handles it structurally rather than with a promise:

Roles come from your profile. The CV is assembled from roles picked out of your profile, not written from scratch.
Added skills are dropped. A skill the model adds that your profile doesn't list is removed, and you're told.
Unbacked claims are flagged. If the tailored CV still names something your profile doesn't back, the after score says so: claimed but not evidenced.

It also never applies, never logs in and never sends anything. LinkedIn walls
off automated access, and the risk would land on your account, so it builds the
searches and you run them.

Try it

Inside Claude Code:

/plugin marketplace add mohamedaminehamdi/job-hunter
/plugin install jobhunt@jobhunt

Any other agent, on macOS or Linux:

curl -fsSL https://raw.githubusercontent.com/mohamedaminehamdi/job-hunter/main/install.sh | sh

Or download the folders from the site
and drop them in. It needs Python 3.9+ and Chrome, Chromium, Edge or Brave.

What's next

One-click apply on the boards that allow it, jobs found for you, and
application tracking. None of that is built yet: today it prepares the
application, and you send it.

jobhunt is free for your own job search, and the code is on GitHub. If you try
it, I'd love to hear where it breaks: open an issue, or leave a comment here.

I built jobhunt with Claude Code, and drafted this post with Claude's help.

Leaf & Gill: an offline plant and mushroom identifier that knows when it's guessing

mohamedaminehamdi — Sun, 11 Oct 2026 22:26:33 +0000

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

The best places to hike have one thing in common: no signal. That's exactly where you find the plant you want to name, or the mushroom you really shouldn't touch. It's also exactly where every identification app stops working, because they all send your photo to a server.

So I built one that doesn't.

What I Built

Leaf & Gill identifies wild plants, trees and mushrooms offline, anywhere in the world. You open it once with Wi-Fi, and it saves an open-source AI model to your phone, like downloading offline maps. After that it works in airplane mode, at the top of a mountain or at the bottom of a forest.

You snap a photo, glance at the answer and put the phone back in your pocket. That's the whole interaction, so the screen is the shortest part of the walk.

For every photo you get:

The top 5 matches out of 11,896 of the most-observed plants and fungi on Earth. Never a single verdict.
A trust meter (Very likely, Likely or Not sure) that has learned when the model is guessing.
Red warnings for deadly look-alikes. The warning appears when a toxic genus is among the matches, and also when it's a known look-alike of the top match. In testing, a photo of poison hemlock was once identified as coriander. The red banner still warned about hemlock.
"Often confused with", computed from the model itself rather than written by hand.
A short description from Wikipedia, with every sentence about eating removed.
A life list of your finds, which never leaves the phone.

It never tells you something is edible. Every mushroom result says: never eat a wild mushroom based on an app. That isn't just a disclaimer. In a 2023 study of mushroom-poisoning cases in Australia, the best identification app got the species right only 49% of the time. Safety shaped every design decision below.

Demo

Try it: https://mohamedaminehamdi.github.io/leaf-and-gill/
On an iPhone, open it in Safari, choose Share → Add to Home Screen and open it from the icon. The first launch downloads the model (609 MB) in the background. After that, turn on airplane mode and it still works.

No plant photo handy? Tap one of the example photos (fly agaric, poison hemlock, chanterelle, dandelion). They answer instantly, even while the model is still downloading, so you can see the warnings and the trust meter in action.

Deadly look-alikes	A classic mix-up

On the right, a chanterelle is only rated Likely, not certain, and the app warns about the toxic jack-o'-lantern that chanterelle hunters confuse it with.

Code

mohamedaminehamdi / leaf-and-gill

Identify wild plants, trees and mushrooms offline, anywhere. Open-source AI (BioCLIP 2) running on your phone.

Leaf & Gill

Identify wild plants, trees and mushrooms offline, anywhere in the world. An open-source AI model runs inside your phone's browser. No signal, no account, no install, no photo ever uploaded.

Try it: https://mohamedaminehamdi.github.io/leaf-and-gill/ On an iPhone, open it in Safari and choose Share → Add to Home Screen The model is downloaded once (~600 MB, like offline maps) and works in airplane mode after that.

Snap	Deadly look-alikes	Honest uncertainty

What it does

Point the camera at a leaf, a tree or a mushroom, then put the phone back in your pocket.

Top 5 matches from 11,896 of the most-observed plants and fungi on Earth, never a single verdict.
A trust meter (Very likely / Likely / Not sure) that knows when the model is guessing.
Red warnings for deadly look-alikes, from a hand-written list of toxic genera
- When one is among the matches.
- When…

View on GitHub

How I Built It

The model: BioCLIP 2, inside the browser

BioCLIP 2 is an open model from the Imageomics Institute, released under the MIT licence. It was trained on 200 million biology images across the tree of life. It works like CLIP: it turns a photo and a species name into vectors, and a photo lands closest to its own name. That means I don't need a classifier for a fixed list. I can match photos against any list of names.

Export. I exported BioCLIP 2's image half to ONNX and converted it to fp16, which comes to 609 MB. Before uploading it to Hugging Face, I checked it against the original PyTorch model on real iNaturalist photos: the minimum cosine similarity was 1.00000.
Species list. I pulled the 11,896 most-observed plants and fungi worldwide from GBIF, counting human observations only. The deadly species are force-included however rare they are, because the app must always be able to warn about a death cap.
Names. I turned every name into a vector once, at build time, using BioCLIP 2's text half. The result is an 18 MB file the phone downloads with the app.
On the phone. onnxruntime-web runs the image half on the GPU through WebGPU, falling back to WebAssembly. One photo becomes one vector, which is compared against 11,896 names. That takes about 150–300 ms on a laptop GPU.

The app itself is one HTML file and one JavaScript module. There's no framework and no build step. A service worker caches the app, and the model sits in the browser's Cache Storage.

No generated text, anywhere

Writing field-guide cards with an LLM was tempting. For a tool that talks about poisonous mushrooms, it was also the wrong call. So nothing in the app is generated:

Names come from GBIF.
Descriptions come from Wikipedia, credited. A filter drops every sentence that mentions eating, taste, cooking or foraging.
"Often confused with" comes from the model itself. For each species, I find the most similar species from a different genus, because cross-genus mix-ups are the ones that hurt people. Some of what fell out:
- Wild carrot → poison hemlock
- Morel → false morel
- Chanterelle → false chanterelle
- Wild garlic → lily of the valley, autumn crocus
Danger warnings come from a hand-written list of toxic genera, with no AI involved.

A small test suite runs in CI and fails the build if edible, tasty or delicious appears anywhere in the shipped data. It caught three things I'd never have spotted by eye:

GBIF's common name for Musa acuminata: "Edible banana".
Wikipedia's "the delicious milk cap".
My own warning text, which said one plant "resembles edible members of the carrot family".

The trust meter: TabPFN learns when to doubt

A raw model score is a bad guide: it says "100%" far too often. So I measured how often it's actually right.

The test set. I collected 3,000 iNaturalist research-grade photos observed after June 2025, newer than BioCLIP 2's training data, so it can't have memorised them.

	Plants	Fungi
Right species as the top match	85.3%	85.4%
Right species in the top 5	97.4%	96.6%

Figures are for photos of species in the pack.

Then the real-world catch: 22% of the photos were species outside the pack. On a real trail you'll photograph things the app doesn't know, and a good app should say "not sure" when that happens.

The meter. TabPFN is an open tabular foundation model. It learns from a small table in one pass, with no training run. I gave it four numbers per photo, labelled with whether the top match was right:

the top match's probability
its lead over the runner-up
how close the photo is to the best name at all
whether it's a plant or a fungus

Results. I tested it on 1,219 held-out photos:

	Raw model score	TabPFN trust meter
Separates right from wrong (AUROC)	0.817	0.843
Calibration (Brier, lower is better)	0.167	0.148
Answers it dares to call "Very likely"	1.1%	23.6%

The miss. I aimed for top-band answers to be right at least 95% of the time. On held-out photos it reached 92.4%. So the top band is labelled "Very likely", not "Confident", and every result shows the calibrated "% likely right" next to it.

On the phone. TabPFN can't run in a phone browser, so I evaluate it on a 21×21×21 grid for each kingdom and ship the predictions as JSON. The phone interpolates between grid points, offline.

Why Does Open Innovation Matter?

Because the trail has no signal, and closed apps need one.

It runs with no internet. That's only possible because the weights are open. I could download BioCLIP 2, convert it, shrink it and run it in Safari. With a closed API, the model stays on someone else's server, and so does your photo.
Your photos and location stay yours. Nothing is uploaded, ever. There's no account, no analytics, no server.
I could measure it honestly. Because I own the whole pipeline, I could test the exact model the phone runs on photos it has never seen, publish the numbers, and build a trust meter on top. With a closed model I'd be trusting a marketing page.
It costs nothing per photo. No API key, no quota, no bill. It runs on GitHub Pages for free.
Anyone can fix it. Every piece is open: BioCLIP 2, GBIF, Wikipedia, onnxruntime, TabPFN, and this repo (MIT). Anyone can extend the danger list, rebuild the species pack for their region, or swap in a better model next year.

An open model from a biology institute, open species data from GBIF, and an open tabular model from Prior Labs, all running offline in a browser on a hiking trail. That combination isn't available from any closed API.

My Agent Session

I built this with Claude Code as my pair programmer, from the first research question ("can a 609 MB biology model run in iPhone Safari?") to the evaluation and the safety tests.

Prize Categories

Best Use of TabPFN: TabPFN is the app's trust meter. It learned from 1,781 labelled photos when BioCLIP 2's answer can be trusted, and beats the raw model score on held-out photos (AUROC 0.843 vs 0.817, Brier 0.148 vs 0.167). Its predictions ship as a grid the phone reads offline.
Best Use of GitHub Copilot: the project is automated with GitHub Actions:
- CI runs the offline safety tests on every push: no edibility wording, every deadly species present and flagged, classic deadly mix-ups raise the alarm, and the pack and trust grid are consistent.
- A second workflow deploys the app to GitHub Pages.

Not a substitute for an expert. Never eat anything based on an app. Go outside anyway. 🌿🍄

The Localhost Times: a private morning newspaper, printed on your laptop by Gemma 4

mohamedaminehamdi — Mon, 05 Oct 2026 00:53:40 +0000

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

In 1995, Nicholas Negroponte imagined "The Daily Me": a newspaper edited for exactly one reader. Thirty years later we got the opposite: a dozen apps, each fighting for the first ten minutes of our morning.

What I Built

My friend starts every day the same way, half awake with a toothbrush in hand. Open Gmail. Open the calendar. Check the weather. Scroll the news. By the time he's worked out what actually matters today, the coffee is cold. So he asked me for something simple: read it all for me, and tell me what my day looks like.

There was one condition: he didn't want to hand his entire inbox to yet another cloud AI.

So I built The Localhost Times: All the news that's fit to print. Printed on your machine.

Every morning it reads your inbox, today's calendar, your tasks, the weather and the news. Then an open-weight model running on your own laptop writes two things:

📰 A one-page newspaper you can flip through in the browser (it really turns pages) or read straight from your inbox.
🎧 A 3-minute audio briefing, written to be heard while you brush your teeth.

The paper has a front page with the headline of your day, then:

Today: your calendar.
Must do: actions pulled from your email and tasks.
Waiting on you: people who need a reply.
Worth knowing: things that need no action.
The world: the four stories most relevant to you.

Demo

Landing page: (https://mohamedaminehamdi.github.io/the-localhost-times/). It's a newspaper you flip through (drag a corner, swipe, or use the arrow keys), with a .env builder that runs entirely in your browser.
Today's demo edition: https://mohamedaminehamdi.github.io/the-localhost-times/demo/. It was written by Gemma 4 for Sam, a made-up reader with a made-up inbox, using real news and real weather. Press play on the audio bar.

Code

mohamedaminehamdi / the-localhost-times

A private morning newspaper + audio briefing from your inbox, calendar and news, written on your own machine by Gemma 4. All the news that's fit to print. Printed on your machine.

The Localhost Times

All the news that's fit to print. Printed on your machine.

A private morning newspaper with exactly one reader: you.

Every morning it reads your inbox, today's calendar, your tasks, the weather and the news Then an open-weight model running on your own laptop (Gemma 4 via Ollama) writes:

a one-page newspaper you can flip through in the browser or read in your inbox, and
a 3-minute audio briefing to listen to while you brush your teeth.

A friend asked for it. They wanted their whole day to fit on one page, without handing their inbox to someone else's cloud.

Live demo (a made-up reader, Sam): https://mohamedaminehamdi.github.io/the-localhost-times/ · demo edition

How it works

 mail (IMAP, read-only) ─┐
 calendars (iCal) ───────┤
 Todoist · GitHub ───────┼──> Gemma 4 on your laptop ──> edition.json ──┬─> newspaper (flip-through web page)
 weather (Open-Meteo) ───┤    (Ollama, JSON schema,                     ├─> audio briefing (ElevenLabs or

…

View on GitHub

How I Built It

The editor is Gemma 4 (gemma4:e4b), running locally through Ollama. The whole thing is one morning run:

mail (IMAP, read-only) ─┐
calendars (iCal) ───────┤
Todoist · GitHub ───────┼──> Gemma 4 on your laptop ──> edition.json ──┬─> flip-through newspaper
weather (Open-Meteo) ───┤    (Ollama, JSON schema)                     ├─> audio briefing
news (Google · RSS · HN)┘                                              └─> email · Telegram · Slack · Discord · ntfy

A few decisions made it work:

1. The model answers in a schema, not in prose. Ollama's structured outputs take a JSON schema (headline, lede, must_do_today, needs_reply, fyi, news, podcast_script). That way a 4B-class model on a fanless MacBook Air returns something I can lay out every single time. For the news it doesn't rewrite headlines. It picks stories by index, so every link in the paper is real.

2. The prompt is mostly about not making things up. It says "Use ONLY the facts in the input". My first test run then taught me three more rules:

Gemma read Sunday night's "before our call tomorrow" on Monday morning and told the reader the call was tomorrow. Now: an email received yesterday that says "tomorrow" means today.
It filed a bank's "new sign-in" alert under "worth knowing". Now: a security alert is always the first must-do.
It padded "Must do" with calendar events. Now: must-dos are things you actively do: send, pay, reply, check.

A small model follows rules it is given explicitly, and stumbles on rules it's expected to infer.

3. One setting that's easy to miss: Ollama's default context window is small. Forty emails plus the news overflow it, and the model silently never sees the rest. num_ctx: 16384 is the most important line in the project.

4. Integrations are one function plus one line. Every source and delivery is a plain function, switched on by its environment variables in a small registry:

SOURCES = {
    "mail":     (("MAIL_USER", "MAIL_PASSWORD"), sources.mail,      "emails"),
    "calendar": (("ICAL_URLS",),                 sources.calendars, "calendar"),
    "todoist":  (("TODOIST_TOKEN",),             sources.todoist,   "tasks"),
    "weather":  (("WEATHER_CITY",),              sources.weather,   "weather"),
    # ...
}

That gives 20+ integrations:


Mail (IMAP)	Gmail, iCloud, Fastmail, Yahoo, Zoho, AOL, GMX, any IMAP server
Calendars	Any iCal link: Google, Outlook, Apple
Tasks	Todoist, GitHub notifications
Weather	Open-Meteo
News	Google News, any RSS feed, Hacker News
Editor	Ollama, or any OpenAI-compatible local server: LM Studio, llama.cpp, vLLM, Jan
Delivery	Email, Telegram, Slack, Discord, ntfy

A broken source is logged and skipped, because one flaky API should never cancel the morning paper. uv run localhost-times --list shows what's switched on.

5. Nearly everything is the standard library. It uses imaplib (opened read-only with BODY.PEEK, so nothing gets marked as read), smtplib, urllib and xml.etree. There are only three runtime dependencies:

icalendar
recurring-ical-events, because your daily standup is a recurring event and a naive parser misses it
python-dotenv

6. The voice. The briefing script is written for the ear: no lists, no URLs, no email addresses. By default macOS's built-in voice reads it aloud (that's what the demo uses), so the whole pipeline runs with the wifi off. Add an ElevenLabs key and it switches to ElevenLabs.

7. The paper turns. The demo edition and the landing page use StPageFlip: drag a corner and the page curls.

Desktop shows two-page spreads sized to your window.
Phones get a calm scrolling paper.
So does anyone with prefers-reduced-motion turned on.
The emailed edition is the same pages in one column, because mail clients strip scripts.

On my fanless M3 MacBook Air, Gemma 4 prints a full edition in 70 to 90 seconds, before the kettle boils.

Why Does Open Innovation Matter?

Your inbox is the most private thing you own. It holds your bank's security alerts, your doctor, your landlord, your mum.

The AI morning briefings I tried all work the same way: connect your Google account, and their servers read your mail. For my friend that was a deal-breaker, and I think he's right.

Open-weight models change that deal:

It runs where the data already is. Gemma 4 reads the mail on the laptop the mail is already on. Nothing is uploaded to be summarised. Every edition carries an honest byline, "Written on-device by gemma4:e4b". If you point it at a remote server, the byline says so.
It costs nothing per morning. No API bill, no subscription, no rate limit, so it can run every day for years.
It can't be taken away. No one can deprecate the model, change the terms or start training on my friend's mail. The weights are on the disk.
It works offline. With the macOS voice, you can print your paper on a plane.
It's open all the way down: Ollama, Gemma, StPageFlip, Open-Meteo, Hacker News's public API. The project is MIT licensed so anyone can print their own paper, and the README shows how to add an integration in three steps.

A closed API would have made this easier to demo and impossible to trust. Here, open was the feature.

Handing It Over

I handed my friend The Localhost Times. He likes it, and he said it will help him be prepared for his morning. That was the whole brief.

My Agent Session

I built this overnight with Claude Code as my pair programmer.

Prize Categories

Best Use of Gemma: Gemma 4 (gemma4:e4b) is the editor. It runs locally through Ollama and writes every edition as schema-constrained JSON: the headline, the triage of your inbox, the news picks and the spoken script.
GitHub Copilot: the project is automated with GitHub Actions. One workflow runs the offline test suite and the CLI on every push and pull request. Another publishes the landing page and the demo edition to GitHub Pages.

Thanks for reading! If you print your own paper, tell me what was on your front page. 🗞️