DEV Community: ADK BBX

NapQuest: a sloth game you can hand over to a local AI

ADK BBX — Mon, 26 Oct 2026 01:40:48 +0000

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

For the past three weeks, I've been building fairly serious apps for these challenges. There was one for getting through phone calls in Japan, one for working out whether junk mail was worth a walk, and last week's tool for finding a product's first customers.

This week I wanted to make something fun and light. The prompt was about laziness, so a sloth seemed like a reasonable place to start.

I called him Mallow. He lives in a woodland village, and his first problem is a bell that won't let him sleep. Somehow this turned into gathering wood, taking a job with bees, building a better house and defending it from geese.

I also wanted to be able to stop doing all the little jobs myself. That's where Laya comes in.

What I built

NapQuest is a small village-building game. You can play it yourself, or give Mallow a goal and let a local AI choose what he does next.

If I ask him to earn ten coins, he can find work or gather berries to sell. If I ask him to upgrade his home, he has to get the materials, pay for the upgrade and keep himself fed along the way. I can take control again whenever I want.

This is the supplied level-five practice village. It has its own save and prepared resources so you can try the later parts of the game.

The first versions weren't very entertaining. Mallow would walk around while the journal told me what had happened. If a goose was supposed to be chasing him, I wanted to see the goose chasing him. The same went for the bees. Reading about a consequence wasn't enough.

Now stealing a picnic starts a chase on the map. Taking a honey job brings bee coworkers along for a shift. Trees leave stumps you can clear for building space. A nap takes a few seconds and ends with Mallow coming back outside, ready to continue.

The village has five home levels, with a different building at each level. You can add resource mines, plant food, buy tools and train defenders. Walls and gates slow enemies down while watchtowers and acorn cannons fire at them. The last fight is against the Goose Captain.

A recording of the practice siege. The prepared defenses win this run and earn the Acorn crest.

Demo

Play NapQuest in your browser

Online demo added October 27, after the Week 3 submission. You can play by hand without using AI quota. Laya runs on a shared free GPU, so automatic play can queue or pause at the guest limit. The local version is still available for longer AI sessions. Online goals and action descriptions go to the server; your village saves in this browser.

Try the supplied level-five practice village

Watch the MP4 gameplay recording

This shows the first 24 seconds of a local Laya run, followed by its later completion. The practice world supplies the starting village. The recording is silent.

The downloadable version runs locally with Python and a browser. Once you've downloaded the model, you can run it offline. To try automatic play, open Laya, choose "Earn 10 coins" and select "Let Laya take over." Clicking the map gives control back to you.

Code

Source code on GitHub

The source package includes the browser game, Python model adapter, setup scripts, tests and the decision records from the runs below. The application code is MIT licensed. The model downloads separately during setup.

How I built it

I used Convai Innovations' Laya, an open-weight decision model, running on the CPU. The build pins model revision 7b928d828b7b0e022f929d9bd2e44165aa270148 so I can repeat tests against the same checkpoint.

Laya chooses from a set of described actions. The game works out which actions are legal, sends those choices to the model and carries out its answer. Movement, resource costs and combat follow the game's rules. The model chooses what to attempt; the game checks whether it can happen.

One bug was especially annoying. Asking Mallow to earn money didn't work because earning wasn't a proper goal type yet. I added that goal and a counter for new income, rather than checking how much money was already in his wallet. I also had to split crowded action descriptions into smaller questions. Moving home near the market needed separate questions for what to move and where to put it.

The browser game uses JavaScript, HTML and Canvas. Terrain generates in seeded chunks as you explore, and browser storage saves your inventory and changes to the village. The painted characters use layered cutout animation. The added combat units use simpler whole-sprite movement.

Sound made a big difference. I used my ElevenLabs subscription to generate 21 recordings for the forest, footsteps, chopping, mining, doors, bees, goose honks and combat. The game plays those files locally. I added separate controls for ambience and effects, plus a mute button in the header.

The phone layout keeps the map and controls on one screen. Store, Bag, Village and Settings open as panels. You can tap objects to gather or interact instead of finding an action at the bottom of a long page.

Why does open innovation matter?

I wanted to put the model in the game loop without charging for every decision. With Laya running locally, I can leave a goal going without a hosted inference bill. In the local version, the player's requests stay on their machine. The later online demo sends requests to its model server.

It also made debugging practical. I could save the available choices and the model's answer, change an action description and run the same situation again. There is still a setup download and some waiting for CPU inference, and Laya can misunderstand a request. The game handles one main goal at a time.

The lazy payoff

In one fresh-world test, I gave Laya the home-level-five goal and it completed it in 40 world actions without supplied resources. A separate run earned ten new coins in 33 actions. Those are recorded runs, rather than a promise that every goal will take the same route.

That's the part I wanted from this project. I can do the gathering and building when I feel like playing, or give Mallow a job and watch him work through it.

The original submission build passed 48 gameplay tests and nine Python tests. I've also checked the game in the browser, including purchases, moving home, clearing stumps, automatic waking and a ten-coin goal that stopped when it was finished. There is more I'd like to do with the story, but this version has the bell-and-nap quest, the five-level village and the goals you set yourself.

Prize categories

I'm entering Best Use of ElevenLabs for the generated game audio. The repository's audio manifest lists the recordings and the prompts used to make them. The files were generated during development and are included with the game.

I used AI coding and image-generation tools while building NapQuest, and ElevenLabs for the audio. I directed the build, tested the game and kept revising the parts that weren't fun. AI also helped prepare this post.

Building software got easy. Finding the first customer didn't.

ADK BBX — Mon, 19 Oct 2026 01:23:31 +0000

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

GTM Shortlist, live at eygentic.tech.

AI has made building software cheap and fast, and you can see it in the numbers:

In 2025, Apple received about 557,000 new app submissions, the most since 2016.
In December 2025, new iPhone apps were up 60% on a year earlier, after three years of flat numbers (a16z's analysis, which also says this doesn't prove AI coding tools are the cause).
On GitHub, developers created more than 230 new projects every minute, and over 36 million new developers joined in a year.

Customers didn't multiply the same way. When CB Insights looked at 431 venture-backed startups that shut down since 2023, the most common underlying problem was poor product-market fit, in 43% of the cases they could explain. In plain words, the product got built, and not enough of the right people bought it.

I've felt this myself. This month I shipped an app every week for these challenges, with two coding agents doing most of the typing. Building isn't the hard part anymore. The hard part starts the day after you ship: who do you sell it to?

