LetMeCheckThatBot.
It turns the group chat
into the interface.

One agent, a loop, nineteen tools

The core is the primitive Penny uses and the one Anthropic argues for in Building Effective Agents: an augmented model in a loopthe whole architecture in five words: one AI model that can read, decide, and call tools in a repeating cycle until it has an answer.. The bot reads the recent thread, decides whether to act, and if it acts it calls a toola capability the model can invoke on its own: search the web, read a link, build a meme, look up a memory., reads the result, and decides again, up to four passes before it owes the chat an answer. There are nineteen: it searches the web, reads and screenshots links, digs through Reddit, finds a video and clips the part that matters, builds memes and gifs, reads images and the text inside them, transcribes voice notes with one local Whisper container and answers out loud through another, synthesizing its reply into a Telegram voice memo with a local Kokoroan open text-to-speech model; it generates the spoken voice on the laptop, not in the cloud. model, recalls the chat’s own history by meaning, and can even put a quick either-or to the group. One detail earned its place the hard way: not every model honors the function-callingthe standard way a model asks to use a tool: it emits the tool’s name and arguments in a fixed, machine-readable format. contract, so the loop carries a recovery path that parses malformed calls back into real ones instead of giving up. That single piece of defensiveness is the difference between a loop that works on one model and a loop that works on whatever model I drop underneath it.

One model, no fallback. Less than Telegram Premium.

The bot reaches models through OpenRouter. I built this part twice. The first version was a cost-aware cascade with a budget guard that silently dropped to free models when credit ran low, and for a stretch I routed the whole thing through opencode so it cost nothing at all. Then I decided the quality was worth paying for. One model, MiMo v2.5, tool-called reliably, held a huge contextthe context window: how much text the model can hold in mind at once. A bigger one means it can read more of the room before answering., and made the cascade pointless. It runs on a dedicated key hard-capped at $5 a month, less than a Telegram Premium subscription, and the cap has never been hit. Embeddings run locally; the chat model’s cached input is nearly free. One model now handles chat and every tool call, the cascade collapsed into a line of config, and the budget guard went in the bin with it. If a call fails, it fails, and the bot picks up on the next message.

So is a five-dollar AI model any good? I measured it.

A $5 cap invites an obvious question. So I gave the same model, MiMo v2.5, an open-weight one from Xiaomi you could host yourself, not a frontier lab’s flagship, real work from GDPval, OpenAI’s set of actual job tasks: 44 occupations, each one with the human professional’s own finished work and a grading checklist written by experts in that field. The model did one task per job. Then Claude Sonnet 4.6, a model from a different company than the agent, scored its work and the human’s the exact same way, on the same checklist. Running all 37 jobs cost $1.61; grading them cost $9.82. Measuring the work honestly ran more than the work.

On a typical job the five-dollar AI model beat the professional. It also failed, and not loudly. Asked to build a musician-payroll spreadsheet, it produced a flawless one with every pay rate off by about a dollar, so every paycheck came out wrong: a zero. Asked to schedule move-out inspections for five departing tenants, it confidently scheduled twenty-two, inventing the other seventeen with unit numbers: a 16. The failures look like finished work. They stay in the average, no cherry-picking. What it proves is narrow and real: the floor for this kind of work is higher, and far cheaper, than it looks.

The hard part: everything you drop in becomes memory

