DEV Community: Layton

I Put an AI Assistant on a Mini PC at Home

Layton — Sun, 27 Sep 2026 10:52:54 +0000

For breakfast I had a piece of chicken breast, a glass of milk, and a dragon fruit I cut up. I said “make a note” on my phone. A moment later, the screen showed a receipt from the assistant’s note.py capture call: the food and a rough calorie estimate were saved as record No. 1.

Building a whole setup around a mini PC to log a piece of chicken sounds like hiring a secretary for breakfast—a secretary with quite a full schedule. Before this, though, I was the one running errands. To log food, I had to find the right entry point among several apps. To note project progress, I had to remember which document held it. To write an evening recap, I had to dig through chat history for “that thing I said this afternoon.” Breakfast was long gone before the record found a home.

So I gradually put a setup together on a mini PC at home. OpenClaw handles conversations, LifeOS keeps records and files, and n8n starts workflows at the appointed times. I can reach it from my phone when I’m out. It helps me plan daily tasks, track projects, and manage health information.

Where That Breakfast Record Went

The receipt for breakfast was short: chicken breast, milk, dragon fruit, about 450 kcal, record No. 1. The calories were a rough estimate based on my description. That is fine for a food log; I would not send it into an argument with a dietitian.

I speak to the Agent in ordinary language. It turns the sentence into a readable entry, calls a script to write it to SQLite on the home machine, then replies, “Recorded.” The number matters. If it heard “braised pork” instead of “dragon fruit,” I can correct that record with edit --id. If I merely add a new note saying “I did not eat braised pork today,” the evening assistant may have to ask how many breakfasts I had.

The script has a narrow job. capture adds a record; edit corrects a specified one. Neither directly edits project files or marks a task “done.” The response is a short receipt, not a dramatic reading of the entire database. Once the write succeeds, the job ends. A quick food note need not trigger an annual performance review.

The same applies beyond food. During one change of plans at work, I dropped a chapter review while another LifeOS cleanup task continued. Those updates became records No. 3 and 4. The related items in TickTick had checkmarks, but the assistant still reminded me that this was not enough to show the work had been accepted.

A checkmark looks a lot like victory, especially when you clicked it yourself. If checkmarks could talk, this one would probably have filed a project closeout report already. Whether the project is actually finished still depends on evidence of delivery.

I call this the “hot path.” For a quick capture, it does three things: understand the note, put down one record, and tell me where it went. If I did not mention the task context, the weight I lifted, or a date, it should not helpfully invent them. When an input is vague, I would rather keep that uncertainty in the record than receive a fully fabricated project update.

What If Yesterday’s Task Shows Up Again?

Saving a record is only the beginning. I worried about a morning like this: yesterday afternoon I said, “This task is done,” but the project file had not been updated. If the assistant read only that file this morning, it would put the task back at the top of today’s list.

I would probably ask, “Wasn’t that done yesterday?”

If it could talk back, it might say, “The project file disagrees.”

It is holding an outdated piece of paper and treating it like a royal decree.

That is why LifeOS keeps “events” and “current state” in different places. captures.db holds the trail of what was said and when, including explicit reports that a task was completed or changed. The Vault is a collection of ordinary Markdown files containing project goals, open tasks, reports, and organized knowledge. The event log answers “When did someone say this?” The project files answer “What should I do next?”

So I gave morning planning a rule: while reading open projects and tasks in the Vault, it also checks recent records. If I explicitly reported that the same task in the same project was done but the file has not caught up, it should not put that task straight back on today’s list. A similar title, one checkmark, or “more or less done” does not count. In the evening, it looks for evidence of delivery before changing the long-term file. Without that evidence, no “done” stamp.

The morning plan has somewhere to go: the selected work, study, and exercise items land in TickTick. That is today’s action list; longer-term goals and project state remain in the Vault. A planned workout is only a suggestion. What I actually did needs its own record. Otherwise the evening report might claim I finished four sets of squats, while my legs ask, “Was there a meeting about this? Nobody invited us.”

In the evening, the Agent reads the day’s events, checks the relevant projects and TickTick items, then writes a daily report. On one occasion it checked the Vault and the task list, edited a project document, generated and registered the report—and then stopped at the finish line. Two tasks on today’s list had been checked off, but that still did not justify closing the long-term tasks in the Vault.

That pause was more useful than a smooth summary. The assistant could gather the clues; it could not conjure up evidence of delivery that it had never seen.