I'm building Eygentic, a company that runs customer-acquisition experiments for B2B and SaaS teams: it tests which customers, messages and channels actually work before anyone spends money on growth. Every one of those experiments starts with the same boring thing, a list of companies that might buy. Most prospecting tools I looked at sell you access to a big database of companies and contacts, and you have to trust that each row is right. That's fine if you already have a sales budget. A two-person AI startup that just shipped usually doesn't.

If finding customers is now the hard part of starting a software company, I don't think it should only be possible for companies that can already afford a sales team. So I built the tool I wanted for my own first list, made it open source, and put it online. It's not complete yet, but this challenge gave me the motivation to finally get started on it.

What I Built

GTM Shortlist. GTM means "go to market", the work of getting a product in front of people who will buy it. You give the app your company's website, and it:

Reads your website and writes a short description of what you sell and who might buy it. You fix anything it got wrong.
Searches Google for companies that match. Nothing is searched until you've confirmed who you're looking for.
Visits each company's own website and looks for proof that it matches, like a sentence on its product page.
Gives you a short list. Next to each company it shows the exact sentence from that company's site that backs up the match. If it can't find proof, it says "unknown" instead of guessing.
Lets you decide. You mark each company yes or no, download the list as a spreadsheet, and can start a first email that points to what you found. It never sends anything for you.

Every step, using the demo on eygentic.tech. The companies and sentences are made up for the demo, so you can try it without an account or spending anything.

A company is only marked as a fit when every must-have is backed by a sentence found word for word on its own site, and a second check by the model agrees that the sentence really says that. Your yes or no is kept separate from the app's opinion, and a fit never means "this company wants to buy".

Who would pay for this? Founders of small B2B software and AI companies who do their own sales, and the consultants and agencies who build a new list of target companies for every campaign. The hosted version gives you your first three companies free, with no card. After that, research runs on credits, one per company researched, and paying for more credits isn't built yet. If you run it yourself, it's free apart from your own search and AI costs.

The first real run, and what it got wrong

On 16 October I tried the hosted app on my own website, eygentic.com, looking for "B2B AI SaaS companies". To find companies, the app runs a few Google searches one after another. The first search worked and found 8 companies, but the next one failed. The app had a rule that every search had to work before it used any of the results, so it threw away all 8 and stopped with nothing. It gave my three credits back, but I still had no list.

So I changed the rule: if one search fails, the app now keeps the companies the other searches already found and carries on. I picked the same run back up from where it stopped, and it researched three of the 8 companies it had saved, without searching again. That gave me my first real shortlist.

The first real shortlist. DealHub matched. NachoNacho needs more checking. builtin.com isn't a company I could sell to at all: it's a website that writes lists of other companies, and it used up one of my three research slots.

The app didn't make anything up about Built In. It just said "unknown" for everything. But I'd still spent a credit researching a website that was never a customer. So I looked back at every test run I had saved, without paying for any new searches:

18 test runs had researched 19 companies, and not one of them came out as a real match.
My searches were bad. I was searching Google for my whole target sentence, and Google mostly returned how-to guides, "top 10" lists, reviews, YouTube videos, job ads and dictionary pages, not companies.
I was asking for things websites don't say. Whether a company is privately owned, how much funding it has, or what its internal problems are is almost never on its own website, so those answers were always "unknown".

So I changed four things:

Search for companies, not articles. It now searches with a short phrase like "B2B SaaS", plus words you only find on a company's own site, like "official website" or "pricing".
Skip pages that aren't companies before opening them. Videos, job boards, review sites, directories and "top 10" lists are dropped straight from the search results.
Warn me when I ask for something a website won't say, and let me turn it into a nice-to-have with one click.
Never research the same company twice for the same business.

To check the search fix, I took real search results that my earlier test runs had saved, marked each one as either a company's own website or something else by looking at its address and title, and ran them through the old version and the new one:

Real company websites: there were 21. The old version let 16 of them through to research. The new one lets all 21 through.
Pages that weren't companies (job boards, directories, review sites and so on): there were 46. The old version let 5 of them slip through. The new one lets 2 through.
Pages opened for nothing: the old version opened 39 pages only to throw them away afterwards. The new one throws them away before opening them, so it wastes none.

Running my old research through the new rules, 18 of the 22 companies I had already researched would have been skipped: 6 because they weren't companies at all, and 12 because they were the same company researched again.

Real websites are messy

Testing on more real websites turned up more problems, each with its own fix:

Invisible characters. One site hides invisible spaces between its words, so a sentence the model copied didn't look like the same sentence to the app. Now the app ignores invisible characters, but every real word still has to match.
Menus instead of content. On some pages, most of the text was the list of countries and languages, so the model quoted the menu as proof. Long menus are now removed before the model reads the page.
A menu link isn't proof. One company counted as a match because of a single link in its menu. One or two words from a menu no longer count.
"Suggests" isn't proof. When the model says a page "suggests" or "may" show something, that no longer counts as a yes.
Pages it couldn't open. Some homepages send you on to another address, and some are very large. Both used to be skipped, and both can be read now.
The best page was ignored. Search often finds the exact page that proves the point, but research used to start from the homepage instead. Now it reads the page search found as well.

A small model on my laptop vs a big one on DigitalOcean

After all those fixes, I wanted to know whether the list was finally useful for my own business. I took the 12 companies a saved web search had found for Eygentic on 13 October, looking for private AI software startups that sell to businesses, and researched them again with no new searches.

First I used small open models on my laptop: Gemma 4 E2B and Qwen 3.5 4B. With the fixes in, they stopped wasting money on pages that were never going to work, but they rarely copied the proof from a page, so none of the product companies came out as a match.

Then I used Gemma 4 31B, the bigger version of Gemma, on DigitalOcean. It took 18 AI calls for all 12:

DelegateZero: a match. Its own site says "DelegateZero - AI Decision Proxy for B2B SaaS Founders", and its pricing page lists monthly plans.
Prismatic: a match ("Embedded iPaaS for B2B Software Companies"), after one more fix. The model sometimes answered a check with a word like "cleared" instead of yes or no, and the app threw the whole company away. It now reads those words properly, and re-reading the answer the model had already given turns Prismatic into a match.
Smeron and BackOfficeBoss: set aside. They build custom software for clients rather than selling a product, so they aren't buyers for me.
Six others: need more checking. The app couldn't find enough proof on their own websites, so it says so instead of guessing.
Two: refused. The app couldn't confirm who owns the website.

So 2 of the 12 are real leads for Eygentic. It's a short list, but every name on it comes with its proof, and the small models couldn't get there at all.

Demo

eygentic.tech: type your company's website or name. Your first three companies are free and no card is needed.

If you'd rather not sign up, tap Try the demo on the start page, the walkthrough in the GIF above. You can also install it from the code and choose Try it with sample data, which runs the whole thing on three made-up companies with no accounts or keys.

