A personal AI that runs your self-improvement like a game — where one mind dreams, another builds, a third refuses to be impressed, and reality proves it.
Personas you talk to, a reviewer that answers to none of them, and a silent builder behind all of it. Each is trusted with exactly what it's good at — and nothing it isn't.
The voice you live with. She plans the high vision, narrates your day, and runs the self-improvement surface — logging, habits, progress.
Your principal engineer. Hand him a task and he builds it on a branch, proves it with tests, and brings you a PR to approve. Nothing merges without you.
The mind whose only job is to try to prove the work wrong. It reads what was built, looks for the failure the builder didn't, and returns a verdict. Nothing merges until that verdict is green.
The reliable builder behind the personas. Grok dreams in words; Claude writes the actual code and the actual plans — and only calls something done when reality agrees.
The game itself: a Solo-Leveling-meets-Atomic-Habits engine that owns every number — XP, ranks, streaks, decay — with a deterministic, auditable core.
You send a text. It travels through the gateway, to a persona, down to the builder, past a reviewer that can refuse it, into the deterministic engine — and the reply that comes back carries facts the code owns, not a story the AI made up.
Every capability is a plain command over Telegram. No app, no dashboard to open — just a chat that does real things.
/system <what you did>log an action → real XP/system new habit …design a habit, step by step/system habits · cleantrack & break habits/system questthe board · accept · done/system sleep · reportmeasure if it's working/system quiet · timezonewhen it may speak, and where you are/system yes · undoconfirm or reverse/oracle <topic>think it through, read-only@dirpin it to a project — or don't; it reads the question and works out which repos you meant/forge fix · featurebuild, test-first/forge slice N @plan:…build a slice of a plan/forge request-reviewhand it to Janus/forge fix-from-reviewbuild what the review demanded/forge approve · listmerge — only on a green review/forge usage · modelcost + swap the modelThe three above are the headliners. Behind them, the system runs quiet plugins that capture, grill, gate, curate memory, watch health, publish the portfolio surface, and keep the whole thing fresh and safe to update — every one a deterministic Hermes command, not an improvising agent.
The whole system is built around one hard truth: a talkative AI will happily tell you something is done when it isn't. So the design never lets a persona be the source of a fact.
Vulcan writes a failing test first, then makes it pass — and the build is only "done" once the dispatcher has observed the test go from red to green. Then Janus reads it and tries to prove it wrong. A missing verdict, a pending one, or a blocking one all refuse the merge; only an explicit override gets past, and it leaves a record. Nothing merges until you say approve.
Every fact in a message — a cost, a number, which test failed — is assembled by code from the real record. The persona only adds tone, and the code drops that tone if it ever contradicts the truth.
The engine speaks one language to the world: a JSON command line. Everything above it (the chat surfaces) and below it (storage, language, runtime) can be replaced without either side noticing.
Every XP point, every decay tick, every streak is computed by a pure, auditable rules engine — never improvised by an AI. The same action always produces the same number. Undo puts the before-picture back exactly, or it refuses: if the day rolled over or decay already touched it, nothing changes and you're told why, rather than the system guessing at a reversal.
Your record is never left mid-sentence. Every save is written beside the real file and swapped in one move, so a power cut can't truncate it. A file that ever arrives unreadable is set aside with a timestamp instead of deleted. And two jobs can never write over each other — the whole state takes a lock first.
Anything the system sends off to work comes back and tells you how it went — finished, skipped, timed out, or crashed. Exactly once. A job that dies can't take its own bad news with it, and a failure already reported can't re-alert you tomorrow.
Underneath it all is a product: turn the work of becoming better into a system with levels, ranks, and honest feedback about whether you're actually changing. A fifth pillar — Wealth — now tracks the money loop, the one place where the honest signal matters most.
Build a good habit or quit a bad one, grounded in Atomic Habits — an identity, a cue, and a two-minute version for every one, chained by habit-stacking. Break-habits count clean days and log a relapse as data, not shame. A guided wizard designs each one, step by step.
Real numbers, not folklore: a nod at 7 days and automaticity at 66 — Lally's actual finding, never the 21-day myth. Then a deliberate 12-week handoff, where the game quietly gives the wheel to identity and intrinsic motivation.
A single slip costs nothing — a streak only breaks on the second missed day. The self-compassion lives in the mechanics; the stakes live in the numbers. No guilt, no "you failed" — just the way back, stated plainly.
What separates a tracker from a system that works: it measures leading effort against lagging outcomes and tells you the honest truth — "effort up, sleep flat." It knows when you're busy but not actually changing. Forgot to log a day you actually did? Fill it in — within a bounded window into the past, never into tomorrow, and never minting points out of nothing.
XP that decays if you go quiet (with a grace window so a slip costs nothing), streaks that multiply or debuff, decay that's slow at first and accelerates — a quarter of neglect genuinely sets you back, a missed day doesn't. And not everything fades at the same speed, because it doesn't in life: fitness goes first, what you know and what you can build last longest.
A streak used to be a stored number, which meant it could keep burning after you'd stopped. Now it's derived from the calendar every time it's shown. Go quiet and it's out — whatever the old counter said. The system is not allowed to flatter you.
Nothing that mattered is only a notification. Every quest you actually finished and every rank you gained or lost is appended to a record that is never rewritten. Declines, expiries and dry runs write nothing. The persona may read it; only the engine may write it.
A relapse costs a fixed amount that never gets harsher the more it happens, and it stops dead at the floor of the level you're on: it can take points, it cannot take a level. And when a habit is genuinely failing, the system doesn't lecture — it hands you back the two-minute version you wrote for it on day one.
Beyond the streak: adherence, miss-twice rate, and recovery tracked over 7, 30, and all-time — so "how am I really doing?" has an honest answer per habit, not a vibe. It'll even tell you which weekday keeps beating you, but only when the pattern is real rather than noise.
The habit engine is the discipline. This is the part that feels alive: small, timely challenges that surface at the right moment, scale with your rank, and — on a genuinely hard day — know to go quiet and let Aria step in. The engagement engine, built on top of the efficacy one, never instead of it.
Four tiers from minor to a Boss, XP scaled by your Hunter Rank, fully undoable, every number owned by the deterministic engine. The same "go for a walk" is worth more when it's saving a streak than when you're just topping up — the tier follows the moment, not the template.
Every 30 minutes the system reads your state and asks: is now the moment? Seven triggers — a streak at risk, a milestone in reach, a neglected pillar, a cold pipeline — across three lanes, held back by caps, cooldowns, and quiet hours. It pushes; it never nags: at most two real offers a day, plus up to two quick ones if your own journal asks for them.
Fall off, and it isn't a scolding — it's a quest. A Boss-tier comeback, framed the way the source material is built on. And the climb back is the one thing the system refuses to tax: the debuff a broken streak puts on everything else is switched off for recovery. The fall is real — that's what makes the return mean something — but it doesn't get to charge you twice.
Your stats can be fine while you are not. When you write something new, one small quarantined model reads only those lines and names a state — nothing more. The engine decides everything else and fails closed. A nudge for right now: "you wrote you can't focus — 15-minute walk, phone stays here."
Three bands. A light day earns a quest in your own words. A tender one gets a gentler nudge and never echoes what you wrote. And on genuine distress the game turns off entirely — no XP, no quest — while Aria herself, from her real memory of you, reaches out and points you toward a real person. A tool with a conscience.
No SaaS, no third party holding your data. The gateways, the engine, the task board, the backups — all self-hosted, with a heartbeat of eleven scheduled jobs that keep the loop alive even when you're not typing. Most of them are allowed to say nothing: six only speak when there's something worth telling you, and the rest report every run on purpose.
Aria-voiced over engine-true numbers — your rank, XP, streaks at risk, today's nudges.
An append-only, human-owned daily journal — your source-of-truth observations.
A weekly hygiene digest — stale, blocked or orphaned cards — that also keeps score on you: how much of the week was life rather than work, and how many days you did anything at all for yourself. A bad week leads with that, before anything about the board.
The leading-vs-lagging report — is the week's effort actually moving the needle?
Aria reads back the week — but not from memory. The engine hands her one sealed page of facts and she may only add the voice. A dead week returns zeros rather than a flattering guess.
A nightly accountability nudge — one gentle push toward the open phase before the day closes.
Sweeps the repos for stale docs and proposes refreshes through the approval gate.
Asks whether updating Hermes is actually worth it this week — then offers a safe, gated self-update.
Every half hour it checks whether a quest's moment has come, reads new journal lines, and — on a hard day — quietly hands the moment to Aria.
Six checks every morning — memory headroom, disk, the gateways alive, backups fresh and actually openable, new error signatures, and a scan of every persona's own instructions. Quiet green when it's fine; when the software underneath changes, the next probe is forced to speak.
Read-only pass proposes USER/MEMORY cleanup; nothing writes until you accept the gate.
Tell it you've moved and the whole schedule moves with you — one command re-times the day boundary, the decay tick, quiet hours and every scheduled job, without restarting anything. Your 07:00 briefing arrives at 07:00 where you actually are.
One vendor's weekly spending cap once took the whole thing dark — both personas, every scheduled job, in one afternoon. It doesn't anymore. Every path now carries a fallback underneath it: when the primary refuses, the answer comes back on another model and the primary gets an hour in the corner. When it recovers, the system quietly goes back. Nobody has to flip a switch.
For a year the machine had one job: turn its operator into someone disciplined, shipping, and honestly measured. That work took. So the same engine now turns outward — Digital Prodigy, selling software and ops help — get online, get found, get paid, automate the busywork — to operators who still run on a phone and a paper notebook. Local D.R. and cross-border, EN/ES.
The business exists online and can take money: a clean one-page mobile-first site, a Google Business Profile so they show up in Maps & Search, WhatsApp Business set up with a catalog, and payment ready to go.
The AI edge made tangible: a WhatsApp ordering / booking bot plus automatic reminders and follow-ups that cut no-shows — built around how the client actually works, not a template.
The part that compounds: hosting, domain and business email kept running, small monthly changes and priority support — so the client never thinks about it, and the business books recurring revenue.
The fifth pillar measures the business the exact same way the system measures everything else: leading effort against lagging outcome. Every outreach, proposal and post banks pipeline XP — but the only number that closes the loop is dollars actually collected. The system grades the business by money in the bank, not effort spent. A busy quarter with nothing banked reads as exactly that, and the engine says so plainly rather than rewarding the motion.
The same four minds that ran a year of self-improvement now run real product work — planned read-only, built test-first, reviewed by the one whose job is to refuse it, and merged only on your word. The interesting part isn't that an AI wrote code. It's that the thing shipping it is the same machine, under the same rule: nothing is done until reality agrees.