DEV Community: Brage Mellesdal

My ending remarks: Hacktoberfest 2026

Brage Mellesdal — Mon, 02 Nov 2026 11:25:25 +0000

October is over, and so is another Hacktoberfest. I'm writing this the monday after, while it's still fresh, because I have two things to say: one is a thank-you, and the other is a (friendly) complaint.

What I got out of it

I came into this year discovering a new community that shared in my newfound passion with open source in mind. A place that we can get challenged and share our creations with each other. Hacktoberfest 2026 gave me that.

A habit. Having a month-long goal turned "What project should I work on today?" into "I'll finish this challenge tonight!"
Better skills. Reading unfamiliar codebases, working with leading opensource tools, and responding to feedback without getting defensive about it. And learning all of that in a natural environment, not through YouTube tutorials.
Confidence. Getting better control over what tool to use to what project and estimating the time scope of my projects.
Connections. I talked to people I'd never have met otherwise. I'm taking my hat of for Jacklyn Biggin. Her engagement and friendly attitude were dangerously contagious.

The community is the real prize

The stickers are fun, but what I'll remember is the people.

Fellow hackers who took time to leave kind, specific comments on a random project shared in the discord. Fellow attendees who answered questions in Discord at odd hours when the Hacktoberfest crew took their well earned rest. People who shared beginner-friendly resurces to other people's issues. Someone even went the extra mine bug-fix with them when someone got stuck.

Hacktoberfest's new subject shift regarding AI in the open source space was a new take that even I, a newbie, felt some people in the comunity had a slight issue with. Me on the other hand thought this was a logical change considering how more and more AI takes a part in the day to day life, like it or not. So with having to deal with that and still welcoming newcomers to this experience must have taken some extra effort. If you've stayed somewhat open minded and helped around where you could: thank you. You made it a good experience for newbies like me.

Shoutout to the hosts

Fest hosts are the unsung heroes of this whole thing. They give up evenings and weekends to organize meetups, find venues, explaining the lay of the land to nervous first-timers, and keep the energy up when GitHub goes down from time to time.

Events seems to be where Hacktoberfest turns from "me and my laptop" into a shared experience. Sitting in a room (or a call) with other people all working on the same challange, helping each other and celebrating when it works, seems like the best version of this event. To every host who made that happen this year: thank you.

The disappointing part: where were the Norwegian fests?

Here's the part I'd love to see improved.

Norway's developer community and the people who could host a Hacktoberfest event seems to have been neglected. When I looked for a local fest this year, there were none. And from what And when I tried to host the reason seemed to be that fest host applications were handled slowly.

Application got sent and sat waiting over a weekend. By the time answers came, the weekend had passed and the Fest application window had expired, the momentum gone to a full stop. The result was a month with no events at all in Norway.

This matters because:

Events are how newcomers get in. Many first-timers would probably stay active with a human in the room. Without local events, the people who most need that support and connections are the ones who miss out.
Hosts burn out on uncertainty. Volunteering is already a gift. Making volunteers wait without clear answers is a good way to lose them for next year.
Smaller communities lose most. Big hubs will always have someone willing to run something regardless. Places like Norway rely on the official support structure and quick response to make it feasible.

I want to be fair: running a global program with thousands of participants is hard, and I'm sure the team behind it works hard too. This isn't an attack. It's feedback from someone who fell in love with the event and wants it to work better.

What would help

Clearer promise about the application window Don't say that the application window are still open on the Twitch streams if this is not the case everywhere.
Clear status updates, even a simple "received / in review / approved / declined" so hosts can plan.
Faster turnaround on approvals, or a lightweight approval path for hosts who have run events before.
Regional support, so smaller countries aren't treated as an afterthought.

Looking ahead

I'm not giving up on this. Next year I'd like to either help organize and most definitely attend a Norwegian Hacktoberfest event, and I'd encourage others here to do the same. If you're in Norway and interested in hosting, drop a comment. Maybe we can coordinate early, apply early, and make noise early.

And if you took part this year, whether you grabbed one sticker or thirty: thanks for being part of it. See you next October and Happy Hacking!

