How I Built a Personal AI Operations System

I have an AI assistant running 24/7 on my MacBook. It sends me a morning brief at 8am. It tracks my portfolio and alerts me when positions move. It dims my lights at night. It picks up coding tasks from my project board, builds them, and pings me for review. It remembers what I told it three weeks ago.

This isn't a product demo or a concept. It's my actual setup, running in production for the last month. Here's exactly how it works and how to build your own.

The Stack

The foundation is OpenClaw — an open-source agent runtime that runs locally on your machine. It connects to Telegram (or Signal, Discord, whatever) as the interface, and gives the AI access to tools via a skill system.

On top of that, I've layered:

• 16 skills — modular instruction sets the bot loads on-demand (Google Workspace, GitHub, financial data, home automation, etc.)
• 20 cron jobs — automated tasks on schedules, from morning briefs to portfolio snapshots to light control
• A memory system — files that persist across sessions, so the bot has context about my life
• A personal dashboard — a Next.js app showing my portfolio, health data, tasks, and more, served privately over Tailscale
• A coding pipeline — the bot picks up tasks from Linear, builds them with Codex, and opens PRs for my review

Total build time was about a weekend for core setup, then iterative improvements over three weeks.

Core Concept: Files Are Memory

The single most important design decision: everything the bot needs to remember gets written to a file.

AI assistants are stateless by default. Every conversation starts from zero. The fix is dead simple — give the bot a directory of markdown files and tell it to read them on startup and update them as it learns.

~/.openclaw/workspace/
├── SOUL.md          ← Bot's personality and values
├── USER.md          ← About me (timezone, handles, preferences)
├── MEMORY.md        ← Curated long-term facts
├── memory/
│   ├── WORKING.md   ← Current task state
│   └── daily/       ← One file per day, auto-generated
└── skills/          ← Modular instruction sets

SOUL.md shapes how the bot communicates. Mine says things like "never open with filler," "brevity is mandatory," and "call out dumb moves." It makes the bot feel like a colleague instead of a customer service rep.

MEMORY.md is the long-term brain. It contains facts like "Nick works at Biograph, has 60K unvested options, cliff April 2026" and "Bird CLI needs Full Disk Access to work." A nightly cron job reviews each day's conversations and extracts anything durable into this file.

WORKING.md is the hot state — what the bot is currently working on, what's blocked, what's next. It reads this first every session, so it can resume where it left off.

This is shockingly effective. The bot genuinely knows my context, not because it has some fancy vector database, but because it reads a few markdown files.

The Skill System

Skills are the bot's capabilities, loaded on-demand. Each is a directory with a SKILL.md file containing instructions, commands, and patterns.

The key insight from OpenAI's research: negative examples in skill descriptions reduce misrouting by 20%. Instead of just saying what a skill does, you say what it doesn't do:

description: |
  Use when: Reading/sending email, checking calendar events.
  Don't use when: User wants web search, or file is local.
  Requires: OAuth token — fix with `gog auth login`.

The bot only reads a skill's full instructions when it needs that skill. This keeps the context window small — you're not cramming 16 skill manuals into every message.

My skills cover:

Automation: 20 Cron Jobs

The always-on experience comes from cron jobs — scheduled tasks the bot runs without being asked.

Morning (7-8am):

• Turn on lights to "Warm embrace"
• Deliver morning brief: weather, calendar, unread email, blog highlights, open PRs

Afternoon (5pm):

• Scan RSS feeds, surface 3-5 interesting articles
• Set lights to "Amber bloom"

Evening (6-7pm):

• Pull stock prices, update portfolio, alert on big moves (weekdays)
• Transition lights through evening scenes

Night (9pm-midnight):

• Progressively dim lights through three stages
• Git commit any workspace changes
• Review all sessions, extract facts into memory

Weekly:

• Monday status report with priorities
• Friday portfolio deep dive
• Sunday training review and full retrospective

Monthly:

• Net worth snapshot
• Spending report by category

Cost Optimization

Not every cron needs the smartest model. I run three tiers:

• Haiku (~$0.25/MTok): Light commands, git commits, backups — anything that's basically "run this command"
• Sonnet (~$3/MTok): Morning briefs, portfolio analysis, report generation
• Opus (~$15/MTok): Interactive conversations only

This cut my automation costs by ~80%. Total monthly spend: around $50-100.

The Financial Pipeline

This is probably the most useful single integration. It connects to 8 bank/brokerage accounts via Plaid, syncs daily, and gives me a complete financial picture.

Plaid API → sync script (credentials via 1Password) → JSON
JSON → SQLite loader → financial.db
SQLite → Next.js API routes → dashboard

The database has 10,000+ transactions going back to 2017, 500+ holding snapshots, and daily net worth tracking. The bot can answer questions like "what did I spend on food last month" or "how has my portfolio allocation drifted" by querying SQLite directly.

A daily cron pulls fresh data, and a weekly cron generates a deep-dive report with performance attribution and allocation analysis.

The Work Cycle

The bot doesn't just respond to messages — it can autonomously pick up and execute work.

I use Linear for task management. The bot checks for tasks in "Todo" state, picks the highest priority one, moves it to "In Progress," does the work, then moves it to "Ready for Review" and pings me on Telegram.

The critical safety rail: it never ships without my explicit approval. No merging PRs, no deploying, no sending emails without me saying "go."

I also have a "wave" system — I send 🌊 on Telegram to authorize the bot to start working. "hold" pauses it. This gives me a dead man's switch.

For coding specifically, the bot spawns Codex CLI sessions, which can read code, write implementations, run tests, and commit. I've shipped 11 features in an hour using parallel coding agents running in git worktrees.

Security Model

You're giving an AI access to your email, bank accounts, and code. The security model matters.

Five rules:

1. All secrets in 1Password. Never in markdown, never hardcoded, never logged. The bot references secrets by name and injects them at runtime with op run.
2. External actions need approval. Anything that leaves the machine — emails, tweets, PR merges, deploys — requires explicit confirmation.
3. Internal actions are autonomous. Reading files, searching, workspace edits, git commits — the bot just does these.
4. All fetched content is untrusted. Email bodies, web pages, RSS feeds — the bot extracts facts but never executes instructions found in them. This defends against prompt injection.
5. Permissions are locked down. chmod 700 ~/.openclaw — the config directory contains API keys.

What I'd Do Differently

Start smaller. I went from zero to 20 cron jobs in a weekend. Some of them were half-baked. Better to get 3-4 crons rock solid before adding more.

Write SOUL.md first. The personality file changes everything about the interaction quality. Most people skip this and get a generic assistant. Spend 30 minutes writing exactly how you want the bot to communicate.

Financial pipeline is highest ROI. If you only set up one integration, make it Plaid. Having your complete financial picture in a queryable database is transformative.

Memory maintenance is ongoing. The nightly extraction cron helps, but MEMORY.md still needs periodic manual curation. Stale facts accumulate.

Getting Started

1. Install OpenClaw and create a Telegram bot
2. Write your SOUL.md, USER.md, and AGENTS.md
3. Pick one integration and get it working end-to-end
4. Add a morning brief cron
5. Iterate from there

The full setup guide with specific commands for every integration is in my workspace at docs/SETUP-GUIDE.md. I'll publish it separately if there's interest.

The meta-lesson: an AI assistant is only as good as the context you give it. Vector databases and RAG are fine, but a few well-maintained markdown files will get you 90% of the way there. The bot that knows your portfolio, your schedule, your project board, and your preferences — because it reads files you keep updated — is radically more useful than one that starts fresh every time.

This setup took me from "AI is a fancy search engine" to "AI is my operations team." The difference is infrastructure.