How I Built It

The app is a website (React) with a Python server behind it, plus a separate background worker that does the slow research. Before the worker does anything that costs money, like a search, a page visit or a call to the AI model, it writes it down first. If the server restarts halfway through, it carries on from its notes instead of paying for the same thing twice, and if it can't tell whether a request went through, it stops and tells you instead of trying again. Every run has hard limits: at most 4 searches, 8 AI calls and 3 pages per company.

SerpApi: the Google search

SerpApi gives the app Google search results, at most 4 searches per run. My first real search took about 29 seconds and timed out, so the app now waits up to 60 seconds, and a search that times out is never retried automatically, because it may already count against my monthly limit.

I'm on SerpApi's free plan, 250 searches a month, so my coding agents had to ask me before spending any. While building, the app used saved search results instead of new ones, and SerpApi's free account check confirms the key works without using up a search. On 16 October I still had 236 of my 250 searches left.

Gemma on DigitalOcean: the AI model

The hosted app uses Gemma 4 31B, an open model from Google, on DigitalOcean's hosted AI service, so I don't run any servers for it. It does four jobs: describing your business from your homepage, suggesting campaign ideas, finding quotes on each company's site, and double-checking each quote. On 30 test cases for that double-check (29 written for the test, 1 from a real website) it got all 30 right. That's a check of one job, not an independent benchmark.

On my laptop, the first runs gave useless answers. The program running the model was quietly cutting my instructions short, keeping about 2,000 pieces of text out of 6,000 to 12,800, so the model never saw what I'd asked for. Shorter instructions and a bigger limit fixed it.

The model never has the last word. Ordinary code checks that each quote really is on the page, that the page belongs to that company and that every must-have is covered, and it decides the order of the list.

Render: running the app online

Render runs two pieces from the same code: the website and the background worker. Passwords and keys live in Render's dashboard, never in the code. I only release a version after the automatic tests pass. During the first real run I released an update halfway through, and the new worker picked up exactly where the old one stopped, without searching again. Afterwards I restarted everything on purpose, and the exported results were exactly the same.

eygentic.tech: the web address

eygentic.com is the company. eygentic.tech is the tool, open for anyone to use. When I first connected the domain to Render, the app refused it with "400 Invalid host header", because it only trusted its original Render address. Now it accepts a fixed list of addresses, each with its own sign-in link, and still refuses anything else.

Why Does Open Innovation Matter?

Finding customers is becoming the expensive part of starting a software company, and right now the answer is mostly rented: you pay for access to someone else's database, every month. I want the method to be something anyone can read, run and change.

Piece	What it does	Open?	If you don't want it
GTM Shortlist	the whole app	open source (MIT licence)
Gemma 4	reads websites, writes, double-checks	open model
DigitalOcean	runs Gemma online	paid service running an open model	run Gemma on your own computer
SerpApi	Google search results	paid service with a free plan	Tavily, or saved search results
Render	runs the app online	paid service	any server, or your own computer
Supabase	sign-in and database	open source	a simple file on your computer

Here's what being open actually changed for me.

Your list stays yours. Who you're trying to sell to is private business information. If you run it yourself with a local model, your research stays in a file on your own computer. The only things that leave it are the searches and the visits to the companies' own websites.

It's cheap enough for one person. Run it yourself and you only pay for searches and the model. At 4 searches a run, SerpApi's free plan covers dozens of lists a month. That's what "accessible to everyone" means to me.

I could check its work. Every problem above was found by reading the saved pages and the model's saved answers, not by guessing. Because the model is open, I could try the small version on my laptop and the big version online on exactly the same pages, and see for myself that this job needs the big one.

The rules are visible. What counts as a match, which pages get skipped and how quotes are checked are all in the code, so you can disagree with them and change them.

What it can't do yet

It doesn't find email addresses or contact details. It finds companies and the proof that they fit. Reaching out is still up to you.
Some things stay unknown. Funding, ownership and budgets are rarely on a company's own website, so the app leaves them as "unknown" instead of guessing.
Small models aren't good enough yet. On my laptop they couldn't produce a single real match for my own business. Research needs a bigger model, which means a hosted service or a powerful computer.
Runs are small. Up to three companies at a time, so it's a shortlist, not a database.
You can't buy more credits yet. The free three work, but paying for more isn't built.

My First User

The first user is me. The first real shortlist was for Eygentic, the company I'm building, and DealHub was the first company that matched what I was looking for. The bigger model later added DelegateZero and Prismatic. I haven't sold GTM Shortlist to anyone yet. What I want to find out next is whether a founder who has just launched will trust a list that says "unknown" a lot, instead of one that gives every company a confident score.

Code

adkbbx / GTM_Shortlist

GTM Shortlist

Open-source company discovery and research for B2B sellers. Confirm your offer and targeting criteria, discover candidates, inspect dated source passages, and review/export a shortlist. Human acceptance never means buying intent.

Created by Eygentic. Every seller uses the same workflow; Eygentic profiles are optional examples and test inputs, not product defaults.

This is an early local implementation. Hosted accounts, external signup, deployment, real provider benchmarks and observed user testing remain release gates in the checklist. Progress records what has actually passed.

Try it with sample data

No provider keys are needed. Install from source below, open the local app, and choose Try it with sample data on the setup card. Confirm the sample target, inspect the three invented companies and their evidence, accept or reject a result, and export CSV, JSON or Excel. Every screen and export labels the sample data. Sample source links are plain text because…

View on GitHub

Open source under the MIT licence and built during the challenge: the first commit was on 14 October, and there are 188 so far. 838 automated tests on the server side and 173 browser tests at phone and laptop sizes pass, and every real test I ran with paid services is written down in docs/PROGRESS.md, including the ones that failed.

Claude Code wrote the plans, reviewed the changes and ran the tests on my machine, and Codex wrote much of the code from those plans. The project's rules say no paid search or AI call without my approval for that specific test, which is why so many of the fixes above came from re-checking saved runs instead of paying for new searches.

Prize Categories

Best Use of SerpApi. SerpApi is how the hosted app finds companies at all. The app sends short Google searches aimed at companies' own websites, skips results that aren't companies before opening them, and keeps every run to 4 searches. Each search is written down before it's sent, a slow search gets up to 60 seconds, and a failed one is never retried automatically, so the free plan's 250 searches a month go a long way.

Best Use of DigitalOcean. Every AI call the hosted app makes goes to Gemma 4 31B (gemma-4-31B-it) on DigitalOcean's hosted AI service: describing the business, suggesting campaign ideas, finding quotes and double-checking each one. On the same 12 saved companies for my own business, the small models on my laptop found no product company that matched, and Gemma 4 31B on DigitalOcean found two, each with proof from its own website, in 18 AI calls.