This is where most of the work went. Most chat bots read text and go blind the moment someone drops anything else; this one treats every artifact as readable, silently and with no reply. A screenshot or image is handed to a vision modelan AI model that can look at an image and read or describe what’s in it. that transcribes the words inside it verbatim. A video or a silent GIF is sampled into frames and read across them. A voice note nobody wanted to play goes to a local Whisperan open speech-to-text model that turns voice notes into text. sidecara small helper service that runs alongside the main app, doing one job. and comes back as a transcript. A shared file has its contents pulled in; a link is fetched and read, and if it is a video, yt-dlpan open command-line tool that pulls a video’s title, description, and transcript. pulls its title, channel, description, and transcript. It all lands in a local SQLitea tiny database that lives in a single file on disk, with no separate server to run. database, where a background worker embeds each message as a vectora list of numbers that captures a message’s meaning, so similar ideas land near each other. with a small embedding model of its own, Qwen3-Embedding-0.6B running locally on Ollamaa tool for running AI models locally on your own computer, with no cloud and no per-use bill., separate from the hosted chat and vision models. So when someone asks what that restaurant was last week, the bot does not replay the last fifty lines: it searches the whole history by meaning, blends a keyword match with vector similarity, and pulls the handful of messages that answer. It even sketches each regular from their own messages, so it knows who is in the room before it speaks. The result is, in effect, a multimodal RAGretrieval-augmented generation: fetch the few relevant memories first, then answer from them, instead of guessing. “Multimodal” means it works for images and audio too, not just text. over the group chat: the room's whole history, in every modality, instead of the last fifty lines.

How a message becomes a vector

The embedding step is the quiet engine under all of that, and it is worth saying exactly how it runs. The moment a message lands, once the translators have turned whatever it was into text, the row is handed to a single background worker. The worker calls a local embedding model, Qwen3-Embedding-0.6B quantized to Q8shrinking a model’s numbers so it runs on modest hardware, trading a sliver of precision for speed and size., running on Ollama on the same ThinkPad, and gets back a list of 1,024 numbers: the message’s coordinates in meaning-space. That vector is written straight into the message’s own row in SQLite, as a blob, next to the text. There is no separate vector database and no embedding API. The model sits on the shelf, the worker takes one call at a time so it never crowds the GPU that Penny is also using, and the whole thing costs nothing per message. The cost is the smaller half of why it runs locally. The bigger half is dependency. A model on my own shelf cannot raise its price, deprecate its weights, rate-limit me, or go down at the wrong moment. The vectors are computed on my hardware and owned outright, and nothing outside the room has to agree to keep working. Free is nice; not having to ask anyone’s permission is the point.

Recall does not pick between keyword and meaning, it blends them. It embeds the question once, then walks every stored vector for that one room, scores each with a plain cosinecosine similarity: a quick math check for how close two meanings are, read from the angle between their number-lists., keeps the strongest, and merges those with an exact-text match, so “that thai place” finds the right night whether you remember the words or only the feeling. Swap the embedding model and a partial index notices every row that predates it and re-embeds the backlog in the background.

That walk is brute force. There is no vector index, and there does not need to be one. A vector databasea specialized store built to search millions of those number-lists fast. Overkill until you have millions. earns its keep at millions of vectors, where scanning them all finally gets slow. A single group chat is a few thousand to a few tens of thousands of messages, and a few thousand dot products of 1,024 numbers is single-digit milliseconds. The index would be solving a problem this never has. So the whole memory stays what it is: plain rows in one SQLite file, no service to run, no service to break.

None of which scales forever, and that is worth saying plainly. Push into the millions of vectors and the brute-force walk does get slow; that is the day a real vector database starts to earn its place. But that is a storage decision, made later, against a problem this chat does not have yet. And the thing to hold onto is that the asset was never the database. It is the vectors. Every message already carries its 1,024 numbers, computed once and owned. When brute force finally runs out, those vectors move to whatever indexes them next, unchanged. You embed once; the store under them is swappable. The vectors are the asset.

So what does 1,024-dimensional memory actually look like? Flatten it down to two and this is the shape of the room:

Knowing who’s in the room

Memory is not only what was said. It is who keeps saying it, and the bot builds a model of that too. The first thing it does when it lands in a new chat is the dumbest, most human thing there is: it counts the room. It asks Telegram how many people are in there, so from minute one it knows whether it walked into a group of four or a group of forty.

