Ongoing

OpenClaw Personal AI Assistant

Self-Hoster & Skill Developer · 2026 · 7 min read

Built a self-hosted AI assistant that feels genuinely personal: it lives on my own infrastructure, messages me on WhatsApp, and plugs into the tools and systems I already use day to day.

Overview

This started as a curiosity project: could a self-hosted AI assistant be genuinely useful, not just technically clever? I run OpenClaw on a dedicated Ubuntu VM at home and, bit by bit, turned it into something I actually rely on. It has persistent local memory, a WhatsApp interface, a structured workspace, and a growing collection of custom skills built around the kinds of things I already do online and around the house.

Problem

A lot of AI assistants feel a bit like rented intelligence. They're convenient, but you don't really control where the data goes, what they can connect to, or how closely they can fit around your own life. I wanted something more personal: private by default, shaped around my own habits and systems, and able to interact with the tools I already use instead of living in a sealed product box.

Constraints

  • It had to run reliably as an always-on service at home
  • It needed to be easy to reach without opening yet another app or dashboard
  • Memory and context had to survive beyond a single chat session
  • Any integrations I added needed to stay understandable and maintainable
  • It had to be useful in real life, not just impressive in a demo

Approach

I set OpenClaw up on a dedicated Ubuntu VM under Hyper-V, ran it as a service, and leaned into the idea that the assistant should live inside my own environment. The workspace is a version-controlled repo containing the assistant's personality, memory, notes, workflow, and all installed skills. From there I built practical integrations around things I actually wanted help with: Outlook and calendar management, task tracking, OneNote, home network visibility, UniFi Protect cameras, Home Assistant, Spotify, Ticketmaster, browser automation, and finance and portfolio monitoring. Recurring tasks run on a heartbeat cadence or via cron for exact-time reminders. I developed the skills myself, with a lot of help from Claude along the way.

Key Decisions

Keep it on its own Ubuntu VM

Reasoning:

I wanted the assistant to feel like a real part of the homelab rather than a process I happened to be running. Giving it its own VM makes it easier to manage, back up, restart, and generally treat like infrastructure.

Make messaging the main interface

Reasoning:

If I have to remember to open a special app, I won't use it nearly as much. Putting the assistant on WhatsApp made it instantly more useful because it became available in the same place I already handle lots of lightweight day-to-day communication.

Store everything important in files, not just chat history

Reasoning:

Chat history is ephemeral. A version-controlled workspace with structured memory files, a second brain, and per-skill context means the assistant stays coherent across sessions and can be reasoned about like any other codebase.

Build small focused skills instead of one giant integration blob

Reasoning:

That kept the system flexible and much easier to reason about. Each skill does one thing well, and if one needs changed or replaced it doesn't drag the whole setup down with it.

Use heartbeats for recurring checks, cron for exact-time tasks

Reasoning:

Separating lightweight recurring context checks (heartbeat every 4 hours) from precise scheduled jobs (cron) keeps the automation model clean and predictable.

Tech Stack

  • OpenClaw
  • Ubuntu Server
  • Hyper-V
  • systemd
  • Microsoft Graph (Outlook, To Do, OneNote)
  • Home Assistant
  • UniFi Network & Protect
  • Spotify Web API
  • Ticketmaster API
  • Trading 212 API
  • WhatsApp gateway

Result & Impact

  • 12
    Active skills
  • WhatsApp
    Primary interface
  • Every 4 hours
    Heartbeat cadence

The end result is an assistant that feels much more personal than a typical AI tool. It can manage practical life-admin tasks, keep context in local files, check on home infrastructure, monitor finances and trading positions, and generally act more like part of my environment than a separate service on the internet.

Learnings

  • The biggest upgrade wasn't the model — it was persistence. Local memory and a proper workspace changed everything.
  • An assistant gets dramatically more useful once it can meet you in a low-friction interface like messaging.
  • Direct integrations beat vague automation once you know what jobs you actually want done regularly.
  • Treating the workspace as a proper version-controlled repo — with structured files for personality, memory, and skills — makes the whole setup much easier to evolve and reason about.
  • The sweet spot is not maximum complexity. It's just enough structure that the whole thing stays dependable.

What it actually is

At this point, OpenClaw is less of a toy project and more of a personal operating layer. I can message it, ask it to check email, add something to my calendar, keep an eye on recurring tasks, query bits of my home setup, check on my trading positions, and generally help me stay on top of the admin that tends to leak across the day.

The important part is that it lives with me, not somewhere abstract in the cloud. Its working memory is stored locally. Its instructions live in files. Its skills are things I’ve added because I actually wanted them, not because they looked good in a feature list. That makes the whole thing feel much more companionable and useful than a generic AI tool ever could.

Infrastructure setup

The assistant runs on a dedicated Ubuntu VM in my home lab, hosted on Hyper-V. I run OpenClaw as a proper service so it starts automatically, survives reboots, and behaves like infrastructure rather than something I need to remember to launch manually.

The workspace is a Git repo that contains everything needed to describe and run this specific setup: the assistant’s personality (SOUL.md), user preferences and routines (USER.md), workspace rules and conventions (AGENTS.md), long-term operational memory (MEMORY.md), a heartbeat checklist, and all the installed skills. There’s also a second-brain/ directory for daily notes, meeting notes, project context, and reference material.

The idea is simple: important context should live in files, not only in chat history.

Skills

The current setup is integration-heavy by design. Skills are kept small and focused — each one does one job.

Productivity and personal ops

  • Outlook Graph for inbox triage, calendar lookups, and message management
  • To Do Graph for task capture and reminders — the preferred path for anything phrased as “add a reminder”
  • OneNote Graph for notebook and page access

Smart home and local infrastructure

  • Home Assistant for smart-home control via the Assist API
  • UniFi Network for WAN status, client inspection, and security alerts
  • UniFi Protect for camera snapshots and recent motion events

Research and browsing

  • Agent Browser for interactive website work where a simple fetch isn’t enough

Media and lifestyle

  • Spotify for playback control, queueing, and device selection
  • Ticketmaster for live music lookups by artist and location

Finance and market monitoring

  • Trading 212 for positions, orders, history, and account activity
  • Trading Brain for portfolio monitoring, ISA reviews, and structured trade ideas
  • FMP as a financial data layer to enrich market analysis

Automation model

Recurring tasks run on two patterns:

  • Heartbeat — a lightweight recurring check that runs every 4 hours, used for things that benefit from recent conversational context (calendar checks, daily memory maintenance, monitoring sweeps)
  • Cron — for exact-time reminders, scheduled follow-ups, and isolated recurring jobs that don’t need context

Why messaging matters

Putting it on WhatsApp changed the whole feel of the project. Instead of having to “go use the assistant”, I can just send it a message when I think of something. That sounds small, but it makes a massive difference.

It means the assistant fits into everyday life much more naturally. It’s there when I need to add a gig to my calendar, check a detail from an email, ask for a bit of research, look up something in my inbox, or nudge one of my own systems. That ease of access is probably why the project stuck — it became pleasant to use.

Why I keep working on it

The interesting part now isn’t whether a self-hosted assistant is possible. It clearly is. The interesting part is how personal it can become when it’s shaped around one person’s tools, habits, infrastructure, and preferences.

That’s the bit I like: not building a generic AI product, but building something that feels increasingly like my assistant.

All projects