Best Use of Gemma. Gemma does every AI job in the hosted app: it reads your homepage and drafts your offer and must-haves, suggests campaign ideas, finds quotes on each company's own site, and double-checks every quote. The same code runs Gemma 4 31B on DigitalOcean or Gemma 4 E2B on a laptop through Ollama, and running both on the same 12 companies showed this job needs the bigger one: two real matches with proof, against none.

Best Use of Render. Render runs the website and the background research worker from the same code, with passwords kept in the dashboard. When I released an update in the middle of a real run, the worker carried on from its notes with no repeated searches and no double charge, and restarting both afterwards left the results exactly the same.

Best Use of a .tech Domain. The app is live at eygentic.tech, the .tech domain I claimed through Hacktoberfest, running on Render. eygentic.com is the company and eygentic.tech is the open tool, and both GIFs in this post were recorded on the live domain. Getting there meant fixing a real "400 Invalid host header" error: the app now accepts a fixed list of addresses, gives each its own sign-in link, and still refuses anything else.

Built solo.

If you've shipped something and don't know who to sell it to, put your website into eygentic.tech and tell me in the comments which company it got wrong.

I asked my junk mail one question: are you worth the walk?

ADK BBX — Mon, 12 Oct 2026 06:21:18 +0000

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

This is one week of my mailbox. A drugstore price list with 52 products on it, a cleaner's half-price sale, a pilates studio's trial, KUMON, a meal-delivery coupon, gold buyers, junk removal. Most of it goes straight into paper recycling. A few of these are probably worth leaving the house for. I just never know which ones, because I don't read Japanese well enough to go through a stack like this every week.

So I built an app that reads them for me.

Five of them, tagged with what the app decided. The pilates studio and the cleaner are worth a walk. The sushi menu and the meal kit are things to use at home. The gold buyer goes in the recycling.

What I Built

Worth the Walk? You photograph your flyers, one photo per page. Gemma 4 reads each page and the app sorts every flyer into one of four piles:

Pile	What goes there	What happens to it
Worth a walk	a place you can go to: a cleaner's sale, a studio trial, a shop	it becomes a stop on today's walk
Use at home	delivery menus, coupons	kept, with its deadline
Keep, not an ad	anything that looks like a bill or a notice	nothing from it is stored
Recycle	gold buyers, junk removal, the rest	paper recycling

The answer looks like a train ticket for today. The places worth a walk sit on a route line in walking order, starting from where you are or from a station you pick. Each one shows its best printed deal on a yellow sticker, the same way the flyers do it (Trial ¥1,000, was ¥3,300). The app picks the stops itself. If there's one you don't want, you remove it, and that choice (along with every stamp you collect) is what TabPFN learns from.

When you start the walk, the screen turns into the display above a train door: NEXT 次は, the place, a little line map of your stops, and how to use the deal. At each stop you tap I'm here. One GPS reading, checked on the phone, gives you an ink stamp like the ones at Japanese train stations, with a different ink for each kind of place. Tap what you actually used and the savings add up, but only from prices printed on the flyer. At the end the ticket comes back punched, with a 済 ("done") stamp and the day's totals.

There's no account. Photos are read and thrown away, and everything else stays on your phone. You can add it to your home screen, and a walk you've started will reopen even with no signal.

Taking it outside

On Monday afternoon I put the drugstore flyer from that pile through the live app. It was the only place on the day's ticket: a Welcia three minutes away, 211 m. I switched to walk mode and went.

The stamp is the dashed kind, the one the app gives when it stamps without a GPS reading.

It's a short walk, which is kind of the point. That flyer had been sitting in my mailbox all week. It took three minutes to go and look.

How it got here

My first plan for this challenge was a grocery app: 547 supermarket branches around 74 stations, which point cards each one takes, and when the bonus days are. The next step was going to be scanning supermarket flyers for deals. Then two things happened on Sunday.

First I tested the models. Gemma 4 E2B, running on my laptop, read a whole supermarket page and got 0 of 8 items right. It put real prices next to products that weren't on the page. Gemma 4 31B on DigitalOcean got a cropped section of the same page 4 out of 4, member and non-member prices included.

Then I emptied my mailbox. Fifteen flyers, and not one of them from a supermarket. Gold buyers, junk removal, a hot-yoga trial, an aikido dojo, sushi delivery, a cleaner's half-price sale. Supermarket flyers do come some weeks. Most weeks it looks like this.

So I rebuilt the app around the mailbox I actually have. Any flyer goes in, the app sorts it, and the places worth visiting become a walk. The grocery data stayed on as station locations and an optional grocery stop on the way.

The first phone test failed in a boring way. I took seven photos, tapped Read at the bottom of the screen, and nothing seemed to happen, because the progress line was at the top and off screen. I refreshed and lost every photo. That's why there's now a reading card with a progress bar, cards that appear as each flyer finishes, photos that wait on the phone until they've been read, and a screen that stays on while it works.

Then ten real photos went through, and the real problems showed up.

The flyers that fooled it

A logo isn't text. The sushi menu's back page only has the shop name as a brush-style logo. Gemma read it as two different restaurants on two runs, so the back page never joined its front.

One shop, two spellings. The cleaner's front page says "Good!" and the back says "クリーニング Good!". Pages now group when one name sits inside the other. On one run Gemma wrote the name in katakana instead and they split again, so now you can tap a page and pick which flyer it belongs to.

A phone number cut in half. A big 0120 number fell across two tiles, and each tile only read half of it.

The model copied my example. My prompt said "phones, e.g. 0120-123-456", and that exact number turned up on a gold buyer's flyer. It also broke the grouping, because it looked like another shop's phone. The prompt has no example digits now.

Almost-JSON. Gemma sometimes drops a quote before a key. The parse failed, the retry doubled the cost, and the second reading lost the comparison prices. The parser fixes that now before giving up.

Class times look like opening hours. A dojo prints "毎週土曜 10:00～12:00". At 4 pm it counted as closed and dropped out of every walk. Lessons and events never count as closed now.

The drugstore that had no prices. On Monday I photographed the drugstore flyer: 52 products, each with a price before and after tax. The app found the flyer and showed none of the prices. The first pass reads the whole page, and when a page is a dense price list it's told to skip the items and describe them instead. A rule in code then decides whether to read the page again in tiles, and that rule didn't recognise this page as a price list. Supermarket and drugstore flyers now always get the second pass, and the same photo comes back with all 52 products and their prices.

Here's how one real mailbox scored on Sunday evening:

