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 technical 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 was (and still kinda is) a huge hype around OpenClaw - 24/7 AI Assistant that runs on VPS, or Mac Mini (of course) and helps you to run your life on autopilot. I tested it, but it failed. I totally see that this is the future, but as of now, it's just too clunky, too big and unreliable. I was just not getting the productiviy boost I was hoping for. So I turned it off.
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 as they want. 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 cheaper tasks)
- Interface: Telegram (primary) + web dashboard with Chrome new-tab extension
- Runtime: Node.js 22 inside Docker (isolated per group)
- 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, but for my workflow that's fine.
Skills & CLIs: The Things It Can Actually Do
The agent's capabilities come in two forms. Skills are markdown instruction files that give the AI agent structured workflows — each defines what tools it can use (Bash, MCP servers, etc.) and step-by-step instructions to follow. CLIs are standalone command-line tools installed in the Docker container that skills and the agent can call directly. Both are self-contained and can be added, removed, or modified independently.
Skills
kickoff — Morning Briefing
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.
wrapup — End-of-Day Summary
At 17:30 on weekdays, 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
This is the accountability piece. It's easy to end a day feeling like you didn't get enough done. Having a summary that shows what you actually accomplished (and what to tackle tomorrow) is surprisingly motivating. And it also helps me to close to loop on things.
agent-browser — Full 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.
CLIs
task-cli — Time Tracking & Task Management
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 through task-cli, then passes them to the invoicing skill.
idoklad-cli — Invoicing Automation
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) - 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.
Built-in Tools (Claude Code SDK)
Beyond custom skills, every agent has access to the full Claude Code SDK toolset. These come out of the box with the default nanoclaw setup — no configuration needed. They're the same tools Claude Code uses on your local machine, but running inside the container:
File operations:
- Read, Write, Edit — full filesystem access within the container's workspace
- Glob — find files by pattern
- Grep — search file contents with regex
Execution:
- Bash — run any shell command (git, npm, curl, custom CLIs)
Web access:
- WebSearch — search the web and get results
- WebFetch — fetch a URL and extract content as markdown
Agent orchestration:
- Task, TaskOutput, TaskStop — spawn subagents for parallel work
- TeamCreate, TeamDelete, SendMessage — multi-agent swarms where subagents coordinate on complex tasks
Other:
- NotebookEdit — edit Jupyter notebooks
- Skill — invoke registered skills (kickoff, wrapup, etc.)
MCP servers (custom integrations):
- nanoclaw MCP — send messages to chat, schedule tasks, list/pause/resume/cancel tasks, register new groups
- Gmail MCP — search, read, draft, and send emails directly from the agent
This means the agent isn't limited to the skills 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.
Integrations
Gmail MCP — Full Email Management
The Gmail integration runs as an MCP (Model Context Protocol) 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.
iDoklad API
The Czech invoicing system integration (described above in the skill section). Handles the full invoice lifecycle from creation to payment tracking.
Telegram
Beyond being the 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
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.
Group-Specific Memory
Each Telegram group can have its own context. My work group knows about clients and projects. A personal group has its own separate memory and 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.
Automations That Run Without Me
Scheduled Tasks
| Automation | Schedule | What it does |
|---|---|---|
| Morning kickoff | 7:00 weekdays | Briefing email + Telegram summary |
| Evening wrapup | 17:30 weekdays | Day review + carry-over items |
| Email-to-task sync | Every hour (work hours) | Classifies inbox, creates/updates tasks |
Kickoff and wrapup run as scheduled tasks (cron expressions stored in SQLite). The email monitor runs as a background process with a 1-hour interval. I can also set up custom one-time or recurring tasks through conversation.
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.
Daily Workflows
Morning
- Arthur (yes, I named my assistant Arthur) sends the briefing at 7am
- I review priorities, check if any invoices are overdue
- Decide what to focus on today
During Work
- "Start tracking the API migration for Client X" — timer starts
- Need to research something? "Check what pricing tiers competitor X is offering" — browser skill handles it
- Random idea pops up? Send it via Telegram — auto-saved to the right notes file
- Client email comes in — already tracked as a task before I see it
End of Day
- Arthur reviews what I actually did versus the morning plan
- Suggests which tasks to mark as done, which to carry over
- I approve the updates, and tomorrow's kickoff will reflect the changes
Invoicing (Monthly)
- "How many hours this month for Client X?"
- "Create an invoice for Client X for February"
- Arthur pulls time entries, creates the invoice, downloads the PDF
- "Send it" — done
What Works and What Doesn't
What works well
Privacy. Data is stored locally — emails, client files, and conversations live on my machine, not in a third-party SaaS. API calls still go through Anthropic, but nothing is persisted on their side (wink wink).
Flexibility. Skills are just markdown files with instructions and tool permissions. When I need something new, I write a skill file and plug it in. No waiting for a SaaS to add a feature.
Integration. All my tools talk to each other through the assistant. Time tracking feeds into invoicing. Emails become tasks. Daily notes connect to task status.
Accessibility. Telegram means I can interact from my phone, desktop, or any device with Telegram installed. No special app, no VPN needed.
Automation compound effect. Each individual automation saves a few minutes. Combined, they save over an hour a day — and more importantly, they eliminate the mental overhead of remembering to do all these small things.
What doesn't work perfectly
Requires Mac awake. Since it runs locally, my machine needs to be on. Not a problem for me day-to-day, but it means no 3am automations unless I leave it running. (Could move to a VPS, but then I lose the local-data benefit.)
Setup complexity. The initial configuration takes time. Docker setup, API keys, Telegram bot registration, Gmail OAuth, iDoklad credentials. Once it's running, it's low-maintenance, but the first setup is a weekend project.
Maintenance. APIs change, packages need updates, things occasionally break. It's software — it needs care. Not a lot, but some.
Context limits. Despite the memory system, long conversations can still lose context. The daily-notes and CLAUDE.md help, but it's not perfect. I occasionally need to remind the assistant about something it should know.
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:
- Different chat platform? Swap Telegram for Discord, Slack, or WhatsApp (all supported out of the box)
- Different time tracking? Replace task-cli with Toggl, Harvest, or Clockify integrations
- Different invoicing? Replace iDoklad with Stripe, QuickBooks, FreshBooks, or whatever your country uses
- Different AI model? The Anthropic Agent SDK supports swapping models
- Different automations? Write your own skills for whatever repetitive work you do
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
After a few months of running this setup, here's what changed:
- Emails automatically become tasks — nothing falls through the cracks
- Morning briefings save 15-20 minutes daily — I start each day knowing exactly where things stand
- Invoicing takes 2 minutes instead of 30 — and I actually send invoices on time now
- Time tracking flows into invoicing — no more manual hour calculations
- Notes sync between phone and desktop instantly — ideas don't get lost
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.