Mein persönlicher Jarvis: Autonomer Antigravity AI-Agent mit Telegram-Gateway, Multi-Layer Memory & MCP

by · 25. August 2026

Stell dir vor, dein persönlicher AI-Coding- und Server-Assistent ist nicht an ein Terminalfenster oder eine Desktop-IDE gefesselt, sondern begleitet dich 24/7 in der Hosentasche – mit vollem Zugriff auf dein Homelab, persistentem Multi-Layer-Gedächtnis und einer nahtlosen Session-Übergabe zwischen Desktop und Smartphone.

Die meisten Entwickler kennen das Dilemma: Moderne AI-Agenten wie die Google Antigravity CLI (agy), Claude Code oder Aider sind im Terminal extrem mächtig. Sie analysieren Codebasen, führen Shell-Befehle aus, fixen Bugs und steuern Docker-Container. Doch sobald man den Schreibtisch verlässt – sei es für den Weg zur Arbeit, beim Einkaufen oder auf dem Sofa –, ist die Magie vorbei. Man ist wieder auf limitierte Web-Chatbots zurückgeworfen, die weder das eigene Dateisystem noch die laufenden Server-Dienste kennen.

In diesem Deep Dive zeige ich detailliert, wie ich ein vollständiges, sicheres und hochautonomes Agenten-Ökosystem aufgebaut habe. Das Setup verbindet die Google Antigravity CLI über ein maßgeschneidertes Telegram Gateway, eine SQLite-FTS5 Kognitions-Engine und ein modulares MCP-Nervensystem (Model Context Protocol) mit der realen Welt – abgesichert durch ein Tailscale Mesh-VPN ohne offene Internet-Ports.

1. Das Kernkonzept: Der Desktop-to-Mobile Handover

Das wichtigste Designziel war der nahtlose Kontextwechsel. Ein typischer Arbeitstag sieht so aus:

  1. Am Rechner: Ich starte eine komplexe Refaktorisierung oder ein Docker-Deployment im Terminal via agy.
  2. Unterwegs: Ich klappe das Notebook zu, steige in den Zug, öffne Telegram und tippe /resume.
  3. Fortführung in Echtzeit: Das Telegram-Gateway greift direkt auf dieselbe conversation_id im lokalen Brain-Speicher zu. Ich sehe den aktuellen Stand, kann Testergebnisse abfragen oder Folgeanweisungen geben – ohne den Kontext neu erklären zu müssen.

2. Die Systemarchitektur im Überblick

Das Gesamtsystem ruht auf vier eng verzahnten Säulen:

📱 TELEGRAM CLIENT (Mobile)
   │ (TLS / Telegram Bot API)
   ▼
🤖 AGY-TELEGRAM-BOT (Gateway Daemon auf Node.js 22 / TypeScript)
   ├── Interactive PTY Runner (Pseudoterminal & ANSI-Sanitizing)
   ├── Mobile Formatter (Markdown → HTML, Chunker, Math Clean)
   ├── Dynamic Quota Pacing (Budget-Puffer mit ⭐ / 🟢 / 🟡 / 🔴)
   └── SQLite Session & Task Queue Manager
   │
   │ (PTY Session / Headless Subprocess)
   ▼
🧠 ANTIGRAVITY CORE CLI (agy - Gemini 3.7 Pro / Flash)
   ├── Subagent-Orchestrierung (Planner, Self-Reflection, Worker)
   ├── Native Tools (Shell, Edit, Grep, Find, Task Manager)
   └── Sandboxing & Safety Guardrails
   │
   ├── [Sub-2ms Prefetch] ──► 💾 AGY-MEMORY-ENGINE (SQLite FTS5 in ~/.gemini/memory.db)
   │                          ├── Layer 1: Semantische Fakten & Stammdaten
   │                          ├── Layer 2: Narrative Episoden & Chroniken
   │                          └── Layer 3: Learnings & Heuristiken
   │
   └── [JSON-RPC Stdio] ────► 🔌 MCP NERVENSYSTEM (Model Context Protocol)
                              ├── Google Workspace (Mail Drafts, Kalender, Tasks)
                              ├── Home Assistant (Sensoren, Relais, Smart Home)
                              ├── Docker-Ops (Multi-Host Management via Tailscale SSH)
                              ├── Immich (AI Photo Search & Vision Analyse)
                              └── Postgres (TeslaMate Telemetrie & DBs)

3. Deep Dive: Das Telegram Gateway (agy-telegram-bot)

Das Gateway wurde in TypeScript auf Basis von Node.js 22 entwickelt. Es ist weit mehr als ein einfacher Webhook-Forwarder:

A. Der PTY-Runner für interaktive TUI-Kommandos

Antigravity besitzt interaktive Befehle wie /usage (Quota-Anzeige), /context (aktive Token-Verteilung) oder /credits, die als Terminal-UIs (TUI) gerendert werden. Ein normaler Subprozess liefert hier leere Ausgaben oder ANSI-Bruchstücke. Der integrierte pty-runner spawnt eine echte Pseudoterminal-Sitzung, wartet auf die Prompt-Bereitschaft, sendet Steuerzeichen und bereinigt Terminal-Escape-Codes:

export function cleanAnsi(text: string): string {
  return text
    .replace(/\][^]*(?:|\)/g, "") // OSC Sequenzen
    .replace(/\[[0-9;?:>=<!]*[ -/]*[@-~a-zA-Z]/g, "") // CSI Escape-Codes
    .replace(/[()#%*+-.][0-9a-zA-Z]/g, "")
    .replace(/
/g, "");
}

B. Mobiler Streaming-Formatter & LaTeX-Cleaning

LLM-Ausgaben auf dem Smartphone müssen perfekt lesbar sein. Der Formatter übernimmt entscheidende Aufgaben:

  • Telegram HTML Chunking: Nachrichten werden unter dem 4096-Zeichen-Limit an natürlichen Zeilenumbrüchen geteilt, ohne offene <code>– oder <pre>-Blöcke zu zerschneiden.
  • Tabellen zu Mobile Cards: Große ASCII-Tabellen werden automatisch erkannt und in übersichtliche Key-Value-Karten umgewandelt, damit auf dem Smartphone kein horizontales Scrollen nötig ist.
  • LaTeX-Bereinigung: Mathematische Ausdrücke wie ext{EUR} oder \ge werden in saubere Unicode-Zeichen konvertiert.

C. Dynamisches Quota-Pacing mit Puffer-Erkennung (⭐)

Um böse Überraschungen bei Rate-Limits zu vermeiden, berechnet das Gateway bei jedem Quota-Abruf die lineare Zeitkurve (5-Stunden-Fenster vs. Wochen-Fenster). Liegt der Verbrauch vor dem Budget, wird dies dynamisch signalisiert:

// Dynamische Ampel- und Puffer-Klassifizierung
if (actualPct < 10 || delta < -12) {
  indicator = "🔴"; // Kritisches Defizit
} else if (delta < -3) {
  indicator = "🟡"; // Hinter dem linearen Budget
} else if (delta >= 10) {
  indicator = "⭐"; // Großer komfortabler Puffer (>10% Vorsprung)
} else {
  indicator = "🟢"; // Im Plan [On track]
}

Beispiel-Ausgabe in Telegram:
📊 Models & Quota
• Weekly: 🟢 82% (in 140h 1m) [On track]
• 5-Hour: ⭐ 82% (in 1m) [+82%]

4. Deep Dive: Das Multi-Layer Langzeitgedächtnis (agy-memory-engine)

Klassisches Vector-RAG leidet bei persönlichen Assistenten oft unter Kontext-Verschmutzung: Unzählige semantisch ähnliche Textfragmente blähen den Prompt auf, ohne echten Mehrwert zu liefern. Die Lösung ist ein dreischichtiges SQLite-FTS5-Modell in ~/.gemini/memory.db:

SchichtTypInhalt & ZweckSuchstrategie
Layer 1Semantische FaktenAtomare Stammdaten, IP-Adressen, Server-Namen, Hardware-Specs, Benutzerpräferenzen.FTS5 Exact & Prefix Match
Layer 2Narrative EpisodenProjektverläufe, Vorgeschichten, Diskussionen, Haltungen (Stances) und Stimmungen.BM25 Ranking & Status-Filter
Layer 3Learnings & HeuristikenErfahrungswerte und Faustregeln («Simple first», «Mails immer als Draft», «XLSX vor CSV»).FTS5 Keyword-Cluster

Vor jedem Agenten-Turn feuert die Engine einen Sub-2-Millisekunden-Prefetch ab und injiziert nur die hochrelevanten Fakten und Heuristiken direkt in den System-Prompt. Dadurch weiß der Agent sofort, welche IPs die Docker-Hosts haben, welche Konventionen gelten und welche Vorlieben ich habe – ohne unnötige Token zu verbrennen.

5. Das MCP-Nervensystem: Wenn der Agent die reale Welt steuert

Über das standardisierte Model Context Protocol (MCP) dockt der Agent an meine gesamte digitale Infrastruktur an:

  • Google Workspace MCP: Termine im Familien- oder Arbeitskalender koordinieren, E-Mails durchsuchen und Antworten sicher als Entwurf vorbereiten.
  • Home Assistant MCP: Raumtemperaturen abfragen, Relais schalten, Automationen und Blueprints analysieren.
  • Docker-Ops MCP: Über Tailscale SSH Container-Logs über mehrere Hosts hinweg aggregieren, ungenutzte Images bereinigen und SQLite-Datenbanken (z. B. Paperless, Immich) per VACUUM optimieren.
  • Immich AI-Bridge: Durchsucht meine selbstgehostete Fotobibliothek in natürlicher Sprache, nutzt Vision-Modelle zur Analyse und erstellt auf Knopfdruck fertige Blog-Beiträge.
  • TeslaMate / PostgreSQL MCP: Echtzeitabfrage von Batteriezustand, Ladehistorie und Ladekosten direkt aus der Datenbank.

6. Sicherheit & Zero-Trust: Keine offenen Ports

Ein autonomer Agent mit Shell-Zugriff erfordert ein kompromissloses Sicherheitskonzept:

  1. Tailscale Mesh VPN: Der Server hat keine offenen Ports zum Internet. Alle Verbindungen zwischen Smartphone, Server und Homelab-Nodes laufen verschlüsselt über das Tailscale-Mesh.
  2. Striktes Telegram Allowlisting: Das Gateway akzeptiert ausschließlich Befehle von meiner explizit hinterlegten Telegram User-ID. Unbekannte Nutzer erhalten weder Antworten noch Fehlermeldungen.
  3. Human-in-the-Loop Guardrails: Kritische Aktionen haben Sicherheitsnetze. Ausgehende E-Mails werden ausschließlich als Draft angelegt. Datei-Löschungen landen im Papierkorb statt im digitalen Nirwana.
  4. Systemd User Daemon: Der Dienst läuft als unprivilegierter Benutzer mit automatischem Restart und Ressourcenbeschränkungen.

7. Blueprint: So baust du das Setup nach

Für alle, die ein ähnliches autonomes Setup aufsetzen möchten, hier die vollständige Schritt-für-Schritt-Anleitung:

Schritt 1: Telegram Bot anlegen

Erstelle bei @BotFather auf Telegram einen neuen Bot und notiere dir das TELEGRAM_BOT_TOKEN sowie deine persönliche numerische User-ID (z. B. via @userinfobot).

Schritt 2: Telegram Gateway klonen & konfigurieren

git clone https://github.com/ardiannurcahya/antigravity-cli-telegram-bot.git /opt/agy-telegram-bot
cd /opt/agy-telegram-bot
npm install
npm run build

Erstelle die Konfigurationsdatei unter ~/.config/agy-telegram/.env:

TELEGRAM_BOT_TOKEN=123456789:ABCdefGhIJKlmNoPQRstuVWXyz
ALLOWED_TELEGRAM_USERS=12345678
AGY_WORKSPACE=/home/ubuntu
AGY_ALLOW_FULL_CONTROL=true
AGY_PROGRESS_MODE=edit

Schritt 3: Als Systemd User Service einrichten

# ~/.config/systemd/user/agy-telegram.service
[Unit]
Description=Antigravity CLI Telegram Gateway
After=network-online.target
Wants=network-online.target

[Service]
Type=simple
WorkingDirectory=/opt/agy-telegram-bot
EnvironmentFile=%h/.config/agy-telegram/.env
ExecStart=/usr/local/bin/node /opt/agy-telegram-bot/dist/cli.js
Restart=always
RestartSec=5

[Install]
WantedBy=default.target
systemctl --user daemon-reload
systemctl --user enable --now agy-telegram.service
loginctl enable-linger ubuntu

Schritt 4: Kognitive Memory Engine einbinden

Die Memory Engine verwaltet das Multi-Layer-Gedächtnis in SQLite FTS5:

git clone https://github.com/sbolten/agy-memory-engine.git /opt/agy-memory-engine
cd /opt/agy-memory-engine

# Erste Stammdaten und Fakten in SQLite FTS5 anlegen (~/.gemini/memory.db)
python3 agy_memory.py add --id "homelab_server" --category "infra" --fact "Homelab Host läuft auf Linux im Tailscale Mesh" --keywords "server, ip, tailscale, homelab"

Schritt 5: Antigravity Skill für automatisches Gedächtnis aktivieren

Damit der Agent vor jedem Prompt automatisch die relevantesten Fakten und Learnings abruft, erstellen wir einen Skill unter ~/.gemini/config/skills/user-memory/SKILL.md mit dem Schalter always_on: true:

---
name: user-memory
description: Persistentes Multi-Layer Langzeitgedächtnis in SQLite FTS5 (~/.gemini/memory.db) mit dynamischem Prefetching via agy-memory-engine.
always_on: true
---

# User Memory & Cognitive Architecture
Vor jedem Turn ruft der Agent relevante Fakten und Heuristiken ab:
python3 /opt/agy-memory-engine/agy_memory.py prefetch "<query>"

Zusätzlich kann die Memory Engine als Standard-MCP-Server in der Antigravity-Konfiguration (~/.gemini/antigravity-cli/mcp_config.json) hinterlegt werden:

{
  "mcpServers": {
    "memory": {
      "command": "python3",
      "args": ["/opt/agy-memory-engine/agy_memory_mcp.py"]
    }
  }
}

8. Fazit: Ein neues Paradigma für persönliches Hacking

Die Kombination aus einem autonomen Coding-Agenten, einem nativen Messenger-Gateway und einem persistenten Langzeitgedächtnis verändert die Art und Weise, wie ich IT-Projekte und mein Homelab verwalte, grundlegend. Es fühlt sich nicht mehr an wie das Bedienen einzelner Tools, sondern wie ein Dialog mit einem kompetenten Kollegen, der rund um die Uhr einsatzbereit ist.

Hast du Fragen zur Architektur, zu einzelnen MCP-Servern oder zum Memory-Engine-Design? Schreib gerne einen Kommentar oder tausche dich mit mir aus!

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert

Henrik*Lena*Karin*Stephan
© Stephan Bolten / August 2017