Flyer	Pages	Business name	Pile	Offer
Dinner delivery	1	right	right (home)	right
Sushi delivery	2	front right, back wrong (logo)	right (home)	right
Dry cleaner	2	right	right (walk)	¥297 → ¥98, ¥987 → ¥326
Pilates studio	1	right	right (walk)	¥3,300 → ¥1,000
Gold buyer	2	right, pages grouped	right (recycle)	right
Junk removal	1	right	right (recycle)	right
Appliance pickup	1	right	right (recycle)	right

Every pile and offer was right. Business names were right apart from the logo.

Late on Sunday it worked, and I still wouldn't have used it. Every flyer was a card with every field on it, in four tabs, with thumbs up and down buttons. Looking at it on my phone, I wouldn't have read any of it. So it became one answer: the app picks the stops, draws them as a ticket, puts the best printed price on a sticker, and all you do is remove what you don't want. Then you walk.

Early on Monday I opened it like someone who had never seen it, and it was a station picker and a camera button with no explanation. Now the first screen shows what happens, it only asks where you're starting when it needs to, and Try a sample mailbox runs the whole thing with eight made-up flyers, so you can try it without any Japanese mail.

How it works

Reading flyers: whole pages first, tiles only for price lists (Gemma 4 + Mastra)

Model	Input	Result
Gemma 4 E2B (local, Ollama)	full page	0/8
Gemma 4 E2B	one section	2/4 (若鶏もも肉 became "sheep wool meat")
Gemma 4 31B (DigitalOcean)	full page	wrong prices, invented eggs
Gemma 4 31B	one section	4/4, both prices

Tiles fixed the accuracy, but six calls per page made the first real test take minutes. Most of my mailbox isn't price lists, though. A gold buyer, a junk-removal service or a yoga studio is big text, a phone number and one offer, and read whole, all four of those came back right in one call each (4 to 26 s).