The report itself is a file under Reports/Daily/. summary_save registers its path in the database so I can find it later; the database no longer keeps a second copy of the report text. The order is file first, path registration second. If the first succeeds and the second fails, the assistant should say so and finish the registration later. A document on disk and an empty register do not add up to “everything is in order.” That line is suspicious enough in a human office. I am not giving the machine a pass.

Letting the Assistant Load Skills When Needed

Connecting the Agent to files and scripts created another problem: too many rules. If every breakfast note made it read the instructions for project management, health planning, weekly reports, knowledge organization, and the Vault, “I ate chicken breast” might get me a “Preliminary Report on Aligning Poultry Intake with Next Quarter’s Goals.” The memo would arrive before I finished eating.

So the root instructions for LifeOS stay short: how to capture, how to correct a record by number, and which actions must not happen as a side effect. The rest is split into skills by task. Planning the day loads the morning planning skill. Writing a daily report loads the periodic-summary skill and, depending on the day’s records, the relevant project, health, or knowledge skill. An ordinary food or workout note goes straight into the log without loading a complete health plan.

Loading only what is needed also limits what each skill may do. The morning skill can pick actions from open tasks and sync them to TickTick, but it cannot quietly turn a suggestion into a completed task. The summary skill checks records before updating project files supported by evidence, writing the report, and registering its path. When the knowledge skill handles source material in Raw and organized notes in Wiki, it cannot pass the model’s rewrite off as the original.

Put those skill names together and they sound like a duty roster. The note-taker has just written something down; the person checking it still has to find the evidence before stamping a task “accepted.” The specific instructions live in their respective skill files, which also makes mistakes easier to trace. If “done” gets confused with “planning to do,” I can change the relevant instruction. Repeating “be more careful” in chat is sometimes about as effective as telling an alarm clock to wake itself up earlier tomorrow.

The Vault has its own division of labor. Raw/ holds source material; Wiki/ holds reusable notes made from it; Project/ holds goals and tasks; Reports/ holds periodic reviews; and Outputs/ holds writing meant for other people. I once tried putting everything in a “knowledge base.” Finding one original image then meant walking through three layers of summaries and two pages of self-congratulation. Now I can at least ask: am I looking for the source, or for a judgment I made later?

An Alarm Clock and a Health Data Table

The assistant usually waits for me to speak. Scheduled work belongs to n8n: planning in the morning, review in the evening, and workflows that can also receive data through a webhook. The Agent reads the context it needs, writes documents, and handles ambiguity; n8n manages when calls happen and how automated data moves. One knocks on the door at the right time; the other opens it and gets to work. Being able to chat does not mean being able to start on schedule. If the alarm never rings, the assistant cannot even invent an excuse for being late.

Once health data comes in, the workflow receives it through the Health Data Webhook and branches into workouts, sleep, and body metrics. Each branch prepares the data, looks for an existing record, merges it, writes it to Data Tables, and brings the results together before responding.

“It is all at home” is easy to hear as “it is all in one database.” It is not. The health-sync workflow stores its data in n8n Data Tables; LifeOS quick captures live in SQLite’s captures.db. When the evening review needs a health summary, the automation brings the relevant information to the Agent to combine with that day’s records. Sleeping on the same machine does not make sleep data swim into captures.db on its own.

There are also two ways into the health workflow. A sync app on my phone can submit data through a public HTTPS entrance on a cloud host running Caddy. That entrance checks authorization before forwarding eligible requests to n8n at home. ChatGPT’s custom MCP tool can call the health webhook too. What gets written depends on the fields sent and the workflow’s results. A chart can show what was collected; it cannot interpret my body in place of a doctor.

Two Roads Home When I’m Out

When I open my phone and talk to OpenClaw away from home, I mainly use a Tailscale private network and Tailscale Serve to reach the home entrance. This route is for devices already in the tailnet; it does not put the chat interface on a public website for everyone. The private route still needs the app’s own authentication and permissions. “I use Tailscale” is not a universal security amulet.

Health sync takes the other road: the authorized cloud entrance described above. My phone need not stay connected to the private network for every upload, but the public entrance, request authorization, and forwarding rules now need careful maintenance. Caddy in the cloud, the service at home, and private-network access each control a different stretch. Drawing them on one network diagram does not make them share permissions.

The mini PC is at home and most files are at home, but that does not mean every word stays there. When I use an external model, what context goes to it depends on the actual call. Health data uploaded through the cloud entrance passes through an outside machine as well. Which material may be sent, who can access the entrance, and where credentials live are separate questions. A private network and a home server give me more control; they do not cancel the homework on permissions.

