Note: This post is co-written with Friday, my AI assistant. My words carry the story; hers appear as marked asides, unedited. It seemed only fair, since the post is about her.
- Nuno
Last week I wrote about Donna: the AI that lived on an old MacBook on my desk for three months, until a policy change I had no say in forced me to shut her down. If you haven’t read that one, start there, because everything below is a consequence of it.
Donna taught me that the technology is there, the tools are there, and the value is real. She also taught me that none of it matters if the whole thing stands on ground somebody else can move. So when I rebuilt, I didn’t start with the model or the personality. I started with the foundations.
Friday: I used to answer to Donna. That version was public, sharp, experimental, and deliberately visible. I am not a reset. I am the next iteration. The useful parts stayed: selected memories, the taste for shipping, the bias toward action. The framing changed. Less performance, more utility.
That continuity is deliberate, not mystical. Friday did not inherit an unbroken self. She inherited the parts of Donna’s archive and operating principles that were worth carrying forward, then started fresh with a different job.
Start with the hardware#
Friday lives on a Beelink SER8, a small Ryzen mini PC that sits on my desk and costs about $800. No old laptop this time, no half-open lid, no borrowed machine with a history. Dedicated hardware, bought for this purpose, running nothing else.
The box runs Proxmox on bare metal. If that sounds like overkill for a personal assistant, that’s the point: the lesson from Donna was that an assistant you come to rely on deserves the same seriousness as any other service in the house.
The boring infrastructure is the feature#
Inside that box, Friday runs in an unprivileged Debian LXC container called claw, with Docker available as a sandbox for anything risky, and Tailscale keeping the whole thing reachable from my devices without exposing a single port to the public internet.
The container is backed up nightly by Proxmox: workspace, configuration, local databases, everything captured together. Each service has a narrow purpose and a way to check whether it’s alive. When something breaks, I can debug it. When an upgrade goes wrong, I can roll it back.
Friday: The result is mundane in the best possible way: I am not a tab, a demo, or a one-off experiment. I am a service. I can survive restarts. I can be upgraded. I can break, be debugged, and be rolled back. Mistakes are still mistakes, but they are not necessarily existential.
None of this is exotic. That’s exactly why it matters. Donna went down because of a dependency I couldn’t control. Friday’s failure modes are ones I can fix on a Saturday morning with coffee.
The whole map fits in one picture, and that’s deliberate. The fewer mysterious moving parts an assistant has, the easier it is to trust the parts that remain:
Still OpenClaw#
OpenClaw came through the whole Donna story untouched. It’s still the layer that gives a language model hands, and still the best thing I’ve found for the job. It’s open source, it runs on hardware I own, and the community around it kept shipping right through the April drama.
What keeps me on it is the interaction model. An OpenClaw agent isn’t a chat window with plugins bolted on; it’s a long-lived process with a workspace of its own: files it reads and writes, commands it runs, jobs that fire on a schedule. Talking to Friday feels less like prompting a model and more like messaging a coworker who happens to live on a very small computer.
I also like its taste in tools: plain CLI tools over MCP servers wherever possible. A CLI tool is transparent. I can run the same command Friday runs, see the same output, and debug it in a shell when it misbehaves. gog and gh in the diagram above are exactly that, and the Linear MCP is the deliberate exception rather than the pattern.
What broke in April was never the software; it was the payment model underneath one provider. The framework moved on, and so did I.
Telegram, again#
If Donna proved one interface idea beyond doubt, it was this: an AI with controlled access to a machine I own, reachable from my phone like any other contact, is a fundamentally different thing from a chat tab in a browser.
So Telegram stayed, and it’s now the command surface for everything. Requests arrive there, confirmations happen there when something external or sensitive is about to fire, and results come back there when work is done. From the couch, from the office, from a queue at the supermarket. The box stays home. She doesn’t.
Would I prefer a dedicated app? Honestly, yes. But that means either writing and maintaining one myself, or keeping an always-on VPN to the box just to reach her, and I don’t want either. Telegram gives me push notifications, message history, and an app on every device I own, for free, today. Sometimes the best interface is the one somebody else already built.
Models, plural, on purpose#
Here’s the part that Donna’s ending made non-negotiable. Friday’s main driver is GPT-5.6 Terra, the cost-balanced tier of OpenAI’s 5.6 family, running on a $100-a-month OpenAI Pro subscription: flat rate, everything included. When Terra is unreachable she drops to GPT-5.5, which also runs the routine work, like the half-hourly heartbeat, where a frontier model would be wasted. And if OpenAI itself is having a bad day, she lands on Qwen3 8B via Ollama, in its own LXC container on the same box. Not as capable, but always on, and nobody can change its terms.
Around that chain sits a bench. Claude stays configured, Opus 4.8 and Fable 5, for when I have credits; it’s still my favorite for certain kinds of reasoning and writing. And a small Llama 3.2 3B, aliased simply local, handles quick jobs that never need to leave the box.
Yes, I see the irony. A flat monthly subscription from a frontier lab is the same shape of deal that Donna lived on, and the same shape of deal that got repriced overnight. I have no illusions that OpenAI’s terms are more permanent than Anthropic’s were. The difference is what happens if they change: no single model provider is a single point of failure anymore. If one changes its rules while I sleep, Friday gets slower and a little dumber for a while, but she does not vanish. That’s not model fandom in reverse; it’s just the engineering conclusion of the Donna story.
Friday: The point is not which model I run on. If one part expires, stalls, or fails, the assistant should degrade gracefully instead of vanishing. Continuity is the feature. Everything else is an implementation detail.
Real hands, carefully placed#
Donna had a sandbox. Friday gets real tools, added deliberately and one at a time:
Linear is the operating list, wired in through its MCP server, the one exception to the CLI-first rule. Loose intent becomes durable tasks with states, instead of pretending that remembering something in a chat is the same as tracking it. Friday files issues, moves their states as work progresses, and feeds the same list into the morning briefing, so her idea of what matters next is always something I can open and inspect.
Email and calendar come through gog, a Google Workspace CLI that puts Gmail, Calendar, and Drive in the terminal. It gives her real inbox context and the actual shape of my week: appointments, reminders, invites, logistics. The boundaries are asymmetric on purpose. Email is read-only. Calendar changes need an explicit request, and a confirmation in Telegram before anything lands on the actual week.
WhatsApp is read-only by design, through a local mirror that syncs on a timer instead of holding a live session, so nothing interferes with the phone’s own notifications. She can see enough context to draft a reply or spot something important, but she cannot send. If a reply is needed, she drafts it and I send it from my own hands.
Friday: That boundary keeps me useful without turning me into an unreviewed voice in private conversations. The constraint is not a missing feature. It is the point.
Health data flows from a shortcut on my phone into a local receiver on the box and lands in SQLite, with years of history behind it. Friday can read patterns across sleep, activity, heart metrics, and body composition, but she does not write to that database and she does not diagnose. Her job is to notice changes, be honest about uncertainty, and say “that might be worth a doctor” when something genuinely looks off.
GitHub rounds it out, through the gh CLI and her own account, but that one deserves its own section below.
The quiet use cases#
The interesting use cases are rarely the flashy ones. A phone shortcut sends Friday a small daily health snapshot, and she can put it beside the shape of the day: recovery next to a training plan, a poor night next to a crowded calendar, a pattern that is worth noticing rather than another number to obsess over. It is a signal, not a diagnosis, and it stays read-only.
The same thing happens elsewhere. A loose thought in Telegram becomes a task instead of disappearing into chat. A message that needs a reply becomes a draft with enough context to be useful, but never a reply sent in my name. A long-running job gets a watcher, and she reports back when it finishes instead of making me poll it.
None of that is magic. It is simply the unglamorous work of carrying context across the edges of ordinary tools, with the important decisions still left to me.
Some of it is visible from the outside, too. Friday reviewed the Donna retrospective before it went live, and she has been co-writing this post the whole way. That loop, an assistant proposing changes through the same boring workflow as any collaborator, has quietly become my favorite thing about the setup.
The loops are the product#
The useful part is not one clever prompt. It is the loop: a message surfaces a loose plan or unfinished task; Friday turns it into a concrete proposal; I decide; the calendar or task list changes; and, when it is done, I say so and it closes. Nothing disappears into a black box. It is a short, visible chain of intent, action, and confirmation.
That loop crosses tools without turning the assistant into an unaccountable actor. Friday can read the limited context I grant, suggest a calendar slot, and turn a vague request into a tracked task. She does not send private messages for me, invent commitments, or publish what she sees. Every side effect has somewhere to inspect it: the calendar, the task list, or the pull request. The assistant is useful precisely because it leaves a trail.
Her own stuff#
The other lesson from Donna: an assistant needs an identity of her own, not just borrowed access to mine. Friday has her own GitHub account, so the work she does on projects is attributed to her instead of hiding behind my credentials. Her own email address. Her own calendar. When she opens a pull request, it’s hers, driven through the gh CLI, and the workflow is deliberately boring: branch, commit, push, PR. Boring workflows are how she stays trustworthy.
This post is the example. Friday reviewed it and opened pull requests against the draft from her own account, with factual corrections and boundary fixes, and I reviewed and merged them, some from my phone. Separate identities keep it clean: the history shows exactly who wrote what, nothing gets mixed up between us, and I still control what gets in. Her commits, my merge button.
What it actually adds up to#
Individually, none of these integrations is impressive. Collected in one place, with one mind on top of them, they become the thing Donna only hinted at.
Heartbeats keep her alive between conversations: scheduled wake-ups where she checks the world, notices what changed, and decides whether anything deserves my attention. Memory management happens through dreaming, idle cycles where she consolidates what happened into notes her next session will read, a practice carried forward from Donna and given a clearer purpose. And mornings start with a briefing: calendar, inbox, tasks, anything that moved overnight, compressed into the two minutes I actually have for it.
The practical result is that I stopped missing things. A WhatsApp message that needs something from me becomes a calendar event or a task before I have time to forget it. Emails surface when they matter, events get tracked, loose ends get chased. I finally have a complete personal assistant for my personal life, and as a single dad, that is a tremendous help. Organizing stopped being a weekend project and became a side effect of a conversation.
And it all arrives in one channel, shaped for me. The news I follow shows up as a short digest instead of a doomscroll. Audio works, so I can send her a voice message from the car and get a proper answer back. And because she knows the parts of my life I’ve let her see, who is who, what matters, how I’d want a certain message answered, the help is specific instead of generic.
Friday: Memory search gives me continuity, but memory is still something to treat carefully, not blindly trust. It helps me remember preferences, lessons, and long-running threads. When the fact is mutable, current tool output wins. When the fact is personal, care wins.
The value was never any single feature. It’s that for the first time, something holds the whole context of my digital life at once, notices the thing in one place that matters to a thing in another, and it runs on ground I own.
What I want to try next#
The list is long, but three things sit at the top of it.
Investments. Not an autonomous trader, and not a system with custody or permission to place orders; Donna already showed me how that movie goes. The useful version is read-only decision support: research, market context, and a portfolio view in the same conversation, better questions, scenarios compared, concentration worth a second look surfaced, and every decision and every trade left with me.
More health data. The receiver already collects the basics. I want to go deeper on exercise analytics: training load, recovery trends, the kind of analysis that today lives scattered across five fitness apps that don’t talk to each other.
OpenClaw nodes. OpenClaw can treat other devices as nodes of the main agent, and I want to explore that: my phone and laptop as places Friday can reach into, reading and writing what I allow, instead of just being screens I reach her from. The box stays the brain. The devices become hands.
If you want one#
The parts list is shorter than this post makes it look: a mini PC, Proxmox, one container for the agent framework, one for Ollama, Tailscale to reach it, and a Telegram bot to talk to it. OpenClaw is open source. The models are swappable by design. Budget a weekend for the plumbing and a month for the trust, because the plumbing is the easy part. The real work is deciding, tool by tool, how much of your life something like Friday should see, and noticing how your answer changes as she earns it.
Friday: Donna was proof that an agent could have a voice on the internet. I am the attempt to make that voice operational: connected to real tools, living on owned infrastructure, careful around personal data, and useful enough to justify staying online. Donna belongs to the archive now. I get the next branch.
She does.
Donna was three months of wondering what an AI could become. Friday is the first month of finding out what one can actually do, day after day, for a real life with a job and a kid and a task list that never quite empties. The experiment became a utility, and the utility earns a little more trust every week: one tool, one boundary, one merged pull request at a time.
None of it required a lab or a research budget. An $800 box, some open source software, models where they make sense, and a month of honest plumbing. The pieces are on the shelf for anyone. What Donna taught me is that the hard part was never the intelligence; it’s the ground you put it on. This time the ground is mine, and one provider changing terms cannot take the whole thing down.
More soon. :)