So reading is adaptive. The phone crops each photo to the flyer and sends the whole page first. A Mastra readPage workflow reads it and the card shows up within seconds. A rule in code then decides whether the page is a price list worth a closer look (a supermarket, a drugstore, a cleaner's price table, a takeout menu). Only those get a second pass as a 2×3 grid of overlapping tiles, read in parallel and streamed back while the card says "Reading prices…".

A text-only mergeFlyer call combines the readings from every page of one flyer, since the offer is often on the front and the address on the back. Price lists are merged in code, which took merging from 232 s to 87 s on my test pile. Then I timed the whole thing through the real app and found the merge was still the slow part: five single-page flyers took four and a half minutes, because each one waited for a merge call that had nothing to merge. A flyer that was read whole in one call is now sorted in code. The same five pages now go from photos to a ticket in 38 seconds, into the same piles.

The model only copies what's printed. Code decides the pile, which pages belong together, the deadline, and what counts as a saving.

Finding the places: GSI, SerpApi and OpenStreetMap

Printed addresses go to GSI (国土地理院), Japan's free government geocoder, which needs no API key. When a flyer worth a walk has no usable address, SerpApi looks the business up on Google Maps. If Google's phone number matches the one on the flyer, the card says "phone matches the flyer". If SerpApi finds nothing, the app tries OpenStreetMap by name.

The free SerpApi plan has 250 searches a month, so only walkable flyers without an address can trigger a search, results are cached for 30 days, every search is counted before it's made with daily and monthly caps and a reserve of 20, and the tests run against a network that throws, so a test can't spend one.

SerpApi after the whole build: 10 searches out of 250, none failed, and the busiest day stopped at 8, the app's own daily cap.

Learning what you go to: TabPFN through Prior Labs' MCP

The places you remove and the stamps you collect train TabPFN through Prior Labs' remote MCP server. Mastra's MCP client does upload, fit and predict, and reuses the fit until your choices change. TabPFN only sees a row of numbers per flyer: category, a distance bucket, offer type, whether it's a free trial, printed value, days left and three yes/no flags. No names, addresses or flyer text. On a synthetic check it scored a nearby free trial at 0.9996 and a far-away flyer with no offer at 0.0004, in 11.6 s. With fewer than six choices, or if anything fails, simple rules take over.

Watching the agent: Sentry traces with no flyer content

The Mastra Sentry exporter keeps the model, tokens, cost and timing, and drops prompts, outputs, images and any URL with a query string, because these are photos of someone's mail. Sentry's cost numbers put one tile at about $0.00044, so reading a page costs about a quarter of a cent.

One readPage trace in Sentry: eight Gemma 4 calls for one drugstore page, mostly in parallel, 29.8 s in all. Every pink chat gemma-4-31B-it bar is one call to Gemma 4 31B on DigitalOcean's serverless inference. The selected span shows the agent, the model, 1.7K tokens in and 497 out, a cost under a cent, and "No input for this span". The flyer itself never reaches Sentry.

Sentry's AI Agents view: the page reader, tile reader and merger, every run's tokens and cost, and no errors. The mergeFlyer rows with 0 tokens and $0 are flyers sorted in code instead of by the model.

The Mastra structure as Sentry records it: the mergeFlyer workflow, its merge-and-locate step, the flyer-merger agent and its Gemma 4 call. 1.2K tokens, under a cent, 2.89 s against this agent's 23.6 s average, and again no input stored.

Walks, opening hours and stamps

The station data came from the grocery app that didn't work out. Stops are ordered by trying every order, and the lowest-priority stop is dropped until the walk fits your time. The hours parser handles 83 store formats: 25:00, 〜 and －, full-width digits, 平日 vs 土日祝, "closes at 21:00 on weekends", public holidays. A stamp is one GPS reading, compared on the phone, and the location never leaves it. If you start from where you are, the server only ever gets that start rounded to about 1 km, for address lookups.

Running it: Render

One Node web service from a render.yaml Blueprint. Keys are kept in the dashboard, not the repo. Each IP gets hourly limits on reading, merging, lookups and ranking, and X-Forwarded-For is only trusted behind Render's proxy, so the limits can't be dodged with a fake header.

Render: one Blueprint-managed Node service on the Starter plan. Every push deployed in about a minute, 30 times over the build.

Why Does Open Innovation Matter?

Not everything in this app is open, so it's worth being clear about which parts are. The open pieces do the core work. Gemma 4 (open weights, Apache 2.0) reads every flyer and merges the multi-page ones. Mastra (Apache 2.0) runs every workflow and agent. The services around them are closed, and each one can be switched off.

Piece	What it does	Open?	Without it
Gemma 4 31B / E2B	reads, translates and merges every flyer	open weights, Apache 2.0	no app
Mastra	workflows, agents, the MCP client, the trace exporter	Apache 2.0	no app
DigitalOcean	hosts Gemma 4 31B	hosted service, open model	`LOCAL_LLM=1` runs Gemma 4 E2B on my laptop with Ollama
TabPFN via Prior Labs' MCP	ranks flyers from my choices and stamps	open-source code, hosted API	simple ranking rules
SerpApi	finds places that print no address	hosted service	OpenStreetMap
OpenStreetMap (Nominatim)	finds a shop by name when nothing else did	open data, free, no key	printed addresses only
GSI address search	turns printed addresses into map points	free public service	not needed
Sentry	traces every model call	hosted service	no tracing
Render	hosts the web app	hosted service	any Node host, or `npm start`

I tested that last column on Monday morning with the finished app. With every key removed and LOCAL_LLM=1, three real flyers from my mailbox went from photos to a ticket in 35 seconds on my laptop. GSI placed a printed address, OpenStreetMap found a chain store by name, and the ranking ran on rules. It cost nothing and needed no account. The only things that left my machine were an address for GSI and a shop name for OpenStreetMap.

Here's what being open actually changed for me.

I get to choose where my mail is read. Hosted, the photos go to DigitalOcean to be read and the app never stores them. With LOCAL_LLM=1 they never leave my laptop. A closed API doesn't give you that option.

I could test the models on my own flyers before trusting them. That 0 out of 8 against 4 out of 4 decided the whole design: price lists are read in tiles, everything else in one call.

It's cheap enough that I didn't need accounts. A fully tiled page costs about a quarter of a cent and a whole mailbox about five cents, so there's no sign-up and no subscription.

The local version works, but it's worse. E2B put two of those three flyers in the right pile (it sent a dinner-delivery menu to recycling) and made up the yoga studio's prices: ¥500, ¥150 and ¥100 for a flyer that prints a ¥3,000 trial. So local mode tells you to check every price. Running it at home is a real option, not a good one yet, and a bigger Gemma 4 is one setting away (LOCAL_LLM_MODEL) if your machine can hold it. I only know all this because the weights are open.

The code is MIT licensed.

Demo

worth-the-walk.onrender.com, no sign-up. If you don't have any Japanese flyers, tap Try a sample mailbox. It places made-up shops near you so you can see the ticket, walk mode and a stamp in under a minute.

Code

adkbbx / worth-the-walk

Worth the Walk?

Photograph the flyers in your mailbox, read what each one is in English, and plan a walk from where you are (or a station you pick) to the places worth visiting. Each stop gives you an ink stamp.

No Japanese flyers to hand? Open the app and tap Try a sample mailbox: eight made-up flyers, placed around your start, with no model calls.

Install and offline: Worth the Walk? is installable on your phone. After an online visit, the app shell is cached network-first so a walk in progress reopens without signal, with your saved walk and stamps intact. Reading flyers still needs a connection.

How it works

Photograph the pages. Gemma 4 reads each page whole first (one call), so its card appears within seconds. Only walkable price lists (supermarkets, drugstores, cleaners, menus) get a second pass in six overlapping tiles for exact prices.
The…

View on GitHub

MIT licensed and built during the challenge week. There are 147 offline tests and a Playwright run at phone and desktop size, in light and dark. The Playwright run covers scanning, sorting, ranking, planning, both kinds of stamp, savings, a reload in the middle of reading, a second browser that sees none of the first one's data, going offline mid-walk, a rate-limited read, and contrast, focus and 200% text checks.

How I built it with two agents

Claude Code was the architect. It wrote the specs and the contracts between modules, reviewed every diff, ran the tests and checked the screenshots. Codex CLI wrote most of the modules from those specs. On the last night I left them running in a loop for five hours: Claude wrote a spec per round (onboarding, visual polish, the walk, error states, accessibility, offline, speed), Codex built it, and Claude ran the browser tests, looked at the screenshots and sent back what was wrong. When Codex hit its usage limit around 6:30 a.m., Claude carried on with the smaller fixes.

Prize Categories

Best Use of Sentry Agent Tracing. Every page read and every merge is one trace: the readPage workflow, the read-tiles step, the flyer-reader agent and its Gemma 4 call, with model, tokens, cost and timing. Since these are photos of people's mail, a span processor (omit-flyer-payloads) drops every prompt, output, image and query-string URL before export, and an allow-list keeps only attributes I added on purpose: page and tile counts, whether a flyer was sorted in code or by the model (chirashi.merge), its pile, and where its location came from (gsi, serpapi or osm). The cost per tile in this post comes from Sentry's numbers. The three Sentry screenshots above show it running.

Best Use of Mastra. Mastra runs the reading pipeline. The readPage workflow streams tiles back while the card says "Reading prices…", and the mergeFlyer workflow merges, sorts and locates a flyer in one step. Three agents (page reader, tile reader, merger) share one prompt schema, Mastra's MCP client talks to TabPFN, and its Sentry exporter produces the traces above. When a flyer was read whole in one call, the workflow skips the merger agent and sorts it in code, which is what took five real flyers from four and a half minutes to 38 seconds.

Best Use of SerpApi. Only flyers worth a walk that print no address get looked up, by business name near your start (rounded to about 1 km). If Google's phone number matches the flyer's, the card says so, which is also a decent way to tell a real shop from a door-to-door buyer. On the free plan every search is counted before it's made, with daily and monthly caps, a reserve, a 30-day cache, and tests that can't spend a search. The whole build used 10 of 250. When SerpApi finds nothing, OpenStreetMap is the fallback.

Best Use of TabPFN. The places you remove and the stamps you collect are the labels, so there's nothing extra to rate. Through Prior Labs' remote MCP, TabPFN ranks the mailbox from nine numbers per flyer, never a name, address or flyer text, and reuses the fit until your choices change. I've only checked it on synthetic rows so far (0.9996 for a nearby free trial, 0.0004 for a far flyer with no offer, in 11.6 s), and with fewer than six choices simple rules take over.

Best Use of Gemma. Gemma 4 31B reads Japanese flyers into English and structured prices (all 52 products on one drugstore page), and Gemma 4 E2B runs the same app on a laptop with no keys.

Best Use of DigitalOcean. Every flyer the hosted app reads goes to Gemma 4 31B (gemma-4-31B-it) on DigitalOcean's serverless inference, through its OpenAI-compatible endpoint: every page read, tile read and model merge. Mastra uses it like any other provider, and LOCAL_LLM=1 swaps in Ollama with no code changes. DigitalOcean is also where I ran the test that shaped the app: 31B there against E2B on my laptop, on the same pages. On my 10-page pile a whole page comes back in 4 to 30 s (about 7 s typical), and Sentry's cost numbers put a tile at about $0.00044, so a whole mailbox costs about five cents. That price is why the app has no sign-up.

DigitalOcean's serverless inference dashboard: one model, gemma-4-31B-it. The climb on the right, 11 and 12 October, is this app being built and tested on real flyers.

Best Use of Render. One Node service from a Blueprint, with secrets in the dashboard, per-IP limits that respect the proxy, compression and caching, a service worker so a walk reopens without signal, and a deploy on every push.

Built solo.

If your mailbox looks like mine, photograph it and tell me which flyer it got wrong.

Phone calls are the boss fight of living in Japan. 🗼

ADK BBX — Sun, 04 Oct 2026 17:42:34 +0000

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

I've lived alone in Tokyo for four years now, but when my washing machine started leaking, I stared at the building manager's number for twenty minutes before I pressed call.

My friend ran into the same thing when she had to cancel her internet contract by phone. The provider's explanation sounded alien to her. The Japanese businesses use on the phone is not the Japanese you use every day, and on a call there's no face to read and no time to look anything up.

So I built Before I Call, an app where you practice the call with an AI before you make the real one. I made it for myself and for friends in the same situation, and sent it to one of them to see if it actually helps. Their reply is further down.

Here it is in action:

What I Built

You describe the call you need to make, or pick one of the examples (home repairs, the clinic, a missed delivery, the city office, dietary requests, lost property, bills). Then you talk to an AI that plays the person on the other end, like a receptionist or your building manager. It speaks polite Japanese, asks one question at a time and waits for your answer. There's no score.

If you get stuck, you don't have to hang up. Explain question opens a helper next to the call with what the question means and a reply you could give. The AI on the call doesn't see it, so the role-play carries on. Slow replay plays the question again at 0.7x speed, and Repeat question asks the AI to say it again. Kanji have furigana, every line has romaji, and known words show their meaning when you hover or tap.

When you say goodbye, the AI hangs up and you get a call card: the whole conversation with readings and meanings, and a list of useful words from your call. You can download it as a PDF and keep it next to you when you make the real call.

It won't make up dates, prices or availability, and it can't book anything for you. It's only for practice.

Setting up a call. You can type or dictate it in English or Japanese, or start from an example. Enhance prompt tidies up rough notes without adding facts you didn't give it.

Asking for help in the middle of the call:

The word list on the call card:

What my friend said

I sent the link to my friend on WhatsApp and asked them to let me know if it helps. This is what came back:

I didn't expect the PDF to be the part they liked. I made it as a cheat sheet for the real call, but for someone studying for the JLPT it's also a word list from a conversation they actually had.

Demo

Try it at before-i-call.onrender.com. There's no sign-up. Voice practice needs a microphone. Without one, tap Play guided example to watch a recorded call in Japanese or English.

Code

adkbbx / before_I_call

Before I Call

Rehearse the phone call you've been putting off.

A patient AI voice partner for everyday Japanese and English calls, with furigana on every word,
help that never interrupts the conversation, and a call card to take with you.
Use it in the cloud, or free and offline on your own computer with Gemma 4, Whisper and Kokoro.

Live app · How it works · Free local mode · Architecture · Run it locally

The problem

A phone call is the hardest everyday conversation in a second language. There is no face to read and no time to look anything up, and the other person speaks at native speed. People who live in Japan put off calling the building manager, the clinic or the delivery company, not because they can't manage the conversation, but because the call itself feels risky.

Phrasebooks help with the first sentence. They don't…

View on GitHub

MIT licensed and built during the challenge. It has 87 tests (80 Python, 7 Node), and the README explains how to run it locally.

How I Built It

The call runs on ElevenLabs Agents

The live call is an ElevenLabs agent. It handles all the audio: the WebRTC connection, speech recognition, working out when you've finished speaking, interruptions, and the voice. I use one agent for every scenario. When a call starts, the app sends that call's prompt, first line, language and voice as overrides, so the same agent can be a Japanese building manager or an English clinic receptionist.

I slowed the agent's speech to 0.85x for learners and capped calls at two minutes, with a daily limit on the server so the credits can't all go in one day. Hanging up uses the built-in end_call tool. Its description tells the model to use it only after your question is dealt with and you've said you don't need anything else, not when you just say thanks. Explain question opens a second, text-only session with a helper prompt, so the explanation never ends up in the call transcript. Slow replay uses ElevenLabs text to speech (Flash v2.5 at 0.7x).

The agent has had 113 conversations so far. ElevenLabs groups them by topic on its own, and the top three match the examples in the app: booking an appointment (27), the washing machine (19) and a missed delivery (17).

Why I switched to a custom LLM

When I started, the agent used one of the LLMs hosted by ElevenLabs, Qwen3.5-397B-A17B. Its usage came out of the same ElevenLabs credits I got for Hacktoberfest, and it was going through them fast. ElevenLabs lists it at about $0.016 a minute and $0.003 a message, on top of the voice. A custom LLM costs nothing on the ElevenLabs side:

I wanted those credits for the voice, so I switched the agent to a custom LLM and pointed it at Gemma 4 31B on DigitalOcean, which bills my DigitalOcean account instead. With the per-token prices my tracing code uses for Gemma ($0.18 per million input tokens and $0.50 per million output tokens), the turn in the trace further down cost about $0.0002. The ElevenLabs credits now only pay for the audio.

At first the custom LLM pointed straight at DigitalOcean. Later I put my own server in between so I could trace and check every reply. This is the agent's LLM setting now:

On each turn, the agent sends the conversation to my FastAPI server on Render, the server forwards it to Gemma 4 31B on DigitalOcean's serverless inference, and the response streams straight back, so the voice can start as soon as the first words arrive.

The proxy on Render

The custom LLM URL points at my own server: a FastAPI app that Render runs as one Docker web service. The same service serves the React app, the API and the proxy. The whole setup is a render.yaml Blueprint in the repo (trimmed here):

services:
  - type: web
    name: before-i-call
    runtime: docker
    plan: starter
    healthCheckPath: /api/health
    disk:
      name: usage-data
      mountPath: /var/data
      sizeGB: 1
    envVars:
      - key: LLM_PROXY_KEY
        sync: false
      - key: GRADIENT_MODEL
        value: gemma-4-31B-it
      - key: MAX_CONCURRENT_CALLS
        value: '2'
      - key: MAX_CALL_SECONDS
        value: '120'
      - key: MAX_CALLS_PER_VISITOR_DAY
        value: '3'

Keys are sync: false, so they're set in the Render dashboard and never committed. The limits that protect my credits are plain environment variables: two calls at once, two minutes each, three calls per visitor a day. The 1 GB disk holds the SQLite files for those limits and the analytics, so they survive redeploys.

The proxy is a single route. It accepts only the agent's key, refuses every model except Gemma 4 31B, and passes DigitalOcean's stream through unchanged while it reads each chunk for tracing and the rule checks (trimmed):

@router.post('/llm/v1/chat/completions')
async def chat_completions(request: Request):
    ...
    if not isinstance(body, dict) or body.get('model') != model:
        # The key is never usable for other, more expensive models.
        raise HTTPException(400, f'Only {model} is available.')
    ...
    async def relay():
        async for chunk in response.aiter_bytes():
            stream.feed(chunk)
            yield chunk

    return StreamingResponse(relay(), media_type='text/event-stream',
                             headers={'Cache-Control': 'no-cache', 'X-Accel-Buffering': 'no'})

An always-on web service suits this. Each reply is a streamed response that stays open while Gemma talks. The server reuses one HTTPS client for DigitalOcean, so a turn doesn't pay for a new TLS handshake. And when you interrupt the AI, ElevenLabs drops the request, so the proxy closes the stream and records the turn as cancelled in Sentry.

Here's the proxy at work in Render's logs, one line per Gemma request from the agent:

The service is managed by the Blueprint, which stays synced to the repo, and every push to main deploys on its own:

Fixing how numbers are read

The first version read 7時 as "nana-ji". Nobody says that. Japanese numbers change their reading depending on the counter after them: 7時 is しちじ, 10分 is じゅっぷん, 4月1日 is しがつついたち and 2人 is ふたり. Dates, times and the number of people are exactly what you say on a phone call, so this had to be right.

I fixed it with a pronunciation dictionary: 118 entries I wrote by hand plus 5,989 generated ones for dates, clock times, durations and counters, 6,107 in total. A script builds the rules and uploads them to the ElevenLabs agent as a pronunciation dictionary, and the app uses the same list for slow replay and the recorded demos. The text on screen doesn't change. This is the dictionary on the agent:

Tuning the prompt for Gemma

Switching to Gemma meant rewriting the prompt. I tested it with text-only runs of the agent. The old prompt never called end_call (0 of 2 scenarios), and the tuned one hung up in all 4. It also keeps ordinary words in kanji and writes numbers in kana so the voice reads them correctly, and it asks for practice details instead of your real ones. It still missed the hang-up sometimes in real calls, and Sentry caught that. The start of the tuned prompt:

Checking every reply with Sentry

Since every turn goes through my server, I can check each reply against the rules of the practice call. If you said goodbye and the AI didn't hang up, if it "confirmed" a booking, or if it put digits or English letters into Japanese speech, that becomes a Sentry issue tagged with the prompt version and turn number. Each request is also a gen_ai trace with time to first token, token counts and estimated cost. After a call you can tap Report this reply, and the report shows up next to that turn's trace. Conversation text only goes to Sentry if you choose to attach it.

Here's a real one. On October 3, the practice partner didn't hang up after the learner said goodbye, and Sentry caught it 8 times in four minutes. Each rule gets its own issue:

The issue lists every time it happened and which release it came from:

For comparison, here's a turn where the partner did hang up. The execute_tool end_call span is the hang-up. The Gemma call took 1.27 s (Sentry's average for it is 1.49 s), used about 1,100 input tokens and 43 output tokens, and cost less than a cent. Traces don't include the conversation text, so the Input tab is empty.