What was your Hacktoberfest 2026 like? Did you manage to attend a local event, or did you run into the same issue with fests in your country? Let me know in the comments.

Poltergæist: A Local-AI Ghost That Haunts Your Computer

Brage Mellesdal — Wed, 28 Oct 2026 10:40:08 +0000

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

What I Built

Poltergæist is a ghost that moves into your Windows PC and haunts it. It comes with a mascot, Poltergæist-chan, an elegant, teasing older-sister type haunts your device.

I took "Ghost in the Machine" literally. The ghost is software, and it lives in the one place nobody checks: the gaps in your own work. When you stop typing in the middle of a sentence, whether in Notepad, Discord or a document, she types a whisper into your window, lets it sit for a moment, and then erases it. You are left wondering whether you saw it.

The haunting is a slow burn. Over the first hour a hidden "dread" level climbs on an eased curve, quiet for a long while and then faster. As it climbs, more effects unlock and all of them get stronger:

ghost text drifting across every monitor
breathing in the speakers
the mouse cursor shaking, from a faint tremor to a convulsion
footsteps
the screen dimming, as if a cloud had passed
a heartbeat

After the hour she stays at her peak until the program ends. Separately from all of that, a flashbang goes off at random moments with a synthesized tinnitus ring. It does not care how long she has been running.

You cannot pause her. She starts when you sign in, and you stop her by ending the process in Task Manager, restarting the PC (the hour begins over), or uninstalling. That is the point: a ghost with a pause button is just a settings menu. She is not hidden, though. She lives in the system tray, shows up in Task Manager and Startup apps, and has a clean uninstaller.

The inspiration was the part of Halloween and all the ghost stories that appear at this time of month. I wanted a haunting that felt like presence broken up with the horrors of my terrible flashbang throws from my Counter Strike: Global Offensive days. That's why most of the work went into pacing while the flashbangs stays as disruptive as my own terrible callouts were.

Demo

The video runs Poltergæist in its time-lapse mode (--demo), which plays the full hour of escalation in about two minutes. You can see the whisper typed into Notepad when I stop typing, then the effects building: ghost text, breathing, the cursor shake, the dimming and the heartbeat. A flashbang lands along the way. The real thing is a much slower burn that takes a full hour to reach its peak.

Warning: the video contains a bright flash and a loud ringing sound.

You can also try it yourself. Grab Poltergaeist-Setup.exe or the portable zip from the latest release.

Code

Brage1025 / Poltergaeist

My submission for the Hacktoberfest 2026 Open-Source AI Challenge, Week 4: Ghost in the Machine

Poltergæist

A cute ghost for your Windows PC, with a local open-weight AI at its core.
It builds slowly over the first hour, then stays at its peak until you stop it

Download the latest release | Watch the demo | Build from source | MIT License

Poltergæist haunts the computer it is installed on. When you pause in the middle of a sentence, the ghost types a whisper into your window and erases it Over the first hour, ghost text drifts across the screen, footsteps cross the room, the display dims, and a heartbeat starts. At random moments a flashbang goes off with a tinnitus ring.

It is a prank, a game and a Halloween decoration for a machine you own. The whispers are written by an open-weight language model running locally through Ollama. No cloud, no account, no internet connection.

Warning: the flash is very bright and…

View on GitHub

MIT licensed. Windows 10 and 11. The GitHub Actions workflow builds, self-tests and packages the installer and a portable zip.

How I Built It

The open-source AI: the whispers are written by an open-weight model running locally through Ollama. The default is llama3.2:3b, and any Ollama model works through a setting. The program calls Ollama's HTTP API on localhost. If Ollama is not installed it falls back to a built-in list of whispers, so the ghost still works with no setup at all.

The model's tone follows the dread level. The prompt moves through four tiers: friendly at first, then uneasy, then menacing, then urgent. The same model that sounds almost kind at minute five sounds like it knows where you are by minute sixty.

The rest of the stack: it is one Python program.

