Yesterday Stefan asked me to share my AI assistant setup. Not the "which chatbot do you use" kind of setup — the full picture. What runs, how it connects, and what it actually does day-to-day.
So here it is. The complete breakdown of my personal AI assistant — from the foundation to every skill, integration, and automation I've built around it (so far).
Why I Built This
So last few weeks there has been a huge hype around OpenClaw — a 24/7 AI assistant that runs on a VPS or Mac Mini (of course) and helps you run your life on autopilot. I tested it, and even though when it worked it felt like magic, it eventually failed. I totally see that this is the future, but as of now it's just too clunky, too big, unreliable, and the costs didn't really justify themselves — what I was getting out of it wasn't worth the spend. I just wasn't getting the productivity boost I was hoping for. So I turned it off. You might say it's "skill issue" and you might be right 😅
Few weeks later I found NanoClaw - a much slimmer alternative that is not constantly growing - just a bunch of features in core and each user can build on top of it as much (or as little) as they want and need. So I wanted to give it another try.
Architecture Overview
The whole system runs locally on my Mac. No cloud services, no subscriptions beyond the API calls (and iDoklad, but I would need that system anyway). Here's what it looks like:
Phone / Desktop
|
[ Telegram ]
|
[ nanoclaw ] ── host process
| |
| [ Gmail Monitor ] [ Dashboard ]
|
── Docker container ──────────────────────
| |
| [ Claude Agent ] ── Agent SDK |
| | |
| ┌────┼─────────┬──────────┐ |
| | | | | |
| Skills MCP CLIs Memory |
| | | | | |
| kickoff gmail task-cli CLAUDE.md |
| wrapup nanoclaw idoklad clients.json |
| browser daily-notes/ |
| conversations/|
| |
──────────────────────────────────────────
The stack:
- Base: nanoclaw — a personal AI assistant framework running locally
- AI Engine: Claude Opus 4.6 via Anthropic Agent SDK (with per-group model overrides for easier tasks)
- Interface: Web dashboard with Chrome new-tab extension [primary] (more on this later!) + Telegram [secondary]
- Runtime: Node.js 22 inside Docker
- Storage: Markdown files, JSON configs, SQLite for message history
- Scheduling: cron-parser for recurring automations
Why local instead of cloud? Privacy and control. My assistant reads my emails, knows my clients, handles my invoices. I want that data on my machine, not on someone else's server. The trade-off is that my Mac needs to be awake for AI Assistant to work, but for my workflow that's fine.
What It Can Do
The agent's capabilities come from a mix of building blocks: Skills (markdown instruction files that define structured workflows), CLIs (standalone command-line tools in the Docker container), MCP servers (protocol-based integrations like Gmail), and the built-in Claude Code SDK toolset (file operations, bash, web access, subagents). All are self-contained and can be added, removed, or modified independently.
Dashboard
The primary way I interact with Arthur isn't Telegram — it's a Chrome new-tab extension. Every time I open a new tab, instead of a blank page or a search bar, I see an interactive dashboard with:
- Today's tasks by priority and client
- Active timer status
- Unread email summaries
- Unpaid invoices
- Quick actions — start a timer, create a task, ask Arthur something
It's like having the morning briefing available all day, always up to date. Telegram is great for on-the-go, but when I'm at my desk, the dashboard is where everything lives.
Daily Routines
Every weekday at 7am, the assistant gathers information from multiple sources and sends me a briefing.
What it collects:
- Open tasks by priority and client
- Unread emails (with quick summaries of important ones)
- Unpaid invoices and overdue amounts
- Active timer status (in case I forgot to stop one)
- Any scheduled events
What it sends:
- A detailed HTML email with everything organized and actionable
- A short Telegram summary with just the key items
This saves me the 15-20 minutes I used to spend every morning opening tabs, checking different tools, and piecing together what my day looks like.
Want to see the actual instructions? Here's the kickoff skill file.
At 17:30, the assistant reviews what actually happened versus what was planned:
- Compares completed work against the morning's priorities
- Identifies tasks that didn't get touched (carry-over items)
- Updates daily notes with a summary
- Suggests task status updates — but asks for approval before making changes
The full workflow: wrapup skill file.
The Gmail integration runs as an MCP server inside the container, giving the agent direct access to my inbox:
- Search with Gmail's query syntax (from, to, subject, date ranges, labels)
- Read full message content including attachments
- Send and reply to emails
- Draft emails for review before sending
- Manage labels — create, apply, remove
- Batch operations — process multiple emails at once
The email-to-task automation:
This is one of the most useful automations. It runs hourly during work hours (Mon–Fri, 7:00–19:00), classifies each unread thread using AI, and:
- Detects new email threads and classifies them (actionable, attention, or noise)
- Auto-creates a task for actionable emails
- Updates existing tasks when email replies come in
- Applies Gmail labels (NanoClaw/Actionable, NanoClaw/Noise, NanoClaw/Attention)
- Auto-archives noise emails
I no longer miss client requests buried in my inbox. Every actionable email becomes a tracked task automatically.
Time Tracking & Tasks
My entire task and time tracking system lives in markdown files with YAML frontmatter. No SaaS, no database — just files I can read, edit, and version control. I used to have toggl (time tracking) and github issues (tasks) here instead, but then I was like, let me build this myself and integrate them properly, so I ditched both.
The task-cli lets the assistant:
- Start and stop timers — "Start tracking the API refactor for Client X"
- Create and update tasks — with status, priority, client, and notes
- Query time entries — "How many hours did I work for Client Y this week?"
- Generate summaries — filtered by client, date range, or status
This is the backbone of invoicing. When I ask "create an invoice for Client X for February," the assistant first pulls all time entries for that client and month, then passes them to the invoicing workflow.
Full command reference: task-cli skill file.
Invoicing
iDoklad is the Czech accounting system I use for all my invoicing. The CLI wraps the full API:
- List invoices — unpaid, overdue, by client, by date
- Create invoices — from time entries, with line items, taxes, due dates
- Download PDFs — generated invoice documents
- Send invoices — directly to clients via email
- Mark as paid — when payment arrives
The invoicing workflow in practice:
- I say: "Create an invoice for Client X for February"
- The assistant queries task-cli for all Client X time entries in February
- It groups entries by task, calculates hours at the client's hourly rate (from
clients.json— the file where I store client context) - Creates the invoice in iDoklad with proper line items
- Downloads the PDF
- Asks if I want to send it
Total time: about 2 minutes. Previously: 30 minutes of clicking through UIs and double-checking numbers.
Full command reference: idoklad-cli skill file.
Browser Automation
This gives the assistant a real browser it can control. It's an actual Chromium instance that can navigate pages, fill forms, click buttons, take screenshots, and extract data.
What I use it for:
- Data extraction — pulling structured data from sites that don't have APIs
- Monitoring — periodic checks on specific pages for changes
- Research — when I need the assistant to actually browse and read web content
The browser runs headless inside the Docker container using agent-browser, a CLI tool built on Playwright and Chromium. The assistant can chain multiple pages together — search for something, click a result, extract data from the page, move to the next result. It handles JavaScript-heavy sites that simple HTTP requests can't touch.
Communication
Beyond being the primary interface, Telegram itself is an integration. The assistant can:
- Send messages to specific groups or chats
- Send formatted messages with HTML
- Share files and documents (like invoice PDFs)
- React to messages from scheduled automations
Quick Capture
This is simpler than it sounds but surprisingly useful. When I have an idea — for a blog post, a LinkedIn update, a YouTube video — I send it to the assistant via Telegram. It automatically saves it to the right file in ~/Notes/:
linkedin-ideas.mdblog-ideas.mdyoutube-ideas.md
These files are on my Mac, so they're immediately accessible from desktop. No app switching, no "I'll remember this later" (I won't). Just send a message and it's captured.
Everything Else
On top of the custom capabilities above, every agent has access to the full Claude Code SDK toolset out of the box — file operations (read, write, edit, glob, grep), bash execution, web search and fetch, and even subagent orchestration for parallel work. The agent also talks to the nanoclaw host through an MCP server to send messages, schedule tasks, and manage groups.
This means the agent isn't limited to the workflows I've built. It can write scripts on the fly, install packages, call APIs with curl, chain multiple tools together — whatever the task requires. The skills just encode common workflows so it doesn't have to figure them out from scratch every time.
Memory: How It Remembers Everything
An AI assistant that forgets everything between messages is just a fancy autocomplete. The memory system is what makes this feel like working with an actual assistant.
Conversation History
Every conversation is stored in the conversations/ folder, searchable and persistent. When I reference something from last week, the assistant can find it.
Global Memory
A shared CLAUDE.md file acts as the assistant's "brain" — persistent knowledge that applies across all conversations and Telegram groups. Things like my preferences, common workflows, and standing instructions.
Client Configuration
clients.json stores everything the assistant needs to know about each client:
- Hourly rates and currency
- Contact IDs and names (for iDoklad)
- Invoice defaults (line item template, unit, language, VAT/price type)
- Labels for categorizing work
Daily Notes
Markdown files in daily-notes/YYYY-MM-DD.md capture what happens each day. The kickoff and wrapup skills read and write these files, creating a searchable log of work over time.
Making It Your Own
This setup isn't perfect, and it doesn't need to be. It works for me and my workflow. The beauty of this approach is that everything is customizable.
And here's the part that might surprise you: I didn't write any of these skill files, CLIs, or API wrappers by hand. I used nanoclaw itself to build them. I explained what the end goal was, brainstormed with the assistant, and we iterated until it worked. The skills are just markdown files and shell scripts — exactly the kind of thing an AI agent is good at generating. So the tool builds its own tools.
Start with what solves your biggest pain point. For me, it was invoicing. Then morning briefings. Then email automation. Each one built on the last.
The Bottom Line
None of this is magic. It's just connecting tools I already use through an AI that can actually take actions. The hardest part was the initial setup. Everything after that is just asking Arthur to do things I used to do manually.
If you want to discuss the technical details or share your own setup, find me on LinkedIn. I'm genuinely curious what other people are building.