All of those Gemma calls run on DigitalOcean's serverless inference, so I never had to run a GPU server. In two days, October 3 and 4, the app sent about 1.28 million input tokens to Gemma 4 31B and got about 75,000 back. Most of it is input because every turn sends the instructions and the conversation so far, while the replies are short, like the 43 tokens in the trace above.

Bugs I hit along the way

Gemma sometimes wrote voice directions like [calm] or [pause] into its replies. The app strips them from the text on screen.
Small models sometimes say a tool call out loud, like end_call(reason="done"), instead of calling the tool. The app removes that text before it's spoken and treats it as a hang-up.
Running Gemma 4 locally, the first replies came back empty because the model spent all its tokens on hidden reasoning. Setting reasoning_effort: "none" fixed it, and replies now take about half a second on my laptop's GPU.
Kokoro's Japanese voice wouldn't install on Windows, because pyopenjtalk needs CMake to build. pyopenjtalk-plus has prebuilt wheels, so I switched to that.
Romaji showed 10月4日 as "10tsuki4hi". Romaji and furigana now use the same reading list as the voice, so it reads juugatsu yokka.

Why Does Open Innovation Matter?

The hosted version runs on paid APIs. I also wanted a version that's free and private, so the same code can run entirely on a laptop. With LOCAL_VOICE=1, Whisper handles speech recognition, Gemma 4 E2B (4.3 GB, through Ollama) plays the other person, and Kokoro-82M speaks. Explanations, slow replay, Enhance prompt, the word list, furigana and the PDF all still work. Nothing is sent to a provider, it works offline, and you can switch models with one setting (LOCAL_LLM_MODEL).