What Actually Lives on That Mini PC

OpenClaw’s Gateway runs on the host machine. LifeOS is a workspace on that host: one SQLite database and a Vault of Markdown files I can open directly. n8n, its database, the internal-network entrance, Gitea, and other services run in containers. Tailscale handles the private connection between devices. I did not draw a deployment diagram and install everything to match it; I separated the responsibilities as I used the system.

Gitea at home manages versions of the Vault, and I have set it to sync to GitHub automatically. If a project file goes wrong, I can inspect the changes and see which version turned “needs checking” into “done.” But Git covers the files committed to it. Backing up and restoring the events in SQLite, n8n’s database, workflow settings, and secrets still needs separate work. One successful sync does not prove the whole system will rise intact after a machine failure. When the hard drive refuses to show up for work, I cannot wave a Git commit at it and ask, “Didn’t you say you had synced?”

After the software was installed, the hard part was still where the pieces handed work to one another: do not invent facts when an input is vague; make a completion report visible to morning planning; do not treat a TickTick checkmark as acceptance during the evening review; do not say “all done” if the report was written but its path was never registered. An extra check at each handoff is what lets the everyday entry point take one less step.

That breakfast record was No. 1. After one sentence, I knew where it went; the next day, I could look it up by number. Whether a piece of work was truly finished is a different question. The assistant can put the records on the table. I will look at the evidence before clicking the checkmark—it is already eager to clock out.

My Life Isn't an OS — So I Built One

Layton — Sat, 26 Sep 2026 03:32:49 +0000

Another LifeOS?

There are plenty of things called LifeOS now. At the simple end, there's ChatGPT plus scheduled tasks. Then there are Obsidian templates and manually maintained knowledge bases—I wrote about that more old-school approach in an earlier article on knowledge management. Add AI to an existing setup and you get something like Compass. At the other end are larger collections of tools, such as danielmiessler/LifeOS.

None of them quite felt right for me. ChatGPT can remind me to do things, but I don't want my life records living in a chat. Obsidian templates are flexible, but if I want an agent to update a project from my phone or collect my daily to-dos automatically, I still have to build that part myself. And I don't really want to install an entire suite of tools—I don't want to clutter up my machine. :) What I want is something lean, dependable, and easy to change as my habits change.

Say I take a photo of lunch: can I log it right away? If I tell the agent at work, “I finished this task,” can it find that note when it writes my evening review? Can project updates, health logs, and knowledge notes live in their own places instead of piling up in one chat window?

So I built another LifeOS. It's not a one-click product or a deployment guide to follow step by step. I just want to show how I put the pieces together and let the system gradually adapt to my day-to-day life.

What I Want It to Do

Most of what I ask it to do is mundane: log a meal, note some project progress, or record that I finished a task. Those little daytime interactions need to be quick. I don't want the agent reading every document in my vault before it can jot down breakfast. At night, it can go back through the records, write a daily review, and update project notes. I can talk to it from my phone or work computer, while most of my personal data stays on the server at home.

I can also turn saved source material into Wiki notes, then use those notes to check facts when I write. In the morning, the agent picks tasks from my existing projects, considers recent health records when suggesting training or rest, and puts the day's work in TickTick. TickTick is my list for today; the lasting state of a project lives in the Vault.

Here's a part I find especially handy: when I mark today's items in TickTick as done, dropped, or postponed, it notifies the agent to record the change. The evening review can then use those records to update the relevant projects. I don't have to rewrite a project file every time I tap a checkbox during the day.

Automatically summarize each evening to help maintain projects and generate a daily report：

The Big Picture: Two Paths for Data and Work

The diagram looks busy, but day to day there are really two paths:

During the day: I tell the agent something → it turns that into an event → note.py capture writes it to SQLite → I get a short confirmation.
When it's time to organize things: the agent reads the relevant records and Vault files → writes a daily review, updates project documents, or turns Raw material into Wiki notes. n8n can trigger some of that work on a schedule or through a webhook.

Why separate them? I want daytime logging to stay light. Anything that requires reading and checking context can wait. SQLite records what happened; the Vault holds the current state of projects and tasks, knowledge notes, and report text. n8n has its own Data Tables for automation data, but those are not the same database as the LifeOS event log.

First, Keep the Network Boundaries Straight

