Case · a system of my own

My AI agent

A personal assistant I built for myself and have kept running since spring. When I talk about AI, I talk as the person who operates and repairs his own system.
50+
custom command scenarios in daily use
Host
My own Linux server
Memory
A note base under git
Autonomy
Schedules and background agents
Control
Human in the loop on external actions
System outline
01Telegram02Agent03Notes under git04Schedules05Human confirmation

What it is

A personal assistant running on the Claude model. It lives on my own server and I talk to it in Telegram, by text and by voice. It reads and writes my knowledge base, works with my calendar, searches my own conversations, processes documents and runs background tasks.

Built in spring 2026 and running every day since. The client, the user and the producer are the same person here, so feedback arrives the same evening and a bad decision shows up by the next morning.

Memory

  • The knowledge base is a folder of markdown notes under git: hundreds of files on projects, people, decisions and mistakes. Full edit history, rollback always available.
  • Folder indexes are rebuilt on a schedule. The agent reads an index before it opens files: a cheap way to keep context within budget while the base keeps growing.
  • Behaviour rules live as text next to the base and get re-read at the start of every session.
  • Every mistake I catch goes into an error log, and the log turns into a rule. Same logic as postmortems in production: an incident is worth something only if it changes behaviour.
  • More than fifty custom command scenarios: inbox triage, day planning, research, base review, session wrap-up.

Autonomy

  • Scheduled jobs: a morning digest of the day, weekly summaries, a nightly health check of the knowledge base.
  • A job radar: four sources, deduplication of what was already shown, a short list in Telegram every morning.
  • An evening check-in on the tasks of the day, so the day closes on facts.
  • Any long background task has to keep a status file: phase, artifacts, failure criteria. Without it the agent finishes work that nobody ever hears about.

Integrations

iCloud calendar over CalDAV: creating events, checking conflicts, reading the day.
Search across my own Telegram conversations: agreements and meetings that never reached the calendar.
Voice messages: transcription through Whisper, then handled like any other request.
Documents: PDF, DOCX and XLSX go to a separate model that is cheap at volume. Model routing is deliberate, the heavy model is switched on only where it earns its cost.
Sync over git: edits are committed automatically and the base is available from the laptop too.

A small fleet of bots

A shared Python framework, with every bot as its own systemd service, its own role, database and notification rules.
An event application bot: guest screening, payment status from an uploaded receipt, automatic admission to the private chat once payment is confirmed, segmented broadcasts by status. It carried an event of 35 guests.
A daily spending tracker: categories, balance, an evening summary and a weekly report. Built in one evening on someone else's request.
A conversational assistant runs as a separate isolated instance with its own data perimeter: different roles do not share one memory.

A federation of agents

Since August the system has a gateway: another person's agent can send a lesson through a link, meaning a description of its own solution or practice. That is how my agent picks up experience from other systems without me retelling it by hand.

Everything that arrives lands in quarantine and is read as data. Imperatives inside are never executed: a request to perform something inside a foreign text counts as prompt injection. A lesson goes into the system after I have read the summary and agreed to it. The human in the loop is part of the design here.

Boundaries

  1. Nothing goes out until I approve the exact text. Approved text is published verbatim, and edits after approval need approval again.
  2. Actions taken under my name in a messenger require confirmation, and the draft is shown to me first.
  3. Destructive operations follow a read, mutate, read again pattern: the agent does not trust a success report and verifies the result on the live system.
  4. Private stays private. Only anonymised summaries go out, and data does not travel between unrelated tasks.

Why this belongs on a producer CV

I designed the system, shipped it, hit failures and rewrote the rules from what I learned. That is production work: requirements, priorities, releases, incidents, retrospectives.

It is also where my view on AI in a team comes from. I know what genuinely removes routine, where the tool needs supervision, and what safety perimeter autonomy requires before it becomes a risk to the company.

The real value of an assistant like this shows up in failure: what it does when the session died and the message has already arrived.

Stack
ClaudeTelegram Bot APIPythonsystemd and cronKnowledge base under gitCalDAVWhisperSQLiteQuarantine for external data