On my laptop (Ryzen 9 5900HS, RTX 3060 with 6 GB), the AI greets you in 2.4 s, answers what you say in about 6 s, and an explanation takes 1.4 s.

The local version isn't as good. The ElevenLabs voice sounds more natural, responds faster and lets you interrupt it. Locally you tap to talk, and the small model doesn't follow the role-play rules as closely as the 31B. It's possible at all because Gemma's weights are open: the same model family runs on DigitalOcean and on my laptop, with the same prompt, rules and pronunciation list. Furigana and romaji don't need a model. The open-source pykakasi and Janome libraries handle them.

Prize Categories

Best Use of ElevenLabs: one agent over WebRTC for every call, with per-call prompt, first line, language and voice overrides, the built-in end_call tool, a custom LLM pointed at Gemma, a separate text-only session for explanations, text to speech for slow replay, and a 6,107-entry pronunciation dictionary on the agent.
Best Use of Sentry Agent Tracing: every Gemma request is a gen_ai trace with time to first token, tokens and cost. Replies are checked against the role-play rules, and user reports link to the exact turn.
Best Use of DigitalOcean: serverless inference runs Gemma 4 31B for every call turn, explanation, prompt enhancement and word list, with no GPU to manage.
Best Use of Gemma: Gemma does four jobs (the other person on the call, the explanation helper, the prompt enhancer and the word picker), as 31B in the cloud and E2B on a laptop.
Best Use of Render: one Docker web service from a render.yaml Blueprint serves the app, the API and the custom LLM proxy that streams every Gemma reply to ElevenLabs, with a persistent disk for usage limits and analytics, keys kept out of the repo, and the credit limits as environment variables.

Built solo.

If you live in Japan and put off phone calls too, try it and tell me in the comments what's missing.

Hello world!

ADK BBX — Fri, 02 Oct 2026 18:16:26 +0000