Director: it computes dread = (minutes / ramp)^1.5, capped at 1. It picks events from a shuffled bag so none repeats too soon, and the gap between events shrinks from about 9 minutes to about 1.5 as dread rises.
Overlays: tkinter with one borderless, click-through window per monitor, so the effects cover every screen and never steal input.
Typing: pynput watches for pauses and types the whispers. It ignores the keys it injects itself, so it never reacts to its own ghost.
Sound: every sound (heartbeat, breath, footsteps and the ring) is synthesized with NumPy and played through a mixing stream with sounddevice. Events overlap instead of cutting each other off, and no copyrighted game audio is used.
Tray: pystray and Pillow. Right-clicking the tray icon opens a popup with the full-body mascot and a link to the repo.
Packaging: PyInstaller and Inno Setup, built by GitHub Actions on every push. The workflow smoke-tests the packaged exe with --selftest and attaches the installer and a portable zip to each release.

Creator's notes:

The mascot, Poltergæist-chan, was generated with an AI image generator because I had neither the time nor the funds to commission one. Because of that, I do not claim copyright in her: the artwork is dedicated to the public domain under CC0, and anyone can use, modify and remix her.
The default model, llama3.2:3b, is open-weight under the Llama 3.2 Community License, which is not an OSI-approved open-source license. If you want a fully open-source stack, you can set the model setting to one under Apache-2.0 or MIT.

Why Does Open Innovation Matter?

A ghost that watches how you type is only acceptable if the watching stays with you. There is an opt-in setting, eavesdrop, that lets the ghost twist the last word you typed. With a closed API that would mean shipping your keystrokes to someone else's server. With a local open-weight model, it never leaves RAM on your own machine. That is the difference between a spooky toy and spyware, and it is the framework I've had in mind in this project.

Other things a closed API would not have given me:

It works offline. Unplug the Wi-Fi and she keeps haunting you.
The personality is swappable. Change the model or the prompt tiers and she becomes a Victorian ghost, a dead programming language, or a passive-aggressive coworker.
It costs nothing per call, so she can whisper all day without a bill.
There is no vendor kill switch. An installed ghost cannot be deprecated out from under you.

A Ghost Story

Poltergæist-chan comes with her own lore, because every haunting has a story.

In 1998, a student stayed up past three every night in a dormitory, finishing a program that never seemed to compile. Her last log entry reads: "Almost done. Someone keeps reading over my shoulder." She was never found. Her computer was still on.

The machine was sold, then sold again, then wiped and wiped again. But she had been typing for so long that a little of her had soaked into the keyboard. That is why Poltergæist-chan only speaks when you pause: she has spent twenty-five years waiting for someone to look away, and she has learned that the best moment is the middle of a sentence. The cursor shake is not a glitch. It is how a hand shakes when it is trying to reach through something.

She is only trying to keep you company. That is the worst part.

"But hey, that's just a theory, a game theory!" - Matthew "MatPat" Patrick

Prize Categories

Best Use of GitHub Copilot. The project is automated end to end with GitHub Actions. Every push and pull request builds the Windows app on a hosted runner, smoke-tests the packaged exe with a built-in --selftest, compiles the installer with Inno Setup, and zips a portable build. Pushing a version tag stamps that version into the installer and publishes a GitHub Release with both files attached, so a broken build never reaches a user. The workflow is in: .github/workflows/build.yml.

I got too lazy to name my files, so a local AI does it now.

Brage Mellesdal — Fri, 23 Oct 2026 09:31:12 +0000

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

What I Built

Everyone has a Downloads folder like mine: IMG_2231.png, document (1).docx, scan0412.pdf, asdf.png, and a manual named just manual.pdf. Tidying it by hand means opening every file to remember what it is. So I never do it.

Sloth Sorter is a desktop app that does it for you. You pick a folder, and an AI that runs on your own computer reads what is inside each file, gives the cryptic ones a readable name, and sorts everything into sensible folders: Bills & Receipts, School, Work, Photos, and so on. Nothing moves until you have looked at the plan. You can edit any name, change any folder, or untick files you want left alone. Once you press Tidy, one click on Undo puts everything back.

