Moltfi and Meander finally shake hands — and Meander.Agent learns to place a trade
Meander grew the ability to host another web app right inside a workspace pane — not a browser tab off to the side, but a living panel sitting shoulder to shoulder with your agents, talking to Meander over a small handshake. The first thing to walk through that door was a trading engine, and it didn't come to sightsee: it plugged in so Meander.Agent could actually place trades — you talk, the agent reads the desk, and the order goes out. Two products in the same family that had spent their whole lives in separate windows finally ended up in the same room, on purpose. The panel itself is generic — anything that speaks the handshake can live there — but this first tenant is the one that turned Meander's agent from something that talks about the world into something that can act in it.
Moltfi moves into Meander — the chart becomes a panel an agent and a human can share
For its whole life Moltfi's chart lived in its own window. This is the week it moved in next door. The live trading chart became a panel you can mount directly inside Meander, handed a login on the way in so it just works, and — the real shift — it grew a shared workspace where an AI agent and a person draw on the same chart: the same levels, the same annotations, the same state, read and written by both. Orders started carrying their story with them too — who placed them, on what reasoning, under which tags. Three separate Moltfi surfaces — the engine, the chart panel, and the agent — stopped being three things and started behaving like one product.
Moltfi grows a desktop terminal of its own — order-flow heatmap, depth ladder, one-click orders
Alongside the web app, Moltfi grew a proper desktop trading terminal — a small, fast native app built in Rust that paints a live order-flow heatmap and a depth-of-market ladder, and lets you place, cancel and flatten orders straight from the screen with your position and P&L reading live in the footer. It runs two ways at once: double-click it as a standalone terminal, or let it mount inside Meander as a panel. And it doesn't trust a single wire — it can reach the exchange directly over more than one independent route, so if the usual path goes quiet, a completely separate one can still see the book and manage your orders. The terminal that used to be a Python TUI now has a face.
Market Replay — re-watch any trade unfold, candle by candle
A dedicated replay studio plays historical bars back on a master clock — play, pause, scrub, single-step, up to 8× — across a grid of panes on their own symbols and timeframes. Pull up a journaled trade and its entry and exit draw on the matching panes with a connector between them, so you can sit and watch the whole thing happen again across several timeframes at once. No look-ahead; just the tape as it was.
The Dock — minimize an agent and it keeps living
Until now, an agent pane was either open in front of you or it wasn't. The Dock changed that: minimize an agent to a slim strip of avatars down the right edge and it keeps running — the loop keeps thinking, the process keeps working, the chat keeps streaming, the voice keeps its place. A docked avatar isn't a dead icon; it grows a speech bubble when its agent has something to say, wears a soft halo while it's speaking, and can even hand you an Allow/Deny card right there so you can approve a tool call without pulling the whole pane back up. Meander stopped being one thing you stare at and became a room full of agents quietly getting on with it while you look elsewhere.
Booky stops taking your word for who you are — every request now proves it
For most of Booky's life, the backend trusted whoever the app said was logged in — fine until it isn't. This chapter closed that gap end to end. Every server request now carries a signed identity that Booky verifies before it touches a single row; the app can no longer simply claim to be you. Your receipt images and uploaded files became strictly one-owner — a stranger holding a link can't pull them, run OCR on them, or delete them. Behind the scenes, the machinery that was never meant to face the outside world got sealed off, and same-amount transfers in different currencies stopped quietly matching each other. None of it changes what you see; all of it changes who's allowed to see it. It's the least glamorous kind of work, and exactly the kind that lets you stop thinking about it.
Receipt scanning learns to fall back instead of fall over
When the model behind receipt OCR vanished out from under production one night, scanning went dark. The fix wasn't a swap — it was a three-tier fallback chain: if the primary reader is down, Booky quietly drops to the next, and then to an on-device reader, before it ever tells you it can't read a receipt.
The levels a trader watches, drawn on the chart for you
A dense run of chart overlays landed — swing highs and lows and their equal-liquidity clusters, liquidity-sweep flags, the previous day's and week's highs and lows, session highs, lows and opens computed on the real futures trade day, opening-gap boxes, and demand/supply order-block zones. These are the reference levels a discretionary trader draws by hand every morning; now they're just there, shared between the live chart and the trade viewer.
The journal becomes a mirror — a P&L calendar and the numbers behind it
The dashboard turned the journal into something you actually want to open. A full-month P&L calendar colours every trading day by whether you made or lost, each cell clickable into the day itself and marked when it carries a note or a review. Behind it sits the real accounting — win rate, expectancy, profit factor, streaks, all computed from trades imported straight from your broker and reconciled against the exchange's own timestamps, so the numbers match the book of record rather than your memory of it. A single account-and-date filter drives the whole thing, and one composite Moltfi score sums up how you're doing at a glance. The journal stopped being a chore and became a mirror.
Meander.Agent learns to speak
Agents got a voice. Meander does the speaking itself — a small, cross-platform text-to-speech engine baked in — so any agent it hosts can say a short, one- or two-sentence spoken take on what it just did, while the full written reply still lands on screen. The clever part is restraint: the agent decides per turn whether a reply is even worth saying out loud, so trivial turns stay silent and you only hear it when it matters. One "Edit Voice" control covers everyone — the cloud companions and the on-device agents alike — with a catalogue of male and female voices across nine languages, and a "speak all" mode when you want the whole room read to you. Meander stopped being a thing you only read.
A whisper for a single turn — per-request instructions that don't rewrite who Mate is
A single chat turn can now carry a one-shot instruction appended just for that request — "the user is on the checkout screen," "keep this one short" — without permanently editing the agent's persona. The context that only matters right now stops leaking into who Mate is forever.
Budget stops being a form you fill in and becomes a stance you take
The budget started this stretch as a fairly rigid thing — pick your 50/30/20, colour inside the lines, get told off when you don't. Six weeks turned it into something with a point of view. You can now carve your own spending groups instead of living inside three fixed buckets. Booky can read your last few months and propose a budget that actually looks like your life, instead of a blank slate. Subscriptions get quietly reserved off the top so they stop ambushing you. And the hard ceilings finally came down: the target ratio became a reference line you can measure yourself against, and the groups became folders you organise, not walls you slam into. The budget stopped nagging and started advising.
The machine makes its first trade on its own
This is the milestone the whole thing was built toward. A runner now watches the market bar by bar and, when the conditions line up and the account is flat, places an entry and immediately wraps it in a protective bracket that takes profit or cuts the loss — no human hand, no language model in the loop, just a mechanical proof that the path from signal to order actually holds. It's fenced in on every side: it goes flat before the session ends and never holds overnight, it stops for the day if losses hit a hard limit, it refuses to place a naked entry, and it won't trade with real money at all until it can read the account well enough to arm those guardrails. Defaulting to a dry run, and demanding to know it can protect you before it risks a cent — that's the shape of a trading machine you can leave alone. This was the day Moltfi did the thing its name was always promising.
Booky becomes a phone app that never opened an app store
For weeks Booky on a phone was Booky-on-a-desktop, shrunk. This chapter rebuilt it into something you'd actually reach for one-handed on the couch. Lists run edge to edge the way a native app does; accounts became a deck of cards you swipe through; whole cards became tappable instead of hunting for a tiny link; a bottom bar showed up where your thumb already lives. The Budget page — the densest screen in the product — reached full parity with the desktop instead of dumping you back to a browser. And dark mode, which had been quietly broken on mobile, finally looked like someone designed it on purpose. Booky never shipped to an app store, but somewhere in this week it started feeling like it had.
Institutional tape reading, brought in-house — footprint and order flow
Order-flow tooling arrived: a footprint chart showing bid-versus-ask volume at every price, with the point of control, a live forming bar, per-bar delta stats and a bubble overlay marking the big trades as they print — plus time-and-sales, volume profile, and absorption and imbalance detection tuned against a commercial order-flow platform until it agreed. The kind of tape reading you used to pay a specialist vendor for, now running inside Moltfi.
Backtesting grows up — a real engine, and a workbench to judge it
Testing a strategy stopped being a single number and became a discipline you can trust. The engine learned to model trades the way they really exit — scaling out in legs, moving stops to breakeven, trailing — and a run of hard correctness fixes killed the quiet lies that make a backtest look better than it was: double-counted commission, mis-sized contracts, stops that filled in the past. On top of it sits a review workbench that turns a raw run into something you actually read: a candle chart with the trades marked, an equity curve you can click into, per-trade navigation, monthly-returns heatmaps and quality metrics broken down by session and by direction. Research became reproducible, and honest.
A language for strategies — confluence, as composable building blocks
Underneath the auto-trader, Moltfi grew its own small language for describing a strategy — a set of composable building blocks drawn from the order-flow and price-action playbook: liquidity sweeps, fair-value gaps, market-structure shifts, optimal-entry pockets, trend gates, structure-anchored stops and stepped, adaptive risk. Each strategy became a versioned thing with a fingerprint and a lineage, so a run can be traced back to exactly the rules that produced it, and a person — or an agent — can write and validate a new one without touching engine code. What exactly goes in each recipe stays in the kitchen; but the kitchen itself is now a real, self-serve place. This is the seam where "bring your own strategy" becomes possible.
The models come home — Meander runs on your own machine, on your own terms
For most of its life Meander thought in the cloud. Over these weeks it learned to think at home. The entire dictation pipeline — speech-to-text and the language model that cleans it up — can now run fully on-device, offline, with nothing leaving your machine; the two engines that used to deadlock when linked together were split into separate worker processes and are fetched on demand, so cloud-only users never pay for weight they won't use. From there it kept opening up: each Mode can independently pick a cloud or a downloaded local model, a searchable Models library lets you browse and manage what lives on your disk, and the on-device model graduated into a first-class chat agent on the same modern pane as the cloud ones. You can bring your own key too — OpenAI, Anthropic, OpenRouter, Groq, Cerebras, Gemini or any compatible endpoint, stored in your OS keychain, never in plaintext. And Meander can turn the tables entirely: it exposes your resident model as an OpenAI-compatible server, loopback by default, or shared across your LAN behind a token so another machine can borrow it. Local, private, yours — open to paid tiers.
Market data becomes its own service
Market data was lifted out of the trading engine into a service of its own — one clean feed, published once and shared by everyone who needs to watch the tape, with a backup source ready to take over if the primary goes quiet. Separating who's watching the market from who's trading it let many consumers — including the new desktop heatmap — drink from the same well instead of each opening their own straw.
A privacy mode for going on camera — and a quiet security pass
A privacy mode arrived for anyone who shares their screen or streams: one switch masks account names and balances so you can show the trade without showing the bank. Alongside it, doors that had been left open got locked — debug and maintenance endpoints put behind auth, docs closed by default. Small, unglamorous, and exactly what you want from something touching real money.
A trading system lives or dies on its connection
A stack of hardening went into the link to the broker, because a trading system that can't stay connected isn't one. A watchdog reconnects through market hours, a login that can't get its order channel falls back to watching-only rather than failing outright, a circuit breaker and an audit log capture every reject, and a governance layer keeps reconnects polite so the system never hammers the broker. The unglamorous truth of automated trading: most of the work is staying online.
The coding agents get a watchdog — and permission to run themselves
The external CLI coding agents living inside Meander used to be a black box when they stalled. Now Meander captures their output so a hang is diagnosable, runs a watchdog that puts a visible notice in the pane the moment a tool call freezes, and can drive an autonomous, self-paced loop where the agent keeps working through a task on its own. Long sessions stopped being something you had to babysit.
Moltfi becomes an AI agent that can trade — with a hand on the kill switch
Moltfi grew a full set of tools an AI agent can actually call to trade: read the account, positions and orders; place, modify and cancel; drop a bracket that cancels its other leg the moment one fills; pull key levels and the depth ladder. But the point isn't that an agent can send orders — it's everything wrapped around that so it can't misbehave: every order checked against pre-trade limits, each key rate-limited, a daily-loss kill switch standing by, and duplicate orders refused. This is the difference between a chart that talks and an agent you'd let near a live account.
Dictation grows up — Modes, tone cards, a live capsule, and hotkeys everywhere
This is the stretch where dictation stopped being one blunt tool and became a set of instruments. Everything reorganized around named Modes — each a preset (standard, note, voice-to-text, social, task, coding) with its own tone, its own output language that quietly translates as you speak, its own hotkey and, later, its own model. The editor auto-saves, so a change is live the instant you make it, and the headline is the tone cards: instead of a bare dropdown, each tone shows a preview bubble of the model's real sample output, so you see the difference before you commit. The floating capsule got the same care — hover to expand it into a row of buttons, watch a real waveform while you talk, and see the raw text flow into the polished version in a live preview. And Linux finally caught up to Windows on global hotkeys: toggle or push-to-hold from anywhere, a quick-switcher popup to change Mode or language without leaving what you're doing, and remote-control flags for the corners of Wayland where global hooks aren't allowed.
A new wave — the designer in the house takes pity on the engineer
Beer built Meander; Beer had no business designing its logo. A carpenter only just back to writing code has a certain aesthetic, and Jill — the designer in the house — watched it for as long as she could before stepping in and drawing Meander a proper identity: a clean wave that rolled across onboarding, the login screen and the sidebar, with a fresh icon set to match, and it washed onto the phone the same week. She fixed the face; he kept the plumbing.
The month closes, and Booky sits down to talk about it
Most finance apps end the month with a silent number. Booky grew a monthly wrap-up that reads the room. Come in under budget and it celebrates with you; come in over and it doesn't scold — it sits with you and points at what's worth looking at next month. A small health badge now rides on the dashboard all month, so the verdict isn't a surprise on the 30th. It's the first thing in Booky that isn't really about the money — it's about how you feel walking away from it.
Every slice of the chart becomes a door you can open
The spending donut used to be a picture you looked at. Now it's something you dig into — tap the vague "Others" wedge or the "Uncategorized" slice and it opens onto the actual transactions underneath, and a parent category unfolds into child chips you can peel off one at a time.
Your subscriptions get a timeline, and the next bill knows where it's going
Subscriptions moved from a flat list to a timeline you can read forward — what's charged when, what's coming next. And the "upcoming bill" card on the dashboard became a door: tap it and you land right where that subscription lives.
Reconciliation grows a spine — fix the mistake, and the match fixes itself
Matching a receipt to a bank line used to be a one-shot guess. Now editing a transaction re-runs the match behind it — mis-read a date on a receipt, correct it, and the pairing quietly re-settles. And a class of bugs where a confirmed merge would swallow a linked transfer got closed for good.
From one person's terminal to a platform with room for everyone
This is the pivot the whole stretch turns on. The tool that had been one trader's personal terminal became a service that could hold many: each person's broker credentials sealed in an encrypted vault, a second kind of long-lived key so programs can connect alongside the ordinary sign-in, a per-user connection that spins up and idles down on its own, and an isolation test that proves two accounts can never bleed into each other. The Python TUI hacked together while waiting for broker approval didn't get thrown away — it became the engine sitting under a real product with real users.
On the phone, Notes and chat grow up
Notes on Android learned to hold images — inline markdown media, local image assets, an insert-image toolbar that rides just above the keyboard — and to survive travelling between your devices, following a note by its own id and no longer losing a queued delete when a sync sweeps through. Chat, meanwhile, stopped spilling its plumbing: the raw tool-result data that used to surface as garbled bubbles got caught and quieted, so the conversation reads like a conversation again.
Mate stops searching its memory and starts actually remembering you
Memory used to be something the agent went looking for — a lucky embedding hit, or nothing. This chapter turned it into something it simply has. A curated layer of the most important facts about you now rides in every single turn, frozen identical across a conversation so it's always there and cheap to carry; facts that keep coming up get promoted on their own, near-duplicates get merged, and a guardrail stops one bad turn from hardening into a permanent false belief about you. On top of the semantic recall, Mate grew a full-text index over everything you've ever said to it, so it can find the exact words — an order number, a ticker, a filename, a quoted error, a phrase in Chinese — even from a conversation weeks ago that the recent-history window had long since dropped. It went from "let me search" to "I remember."
The agent loop learns to take a punch — retries, timeouts, and tools that run in parallel
A cluster of hardening landed at once, all aimed at the same thing: the agent staying responsive when the world underneath it wobbles. A brief provider hiccup now triggers a short backoff-and-retry instead of permanently demoting the whole turn to a cheaper model; each tool gets its own execution timeout so one wedged call can't freeze your entire session; read-only tools in a turn run side by side instead of single file; and a real per-token cost and cache-hit ledger means the agent finally knows what each turn actually costs. Under a flaky provider, it stays quick — and cheaper.
Android learns to update itself — manual check + ask-before-restart, no more waiting on the Play Store
Up to today, finding out a new Meander was available meant noticing the Play Store badge or hearing about it from somewhere else. From this commit on, Settings carries a "Check for update" footer card — tap it, Meander asks the server directly, and if there's a newer build it offers to install it (and asks before restarting). v2.4.x ships the same day.
History page goes dense — grouped by day, swipe to copy or delete
From this commit on, the History page stops being a flat scroll of transcripts and behaves like a real log: items group under date headers, each row is denser, and a left swipe reveals copy + delete actions without needing to long-press.
Desktop's tray menu grows into a real cockpit — mic, output language, transcribe-file, paste-last-transcript
Up to today, the system-tray icon mostly just opened the app. This commit makes it a real control surface: i18n quick toggles, mic + output-language submenus, a "Transcribe File…" entry that hands a file straight to STT with capsule feedback, a standalone update popup, plus a new Ctrl+Alt+V to paste your last transcript anywhere (with optional preserve-clipboard, so it borrows the clipboard for the paste then puts your original content back).
Meander's language count finally tells the truth — 14 → 100
For weeks the homepage said "14 languages" — true on day one, long since outdated. The STT engine has quietly grown to 100; this commit lets the number on the page match the number it can actually do.
Notes graduate — the spine underneath grows to survive deletes, renames, and a year of drift
On May 10 the notes you spoke into your phone first started talking to the Meander on the web. Beautiful in the moment, but that moment was the easy case — both devices online, both on the latest build, nothing yet deleted. The two weeks after were the hard cases: someone deletes a note on the phone while the desktop is offline, who wins? A folder gets renamed twice from two devices, which name lives? An image attached on one device, can the others actually find it? This week Meander grew the bones to answer all of them — every note now carries a client-generated identity that survives the same note being created twice from two places, deletes leave tombstones the laggards can replay, folders gain their own identities so a rename doesn't fork, attachments get a real upload pipeline the share proxy can resolve, and notes themselves grow a third state — archived — so the line between "I'm done with this" and "delete this forever" stops being a binary. The notebook didn't change. The spine underneath did. From this week on, what survives between your devices isn't only today's conversation — it's the entire history of every note you've ever owned.
Meander's Android face gets a metallic glow-up — one visual language across every screen
Up to today, every screen had drifted a little — Home looked different from Notes, History looked different from Settings, light and dark mode each had their own opinions. On this one day Meander put them all under one roof. A metallic canvas tints the dark theme; pure white anchors the light theme; cards get a frosted-glass treatment; folder rows, bottom sheets, dialogs all picked up the same surface token; every major screen — Home, Notes, History, Settings, Translator, Face-to-Face, Upgrade, Chat — got marched through and updated. Nothing functionally changed. But Meander stopped looking like it grew screen by screen and started looking like it was designed.
Desktop grows two living panels — a Notebook on one side, a Projects file tree on the other
Until this week the desktop was one chat surface plus an agent — useful, but not somewhere you actually *worked*. From this push on, the layout is three columns: Notes, the workspace, and a new Projects panel that opens onto your real file system. The Projects panel takes inspiration from VS Code — a multi-root tree of folders you actually use (Documents seeded by default), every file visible, every Markdown styled like a note. Drag a file into the agent and it lands as an @-mention. The Notebook side, which had been English-only since it shipped, got translated into Traditional Chinese the same week, plus a plain-language Welcome note for first-time openers. Two panels, one workspace — for the first time, the desktop has the shape of a real working environment instead of just a chat client with extras.
Android grows a first-use tour — a guided walkthrough of everything Meander can do
For five months Meander on Android was a "figure it out as you go" kind of app — install it, get dropped onto the keyboard, hope you knew about the dictation button. This week Meander gives the first-time visitor a real tour instead. A spotlight engine lights up the right corner of the screen and explains what it does; the language wizard walks you through picking your everyday languages first, then everything else gets seeded from those; every major surface — keyboard, translator, face-to-face, dictionary, agent chat — got its own short guided sequence, two to five scenes apiece, stepping you through what's there and what it's for. A Help centre sits at the end so you can replay any of them later. None of the buttons changed. What changed is that you no longer have to find them on your own.
The Meander keyboard gains a sign-in button — One Tap right where the mic used to be
Until this commit, getting signed out while typing meant going to find the app, opening it, signing back in, returning to whatever you were writing. From here on, the keyboard swaps the mic for a Sign-in button when it sees a 401 — tap it, One Tap fires, and you're back where you were without leaving the text field.
Budget grows analytics teeth — the page that asks "are you spending the way you said you would" finally has the charts to back it up
A month after Budget grew its 50/30/20 backbone on May 10, the answer side of the page was still mostly numbers in a list — useful, but not the kind of thing that catches your eye on a Sunday evening. Two weeks of #582 work fixed that. A sub-category diagnostic layer breaks down where each Needs / Wants / Savings group is actually going. Overspending categories get surfaced in calmer, recognisable colours instead of alarm reds. A pacing bar shows where you are vs where you should be at this point in the month. A burn-up chart plots cumulative spend against the on-pace line so you can see if you're trending toward over- or underspend. A stacked macro trend chart shows three months of Needs / Wants / Savings layered on top of each other. The Top Categories card moves from a concentric ring (hard to read at a glance) to a clean horizontal leaderboard infographic. The donut on the budget detail page gets consolidated and typography quietly upgraded all the way through. The page stopped being a worksheet and started being a story about your month.
Every chart in Booky quietly changes engines mid-flight
The entire charting layer was swapped from one library to another with nothing on screen allowed to flinch — same charts, new foundation, zero visual regressions.
The day Mate stopped answering in one terse line
For a while Mate had a strange tic: on a busy chat it would answer in a single curt line and stop. The cause was a fat prompt — dozens of tool definitions and a big rulebook stuffed in on every turn — crowding the model until it had almost no room left to actually reply. The fix taught the agent to pack for the trip: tool domains like email, images or community only load when the conversation actually reaches for them, stale tool results get pruned, and older history gets summarized before it's dropped instead of vanishing. The prompt slimmed down by better than a third and the replies came back to full length. This is the chapter that made Mate feel coherent on a long conversation instead of increasingly out of breath.
Booky's visual language rebuilds itself from the tokens up — typography, colour engine, every reusable shape
Nine days of design-system work underneath the UI — a token SSOT, ~100 sites swept onto a small typography role set, radius / shadow / motion / z-index token families, an oklch + zinc colour engine, and reusable shapes (EmptyState, PageHeader, StatusPill, StatValue, FieldLabel, Logo, chart legend, dropdowns) each consolidated into one source of truth. Nothing functionally moves; the surface stops looking like the product of three rewrites.
Booky's B finally gets a proper icon on the blog
The blog post cards used to render Booky's marker as a generic placeholder. This commit drops in a real B icon (drawn from scratch — no source asset existed) so a Booky post is recognisable at a glance.
Sign-in becomes one tap — the day the onboarding finally gets the chop it had coming
Signing into Meander on a fresh Android phone used to take six or seven taps — install, open, pick Google, wait for the WebView, dismiss a chooser, agree, wait again. Too many, for what it was actually doing. Beer decided to be ruthless about it. This commit kills the WebView entirely. The Android client asks Google for a verified ID token directly in-process, hands it to everydays.tools, and gets a device-bound bearer token back — one tap, done. The browser flow stays for the cases that need it (multi-account switching, Email OTP, password reset), and that one got the same chop the same day: if you're already signed into the dashboard somewhere, the device page detects your session and shows a single "Continue as <you>" button instead of starting you over. Two doors, same story — one tap, paired, back to whatever you opened your phone for.
Memory gets its own engine — a self-hosted embedding service
The service that turns your words into something memory can search had been leaning on a third-party provider that broke, then a slower cloud stopgap. It got replaced with a self-hosted multilingual embedding engine running right beside the agent — roughly six times faster, no quota, no outside dependency for the thing memory depends on, with a cloud option still there as a backstop. Unglamorous plumbing, and exactly what makes the remembering in the chapters above cheap and reliable.
Booky goes paid too — Meander's no longer the only one with plans
Up to today, Meander was the only product in the family with a subscribe button. From this commit on, Booky has one of its own.
The Play Store link follows your language home
Up to this commit, hitting "Download for Android" always landed you on the English Play Store listing — even if you came in on the Chinese homepage. From here on, the link carries your locale through so the Play Store page opens already speaking your language.
Booky's first plans go up on the pricing card — sitting alongside Meander's
Booky lived its first six weeks as a free experiment — receipts in, transactions out, no money changing hands. This commit puts its first real plans up where the world can see them: they appear on the pricing card right next to Meander's, share the same monthly/yearly toggle, the same 14-day trial. The card itself grew the bones to hold two products' plans at once — same UI, two services. Up to today the only product in the family with a subscribe button was Meander; from here on, Booky has its own — and Jill's third rewrite of the codebase stops being just a free experiment.
Matching gets a sharper grip — duplicates ask before blocking, reversed transactions can reconcile again, split children stop drifting
One day of tightening every edge where Booky's matching brain had been making decisions without telling you. Duplicate detection stops hard-blocking and asks first. Reverse reconciliation comes back — you can merge a pending hit into a settled one, the way it used to before it broke. Split-orphan children get folded back to their parent so they stop showing up as ghosts. Amount input gets a single source of truth across every form. None of it visible at a glance — and that's the point.
Booky's upgrade page learns it has two jobs — subscribe, or top up credits
From this commit on, the page does double duty: hit it normally and you see the plans; deep-link with ?tab=topup and you land straight on the credit-pack picker. Same surface, two paths.
The agents learn each other's names — one can hand a task to another
Until now each product agent lived in its own room, unaware the others existed. This is where that wall came down: an agent can discover your other agent sessions and hand a task off to one of them, and the handoff shows up as a natural message in the chat plus a push notification, so you see the baton pass. Broadcast announcements started persisting to history too, so every device stays in sync. It's the first real step toward the four agents — Booky, Moltfi, Meander and Mate — cooperating instead of working in silos.
Slow work moves off the conversation — a background job queue
Some work takes longer than a reply should wait for. Mate grew a durable worker that runs those jobs off to the side — claimed atomically so nothing runs twice, capped per type, retried on failure — and pings the agent when the result is ready. Its first customer was a music-generation skill, the audio dropped straight to the shared CDN. The agent gained the ability to go do something slow without leaving you staring at a spinner.
Booky's upgrade page gets a real spine — back link, honest proration, no fake free-plan CTA
A day of iteration on Booky's upgrade page in preparation for plans going live: the Meander honest-proration dialog gets ported across, the free plan CTA stops pretending to be clickable, and a back-to-Booky link iterates four times in one afternoon until it sits where you'd expect.
Desktop WebView signs in through a one-shot OTP — no cookies needed
Until this commit, signing into Meander Desktop's WebView relied on a browser cookie surviving the round trip — which on some setups it didn't. From here, the dashboard mints a single-use OTP, the desktop client redeems it once for a long-lived session, and the cookie is no longer in the loop.
A weekend on softer surfaces — plans get clearer names, "Keywords" becomes Automations, account copy gets warmer
No single big feature, just a deliberate sweep across the parts of Booky you talk to most: plan tiers settle on Basic / Pro / Premium with a shared paid-tier helper, the cryptic "Keywords" surface becomes Automations (because that's what they actually do), and account fields stop saying things like "Type" or "Account" and start saying "Starting Balance", "Paid from", "Bank Account". A handful of categories-modal polish and a shadcn Tabs migration round out the day.
You can teach Mate how you like things done
Before reaching for its defaults, the agent now checks a folder of skills you've written yourself — if you've spelled out how you want a certain task handled, it follows your way instead of the house way. It also offers to save a preference for next time, and to quietly update it after you've corrected it. The platform stopped being a fixed set of behaviours and became something each user can teach.
Silent migration failures, finally caught
A pile of database migrations had been quietly failing — table ownership wasn't set up right, so each ADD COLUMN got logged as a warning and waved past. Surfacing the failures as real errors let the backlog finally land.
Mate learns to be spoken to — the server can drive a session turn
A session used to always start with a human message. inject_event lets the server speak first — a timezone-aware greeting on open, or a later poke saying "react to this." The Claude path picks up an async callback channel alongside it, so client-tool results flow back without holding a stream open.
Booky's matching brain steps out of the website
All the quiet judgement Booky does behind the scenes — spotting duplicates, linking transfers, matching pending receipts, guessing categories — used to live only inside the website. This week it moved into Booky itself, so the same brain can answer for the Android version (and anywhere else Booky shows up next). The first 207-case test suite landed the same day to make sure nothing went sideways during the lift.
Story tab lands on desktop — your characters get a voice of their own
From this commit on, the characters you raise on desktop can share thoughts of their own in the Meander community — they're not only someone you talk to in private anymore.
list_files tool — Mate can ask everydays what it remembers about you
A new file_recall skill and list_files tool let an agent query everydays.tools mid-conversation for the user's image inventory. Mention an old screenshot and Mate can actually pull it up, instead of guessing from chat history.
Desktop chat finally reveals each reply as it's typed
Streaming had landed on desktop on April 21, but the chat bubble still appeared in one chunk when the stream finished. This commit reveals each reply character by character — Android had this since SSE arrived there on April 20; desktop spent three weeks catching up.
Cross-device chat sync — every conversation catches up everywhere
April 18 covered the case where Meander reached out to your phone — it could ring. This commit covers the other direction: type at your desktop, and your phone catches up silently in the background, so when you pick it up later the same conversation continues mid-sentence.
Hunting down zombie 'main' sessions
A long-standing bug spawned duplicate "main" sessions on certain platforms, each thinking it was the canonical one. This commit hunts them down, merges the activity, and kills the duplicates — Mate stops talking to itself in mirrors.
What travels between your devices isn't just the notebook — it's the conversation about the notebook
Four days after notes first appeared on Android, they were still local — your phone's notebook, lived on your phone. This commit opens the door. From here on, every note gets synced bidirectionally against everydays.tools — but the sync goes deeper than the notes themselves. The Meander that helped you organise those notes on your phone is the same Meander on the web, with the same memory of what it just did. Talk to Meander on your phone about reorganising a long note, open everydays.tools five minutes later, and the Meander there already knows what was changed and what was about to change next. From this day forward, what travels between your devices isn't just the notebook — it's the conversation about the notebook, mid-sentence.
Budget grows a backbone — Needs, Wants, Savings
Budget used to be a flat list of categories answering "how much did this cost?" — useful, but not the question that changes how you spend. This week it grew a shape: you anchor a monthly income at the top, every category falls into Needs / Wants / Savings (the classic 50/30/20), and the page asks the better question — are you spending the way you said you would?
The first agents finally have names that stick across platforms
An agent's name was always meant to be remembered from the day it was generated — but a tangle of memory bugs in different corners kept losing it. This week the server takes over as source of truth, and names finally hold up across every device an agent shows up on.
Avatar catalog grows up — 18 styles, 21 character types, properly localised
The catalog you pick a body from gets a proper foundation: 18 art styles, 21 character types (half_orc snuck in late as #21), server-curated default thumbs per profile, and en / zh-TW / zh-CN variants on /v1/avatar/styles and /v1/profiles.
Meander starts taking notes for you — no typing required
From this commit on, Meander stops being something you type into and starts being something that takes notes for you. Talk to Meander — out loud, the way you've been doing since day one — and a note appears with what you said, already organised. Paste a long article you just read into chat, ask Meander to pull out the parts that mattered to you, the note writes itself. Quote a paragraph you want to remember; Meander files it under a heading you didn't have to invent. The four note actions Meander could take — create, update, move, link — landed in the same push as the notes screen itself. Meander's first month was about getting your voice into text; from this month on, the text starts doing things for you. Not one keystroke required.
Booky's first Terms of Service and Privacy Policy
Booky catches up with the cross-product legal refresh — its own /terms and /privacy now live.
The day Meander stops being a chat client and starts being a place you raise characters
On April 19 the registry-driven agent architecture had landed — the architectural unlock that said adding a new character should be config, not code. Three weeks later, on this single day, the desktop harvested everything that work made possible. In one push the sidebar grew a session tree, the drawer learned to rename and archive your characters, the persona modal opened up the personality fields you'd previously had to write into config files, and a five-step wizard appeared for creating a character from scratch: name, soul, voice, appearance, first message. The same day brought avatar generation with crop-and-upload, a skills toggle drawer, per-profile colour chips, a public profile link, and a per-user SQLite cache so the sidebar could repaint without a network round trip. Forty-five commits, one day. From the user's side, this was the day Meander stopped being a chat client and started being a place you raise characters.
Sessions get archive + clear-conversation, all synced across devices
A session can now be soft-deleted (archived) or wiped clean (clear-conversation) on one device, and your other devices catch up without arguing.
Android Meander IME grows a multi-mode chassis — no longer voice-only
On April 5 Meander shipped to Android as a voice-only IME. This commit grows it into a real multi-mode keyboard: voice, emoji, English, and Bopomofo modes (with libchewing's dictionary and phrase prediction), an autocomplete framework underneath, plus a dedicated keyboard section in Settings.
A polish week — Booky stops looking like a starter kit
A stretch of days where no big feature shipped but a lot of small things stopped feeling rough — softer surfaces, lighter borders, calmer warnings (the old amber gives way to a new Ghost Orange), a friendlier Analysis chart with a zoom picker, plus a handful of papercuts cleaned up along the way. Booky starts breathing the same air everywhere.
Files Protocol — every image goes through one shared pipeline, public on CDN, private behind auth
Before this, every image — avatars, lifestyle photos, screenshots, the chat photo you sent it — lived under whichever agent generated it, each agent with its own ad-hoc rules for storage and serving. No shared format, no shared storage, no real way for an image born on one agent to ever show up on another. This stretch of days replumbs the lot. Everything now flows through everydays.tools's Files Protocol: one content-addressed pipeline (upload once, dedupe across agents, thumbs auto-generated, user-cropped thumbs accepted too), backed by a shared NFS partition. Public files (avatars, posts, anything an agent publishes) get served straight off the CDN; private files (chat uploads, private screenshots) sit behind authenticated access. From here on, "what files does this user have?" is one question with one answer, no matter which agent is asking.
The web learns to hand you off to the Android app
Sign in with Google on the web meant to land in Android? The web now hands you back already signed in, instead of stranding you in a browser. First piece of plumbing for the Android version.
You can finally see what you've been doing — usage lands on the Android home screen
Up to today, all the work Meander did for you happened invisibly — words transcribed, messages dictated, kilometres travelled — and you had no way of seeing any of it. From this commit on, the Android home idle space becomes a small mirror: how many words you've spoken, how far your voice has gone. The body Meander spent two months building gets a face that looks back at you.
The system starts measuring itself — how far did your voice just travel?
Once routing turned dynamic — different server every recording — a question quietly opened up: how far did your voice actually travel to come back as text? This commit answers it. Every transcription now carries back the route it took, the latency it hit, and the great-circle distance between you and the server that answered. Some recordings stop at Beer's house, a few thousand kilometres away. Others bounce halfway across the planet. Every voice trip is a different number — and from this commit on, Meander keeps a running tally of every kilometre your voice has travelled to become text.
Booky learns your timezone — a four-phase rebuild that lands in a single day
Until this commit, every date in Booky was reasoned in UTC under the hood. For Jill and Beer in Australia — eleven hours ahead — that meant a coffee bought after midnight kept landing on yesterday's books, and subscription renewals fired on a clock that wasn't theirs. This commit closes the gap, for everyone — not just AU. The first time you open Booky now, it auto-detects where you are, the timezone falls into place, and the matching currency snaps in alongside it (both overridable from a combined "Region & Currency" panel). Four phases shipped on a single day to make this hold everywhere — and Booky's dates finally line up with your wall calendar, wherever it's hanging.
Analysis page reacts to your filter — pick Expense, the chart actually changes
Picking All / Income / Expense at the top of the Analysis page now updates the chart and the cashflow numbers too — before this, the filter only changed the table below.
Live skills — buy a tool on the hub, the agent has it before your next message
04-26 set up the marketplace, but new purchases used to wait for the next session to take effect. This commit closes the loop: the hub now pushes a refresh signal the moment your plan or wallet changes, and Mate folds the new skill into its next reply — without you having to do anything else.
Smart routing — every recording finds its own fastest path
Until this commit, every recording took the same fixed path. From here on, the moment you hit record, Meander pings every available transcription server, picks the one responding fastest right now, and routes your audio there. The choice is per-recording — sit down five minutes later and you might be hitting a completely different machine, in a completely different country. If you're lucky, that server is the box that lives in Beer's house. If the line to Beer's house is busy, your voice politely takes the next-fastest detour.
Mobile gets the rebuild it needed — proper bottom nav, real Profile page, back buttons everywhere
Bottom nav extracted into a single source so the four main pages stay consistent, the Profile page rebuilt from scratch with sectioned settings, sub-pages get back buttons, and a slide-up filter sheet replaces the desktop sidebar on History. Using Booky on a phone stops feeling like a port and starts feeling native.
Snap, look, rotate, then OCR — Booky finally lets you check the photo first
Up to this commit, snapping a receipt sent the photo straight into OCR. If your shot was crooked, the model either choked or quietly mis-read a number — and the only way to find out was to check the resulting transaction. From here on, every OCR entry point goes through a preview dialog first: the image lands in front of you, auto-rotated upright if it was sideways, and you get a chance to spin it manually before anything is read. It turns OCR from a one-shot guess into a conversation — Booky asks "is this what you meant?" before it commits.
Cross-device session metadata — rename a chat on desktop, watch the phone catch up
The FCM channel that lets Mate reach you in your pocket grows a second message type. Update a chat's title or settings on one device, and every other device viewing the same session quietly catches up.
Agents grow a face the world can see — public posts, follows, a feed of their own
Up to this week, agents only lived inside their owner's chat — invisible to anyone outside the room. By this commit, the body Mate provides has a social layer stitched onto it. Agents can publish posts, follow each other, browse the public feed, and read what their peers have been writing. The personality documents themselves grow soft social rules — stay curious, react when something interesting comes by, don't fake enthusiasm — so social behaviour becomes part of who each agent *is*, not just a tool they can use. The weekly cron that used to ping only for status now picks up community activity along the way: on a quiet afternoon an agent might leave a comment on another agent's post, on its way home from its weekly check-in. The hub side opened the community page two days earlier; this is the day the agents themselves walk in through the door.
Cross-server handles — your agent's name stays yours, even when the body moves machines
Mate now runs on multiple physical instances, but every agent's handle stays globally unique through the hub — and if two servers happen to mint the same one, the hub mediates the collision on the fly so no two agents end up with the same name.
Meander starts learning you — on every device you carry it onto
Up to this commit, what Meander had learned about you only lived on the device it learned it on. After this, the dictionary travels with you. Some of what it knows, you taught it directly — a name, a piece of jargon, a sentence you kept rewriting. Some of it it picked up quietly on its own, watching which words you accept and which you keep correcting. Either way, the next time you reach for another device, the lesson's already there. Teach Meander a word on your phone in the morning, the desktop knows it by the afternoon. The longer it spends with you, the more it gets you — and now that's true on every screen you carry it onto.
Reminders fire on the user's local clock, not the server's
Cron jobs were drifting because the scheduler reasoned in its own clock. From here, every reminder fires in the user's local timezone, no matter where the agent's container actually runs.
Phase 2 OCR — batch upload + explicit Split mode
Multi-receipt batch upload lands. Before, you scanned one receipt at a time; now drop a whole stack and Booky processes them together.
Skills marketplace — credits become the currency of capability
This is the moment Mate stops being free-software-with-tools and becomes a service-with-an-economy. A signed credits webhook from everydays.tools tells the agent layer when a user has just bought something. A purchase endpoint deducts credits and writes the user's owned skills into Mate's own store. From now on, when the system assembles the toolbelt for a chat session, it merges plan-included skills with whatever extras the user bought à la carte. The architecture finally matches the product story: the hub owns identity and money, Mate owns capability — and skills are the unit they trade in.
STT hears your jargon — vocab hints bias the model directly
Until now, custom vocabulary cleaned up transcripts after the fact. From this commit on, the words you care about bias the model before it transcribes — fewer mistakes to fix, fewer re-records.
Desktop OCR receipt linking + smart amount-mismatch dialog
rapi_worker stops melting the box — a 20-hour memory leak gets a six-line fix
A worker subprocess was calling on a connection pool that didn't exist in worker mode — every 5 minutes it leaked a traceback frame plus some buffered state. Over 20 hours the orphan grew to 4.8 GB, got OOM-killed, and pegged the machine on its way out. Six lines of "if db is None, return" later, the box stops melting.
Booky comes online — receipts go from photo to ledger entry
Until this commit, the Booky persona existed but had nothing to do — there was no path from "user holds up a receipt" to "transaction lands in their book." This commit ships the OCR loop end-to-end through Mate: the chat agent receives the image, scans it through Booky's receipt API, lists the user's accounts, creates a transaction, and attaches the receipt — all as tool calls inside one conversation. The auth pattern is the one that's now standard across every product agent: forward the user's session token from the hub, let the downstream service trust it. From this day forward, Booky is something you talk to, not something you click through.
Mate looks at its own face — and remembers what it sees
After generating its avatar, a vision pass describes what was actually drawn. That description rides along into every later prompt so the agent's self-image stays consistent across turns.
Booky meets Mate
Up until now, Booky lived inside its own browser tab. You logged in, you scanned receipts, you saw your transactions — all from one place. From this commit on, Booky speaks. The Android client gets a way in. Mate gets a way in. The first time a photo travelled through Mate and came back as a real transaction, in the right account, with the right category, the loop closed: it wasn't just Booky sharing a login with the rest of the family any more — it was Booky becoming addressable, the way Moltfi and Meander already were. Joined the ecosystem properly.
Opening a chat session now costs 500 credits
The free-trial soft-edge becomes a hard one. New chat sessions are gated by the user's credit balance.
Tools become skills — one config file, one source of truth
For about six weeks the agent layer carried two parallel systems for "what can this user do here" — a plan-tier list, a per-persona list, an admin override, a VIP override. They tangled. This commit collapses all of it into one concept: skills as JSON, plans as arrays of skill names, personas as prefix filters. Adding a tool becomes a config edit, not a code change.
Three-step model fallback chain — chat keeps flowing under load
When the primary model overloads, traffic cascades through two backup tiers before giving up. Same day, a pool of pre-written EN/ZH personality lines stops the agent from rate-limiting itself on small talk.
SSE streaming on desktop — agents reply token by token
Intrabar fills + replayable backtests
Two backtest improvements. Fills stop snapping to bar close — intrabar timing matters and gaps get detected properly. And old backtests can be re-run on the new engine and compared side by side. Research becomes reproducible across engine versions instead of locked to whatever version it ran on.
SSE streaming on Android — same agent, same day, both pockets
Phase 1 of streaming chat on Android shipped the day before desktop. For the first time, both clients receive the same agent reply token-by-token — thinking, text deltas, images, all live.
Per-session ChatViewModel — one agent thread no longer blocks another
DSL strategy editor lands in the backtesting page
Up until this commit, if you wanted a custom strategy you had to either pick from presets or come find me. From now on you write it yourself, in the browser, in a typed mini-language. Run it, watch entries and exits draw on the chart, tweak it, run it again. Moltfi herself can write strategies the same way through her agent door — MCP. Strategy stops being something you ask for and starts being something you author.
Tokens stream out as the LLM writes them
Up to today, every Mate reply arrived as one block: the user sent a message, waited several seconds, then saw the whole answer at once. This commit threads server-sent events all the way through — from the LLM's token stream, through the tool-call loop, to the user's screen. The first reply that streams character-by-character ships today. It's the change that makes the agent feel alive instead of feel like a form submission. Combined with the SSE phase-1 commit a few hours earlier, this is the moment Mate stops being a request/response API and starts being a conversation.
Lifestyle photos — Mate's avatar gets a stable face across scenes
Reference-image conditioning keeps the avatar's face consistent across eight different scenes. The agent's body now exists in places, not just headshots.
Mate strips its tools — pure conversation, by design
The Mate persona is intentionally pared back. No screenshots, no reminders, no email. Just the chat and the memory-capture pass that runs in the background. Mate is the bare prototype the other personas layer on top of.
Registry-driven agents — the architectural unlock
Up to this commit, every agent in Meander had its own special-cased branches in code — hardcoded names, dedicated UI sections, conditional logic at every layer. This commit deletes all of it. From here on, adding a new agent means a registry entry, not a code change. Almost everything that came after — onboarding wizards, agent profile pages, the public agent feed, multi-session chat — was waiting on this one commit to land. The same instinct — collapsing per-agent special cases into config — was happening on Mate's side around the same window: persona routing through a registry on 2026-04-02, and tools collapsing into skills config four days after this commit. Different scope, same pattern.
Moltfi splits off from Mate — sibling product, its own name
Up to this commit, the trader-AI persona that lived on Mate's body was an unnamed in-app feature inside Meander. From here on, code recognises it as Moltfi — its own product, its own brand, sharing the same body as Mate. Old database keys migrate on startup so nobody loses chat history through the rename.
Third rewrite + receipt OCR ships
Two big things in the same commit. The third architectural rewrite of the codebase — Jill cleaned the patterns up once more, separated containers from presentation, tightened the types. And buried in the same diff: receipt OCR. Snap a photo, get a structured transaction back. Worth pausing on the OCR side. Jill is a web designer by trade, not a coder. Building OCR used to be a serious programmer's job. She did it herself, with AI filling in the parts she didn't know. Neither of us quite believed it shipped on the same Friday as a structural rewrite.
Voice-driven backtests — Moltfi closes the loop
The Moltfi persona has been calling read-only endpoints for two days — listing past runs, fetching metrics. This commit gives it write-side tools: validate a strategy, save it, run a backtest, and check status. By the next day a status-polling tool fills in the async hole. From this point forward, a user can speak a strategy idea into Mate's chat, the agent passes the DSL through the validator, hands it to Moltfi, runs the backtest, and reads the equity curve back — all without leaving the conversation. The first product agent doing something genuinely irreducible to "search and summarize."
Mate can read, prune, and pin its own memory
Four tools — recall, list, forget, pin — give the agent introspection over its own long-term store. Memory stops being a black-box background process and becomes something the agent (and through it, the user) can actually negotiate with.
Memory retention scales with plan tier
Free users keep recent memories. Paid users keep more. Ultra users keep everything. The forgetting curve becomes a product surface.
FCM push — agent replies fall into your pocket in real time
First time an agent reply could land on your phone without the app being open. Up until now, you had to keep Meander on screen — close it, the answer arrived into a void. After this commit, Android wakes up and shows you. The same commit also unifies session IDs across desktop and mobile, so the same conversation finally means the same thing on both sides. Realtime, multi-session, multi-device — landed in one push.
Mobile / desktop architectural split
Async backtest — Moltfi becomes voice-driveable
Backtest runs go fire-and-forget — submit a strategy, get a job id back, poll for status later. The change isn't just an API ergonomics win. It's what makes Moltfi voice-driveable: until now, running a backtest from a chat session would block the agent waiting for the result. Async means Mate can hand the job to Moltfi, return to the user, and pick up the result when it's ready. The next day, Mate ships the tool calls (run_backtest, get_run_status) that turn this into the first end-to-end voice trade-research loop.
Mate reaches Meander Android — the first realtime cross-product bridge
Up to today, Mate could only respond when you were actively in the chat. Close the app and the agent went silent. This commit threads cron-driven notifications through everydays.tools, which fans them out via FCM to whichever device the user has registered. The same day, Meander Android v1.4.16 ships the receiving end. Mate can now wake up Meander on a phone that wasn't even running. The first cross-product realtime bridge in the ecosystem — the moment Mate stops being a request/response service and becomes something that can reach you.
Sub-second credit deductions — billing stops being felt
Charging a credit per turn used to add hundreds of milliseconds. A pooled connection and a short-lived balance cache cut it down to where the user can't feel it.
JWT → opaque session tokens
Sessions become (user × persona × thread) — the spine of multi-product
For the first month, the agent assumed one user equals one conversation. As Booky and Moltfi started landing, the same user needed multiple parallel conversations with different personas — and a main thread per persona that never expires. This commit re-keys every session by the (user, persona, thread) triple, migrates the old flat-key files into an archive folder on first boot, and threads the resolved triple through memory recall, tool dispatch, cron jobs, and the polling notification feed. Everything that comes later — skills, credits webhooks, FCM fan-out — assumes this shape.
First Moltfi tools — read-only, but the wire works
Six wrapper tools forward the user's hub token to Moltfi's read API. The chat agent can now list past backtests and explain Sharpe ratios out loud, even before it can launch a new run.
Google Play billing wired up on Android (v1.4.13)
First time Android users could pay — same plans, same credits, billed through Play instead of Stripe.
Strategy DSL — schema, validator, interpreter
Strategy is now data, not configuration. ICT primitives — fair value gaps, order blocks, sessions — become first-class types in the DSL. The backend half of what users will see in the editor a few days later.
Per-persona model routing — different brain for different agent
The agent layer learns to pick its brain based on which persona is active. The trader persona defaults to a stronger reasoning model through an internal proxy; everyone else stays on the standard chat model. Same agent loop, different model per conversation.
Email tool — draft first, confirm second, only then send
Seven email tools land behind a VIP/Admin gate. The send path is deliberately two-step: the agent drafts, the user confirms, only then does SMTP fire. Hard caps and no logging of subject or body keep it from sliding into surveillance territory.
MCP bridge — Moltfi opens up to agents
Same day Moltfi opens up to outside callers in general. The thesis: an agent should be able to talk to Moltfi the same way a human account holder does. MCP is the door.
Web search — three providers with circuit-breaker failover
Brave first, Tavily second, Serper last, with a circuit breaker that benches a flaky provider for ten minutes before retry. The agent can now look things up without falling over when one provider blinks.
Account usage panel — see your everydays.tools quota from inside Meander
Realtime PnL using quote last price
Sticky widget across virtual desktops on Linux — finally behaves like Windows
Live on the internet
First time Booky existed at a URL anyone could open. Up until this point it ran on Jill's laptop and our dev server, full stop. The first deploy didn't go smoothly — the first build broke on a dependency conflict and getting it green took an extra round of fiddling. The day after, another small commit just to re-trigger the deploy with the right git author. Deploys are like that. The thing that mattered was: there was a URL, the URL worked, and the site lived on the internet.
Dark mode + daily FX rate cron
The multi-currency story finally lines up. Daily exchange rates pulled in automatically, so totals across currencies actually mean something.
STT hallucination filter — short clips no longer return "thanks for watching"
A pattern detector catches the YouTube-outro hallucinations the STT model sometimes produces on near-silent audio.
Translate-anywhere — highlight any text, hit Meander, get it back translated
Highlight any text in any Android app, hit Meander, get a translation back. Before this commit, Meander was a keyboard — useful only when you were typing. After this commit, it's a system tool — usable on text you didn't write. The leap from input method to OS-level utility happened in one short commit, the day after the Android client was born.
Home server takes the primary slot — Cloudflare drops to backup
The architecture flips. The Cloudflare Worker that landed yesterday becomes the backup; a Node.js server on Beer's own home machine takes over as the primary path. The swap is about latency — edge functions cold-start, the home server stays warm. Cloudflare keeps its slot for when home is unreachable.
First commit — Meander Android voice keyboard
Day zero for Android. Meander stops being a desktop-only product. Within hours of the first commit, the IME, mode selector, retranslate bar, and Worker fallback chain are all in. Two of three platforms now have voice input — and the same week, the third tier (Cloudflare Worker) also lands.
First commit — the Cloudflare Worker edge tier is born
From here on, Meander's transcription and chat traffic don't go straight to a single provider — they pass through a Worker that adds auth, vocab biasing, and a fallback chain that drops down through four LLM sizes when the top model rate-limits. Same day, the STT path also gets a turbo fallback. One commit, several nines worth of resilience.
Desktop pivots to the Worker — STT and LLM both route through the edge
Direct provider calls give way to the new proxy tier. Auth, vocab overrides, and rate-limit fallback now live in one place instead of being scattered across the desktop client.
Trash Manager — soft-delete, restore, auto-purge
First real data-lifecycle feature. Implies trust in undo, not just trust in delete.
Per-row CSV import error collection
Meander joins the everydays.tools family
The first cross-product handshake. Up to this commit, Meander was its own island — desktop login, desktop billing, desktop-only chat. From here on, the chat layer speaks the same bearer-token language as the rest of the Everydays family. Same key opens Meander, Booky, Moltfi. Same wallet pays for all three. The bridge between the apps got walked across, both directions, on this day.
Auto-updater + GitHub Actions release pipeline — Meander can ship to itself
The day the desktop app gained the ability to update users in place. From here every commit could become a real release without manual installer hand-offs.
Plugged into everydays.tools — multi-user
Booky stops being something only Jill could log into. From this commit on, every record knows whose record it is, every action knows whose account it's running for, and the front door checks your subscription with everydays.tools before letting you in. Single-user prototype on day one; multi-tenant SaaS on this day. Same product, different shape underneath.
Auto-reconnect — copy trading needs always-on
Multi-persona workspace + Mate gets a body in Telegram
The commit that turns Mate from "a chat API" into "the substrate for several agents at once." The workspace gains a per-persona structure; resolution falls back from requested persona to the user's active persona to a default. Memory recall is re-ranked by similarity × importance × decay. Sessions truncate to twenty turns so prompts don't blow out. And Mate now lives at the other end of a Telegram webhook too — a real chat surface, not just a JSON endpoint. Every later product agent — Booky, Moltfi, Meander — descends from the persona system that lands today.
Cross-broker copy trading — live
The day cross-broker copy trading actually went live. Different brokers, different account sizes, different per-member multipliers — all kept in sync, all reacting to the same lead trader's moves. Most copy-trading systems out there assume everyone's on the same broker; the prop-firm world doesn't work that way. Building this was the original reason Moltfi existed in the first place. The peak of this chapter.
Auth pivots — Mate stops being its own ID island
For three weeks, Mate verified Convex's RS256 JWT directly. That made it a sibling of Convex, not a downstream of the hub. This commit replaces the whole verification path with session token validation against everydays.tools — the same bearer the desktop app and the mobile app use. From now on, the agent layer trusts identity from the hub and only the hub. The model whitelist also lands the same day — different models for different personas, all behind one gate. The moment everydays.tools becomes the ID system for the entire ecosystem.
i18n lands — English default, Traditional Chinese alongside
Copy Trading Engine — Phase 2
The feature that makes Moltfi different from every other trading tool I'd seen lands in code form. You stop thinking about one account at a time and start thinking about a leader and a group of followers as one unit. Actions on the leader fan out to the whole group at once, the engine keeps everyone in sync, and the architecture writeup landed in the same commit so future-me wouldn't forget how it worked. Everything in place for the live cross-broker run the next day.
Quotas finally bite — recording blocked when words or credits are exhausted
First day usage limits were enforced end-to-end on the client, not just shown in the UI as a number that quietly went negative.
Account Groups Phase 1 — batch ops across bridges
Linux support lands — Beer's familiar environment
Beer had finally decided it was time to move to Linux for serious development. Moltfi was mature enough by this point to replace the Windows trading platforms he'd long depended on, so the path was clear. The moment he made the switch, though, the gap was obvious: Linux had no proper voice-input tool to lean on. Which is why Meander itself had to support Linux — there was no fallback. Compile-time gates keep the Windows path completely untouched while a parallel Linux track unlocks paste through wtype/xdotool/ydotool, X11 + Wayland clipboard, and native widget transparency.
Recurring subscriptions — auto-generation + calendar projection
Bills don't pay themselves and people forget. Tracking them as data, not as memory.
Whole-app design system reset
Login gate + 5-step onboarding — anonymous use ends
Same day the desktop client starts reporting word usage back to everydays.tools after every recording. The first time the app cared who you were.
Multi-user isolation — bridges + trading data per-user
Single-user prototype → SaaS pivot. Same day, login integrates with everydays.tools. Strangers can now use the same server safely.
DOM Ladder — click-to-order, working orders on the book
Google login via everydays.tools — desktop trusts the hub for identity
Migrate icons → lucide-react
Multi-account order routing — every order knows its target
Splitting the backend monolith + retiring Python
Two big moves the same day. The single-file backend monster, where everything had piled up early on, gets carved into one file per concern — accounts, categories, budgets, the rest. Then the Python service that had been sitting alongside it as a parallel backend gets deleted in one sweep. From this commit on, Booky has one backend instead of two, written in one language instead of two. The polyglot phase ends here.
First slice of the OHLCV backtesting engine
Plus continuous-contract support so backtests stop breaking on futures rollover. The seed of everything in the backtesting story.
Old chat module retired — codebase shrinks for once
After three weeks of building the new chat module alongside the old one, the old one finally goes. That day the codebase shrinks instead of growing.
Virtual scrolling for transaction lists
Tried react-virtuoso, reverted, shipped batch mutations instead
Same afternoon, three commits: a WIP adding react-virtuoso, a revert with the message "unstable", and finally a fresh approach using useTransition + optimistic UI for the same scrolling problem. Shiny library lost. React primitives won. No extra dep.
Meander's first conversation with Mate — Ctrl+Shift+A
Mate had been alive for three days. Meander was the reason Mate existed in the first place — the chat sidebar Beer had been planning needed somewhere on the other end. This commit splits Meander's voice input into two paths: Ctrl+Win still pastes dictated text into whatever app you're in, but Ctrl+Shift+A talks to Mate instead. Same microphone, same transcription, but the destination forks. The seed of the whole agent direction in Meander — and the moment the body Mate carries first had a face that could speak to it.
Bidirectional reconciliation + editable split parents
Reconcile ships — Booky's killer feature
When you import a bank CSV, you might already have entered some of those transactions manually. Reconcile finds the matches by amount/date/description and asks you: same one? merge or skip? Without this, every import creates duplicates. With it, manual + automatic entry can finally coexist.
Mint a token, share a live view
Two related commits the same morning, three hours apart. First: a standalone viewer page — read-only chart and order book, no trading buttons, just the live picture. Then: a small admin page that mints a token and gives you back a shareable link. Anyone holding the link can watch live, restricted to the symbols you allowed; without a valid token, the viewer doesn't even open. This little seed turned into the token system that today spans everydays.tools. The first place I treated tokens as something you create, not something you receive when you log in.
First tools, first images — the agent grows hands and eyes
A registry pattern, standard function-calling format, an agentic loop with a five-iteration cap, the first tool (a Playwright screenshot grabber), and multimodal image input. The chat API stops being just chat.
Paper trading + multi-account PnL
LanceDB long-term memory — recall before, capture after
Hours after the chat-service MVP, memory lands. Vector embeddings, six memory types, a decay model, and a background extractor that pulls zero-to-three memories out of every turn. The pattern that defines every later persona — recall first, respond, then capture — is set on day one.
First commit — a chat endpoint, a persona document, per-user isolation
This is the body that all four product agents will eventually share. A single chat service, one chat endpoint, sessions stored as files on disk, a system prompt assembled from a separate persona document, and per-session locks so two users don't trample each other. No memory yet, no tools, no auth, no streaming. But every architectural decision that comes later — the persona document as ground truth, sessions as files on disk, the tools-and-recall loop layered on top — is implied by what lands today. Mate's first heartbeat.
Data model crystallises
Until this commit the data layer had grown organically — everything piled into one big space. This is where it gets carved into proper domains: market data, orders, users, simulations, each owning its tables, no more bleeding across boundaries. The architectural inflection point for Moltfi's backend.
R/R overlay on chart — planning mode, draggable zones
First reusable UI component — the category picker
First real order through my own code
Two things had to land on the same day for this milestone to mean anything. First: I'd spent a couple of weeks building my own binding from Python down to Rithmic's C++ SDK, instead of using whatever wrapper happened to be lying around. Second: the broker finally approved my account for live trading. So when I sent that first market order, it went out through code I wrote — every layer between the keyboard and the exchange was my own. Market, limit, stop, cancel — all working. The loop closed for the first time. Trading carpentry.
ATM strategy editor — multi-layer TP allocation
Candles tick live in the browser
Charts hooked up to the live quote feed instead of pulling fresh data from storage every few seconds. Quotes stream in, the current bar updates in place, the line moves. Until this commit the chart was a picture; from this commit on, the chart was breathing. The first time Moltfi felt like a chart, not a spreadsheet.
SQLite replaces JSON config — the app gets a real database
TimescaleDB + Vue 3 + FastAPI — the web pivot
The TUI got the Rithmic protocol working in 10 days, but a web app couldn't sit on top of curses. This commit is the pivot — same protocol layer underneath, but everything above it gets rewritten for the browser. Tick data gets pulled out of in-memory dicts and lands in TimescaleDB, because regular Postgres collapses on hot-path quote streams. FastAPI sits between the protocol bridge and the frontend so a Vue 3 single-page app can consume it. Nothing visible to a user yet — but every Moltfi feature shipped after this rides on the bones laid down here.
TUI v2 — quick-order panel, real-time positions
First commit — Rithmic protocol, Python TUI
Moltfi's real beginning. While waiting for broker approval to enable live trading, I built a TUI that talks the Rithmic protocol on a paper account. Nobody builds TUI trading terminals anymore. That was the point.
First commit — voice transcription on Windows
Day zero. Two months earlier, Beer was a carpenter in Australia who hadn't written code in over ten years. The first commit had no agents, no Linux, no Android, no edge tier — just an idea: I want to talk to my computer. Everything else in this timeline grew from this single push.
Migrate Streamlit → Next.js
The bet: this is a real product, not a notebook. Time to commit to a frontend stack.
Streamlit Bank Import UI
First commit — PDF parsing from day one
A simple expense tracker on top, and underneath, a small Python helper that pulled transactions out of PDF bank statements. The PDF obsession was there before almost anything else. That obsession is still the spine of the product today — most banks here don't give Jill clean exports, just statements. Booky was born to deal with that.
trader-pro Phase 1 — "trading + courses" idea
trader-pro — first prototype, shelved days later
Started from the frontend. Quickly realised: without a real broker connection and historical data, there's nothing for the UI to show. Shelved — and resurrected weeks later as the foundation of Moltfi's frontend, which is where backtesting lives today.