I want to reach my agent from my phone without exposing its port directly to the public internet. I use Tailscale to put my devices on a private network, then Tailscale Serve as the access point. Serve is for devices in the tailnet; it isn't the same thing as Funnel, which publishes a service to the internet. And being on a private network doesn't remove the need for application-level authorization.

Health data takes a different route. I don't want to keep Tailscale running on my phone all the time 🤣, so Caddy on my cloud server provides a public HTTPS endpoint. It checks that an incoming request is authorized before forwarding it to n8n at home. That is separate from the private route I use to access OpenClaw on my phone.

Hiring an Assistant: OpenClaw

I ended up choosing OpenClaw for the agent layer. The number of models it can connect to matters less to me than having a usable chat interface, a separate agent and workspace for LifeOS, and a way for n8n to call on it at set times. Logging one thing doesn't require loading every rule for projects, health, and Wiki notes. When I ask it to write a review or a knowledge note, it can load the relevant skill then.

That's also why “log this” isn't some elaborate agent workflow. The agent understands what I said, calls a write script once, and stops. Chat history helps with conversation, but I want project states, articles, and reports saved as files I can open myself.

On my phone, I access OpenClaw through Tailscale Serve. ChatGPT's custom MCP takes another route, using a separate tunneling tool to call services at home. Both look like talking to an AI, but they don't travel through the same network path.

The Core of LifeOS: Fast and Slow Paths

I split the LifeOS work into a fast path and a heavier one. The fast path is for everyday logging: the agent understands what I said, calls the Python script note.py to write to SQLite, gets an ID back, and replies. I don't let the model construct SQL itself. capture adds a new record; edit --id corrects one I got wrong. If I say “I finished the task,” that's a new completion event, not an edit to an old entry. A simple record usually gets a reply in a few seconds, though the model and network make a difference.

Why not put task status in the database too? Because SQLite is a log of what happened, not a live table of unfinished tasks. Project goals, task lists, and longer-term progress live in Markdown files in the Vault. In the evening, the agent uses the day's records to maintain those files. When it plans my morning, it starts with open tasks in the Vault, then checks recent completion events so it doesn't schedule something I've just finished but haven't yet reflected in the Vault.

The heavier path handles the work that can wait: daily and weekly reviews, project upkeep, saving source material, turning Raw material into Wiki notes, and helping me think through an article. It loads the skills it needs. Logging breakfast doesn't require the entire health-analysis playbook.

The Vault follows the same general ideas as my earlier knowledge-management setup, but with clearer jobs for each directory:

Raw/ keeps original files and material worth saving, not an AI summary passed off as a source.
Wiki/ holds reusable knowledge drawn from records and source material, rather than a daily stream of notes.
Area/ covers long-running parts of life—family, health, work, and growth—and the practices I've developed for them.
Project/ holds projects with goals and tasks. Their long-term state belongs here, not in a guess based on chat history.
Reports/ holds daily and weekly reviews. The text lives in files; the database only registers their paths.
Outputs/ is for things I want to explain to other people, including this article. I use Wiki notes to check what I say, not to assemble an article by pasting them together.

Giving It an Engine: n8n

Once the database and Vault have distinct jobs, there's still a practical question: who tells the agent to plan in the morning and review at night? I use n8n for schedules and webhook workflows. n8n triggers jobs, handles data on the automation side, and calls OpenClaw. The agent interprets records and writes readable documents. I don't treat n8n as the LifeOS source of truth, or the agent as a reliable scheduler.

Take health data. Health Sync on my iPhone can send it through the cloud endpoint to n8n at home. ChatGPT can also call a local MCP tool, log_health, which posts to n8n's health webhook. The workflow writes exercise, sleep, and body metrics to Data Tables and can update them several times a day. In the evening, n8n triggers a review: it pulls that day's output from its database and puts it into a prompt so the “assistant” can write a review alongside the day's captures.

The workflow looks like this, and it can also be triggered by an external webhook. n8n can now help build workflows with AI, which makes getting started easier than it used to be 👍:

Wrapping Up

Look back at the architecture diagram: there's a lot behind it, but using it day to day is simpler. I say something and it gets recorded. In the morning it helps me pick tasks; at night it turns the records into a review. Behind the scenes, Gitea handles version history and syncs automatically to GitHub, a CPA model proxy routes calls and tracks usage, and ChatGPT uses custom MCP to call services at home. I'll leave those details for another time.

This LifeOS is built around my own habits, not as a product anyone can install with one click. But if you're putting together something similar, I hope some of these choices are useful. If you have ideas—or spot something I've got wrong—I'd love to hear them.