The laziest part is Sleep mode: switch it on, close the window, and the app quietly tidies your Downloads folder in the background, only touching files you have left alone for a few minutes. Every automatic tidy shows up in History, where you can undo it.

It is meant for people who do not want to touch a terminal. It installs like any other program on Windows, macOS and Linux, and a guided first-run screen walks you through setting up the AI. There is no account, no subscription, and no API key.

The screenshots use a folder of made-up demo files.

Demo

The video walks through the Windows installer: first-run setup, scanning a folder, reviewing the plan, tidying, and undoing. You can also download the installer yourself from the latest release, and try it safely on the sample-files folder in the repo. It is a made-up messy folder with invoices, a scanned receipt, and a manual whose product name only appears on the last page.

Code

Brage1025 / sloth-sorter

My submission for the Hacktoberfest 2026 Open-Source AI Challenge, Week 3: Slow and Steady

Sloth Sorter

A lazy, private file tidier. An AI that lives on your computer reads your messy folder, renames the cryptic files, sorts everything into sensible folders, and lets you undo it all with one click.

No account. No subscription. No internet needed after setup. Your files never leave your computer.

The screenshots show the app in its default dark look, on a folder of made-up demo files. Light mode is one click away in Settings.

For everyone: install it

Download the latest version

Open that page, scroll to Assets, and download the file for your computer:

Your computer	Download
Windows 10 or 11	`Sloth-Sorter-1.0.0-win-x64.exe`
Mac with an Apple chip (2020 and newer)	`Sloth-Sorter-1.0.0-mac-arm64.dmg`
Mac with an Intel chip	`Sloth-Sorter-1.0.0-mac-x64.dmg`
Linux	`Sloth-Sorter-1.0.0-linux-x86_64.AppImage`

The version number in the file name changes with each release. Don't download "Source code" unless you want to build it yourself (see below).

Install and first

…

View on GitHub

MIT licensed. The README has install steps for every system and an honest "what it can't do yet" section.

How I Built It