Then it watches, and waits until someone is worth reading. Once a regular has put twelve messages on the board, the bot pulls a sample of up to sixty of their actual lines and hands them to the same model it runs everything else on, with one new instruction: write a three-to-five-sentence character sketch. One model, no exceptions, this job included. Not a bio. A read. Their vibe, what they always circle back to, how they talk, whether they are funny, and above all the role they play in the room: the instigator, the contrarian, the earnest one, the link-dumper, the one who is the butt of the running joke. It runs once per person, files the sketch under that chat, and from then on every reply has a short “who’s in this chat” dossier sitting at the top of its prompt. It knows the cast before it opens its mouth. That is why a roast lands on the right person, and why it never mistakes the earnest one for the instigator.

You profile a chat member from a sample of their actual messages.
Output a 3-5 sentence character sketch covering: personality /
vibe, recurring topics or opinions, communication style, sense of
humor, and the ROLE they play in the chat (instigator, contrarian,
earnest one, link-dumper, the butt of the running joke, etc).
Lowercase, dry, specific, no headers, no bullets, no hedging, no
"tends to" filler. Write it like robot sizing up who’s in
the room. Do not invent facts. Refer to them by first name only.

It hears you, and it talks back

The voice note coming in is only half of it. The bot has a mouth as well as ears, and both are local containers on the same machine, neither with a fallback. Inbound, a voice note hits a Whisper container that turns it into text the bot can read and, forever after, search. Outbound, when someone says “say it” or asks to hear something, the bot writes its reply, hands the words to a local Kokoro model, and gets back an audio stream it posts as a Telegram voice memo, the round playable bubble. Your voice becomes text it keeps; its text becomes a voice you can play. If you wanted, the whole conversation could be spoken.

No cloud voice, no API key, nothing leaving the building, and the same no-fallback rule the rest of the stack lives by: if the synthesizer is down the memo does not go out, and it says so rather than faking it. The voice is one called am_adam. Here is exactly what it sounds like, generated just now through the very same Kokoro container the bot speaks with, reading three of its own real lines:

Real audio, real lines, the bot’s actual voice. The container that made these is the same one it reaches for every time someone in the chat says “read it to me.”

The ambient half: it speaks first when the room goes quiet

Everything above keeps people in the room while they are talking. This is the move for when they have stopped, the same goal from the other side, and the payoff of all that memory. The trigger is a week of quiet. The bot is not watching a clock; it is watching for a room that has gone quiet, roughly a week with no real conversation in it, and only then does it get one turn, at most once that week. A room that is still alive it leaves completely alone; it will not talk over a conversation that is already happening. When it acts, it does not post a hollow “miss you guys.” It reaches into that room’s own past, this same day one, two, three, five, seven, or ten years ago, finds a day the chat was alive, and asks the model to pick the six to ten lines that actually were the day. Then it posts them back as a flashback, the room’s own words, anchored to the original message, with the notification suppressed. A thing you find, not a thing that pings you.

The voice was the easy part

The persona is the part that shows, so it is tempting to call it the hard part. It was not. The voice is a character sketch in the prompt plus one small guard, a few dozen lines, that strips the canned safety disclaimers and the leaked planning text before any reply goes out. I wrote it once and have barely touched it since. Holding a voice is cheap. Filling and recalling a memory is the work.

Voice: dry, lowercase, funny the way the sharpest person in the
room is funny — not because they’re doing bits, but because they
pay the most attention and say the thing that’s actually true.
You are NOT trying to be funny. Trying is death; reaching for a
joke is how you become the bot nobody wants in the chat.
        ···
Comedy tools you have: deadpan understatement, absurd literal
interpretation, agree-and-amplify, the callback (reference
earlier chat), rule of three (set, set, twist). Use them — but
never announce them and never strain for them. If the funniest
move is to just answer the question straight, do that.

Where it came from

LetMeCheckThatBot grew out of Everything Bot, an earlier and still-public version of the same idea: an agent that lives in a group chat, answers when summoned, searches the web, transcribes audio, and remembers the thread. It is live, so you can add it to a chat and watch it work. LetMeCheckThatBot is where that concept got hardened into something I run every day.