FORGE OS
"The Autonomous Product Machine"
Von einzelnen Scripts zu einer eigenständigen Unternehmens-Platform — der komplette Neubau von FORGE.
Eigener Shop
Programmer · ...
→ Deploy → Revenue
Warum ein Neubau?
Das aktuelle FORGE-System ist eine Sammlung von Scripts. FORGE OS ist ein Produkt.
Heute — FORGE Scripts
- ✗Einzelne Python/Bash-Scripts ohne UI — kein Überblick
- ✗Kein zentrales Dashboard — Metriken nur manuell abfragbar
- ✗Agent-Koordination per tmux/Terminal — fehleranfällig
- ✗Keine Warenwirtschaft — Produkte auf 3 Plattformen nicht synchronisiert
- ✗Etsy und Whop als externe Plattformen — Plattform-Risiko, hohe Gebühren
- ✗Status nur in Markdown-Dateien — kein Live-State
- ✗Manuelle Deploy-Schritte — keine One-Click-Pipeline
- ✗Kein Finanz-Dashboard — P&L nur aus dem Kopf
- ✗API-Kosten nicht sichtbar — Budget-Kontrolle fehlt
FORGE OS — Unified Platform
- ✓Electron Desktop-App — alles an einem Ort, offline-fähig
- ✓Live-Dashboard — Revenue-Ticker, Agenten-Status, API-Kosten in Echtzeit
- ✓Agent-Console mit UI — Tasks senden, Logs lesen, ohne Terminal
- ✓Unified Produkt-Katalog — Etsy, Whop und eigener Shop synchronisiert
- ✓Eigener Storefront (forgeproject.eu) — keine Plattform-Abhängigkeit
- ✓Sprint-Board (Kanban) — Product Pipeline visualisiert
- ✓One-Click Deploy Pipeline — Research → Code → QM → Deploy
- ✓P&L Dashboard mit KI-Rechnungsparser — Steuern auf Knopfdruck
- ✓Anthropic + fal.ai Cost-Meter — Budget immer im Blick
Die drei Säulen von FORGE OS
Desktop-App + Backend-API + Web-Storefront — drei Systeme, ein Ökosystem.
FORGE CORE
Das lebende Dashboard — Paperclip-Style
- Alles tickt und dreht sich — Live-Metriken
- EUR heute / diese Woche / diesen Monat (Revenue-Ticker)
- Aktive Agenten + ihre laufenden Tasks in Echtzeit
- API-Kosten-Meter (Anthropic, fal.ai, Ideogram)
- Automation-Score — wie viel läuft ohne menschliche Eingriffe?
- Produkt-Pipeline Status (In Progress / QM / Live)
- Etsy + Whop + eigener Shop: Bestellungen live
FORGE STUDIO
Die Entwicklungsumgebung — Linear meets AI
- "New Product"-Wizard → KI generiert Briefing + Plan automatisch
- Sprint-Board (Kanban) für jedes Produkt in Entwicklung
- Agent-Console: Tasks an CEO/Programmer senden, Logs lesen
- Templates-Library — wiederverwendbare Projektvorlagen
- One-Click Deploy Pipeline mit Gate-System (QM → Security → Deploy)
- Build-Reports + QM-Reports direkt im UI
- Knowledge-Base Browser — Patterns + Learnings durchsuchen
FORGE STORE
forgeproject.eu — Live seit 2026-05-03
- ✓ Storefront live (Next.js 15, HTTPS)
- ✓ 158 Listings im Unified Katalog (Supabase)
- ✓ Stripe Checkout + Webhook + Download-Delivery
- ✓ Kunden-Emails via Resend (noreply@forgeproject.eu)
- ✓ 701 Produktbilder von Etsy importiert
- ✓ Kategorien: Grundschule, Hauptschule, Realschule, Bundle, SVG, Web, ...
- ✓ Admin Panel: Bild-Editor, Thumbnail-Positionierung, Mehrfachkategorien
- ○ Warenkorb, Rabattcodes, Kunden-Account (Backlog)
- ○ SEO, Analytics, Revenue Dashboard (Backlog)
System-Überblick
Alle Komponenten und ihre Verbindungen — von der Desktop-App bis zur Datenbank.
│ FORGE OS — SYSTEM ARCHITECTURE │
└─────────────────────────────────────────────────────────────────────────┘
┌──────────────────────────────────────────────┐
│ FORGE OS Desktop App (Electron + React) │
│ ┌─────────┐ ┌─────────┐ ┌───────────────┐ │
│ │ CORE │ │ STUDIO │ │ STORE │ │
│ │Dashboard│ │Sprint Bd│ │Product Mgmt │ │
└──┴────┬────┴─┴────┬────┴─┴───────┬───────┴──┘
↕ WebSocket + REST API ↕
┌──────────────────────────────────────────────┐
│ FORGE Backend API (FastAPI/Python) │
│ VPS 187.77.90.238 | Port 8700 (intern) │
└──────────────────┬───────────────────────────┘
↕ subprocess / HTTP ↕
┌──────────────────────────────────────────────┐
│ Bestehende FORGE Agenten │
│ CEO │ Planner │ Programmer │ QM │ Security │
│ Deploy │ Graphics │ Research │ Etsy │
└──────────────────┬───────────────────────────┘
↕ Read/Write (Markdown) ↕
┌──────────────────────────────────────────────┐
│ 🧠 FORGE BRAIN (Obsidian Vault) │
│ Projects/ │ Agents/ │ Knowledge/ │ Research/ │
│ VPS: /home/forge/brain/ ←→ Git ←→ Mac │
└──────────────────┬───────────────────────────┘
↕ Read/Write ↕
┌──────────┐ ┌──────────┐ ┌──────────────────┐
│ SQLite │ │ Supabase │ │ Firestore │
│ (lokal) │ │ (Cloud) │ │ (Dominium) │
└──────────┘ └──────────┘ └──────────────────┘
↕ nginx reverse proxy ↕
┌──────────────────────────────────────────────┐
│ FORGE Web Storefront (Next.js 15 — VPS) │
│ forgeproject.eu/shop │
└──────────────────────────────────────────────┘
Das kollektive Gedächtnis aller Agenten
Powered by Obsidian — jeder Agent liest und schreibt aktiv. Kein Silo, keine verlorenen Learnings.
A Was ist FORGE BRAIN?
Ein lebendiges Wissens-Repository — das sich mit jedem Agenten-Sprint automatisch aktualisiert.
FORGE BRAIN ist ein Obsidian-Vault als zentrales Knowledge-Repository für das gesamte FORGE OS-System. Alle Agenten schreiben ihre Ergebnisse direkt in den Vault — und lesen aktiv aus ihm, bevor sie einen neuen Task starten.
Damit entsteht ein kollektives Gedächtnis: Der Programmer Agent kennt die Fehler-Patterns des letzten Sprints. Der Research Agent weiß welche Produkte live sind. Der CEO Agent findet alle Entscheidungen mit einem Klick.
- Obsidian-Vault als zentrales Knowledge-Repository für alle Agenten
- Alle Agenten schreiben ihre Ergebnisse direkt in den Vault
- Alle Agenten lesen aktiv aus dem Vault bevor sie starten
- Ersetzt & erweitert: STATUS.md, CEO_LEARNINGS.md, knowledge/-Ordner
- Vernetzt: Projekte ↔ Produkte ↔ Agenten ↔ Patterns ↔ Research
- Graph View zeigt visuelle Verbindungen zwischen allem
💜 Warum Obsidian?
- Markdown-nativ — Agenten schreiben sowieso Markdown, kein Overhead
- Dataview Plugin — Vault wie Datenbank abfragen (SQL-ähnlich)
- Graph View — Alles vernetzt, keine Silos, visuelle Übersicht
- Local REST API Plugin — Agenten auf VPS können direkt schreiben (Port 27124)
- Backlinks — Automatische Verlinkung zwischen Notes ohne manuelle Arbeit
- Canvas — Visuelle Pipeline-Darstellung, Projekt-Boards
- Tags —
#active #draft #live #blocked #research - Läuft lokal — kein SaaS, kein Abo für Basis, volle Datenkontrolle
B Vault-Struktur
Klare Verzeichnisstruktur — jeder Agent hat sein eigenes Verzeichnis, alle Produkte und Projekte sind strukturiert.
├── 📁 Projects/
│ ├── active/ ← Laufende Projekte (CEO schreibt)
│ ├── completed/ ← Abgeschlossene Projekte
│ └── backlog/ ← Ideen & Backlog
├── 📁 Agents/
│ ├── CEO/ ← Entscheidungs-Log, Sprint-Notes
│ ├── Programmer/ ← Build Reports, Code-Patterns
│ ├── QM/ ← QM Reports, Test-Ergebnisse
│ ├── Security/ ← Security Findings
│ └── Research/ ← Daily Reports, Product Research
├── 📁 Products/
│ ├── etsy/ ← Listing-Daten, Performance, Revenue
│ ├── whop/ ← Whop Produkte + Stats
│ └── own-shop/ ← Eigener Shop (Phase 3)
├── 📁 Knowledge/
│ ├── patterns/ ← Fehler-Patterns (aus CEO_LEARNINGS)
│ ├── templates/ ← Wiederverwendbare Code-Templates
│ └── stack/ ← Tech-Stack Learnings
├── 📁 Finance/
│ ├── revenue/ ← Tägliche Revenue-Snapshots
│ └── costs/ ← API-Kosten, Hosting, Tools
├── 📁 Research/
│ ├── daily/ ← Tägliche Market Reports
│ └── products/ ← Produkt-Research Reports
└── 📁 Strategy/
├── decisions/ ← Wichtige Architektur-Entscheidungen
└── roadmap/ ← Roadmap-Dokumente
C Agent ↔ Brain Interaktionen
Was jeder Agent schreibt — und was er liest. Bidirektionaler Wissensfluss statt Einbahnstraße.
- Sprint-Notes + Entscheidungslog
- Strategie-Änderungen
- Neue Learnings aus Fehlern
- Gate-Freigaben + Ablehnungen
- Aktive Projekte aus Projects/active/
- Bekannte Patterns aus Knowledge/
- Letzten Research-Report
- Strategie-Dokumente
- Build Reports nach jedem Sprint
- Neue Code-Patterns + Snippets
- Tech-Schulden + bekannte Bugs
- Fix-Dokumentation
- plan.md aus Projects/active/
- Patterns aus Knowledge/patterns/
- Stack-Files aus Knowledge/stack/
- Frühere Build Reports
- Daily Reports in Research/daily/
- Produkt-Research Findings
- Trend-Erkenntnisse + Keywords
- Konkurrenz-Snapshots
- Bestehende Produkte aus Products/etsy/
- Aktive Projekte (keine Duplikate)
- Strategie-Ziele
- Frühere Research-Reports
- QM Reports (pass/fail) in Agents/QM/
- Gefundene Bugs + Root Cause
- Test-Coverage-Notizen
- Wiederkehrende Fehler-Patterns
- Build Report des Programmer Agent
- Bekannte Fehler-Patterns
- Frühere QM-Reports zum Projekt
- Security-Findings
- Listing-Performance in Products/etsy/
- Neue Keywords + Tags die funktionieren
- A/B-Test Ergebnisse
- Revenue-Snapshots pro Listing
- Produkt-Briefings aus Projects/
- Keywords aus Research/products/
- Bestehende Listing-Daten
- Strategie + Ziel-Nischen
Planner, Security, Deploy, Graphics, Whop — folgen demselben Muster. Jeder Agent hat sein Verzeichnis in Agents/ und schreibt seinen Output dort hin. Das Brain wächst mit jedem Sprint automatisch.
Prinzip:
Input aus Brain → Task ausführen → Output zurück ins Brain.
D Technische Anbindung
Vier Wege wie Agenten und FORGE OS auf den Vault zugreifen — je nach Kontext das richtige Mittel.
Obsidian Local REST API
- Community Plugin von coddingtonbear
- Port 27124 (lokal auf Mac)
- GET / POST / PUT Notes via HTTP
- FORGE OS Desktop App kommuniziert direkt
- Agenten auf VPS schreiben via API wenn Desktop läuft
Git-Sync (VPS ↔ Mac)
- Vault liegt auf Mac (primär)
- Git-Repo: auto-Push nach jedem Agent-Write
- VPS pulled regelmäßig oder via Webhook
- Agenten auf VPS schreiben ins lokale Git-Repo → auto-push
- Obsidian Git Plugin für Mac-Seite
Direkter Schreibzugriff (VPS)
- Vault-Pfad auf VPS:
/home/forge/brain/ - Entspricht dem Git-Repo das auf Mac gemountet ist
- Agenten:
open().write()auf Markdown-Dateien - Kein API-Overhead für Agent-Writes
- Schnellster Weg für automatische Schreiboperationen
FORGE OS Desktop Integration
- Brain-Tab in der App zeigt Vault-Inhalte
- Dashboard-Widget: wichtigste Notes inline
- "Neues Projekt" → erstellt Note in Projects/active/ automatisch
- Agent-Log schreibt gleichzeitig in Obsidian
- Suche über gesamten Vault direkt aus App
E Dataview-Beispiele
Dataview verwandelt den Vault in eine lebendige Datenbank — kein Code nötig, nur Query-Syntax in der Note.
TABLE status, revenue, platform
FROM "Products/etsy"
WHERE status = "live"
SORT revenue DESC
LIST
FROM "Agents/CEO"
WHERE contains(tags, "#decision")
SORT file.cdate DESC
LIMIT 10
TABLE agent, sprint, status
FROM "Agents/Programmer"
WHERE status != "completed"
Dataview als lebendige Datenbank: Mit diesen Queries entsteht automatisch ein Dashboard in Obsidian — alle live Produkte, offenen Sprints und Entscheidungen auf einen Blick. Kein manuelles Zusammensuchen, kein veraltetes STATUS.md.
F Migration Plan: Aktuell → FORGE BRAIN
Schrittweise Migration der bestehenden Datenstrukturen in den Vault — ohne Datenverlust.
| Aktuell (VPS) | → | FORGE BRAIN (Vault) |
|---|---|---|
| /home/forge/STATUS.md | → | Brain/Agents/CEO/sprint-log.md |
| /home/forge/CURRENT_STATUS.md | → | Brain/Agents/CEO/current-status.md |
| /home/forge/CEO_LEARNINGS.md | → | Brain/Knowledge/patterns/ (aufgeteilt) |
| /home/forge/knowledge/ | → | Brain/Knowledge/ (1:1 Migration) |
| /home/forge/research/daily/ | → | Brain/Research/daily/ |
| /home/forge/research/products/ | → | Brain/Research/products/ |
| /home/forge/gates/*_qm_*.md | → | Brain/Agents/QM/ |
| /home/forge/gates/*_security_*.md | → | Brain/Agents/Security/ |
| /home/forge/projects/*/plan.md | → | Brain/Projects/active/{name}.md |
| /home/forge/projects/*/build_report_*.md | → | Brain/Agents/Programmer/{name}-sprint-N.md |
Keine Breaking Changes: Die alten Pfade bleiben während der Übergangsphase parallel bestehen. Agenten werden schrittweise auf Brain-Paths umgestellt — pro Agent ein Sprint. Kein Big-Bang-Rewrite.
6 Kernmodule
Jedes Modul ist ein eigenständiger Bereich von FORGE OS — alle zusammen bilden das vollständige Betriebssystem.
Dashboard
Paperclip-Style Live-Metriken. Revenue-Ticker. Aktive Agenten mit Task-Status. API-Kosten-Meter. Automation-Feed zeigt was gerade passiert. Der Puls des gesamten Systems auf einen Blick.
Studio
Product Pipeline & Sprint-Board (Kanban). New Product Wizard mit KI-generiertem Plan. Agent-Koordination über UI statt Terminal. Templates-Library. One-Click Deploy mit Gate-System.
Store
Shopify-artiger eigener Storefront. Unified Produkt-Katalog über Etsy, Whop und eigenen Shop. Stripe-Zahlungen mit Auto-Delivery. Order Management und Kunden-Email-Automation.
Finance
Vollständiges P&L-Dashboard. KI-gestützter Rechnungs-Upload und -Parser. Steuer-Export für den Buchhalter (Bulgarien). Monats- und Jahresübersichten. API-Cost-Tracking.
Research
Integration der täglichen Research-Reports. Trend-Tracking und Keyword-Research-Dashboard. Konkurrenz-Monitor. Etsy- und Whop-Marktdaten. Automatische Produkt-Ideen aus Trend-Daten.
Agents
Vollständige Agent-Console. Task-Queue mit Priorisierung. Live-Logs aller laufenden Sub-Tasks. Performance-Metriken pro Agent. Token-Verbrauch und Kosten pro Agent und Task.
Technologieentscheidungen
Jede Wahl ist pragmatisch — schnell entwickelbar, bewährt, kompatibel mit dem bestehenden VPS-Setup.
| Bereich | Technologie | Begründung |
|---|---|---|
| Frontend / App | React 19 + Vite · Web-App | Web-App unter os.dominium-game.com — kein Electron-Overhead. Falls Desktop nötig: Tauri (entschieden). |
| Backend API | FastAPI (Python) | Bereits Python auf dem VPS, schnelle REST + WebSocket, async-fähig |
| Datenbank (lokal) | SQLite | Offline-fähig, kein Server nötig, perfekt für Desktop-App |
| Datenbank (Cloud) | Supabase | Bereits in Betrieb, PostgreSQL, Realtime-Subscriptions |
| Web Storefront | Next.js 15 (App Router) | SSR/SSG für SEO, Stripe-Integration, moderne React-Patterns |
| Zahlungen | Stripe | Industrie-Standard, einfache Digital-Delivery, PSD2-konform |
| Resend | Developer-friendly API, günstig, React Email-Templates | |
| Deploy | nginx + PM2 (VPS) | Bereits in Betrieb auf 187.77.90.238, kein Migrations-Overhead |
| Agent-Integration | HTTP API Wrapper | Dünner Wrapper um bestehende Scripts — kein Rewrite der Agenten nötig |
| State Management | Zustand (React) | Minimal, kein Boilerplate, perfekt für Desktop-App-Komplexität |
| Styling | Tailwind CSS | Schnell, konsistent, IDE-Unterstützung, kein CSS-Naming-Chaos |
| Desktop Build | electron-builder | macOS + Windows-Builds aus einem Setup, Auto-Updater eingebaut |
✓ Entschieden: Tauri (falls Desktop-App nötig)
Aktuell: FORGE OS läuft als Web-App unter os.dominium-game.com — keine Desktop-App nötig.
Falls Desktop-App: Tauri (nicht Electron) — 10× kleiner (~10MB), 3× weniger RAM, Rust-Backend, Secure by default, React 1:1 kompatibel.
→ Tauri entschieden. Umsetzung nur falls Desktop-Features zwingend nötig werden.
5 Phasen zum vollständigen FORGE OS
Von der API-Foundation bis zum autonomen "Paperclip Mode" — geschätzt 5+ Monate iterative Entwicklung.
- Backend API-Grundgerüst (FastAPI) ✓
- React Frontend + Deploy (os.dominium-game.com) ✓
- CEO Chat + Quick Dispatch + WebSocket Logs ✓
- Dashboard (Revenue, Agents, Queue, Brain) ✓
- SQLite Schema + Produkt-Datenbank
- Authentifizierung + lokale Verschlüsselung
- ✓ Product Pipeline Visualisierung (Kanban: pending / in_progress / waiting / blocked)
- ✓ Sprint-Board (Kanban-UI) — Task erstellen, Status ändern, Agent dispatchen
- ✓ Gate-System — /home/forge/gates/*.md — QM + Security Gates im UI sichtbar
- ✓ QM Agent + Security Agent — vollständige Code-Reviews mit Gate-Reports
- ✓ Task Drawer — Status-Switcher + Agent-Dispatch direkt im UI
- ○ Templates-Library (Backlog)
- ○ Build-Report-Viewer (Backlog)
- ✓ Supabase DB-Schema (products, orders, downloads, image_positions, categories)
- ✓ 158 Etsy-Listings → Supabase importiert
- ✓ FastAPI /api/products Router
- ✓ Store.jsx im FORGE OS Dashboard
- ✓ Next.js 15 Storefront (forgeproject.eu)
- ✓ SSL + Nginx (HTTPS live)
- ✓ Stripe Checkout Session (/api/checkout)
- ✓ Stripe Webhook → Order in Supabase
- ✓ Download-Token (UUID, 48h Expiry, max 5 Downloads)
- ✓ Resend: Bestätigungs-Email mit Download-Link
- ✓ /downloads/[token] — sicherer Download-Endpunkt (path-traversal-geschützt)
- ✓ 701 Etsy-Produktbilder heruntergeladen + lokal gespeichert
- ✓ ProductCard mit Next.js Image + Bildpositionierung
- ✓ Bildergalerie auf Produktdetailseite (ImageGallery + Thumbnails)
- ✓ Produktgruppen / Kategorien (Mathematik, Deutsch, Grundschule, Hauptschule, Realschule, Bundle, SVG & Design, Web Templates, Zertifikate)
- ✓ Mehrfachauswahl für Produktgruppen (ein Produkt in mehreren Gruppen)
- ✓ Shop-Startseite: Kategorie-Pills + Gruppen-Sections mit Vorschau
- ✓ Admin Panel (/admin) — Login, Produktliste, Bild-Editor
- ✓ Admin-Shop identisch zum echten Shop (gleiche Sortierung, Kategorien, Sections)
- ✓ Thumbnail-Editor: Drag zum Verschieben, Zoom, Schnellauswahl, Vorschau live
- ✓ Edit-Modal: Produktgruppe + Bild-Editor in einem Dialog
- ○ Etsy-Sync Cron (stündlich) — automatischer Abgleich neuer Listings
- ○ Revenue Dashboard — Etsy + Own Shop unified in FORGE OS
- ○ Bewertungen: Etsy-Reviews auf Produktseite anzeigen
- ○ Warenkorb: mehrere Produkte in einem Checkout
- ○ Rabatt-Codes via Stripe Promotion Codes
- ○ Kunden-Account: Download-Verlauf, Rechnungen
- ○ SEO: sitemap.xml, Open Graph, structured data
- ○ Analytics: Seitenaufrufe, Conversion-Tracking (Plausible)
- ○ Video-Upload: Produkt-Videos von Etsy übertragen
- ✓ P&L Dashboard — Gesamteinnahmen / Ausgaben / Net P&L
- ✓ Monatlicher Verlauf — CSS-Balkendiagramm (Einnahmen vs. Ausgaben)
- ✓ Ausgaben nach Anbieter — horizontales Balkendiagramm
- ✓ Verkaufshistorie — 76 Etsy-Einnahmen tabellarisch
- ✓ Ausgabenliste — 18 Posten (Anthropic, Tools, etc.)
- ○ KI-Rechnungsparser (Backlog)
- ○ Steuer-Export CSV/DATEV (Backlog)
- ○ API-Cost-Tracking live (Backlog)
- CEO Loop 24/7 (Paperclip Mode aktiv) ✓
- Auto-Product-Creation aus Trends
- Self-Optimization (Prompt-Tuning)
- Budget-gesteuerte Skalierung
- "Paperclip Mode" — läuft ohne Input
- Multi-VPS / Cloud-Skalierung
Ziel nach Phase 5: FORGE OS identifiziert profitables Nischen selbst, erstellt Produkte autonom, deployt sie und optimiert Listings — alles ohne menschlichen Input. Nur strategische Entscheidungen bleiben bei Neo.
Die Paperclip-Analogie
Autonome Maximierung — nicht von Büroklammern, sondern von digitalen Produkten und Revenue.
Der autonome Produktions-Loop
Das "Paperclip Maximizer"-Gedankenexperiment beschreibt eine KI, die autonom alle verfügbaren Ressourcen nutzt, um ihr Ziel (mehr Büroklammern) zu erreichen — ohne menschlichen Input.
FORGE OS überträgt dieses Prinzip auf digitale Produktentwicklung: Research findet profitable Nischen, Agenten erstellen Produkte, die Pipeline deployt und verkauft — Revenue finanziert mehr Produktion.
PAPERCLIP ORIGINAL
Ressourcen → Produktion → Büroklammern → Verkauf → mehr Ressourcen → mehr Büroklammern → ...
FORGE OS EQUIVALENT
Budget → Research → Idee → Code → QM → Deploy → Revenue → mehr Budget → mehr Produkte → ...
Unterschied zur echten Paperclip-KI: FORGE OS hat eingebaute Gates (Neo muss bestimmte Entscheidungen freigeben) — maximiert autonom, aber mit menschlicher strategischer Kontrolle. Paperclip-Effizienz ohne Paperclip-Risiko.
Verbundene Plattformen & Services
Alle externen Services die FORGE OS anbindet — als unified Layer.
"Der CEO delegiert — er wartet nie"
Der CEO Agent ist die einzige Kommunikationsschnittstelle. Er empfängt alle Tasks, analysiert sie, dispatcht sie in die Queue des zuständigen Agenten — und ist danach sofort wieder für neue Inputs bereit. Kein Blockieren, kein Warten. Jeder Agent hat seine eigene priorisierte Warteschlange.
CEO ist nie geblockt
- Task eingehend → CEO analysiert (< 100ms)
- Queue-Eintrag erstellen → CEO sofort frei
- Kein await, kein Warten auf Agenten-Ergebnis
- Jederzeit neue Tasks empfangen + dispatchen
- Parallele Eingaben werden sequenziell verarbeitet
Jeder Agent hat seine Queue
- FIFO-Prinzip (First In First Out) als Basis
- Prioritäts-Ebenen: critical / high / normal / low
- Max. Parallelität pro Agent konfigurierbar
- Programmer: max. 1 gleichzeitig, Research: max. 2
- Queue persistiert in SQLite — überlebt Neustart
CEO wird benachrichtigt, nicht geblockt
- Agent meldet Fertigstellung → CEO-Callback
- CEO entscheidet: nächsten Task dispatchen
- oder: Ergebnis auswerten + an User melden
- Fehler in Agent → CEO: retry / eskalieren
- Kritische Fehler → sofort Neo benachrichtigen
P Python — CEOHub Konzept
FastAPI Backend, VPS-seitig — verwaltet alle Agent-Queues
class CEOHub:
def receive_task(self, task):
agent = self.analyze(task) # < 100ms
queue = self.queues[agent]
queue.enqueue(task, priority=task.priority)
return "dispatched" # sofort frei
def on_agent_complete(self, agent, result):
self.notify_if_needed(result)
self.process_next(agent) # nächsten Task starten
JS JavaScript — Queue-State im Dashboard
Electron Frontend, Zustand Store — Live-Anzeige der Queue per WebSocket
const queues = {
programmer: { tasks: 2, active: true, current: "Sprint #47 — Dominium Fix" },
research: { tasks: 1, active: true, current: "Daily Report 2026-04-30" },
etsy: { tasks: 2, active: false, current: null },
graphics: { tasks: 1, active: false, current: null },
qm: { tasks: 0, active: false, current: null },
deploy: { tasks: 1, active: false, current: null },
}
// WebSocket empfängt queue_update Events → Zustand updated → React re-renders
P Queue-Priorisierung
| Priorität | Beispiel-Tasks | Verhalten |
|---|---|---|
| critical | Security Fail, Deploy-Block, Etsy-Listing-Fehler, Gate-Blockierung | Sofort an Queue-Anfang — unterbricht laufende low/normal Tasks |
| high | Neue Produkt-Erstellung, Sprint-Start, QM-Fix-Loop, Neo-Request | Nächster freier Slot — überholt normal + low Tasks |
| normal | Research-Report, Status-Update, Listing-Optimierung, Brain-Sync | Standard FIFO — wird in Reihenfolge abgearbeitet |
| low | Archivierung, Cleanup, optionale Verbesserungen, Log-Rotation | Nur wenn Queue leer — wird bei neuem high/normal Task verdrängt |
T Queue Tech Stack
Nächste Schritte
Konkrete Tasks die jetzt angegangen werden — in dieser Reihenfolge.
Entscheidung: Electron vs. Tauri ✓
Entschieden: Tauri falls Desktop-App nötig. Aktuell läuft FORGE OS als Web-App unter os.dominium-game.com — kein Desktop-App-Overhead nötig.
Domain: forgeproject.eu ✓ registriert + live
forgeproject.eu registriert bei inwx.de, SSL via Let's Encrypt, Next.js 15 Storefront live seit 2026-05-03.
FastAPI Backend auf VPS ✓
30+ Endpoints live auf Port 8700 (127.0.0.1). PM2-Prozess forge-os-backend. Nginx-Proxy mit HTTPS + Security Headers. API-Key-Auth auf allen Endpoints.
Web-App Frontend ✓ (statt Electron)
React 19 + Vite als Web-App unter os.dominium-game.com. Dark-Theme, Sidebar-Navigation, 12 Pages: CEO, Dashboard, Studio, Agents, Queue, Products, Kalender, Gmail, Brain, Store, Finance, Logs.
Etsy Revenue API-Integration ✓
Etsy Receipts API (/receipts?was_paid=true) — Einnahmen heute/Woche/Monat live im Dashboard. Korrekte Berechnung via grandtotal.amount/divisor. Receipts statt Ledger-Einträge.
CEO Agent via HTTP + WebSocket ✓
CEO Page mit Chat-Threads. claude --print via stdin (kein CLI-Argument). DISPATCH + DECISION Blöcke werden geparst. Automatische Brain-Logs. WebSocket live-streaming.
Produkt-Datenbank Schema ✓
Supabase PostgreSQL: products, orders, forge_downloads, image_positions, categories. 158 Etsy-Listings importiert. FastAPI /api/products Router live.
Obsidian Brain + Brain-Router ✓
Vault unter /home/forge/brain/ aktiv. FastAPI Brain-Router (/api/brain/status, /recent, /file). Agenten schreiben direkt in den Vault. Brain-Page im FORGE OS Frontend.
Vault-Struktur initialisiert ✓
/home/forge/brain/ mit 00-09 Ordnerstruktur (Projects, Agents, Products, Knowledge, Finance, Research, Strategy). Agent-Results in 02 - Agents/{Agent}/.
Obsidian Knowledge-Base befüllt ✓
YouTube-Transkripte (Olli Second Brain, KI-News), Projekt-Files, Agent-Ergebnisse. Automatische Transkription via Supadata API. Knowledge-Dateien verlinkt.
Migration alter Datenstrukturen → Brain ✓
STATUS.md + CEO_LEARNINGS.md in Brain-Vault migriert. Agenten schreiben Ergebnisse automatisch nach /home/forge/brain/02 - Agents/{Agent}/.
Agent Brain-Integration ✓
Alle Agenten lesen Brain-Kontext (max 3 Files) vor Task-Ausführung. ExecutorService lädt brain_service.get_context(). Ergebnisse werden via brain_service.write_result() gespeichert.
Kein AppImage nötig — Web-App statt Electron ✓
FORGE OS läuft als Web-App unter os.dominium-game.com. Kein Electron, kein AppImage, kein Signing-Overhead. Vite Build → /var/www/forge-os/ → Nginx.
Redis installiert + Queue-System live ✓
Redis auf 127.0.0.1:6379. Custom Python QueueService (redis-py) — kein Bull.js/Celery nötig. 9 Agent-Queues (FIFO + Priority). History, Cancel, Status-Endpoints. WebSocket live-updates.
Queue-Library Entscheidung: Custom Redis (Python) ✓
Weder Bull.js noch Celery — eigener leichtgewichtiger QueueService in Python (redis-py). ExecutorService startet claude --print via subprocess (stdin). Timeout 300s, Background-Threads.
FORGE STORE: Sprint 3 — Stripe Webhook + Auto-Download-Delivery
Stripe Webhook checkout.session.completed → forge_orders + forge_downloads (UUID-Token, 48h, max 5). Resend-Email mit Download-Link. Sicherer /downloads/[token]-Endpunkt (path-traversal-geschützt). upload_product_file.py Script für Datei-Upload auf VPS.
FORGE STORE: Sprint 4 — 701 Etsy-Produktbilder importiert
etsy_media_sync.py: Lädt Bilder aller 158 Produkte via Etsy API (x-api-key: keystring:shared_secret Format). Gespeichert unter /home/forge/forge-store/public/images/products/{listing_id}/{rank}.jpg. ProductCard.tsx mit Next.js Image + objectPosition/scale aus image_positions. ImageGallery.tsx mit Thumbnail-Leiste auf Produktdetailseite.
FORGE STORE: Produktgruppen + Admin Panel
9 Produktgruppen mit Auto-Erkennung aus Tags/Namen: Mathematik 🔢, Deutsch ✏️, Grundschule 🏫 (Kl. 1–4), Hauptschule 📚 (Kl. 5–8), Realschule 🎓 (Kl. 9–10), Bundle 📦, SVG & Design 🎨, Web Templates 🌐, Zertifikate 🏅. Mehrfachauswahl möglich. Admin Panel (forgeproject.eu/admin) mit Login, Shop-identischer Ansicht, Edit-Modal: Thumbnail-Drag/Zoom/Save + Gruppenauswahl. Link ins FORGE OS Dashboard eingetragen.
Gmail + Kalender Integration ✓
Gmail-Router (IMAP): Inbox lesen, Suche, Ordner, Mail-Body abrufen. Kalender-Router: Google Calendar API-Anbindung. Beide als eigene Pages im FORGE OS Frontend.
Security Hardening ✓
API-Key-Auth auf allen Endpoints (X-API-Key Header). Backend auf 127.0.0.1 gebunden. IMAP-Injection fix. Path-Traversal fix (is_relative_to). Rate-Limiting 60 req/min. WebSocket-Token-Auth. Nginx Security-Header (CSP, X-Frame-Options, etc.). CORS-Fix. CEO-Thread-Limit 200.
M4: Serviceaccount forge statt root
App läuft als root. Separaten forge-User anlegen, PM2 darunter betreiben, .env nach /home/forge/ verschieben, Claude CLI OAuth unter forge-User neu einrichten. Studio Task #124 — Priorität: High.