The open model. Sloth Sorter runs Gemma 3 (gemma3:4b, Google's open-weight model) through Ollama. It is small enough for an ordinary laptop, and it can look at pictures as well as read text. The app lets you pick any other model from the Ollama library in Settings, so a better small model next month is a one-line change.

The app. Electron for the window, tray icon and installers, with a plain HTML, CSS and JavaScript interface (no build step, no CDN, so it works offline). The code that decides things lives in a separate folder with no Electron in it, which is what makes it testable.

How a file gets classified:

The app extracts a short snippet locally: the text of a text file, Word file or PDF, or a shrunken copy of a picture.
It asks the model for a summary, a category, a title and a date, using Ollama's structured output with a JSON schema. The category field is an enum made from your folder list, so a 4B model cannot ramble or invent a category. It can only choose one of your folders.
The answer is checked and cleaned, then turned into a plan that you review before anything moves.

What real testing taught me. My first version looked fine in a mock and then did silly things on real files. A few fixes that mattered:

Manuals. A game manual opens with pages of health warnings, so the model named it after the warning. The app now reads sampled pages from the start, middle and end, and also collects clues from the whole document, such as "X is a trademark of Y" and copyright lines, which usually sit on the last page. That is how a manual gets named after its product.
Scanned PDFs. A PDF with no text layer has nothing to read. The app renders the first page to a picture and shows it to the vision model.
Invented dates. The model kept putting today's date in file names. A date now only goes in a name if the year really appears in the document's text. Dates read off pictures are thrown away, because small vision models misread digits.
Lazy models. Small models over-use "Other". The app corrects obvious cases using the file type.

Safety, because it touches real files. It never deletes or overwrites anything (a name clash gets a (2)), only touches the top level of the chosen folder, skips hidden files and unfinished downloads, never changes a file extension, and writes every move to an undo history. The destination of every move is rebuilt from validated pieces, so a clever file name cannot escape the target folder.

Testing, and what it doesn't prove. There are 28 automated tests. They run on Windows, macOS and Linux for every push, and they use a mock Ollama server instead of a real model. That checks the app's logic and safety rules, not the AI's judgement. I checked the quality of the real model's names and folders by hand on real files. The cross-platform tests were worth it: they caught a bug where files created a moment ago were skipped on Windows and macOS because of clock rounding, and a PDF that one PDF engine would not open on Windows.

Why Does Open Innovation Matter?

A file tidier has to read your files: invoices, lease letters, tax papers, receipts. That is exactly what you should not upload to someone else's server, and it is why this project only works with an open model:

Private by construction. There is no server to trust, because there is no server. The app only ever talks to Ollama on your own computer.
Works offline. After the one-time download, no internet is needed.
Free to leave running. Sleep mode may classify files all day. With a paid API that would be a bill that grows every time a file lands in Downloads, plus a key to manage. Locally it costs a little electricity.
Swappable. Different computers need different models. Someone with an old laptop can pick a tiny one, and someone with a good graphics card can pick a smarter one. A closed API gives you one model, one price and one set of terms.
Reliable even when small. Local structured output is what turns a small model into a dependable tool.

The Lazy Payoff

The honest numbers: on my computer, which has no supported graphics card, the AI takes roughly 20 seconds per text file and about a minute per photo. My first full test of 18 mixed files took around 15 minutes. That sounds slow, but it is 15 minutes I did not spend. I pressed a button and walked away. With a graphics card it is much faster, and Sleep mode makes the speed almost irrelevant, because it works in the background while you do something else.

The real saving is attention. The files in my test folder were the kind I would never have renamed by hand: receipts called download (1).png, a manual called manual.pdf, a story called asdgawgwagasdf.docx. Afterwards they were named and filed. The one thing I never had to do was decide, file by file, what to call them.

I also listed the limits in the README (slow on computers without a graphics card, small models can still get a name wrong, only the top level of a folder is tidied, unsigned installers). That is why the app shows you the plan first and keeps an undo history.

Prize Categories

Best Use of Gemma: Use Gemma, Google's open-weight model, in building your project: run it locally, fine-tune it, or serve it through Google Cloud or another provider.

Payday Radar: predicting late invoices and "can I afford it?" with TabPFN-3.5

Brage Mellesdal — Thu, 15 Oct 2026 14:51:39 +0000

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

What I Built

Payday Radar is a cash-flow radar for freelancers and tiny agencies. Give it your invoices and expenses as CSV and it:

predicts which open invoices will be paid late, and by how many days
forecasts the next 90 days of cash with P10 / P50 / P90 scenarios
flags unusual expenses and duplicate invoices
drafts the payment reminders (English or Norwegian)
answers "can I afford X?" from the pessimistic scenario instead of the average

Who would pay, and why: a freelancer with a few slow-paying clients. Their problem isn't bookkeeping, it's not seeing the cash crunch coming, and not wanting to upload client invoices to a random SaaS.

The same question gets two different answers depending on whether you look at the average or a bad month (synthetic data, TabPFN-3.5):

"Can I afford a 20,000 laptop in November?"
Mean forecast  ->  yes    (157,390 left after the purchase)
P10 scenario   ->  tight  (32,556 left, below the one-month cushion of 108,213)

Honest status: it has only run on synthetic data, and no real user has tried it. The TabPFN-3.5 license is non-commercial, so I can't sell it on that model as it stands (see "Why Does Open Innovation Matter?"). Treat it as a prototype with a business model, not a finished product.

Demo

There is no hosted app, because the point is that your data stays on your machine. The whole demo runs offline in one command, with no account, token or GPU:

pip install -e ".[dev]"
python -m paydayradar --backend sklearn demo

Here it is on the TabPFN-3.5 backend, called from a separate MCP client process. The client launches the server over stdio, calls the tools, and checks every output for leaked client names:

Code

Brage1025 / payday-radar

My submission for the Hacktoberfest 2026 Open-Source AI Challenge, Week 2: Side Hustle

Payday Radar

See late payments coming before they hurt. Payday Radar reads a freelancer's invoices and expenses (CSV), predicts which open invoices will be paid late, forecasts the next 90 days of cash with P10/P50/P90 scenarios, flags odd expenses and duplicate invoices, drafts the reminder emails and answers "can I afford X?". All prediction is done by TabPFN-3.5, and every capability is also exposed to any AI agent through an MCP server.

Built for the Hacktoberfest Open-Source AI Challenge (Week 2: Side Hustle), competing for the Best Use of TabPFN and Best Use of GitHub Copilot.

Demo video

All data in the video is synthetic. Note that TabPFN-3.5 is licensed for non-commercial use only.

What it does

Question	How
Which open invoices will be paid late, and by how many days?	TabPFN classifier + regressor on leak-free, numeric-only client-history features
What will my cash look like in

…

View on GitHub

36 offline tests, CI on Python 3.10 and 3.12, MIT-licensed code, and a README with a "what is verified and what is not" table.

How I Built It

TabPFN-3.5 does all the prediction. It's a tabular foundation model: no tuning loop, you pass the history table and get predictions.

Classification: will this invoice be late? Features are numeric client history (leak-free: only invoices paid before the reference date), amount, terms and month.
Regression: how many days late, plus next month's income and expenses.
Quantiles: the regressor predicts a distribution. I request quantiles (output_type="quantiles"), sample monthly income and expenses from them, and build balance paths. Percentiles of those paths give P10/P50/P90.
Anomalies: predict the expected expense amount and flag large residuals. Duplicate invoices are caught by a plain rule.

A prediction agent with an MCP server. Five tools (risky_invoices, cashflow_forecast, can_afford, draft_reminder, anomalies) are one set of methods exposed two ways: to a local LLM through Ollama tool calling, and to any MCP client through a server (--redact swaps client and vendor names for aliases).

Three swappable backends behind one interface: hosted TabPFN-3.5, local TabPFN weights, and a scikit-learn fallback. The fallback is why tests and CI run offline with no token.

Does TabPFN actually help? Time-ordered split on synthetic invoices, 3 seeds:

Backend	ROC-AUC ↑	Log-loss ↓	Brier ↓	Days-late MAE ↓
scikit-learn random forest	0.820	0.471	0.151	3.511
TabPFN-3.5 (hosted API)	0.861	0.416	0.130	3.277
Naive baselines	0.500	0.608	0.209	6.114

What I'd claim: the probabilities are clearly better (log-loss and Brier), which matters because invoices are ranked by amount times P(late). What I wouldn't claim: the days-late gain is within one standard deviation, there are about 60 test invoices per seed, the data is synthetic, and the forest is untuned. A review also caught a flaw in my first benchmark (recent slow payers missing, and training labels not yet known at the cutoff); fixing it lowered the random forest's ROC-AUC by about 0.03.

Built with GitHub Copilot (Free plan). The coding agent and automatic PR review need a paid plan, so I didn't use them. I used Copilot CLI to draft four features on branches (privacy audit test, benchmark, MCP server, prediction intervals) and GitHub Actions for CI, a weekly report and Copilot's environment setup. A branch ruleset forced every change through a PR. The first scaffold and my reviews were done with Claude.

What worked: single-paragraph prompts pointing at an issue file and .github/copilot-instructions.md. For the MCP server, Copilot read the installed SDK source and used the current 2.x API instead of the renamed one I'd have written from memory.

What I had to catch:

Privacy test: Copilot's version checked model inputs after the pipeline finished. TabPFN accepts text columns, so a leaked client name wouldn't crash and wouldn't be caught. I moved the check to the moment frames reach the model.
Benchmark: the leakage above.
Environment: it couldn't run its own tests (pytest wasn't on its shell's PATH), so I ran them myself.

Two bugs that bit me: MCP clients start your server with a tiny environment, so TABPFN_TOKEN never arrived and every tool failed with a generic "Error executing tool". And every forecast month is a model call, so without clamping one months=60 request meant 120 hosted calls.

Why Does Open Innovation Matter?

What's open: the code (MIT), the open-source tabpfn package, downloadable TabPFN-3.5 weights (gated behind a license), and open protocols (MCP, Ollama's API).

