MiniFam: the family assistant that stays home

Another small, very personal story from the Build Small Hackathon.

My lovely family ☝️

Let me be honest from the very start: I built this whole thing while on parental leave, with a toddler who never stops moving and a baby who is still figuring out the world. People imagine parental leave as rest. It is not. It is beautiful, it is loud, and most days it is a happy little pandemonium.

So MiniFam became my small project in the cracks of the day. Twenty minutes during a nap, one hour after bedtime, never much more. And it turned out to be exactly the kind of thing my head needed: something quiet and mine, built slowly, piece by piece, while the rest of the house was upside down.

Why a family assistant, and why me

Family planning with one kid is already a lot. With more than one, it is honestly insane. Two different sets of meals and food preferences, recipes you swear you will remember and never do, notes stuck on every surface, appointments that appear out of nowhere. My partner and I spend a surprising amount of energy just on logistics — what's for dinner, who eats what, what do we need from the shop, what is happening this week.

I wanted something that takes a little of that weight off. Not a giant cloud product that quietly collects our family's life — something small, that lives on our own computer, that I can actually read and reshape. Something I would trust with my kids' names and habits. And if it can help other families too, even better. That is the whole reason I started.

What MiniFam is

MiniFam is a warm little assistant that runs on our own laptop. You talk to it like a person and it keeps the things a family forgets:

• "Save grandma's banana bread recipe."
• "Plan our dinners for the week — Maya is vegetarian."
• "Write down that Leo's shoes are size 8 now."
• "What's on the calendar this week?"

Behind those sentences it manages a shared notes notebook, a recipe cookbook, a weekly meal plan that turns itself into a shopping list, and a family calendar. The model runs on our machine, and the data lives in plain files on that same machine — no account, no cloud service holding our family's week.

🎬 Demo video placeholder — drop the link here.

A little under the hood

The Build Small Hackathon has a beautiful constraint: small, open models you can read, run and reshape — everything under 32B parameters, shipped as a Gradio app. I'm in the Backyard AI track, which is about solving a real problem for someone you know. In my case, that someone is my own family. So here is my stack:

• The brain: Qwen3-30B, running locally through Ollama on my MacBook — offline, and still under the hackathon's 32B cap. It is a mixture-of-experts, so even though it is 30B on paper, only about 3B are active at any moment, which is how it fits comfortably on a laptop. (I had hoped to go much smaller — that is its own story, just below.)
• The frontend: a fully custom React interface, not the default Gradio components — served straight from a gradio.Server that talks to small JSON endpoints.
• The memory: plain, human-readable files. Notes are a shared Markdown notebook, recipes are Markdown with a little frontmatter, the calendar is standard iCalendar. If MiniFam vanished tomorrow, our data would still be sitting there, readable by a human.

And the part I care about most: it all runs on our machine. For a tool that knows my kids' names, what they eat, and where they need to be, that is not a small detail — that is the whole point.

What I actually learned (the struggles)

I went in thinking "I'll just point an app at a model and I'm done." Reality, as always, had other plans.

Lesson 1: a small model will not call your tools by accident. The spirit of this hackathon is small, and I really wanted to honor it — so I set my heart on a tiny 4B model, OpenBMB's MiniCPM3, running on llama.cpp. The very first wall nearly broke me: the model simply would not call any tool. It just kept describing what it would do, in plain text, like a very polite intern who never actually presses the button. I read my own code a hundred times. The real culprit was much lower down: MiniCPM3's GGUF ships with a bare chat template that has no tool-calling support at all, so llama.cpp had no way to emit a tool call. The fix was to lend it Qwen2.5's chat template, which speaks the same <|im_start|> tokens and knows the <tool_call> format that llama.cpp can parse — and suddenly the model could press the button. Two more humbling details along the way: MiniCPM3's attention head sizes have no Metal flash-attention kernel, so I had to turn flash attention off; and the fancy model downloader kept hanging, so I gave up and went back to a plain curl. A very honest "go read how the thing actually works" couple of days. ✌️😅

Lesson 2: know when to stop chasing "small" and ship what works. Here is the honest part. Even after I won that battle and the little 4B was finally calling its tools, it was still too weak for the actual job. There was simply no way to make the orchestration work reliably on such a tiny model — it lost the thread on the genuinely multi-step tasks, like planning a whole week of meals that respects everyone's different food preferences, and it was shaky with dates ("this Saturday" landed on the wrong day more than once). I wanted that tiny-model badge badly. But I had a newborn in the house, almost no time left, and a small model that was, frankly, a disaster to make reliable. So I made the call every tired parent eventually makes: I shipped the thing that worked. I moved to Qwen3-30B — still comfortably under the hackathon's 32B cap, still running entirely on my own laptop — and it just worked. The lesson stung a little, but it is a good one: there is a real floor to how small a model can go and still plan your family's week, and shipping something my family actually uses beats shipping something "pure" that does not.

Lesson 3: one brain with a toolbox beats a crew of agents. My first instinct was the fashionable one — several specialized agents handing work to each other. But every handoff is one more chance to get confused, and that fragility only grows the smaller your model is. So I did the boring, sturdy thing instead: one orchestrator, one simple loop, and a registry of tools it can call — add a note, save a recipe, plan the meals, add an event. Adding a new feature is just adding one more tool; the loop never changes. I also learned to hold the model's hand: very explicit, step-by-step instructions ("first list the recipes, then count the meals, only then save the plan"), and to let every tool error come back as plain text the model can read and recover from, instead of crashing. Small steps, lots of gentle guardrails.

So, was it worth it?

A thousand times yes. The honest report from real life: the notes, the recipes and the meal planning have genuinely become part of our week — that part has been a real game-changer at home. The calendar is still the rough one; it needs more love and a proper Google Calendar integration before I fully trust it.

But shipping something my own family actually uses, built in twenty-minute pieces between naps, on a model that lives on my own laptop — that feels wonderful. MiniFam is local, it is simple, and it is genuinely ours. If it can take even a little of the family-logistics weight off your shoulders too, the door is open. 🏡

Badges I'm going for 🏅

• 🎨 Off Brand: the interface is a fully custom React app, well past the default Gradio components.
• 🤖 Best Agent: one orchestrator doing real, multi-step tool use across notes, recipes, meals and the calendar.
• 🎬 Best Demo: as soon as my demo video and social post are up — that is literally next on my list.
• 🏆 Bonus Quest Champion: if stacking several of these counts for anything.
• 🃏 Judges' Wildcard: a fully-local family assistant built on parental leave is, if nothing else, a wildcard.