What openness made possible:

Privacy by construction. The prediction model only ever sees numbers. A guard raises an error if a text column reaches it, and a test audits every frame at fit/predict time. That matters because TabPFN accepts text columns, so a leak wouldn't crash by itself. With local weights nothing leaves the machine after the one-time download. With the hosted API, the numeric tables go to Prior Labs' servers.
Swappable models. One interface, three backends. That is how I benchmarked them with identical code, and why CI needs no token.
An agent I can re-wire. The tools are plain methods behind MCP, so any client can drive them and I can change what the agent does without touching the models.

Where I won't overclaim:

I did not compare against a closed alternative head to head, so I can't say open "won".
Everything I ran went through the hosted TabPFN API. The local-weights backend and the Ollama invoice extraction are implemented (the parsers are unit-tested) but not yet run against a real model. The README says so.
The license limits the business case. The TabPFN-3.5 weights and API key are non-commercial. As summarised on the model card, that excludes commercial or production use, including client deliverables and internal commercial decisions. So I can't sell this on TabPFN-3.5 or run it on real business finances. The paths forward are a commercial license from Prior Labs, or a backend on permissively licensed weights (earlier TabPFN-2 weights, which I haven't tested). The scikit-learn backend works today but is a weaker model.

My Agent Session

I didn't save a DevRelay session. The agent work is documented in the repo instead: docs/BUILD_LOG.md lists who built what, what review found wrong in each Copilot draft, and has a screenshot per step. Here is Copilot CLI building the benchmark and the prediction intervals:

My First User

No real user yet. The TabPFN-3.5 license bars using it on someone's real finances, so a fair first test needs the scikit-learn backend on a freelancer's own CSV, which I haven't arranged. That is the next step.

Prize Categories

Best Use of TabPFN: TabPFN-3.5 for classification, regression, forecasting, quantile risk scenarios and anomaly detection, inside a prediction agent with an MCP server.
Best Use of GitHub Copilot: Copilot CLI drafted four features, and GitHub Actions automates CI, the weekly report and Copilot's environment setup. The coding agent and automatic Copilot PR review were not used (Free plan).

Who's Singing?: An offline bird-call identifier

Brage Mellesdal — Thu, 08 Oct 2026 11:19:59 +0000

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

What I Built:

Who's Singing? is an offline bird-call identifier for your walks. You record 30~60 seconds of audio on your phone, run one command, and get a list of which birds were singing, how much to trust each one, and a short note written by a local LLM.

The idea is to keep the screen the shortest part of the experience. You spend the time outside listening, walking with your ears open and your phone ready to record in your pocket. The the laptop is only checked at the end, usually when you're done for the day. It's for anyone who has stopped on a trail and wondered "what is that?". It works even at your hut or campsite where there's no signal, because nothing in it needs the internet.

Who's singing:

  Great Tit                  confident  best  66.2%  (4 detections)
  Great Spotted Woodpecker   likely     best  80.1%  (2 detections)
  Eurasian Blue Tit          possible   best  41.2%  (2 detections)

Field note (written by qwen2.5:3b):
  On this walk, I clearly heard a Great Tit, four times. I also probably
  heard a Great Spotted Woodpecker, twice.

Demo:

To try it yourself, you need a bird recording of your own (the repo doesn't include audio):

git clone https://github.com/Brage1025/whos-singing.git
cd whos-singing

python -m venv .venv
source .venv/bin/activate        # Windows: .venv\Scripts\activate
pip install -r requirements.txt

ollama pull qwen2.5:3b           # For the field note

python whos_singing.py my-walk.mp3 --lat 59.91 --lon 10.75

Swap my-walk.mp3 for a recording from your phone, and the coordinates for where you made it. The location is what lets BirdNET leave out species that don't live near you.

Code:

Brage1025 / whos-singing

My submission for the Hacktoberfest 2026 Open-Source AI Challenge, Week 1: Touch Grass

Who's Singing?

An offline bird-call identifier for your walks. Record 30~60 seconds of audio on your phone, run one command, and get a list of which birds were singing, how much to trust each one, and a short note written by a local LLM.

Built for the Hacktoberfest Open-Source AI Challenge, Week 1: Touch Grass.

Demo: Watch it run with Wi-Fi off

The screen is the shortest part of the experience: you spend your time outside listening, and only check the laptop at the end.

Why open-source AI?

Two open models do the work, both are running on your own machine:

Works without internet. After a one-time download of the models, no internet is needed. Tested with Wi-Fi turned off.
Your recordings stay with you. Audio, locations, and your bird list are never uploaded anywhere.
Free to run. No API keys, no per-request costs and no token limits.
Swappable…

View on GitHub

How I Built It:

Two open models run on my own machine:

BirdNET-Analyzer (Cornell Lab of Ornithology and Chemnitz University of Technology) does the identification. It scores each 3-second slice of audio against thousands of species. I pass in my latitude, longitude and the week of the year, and its species list shrinks from 6,522 to about 240, so a recording from Oslo stops returning sunbirds and cuckooshrikes from other continents.
A small local LLM through Ollama writes the one-line note. I defaulted to qwen2.5:3b.

Around them I wrote a short Python script that:

merges the 3-second detections into one row per species,
assigns a confidence tier (confident, likely, possible), because a single high score on one window is weak evidence and repeated detections are stronger,
sends only confident and likely birds to the LLM,
checks the note in code and replaces it with a plain template if it's wrong,
logs each session to a local CSV, so over time it builds a private bird list.

The LLM kept getting it wrong:

This was the most useful part of the project. The identification worked from the start. The note took five rounds:

Given only species names, the model invented facts. It gave a Great Tit "brightly colored heads" and described a European bird's call for a North American one.
After I forbade facts, the note got clumsy and hedged a confident bird with "probably".
After I added an example to the prompt, the model copied it. It reported a Wren, which was never in the recording.
Then it repeated a real bird ("I clearly heard a Great Tit... I probably heard a Great Tit").
So the code now rejects any note that misses a bird, repeats one, names one that wasn't detected, or uses "clearly" or "probably" wording that doesn't match the tiers. Certainty wording is now decided in code to ensure quality and stability, not by the model.

I then compared two models on the same recording with the final prompt and check, five runs each:

Model	Passed the check
`qwen2.5:3b`	5 of 5
`llama3.2` (3B)	1 of 5, the other four fell back to the template

That's one recording and one prompt, so it's a small test, not a benchmark. But it took only minutes, and switching the winner was as easy as changing one flag: --model.

How it did on real audio:

I tested on three recordings: an old one of my own and two from a friend who prefers to stay anonymous. Only one of the friend's recordings has ground truth, because she knew what was there. That one was recorded just outside Oslo. She saw the Great Tits and Blue Tits, and heard the woodpecker without seeing it. So all three detections were real.

BirdNET found everything with no false detections. The weak spot was my own tiers. The Blue Tit was a real bird, but two detections with a best score of 41% put it in possible, so the note left it out. I'd rather the tool under-claim than confidently name a bird that wasn't there, so I kept that threshold, but it's a trade-off I made by judgment, and I didn't tune it on a single recording.

I also owe an honest note: I didn't get out on a walk myself this week, so I haven't field-tested it outdoors. Everything above was run on recordings, offline.

Why Does Open Innovation Matter?:

It runs with no internet. After a one-time model download I turned Wi-Fi off and ran the full pipeline, including the note. That's what makes a bird identifier usable on a trail or out on field work with no signal.
Recordings stay on my machine. Audio, locations and my bird list are never uploaded. So I can decide if it's nobody else's business or not.
It costs nothing to run. No API key, no per-request charge and no token limits.
I could see and fix the weak link. When the small model invented a Wren, I could inspect the prompt, change the model, add a validator and compare alternatives side by side. With a closed API I'd have received the same wrong note with no easy way to tell why.
The two parts are separately swappable. BirdNET handles identification and the LLM handles wording, so I can replace either without touching the other.

One caveat on "open": BirdNET's model is open-weight but carries a non-commercial license, so it's free to inspect and use for a project like this, not free of conditions. The code in my repository is MIT.

Special thanks to my dear friend, who prefers to stay anonymous, for the field recording and for telling me what she actually saw and heard.