Hermes Agent × E-Commerce — Was alles möglich ist

🎯

Paid Acquisition mit Hermes — Creative-Ops & Campaign-Monitoring für ~100k EUR/Mo Meta-Spend

Hermes verdrahtet den Meta-Ads-MCP (Insights, Ad Library, Entity-Updates) mit Cron + no_agent-Watchdogs, vision-Creative-Reading und Gateway-Delivery zu einem 24/7-Always-on-Ad-Ops-Layer — Anomalie-Alerts, automatische Reports und Competitor-Spying laufen ohne dich. Der LLM-Teuer-Teil läuft nur, wenn ein Trigger feuert; das reine Polling kostet $0.

5 Plays

Spend-Anomalie-Watchdog (Zero-LLM bis es brennt)

Heute lauffähig

Was es tutPollt alle 30-60 Min die wichtigsten Kampagnen-KPIs (Spend-Pacing, CPA, ROAS, Frequency) und pingt dich auf Telegram NUR wenn eine Schwelle reißt — z.B. CPA +40% ggü. 7-Tage-Baseline oder eine Adset-Spend-Spike, die das Tagesbudget vor 14 Uhr leerläuft.

Hermes-BausteineCron + no_agent=True (Watchdog-Script ruft Meta-Insights-Endpoint direkt), MCP(Meta-Ads) ads_insights_anomaly_signal + ads_insights_performance_trend, Gateway-Delivery deliver="telegram". Eskalation: wenn Anomalie feuert, startet ein zweiter Cron MIT Agent für Root-Cause.

Wie es läuftTrigger Cron every 30m → no_agent-Script zieht Insights-JSON, vergleicht gegen Baseline-Threshold im Script → bei Reißen: Direct-Push „⚠️ Adset X CPA 38€ (Baseline 24€), 71% Tagesbudget um 11:40 verbraucht" → optional Folge-Session liest mit ads_get_ad_entities die Breakdowns und schlägt Kill/Pause vor.

WertBei 100k/Mo = ~3.300€/Tag. Eine CPA-Entgleisung, die du heute 6h zu spät siehst, kostet schnell 500-1.500€ verbrannt. Ein Watchdog, der das in 30 Min statt am Abend fängt, amortisiert sich in der ersten Woche.

Aufwand & ReifeHeute lauffähig, ~3-4h (Script + Thresholds + Cron). Der no_agent-Pfad ist in der Doku explizit für genau diesen Watchdog-Use-Case dokumentiert.

Stolperfalleno_agent kann nur, was das Script fest verdrahtet — „intelligente" Schwellen (saisonale Baselines, Wochentags-Pacing) musst du im Script kodieren oder auf den teureren Agent-Pfad heben. Meta-API-Rate-Limits bei 30-Min-Polling auf vielen Adsets im Auge behalten.

Competitor-Ad-Spy Daily Digest (Ad Library + vision)

Heute lauffähig

Was es tutScannt täglich die Meta Ad Library für deine 5-10 Wettbewerber (Collagen/Supplements), erkennt NEU live geschaltete Creatives, liest sie per vision aus (Hook, Angle, Format, Offer) und liefert dir morgens einen Digest „was die Konkurrenz seit gestern testet".

Hermes-BausteineCron (every day 07:00), MCP(Meta-Ads) ads_library_search, ads_get_ad_preview, vision/Bildverstehen (Creative → Hook/Angle/Visual-Style strukturiert), delegate_task für paralleles Fan-out über mehrere Konkurrenten, Gateway-Delivery.

Wie es läuftTrigger 07:00 → delegate_task fan-out: pro Konkurrent ein Subagent → ads_library_search zieht aktive Ads → Diff gegen gestrigen Stand (in MEMORY/Datei) → für neue Creatives ads_get_ad_preview + vision-Analyse → Sammel-Digest „Marke Y, 3 neue Ads: UGC-Hook ‚Ich war skeptisch…', Rabatt 30%, 9:16 Video" nach Telegram/Notion.

WertDirekter Input für deinen Supamoe-Angle-Pool und dein eigenes Creative-Testing — du siehst Trends Tage früher als manuelles Ad-Library-Klicken. Spart 2-4h/Woche manuelle Recherche und füttert die Winning-Creative-Pipeline.

Aufwand & Reife~1 Tag inkl. Diff-Logik und vision-Schema. Lauffähig heute, wenn der Meta-Ads-MCP ads_library_search öffentliche Ad-Library-Daten liefert; alternativ browser-automation als Fallback auf die öffentliche Ad-Library-URL.

Stolperfallevision auf vielen Creatives täglich ist der teuerste Posten (token-hungrig) — limitiere auf NEUE Ads via Diff, sonst zahlst du jeden Tag für dieselben Creatives. Ad-Library-Abdeckung pro Land/Marke kann lückenhaft sein.

Auto-Performance-Report (Daily/Weekly, ein Code-Execution-Turn)

Heute lauffähig

Was es tutGeneriert jeden Morgen + montags einen sauberen Report über alle Kampagnen — Spend, ROAS, CPA, Top-/Flop-Creatives, Pacing vs. Monatsziel — als formatierte Nachricht plus optional Notion-Seite, statt dass du den Ads-Manager-Export selbst baust.

Hermes-BausteineCron (every day 08:00 / every monday), Code-Execution (execute_code zieht Insights, rechnet KPIs, baut Tabelle in EINEM Turn), MCP(Meta-Ads) ads_insights_performance_trend + ads_get_creative_ads, MCP(Notion) zum Ablegen, Gateway-Delivery.

Wie es läuftTrigger 08:00 → execute_code: holt Insights aller aktiven Kampagnen via RPC → rechnet CPC neu aus spend/clicks (nie raw vertrauen), Roll-up Account/Kampagne/Creative → rendert Markdown-Report + Top-3/Flop-3 → Push Telegram + notion-create-pages ins Reporting-Board.

WertSpart das tägliche manuelle Reporting (~30-45 Min/Tag = ~15h/Monat) und gibt dir konsistente, vergleichbare Zahlen statt Ad-hoc-Screenshots. Bei einem 100k-Account ist die Pacing-Sicht („on track für Monatsziel?") bares Geld wert.

Aufwand & Reife~1 Tag für den ersten sauberen Report, danach Wartung minimal. Heute lauffähig; execute_code kollabiert die Pipeline in einen LLM-Call, hält die Kosten klein.

StolperfalleMeta-Attribution-Fenster und API-Zahlen weichen vom Ads-Manager-UI ab (verzögerte Conversions) — den Report als „API-Sicht, t-1" labeln, sonst Diskussionen über „falsche" Zahlen. Gateway ist single-owner: gut für DICH/dein Team, kein Multi-Tenant-Kundenreport-Kanal.

Creative-Fatigue-Detector → Kill/Refresh-Vorschlag

Heute lauffähig

Was es tutÜberwacht laufende Ads auf Ermüdung (steigende Frequency, sinkende CTR, steigender CPA über die letzten 3-7 Tage) und schlägt pro Creative konkret vor: skalieren, refreshen oder killen — mit Begründung aus dem vision-Read des Creatives.

Hermes-BausteineCron (täglich), MCP(Meta-Ads) ads_insights_performance_trend + ads_get_ad_entities + ads_get_ad_preview, vision (warum ermüdet der Hook?), optional ads_update_entity für halbautomatisches Pausieren nach deiner Freigabe.

Wie es läuftTrigger täglich → pro aktiver Ad Trend-Slope über 7 Tage berechnen → Fatigue-Score (Freq > 3.5 UND CTR-Drop > 25% → kill-Kandidat) → vision liest Creative für Refresh-Hinweis → Push „Ad Z: Freq 4.1, CTR -31%, CPA +44% → killen; Hook abgenutzt, neue Variante mit anderem Opener testen" → auf dein „ok" ads_update_entity pausiert.

WertVerhindert das stille Verbrennen von Budget auf toten Creatives — bei 100k/Mo sind ermüdete Ads, die 3-4 Tage zu lang laufen, schnell ein vierstelliger Verlust/Monat. Plus direkter Refresh-Brief in deine Supamoe-Engine.

Aufwand & Reife~1-2 Tage (Fatigue-Heuristik kalibrieren ist die Arbeit). Lauffähig heute; halte das Pausieren mit Human-in-the-Loop, nicht vollautomatisch.

Stolperfalleads_update_entity schreibt live in den Account — eine falsche Schwelle pausiert einen Winner. Immer mit Bestätigungs-Gate fahren, nie den Agent autonom killen lassen. Pre-1.0 (v0.15.2): MCP-/Tool-Schemas können zwischen Releases brechen → Version pinnen.

Scale-Opportunity-Scout (was verdient mehr Budget?)

Heute lauffähig

Was es tutFindet täglich die Adsets/Creatives, die unter ihrem Potenzial budgetiert sind (starker ROAS, aber Budget-/Delivery-gedeckelt) und liefert eine priorisierte Skalier-Liste mit konkretem Budget-Vorschlag.

Hermes-BausteineCron (täglich), MCP(Meta-Ads) ads_get_opportunity_score + ads_insights_auction_ranking_benchmarks + ads_insights_industry_benchmark + ads_insights_performance_trend, execute_code für das Ranking, Gateway-Delivery.

Wie es läuftTrigger täglich → für jedes Adset Opportunity-Score + ROAS-Trend + Auction-Benchmarks ziehen → Kandidaten: ROAS > Ziel UND nicht budget-limitiert ausgereizt → execute_code rankt nach erwartetem Mehrumsatz → Push „Top-Scale-Kandidaten heute: Adset A +50% Budget (ROAS 3.8, stabil, unter Delivery-Cap), Adset B +20%".

WertDie teuerste verpasste Chance im Performance-Marketing ist nicht-skalierter Winner. Selbst 2-3 richtig getimte Budget-Pushes/Monat auf einem 100k-Account heben den Gesamt-ROAS spürbar — direkter Umsatzhebel, nicht nur Zeitersparnis.

Aufwand & Reife~1-2 Tage. Lauffähig heute, sofern der Meta-Ads-MCP ads_get_opportunity_score füllt (Meta liefert das nicht für jedes Konto/Objekt gleich gut — vorab gegen deinen Account testen).

StolperfalleSkalier-Empfehlungen sind nur so gut wie das Attributions-Signal; bei dünnen Conversion-Zahlen pro Adset wird das Ranking verrauscht. Erst ab ausreichend Conversions/Adset vertrauen, sonst skalierst du Rauschen. ---

Querschnitt-Hinweise (ehrlich)(1) Alle Plays hängen am realen Meta-Ads-MCP-Server — der ist hier angeschlossen (mcp__5c71da4f…__ads_*), aber pre-1.0-Hermes + Drittanbieter-MCP = Schemas pinnen, sonst brechen Cronjobs still. (2) Der Gateway ist single-owner — perfekt als DEIN internes Ops-Cockpit (Iron Brothers/Pur), ungeeignet als Multi-Tenant-Kundenkanal in Supamoe. (3) Kostenmodell stimmt: no_agent-Watchdogs = $0 bis Trigger; teuer wird nur vision-on-many-creatives und Agent-Folge-Sessions — über Diff/Thresholds gaten. (4) Diese Plays sind dein Ops-Layer NEBEN Supamoe — Supamoe baut Creatives, dieser Hermes-Layer betreibt und überwacht die Accounts.

🎨

Hermes für Creative- & Content-Produktion (D2C / Meta-Ads)

Mit Hermes lässt sich die komplette Creative-Pipeline — Inspiration-Scraping, Hook-/Angle-Generierung, On-Brand-Asset-Batches, Static→Motion-Ads — als wiederverwendbare Skill-Playbooks + Cron-Jobs betreiben, die direkt gegen Meta-Ads-MCP, vision_analyze und 11 FAL-Bildmodelle laufen. Ehrlich: image_generate ist text-to-image-only (kein Packshot-Editing ohne Workaround), token-hungrig und pre-1.0 — also als internes Ops-Tool für dich gebaut, nicht als Kundenkanal.

6 Plays

Winning-Ad-Decompiler → Hook/Angle-Batch (Konkurrenz-Scraping + vision_analyze)

Workaround

Was es tutScrapt täglich die Meta Ad Library nach Wettbewerber-Ads in deiner Collagen/Supplement-Kategorie, zerlegt die Top-Performer per Vision in Hook-Typ, Format, Claim, visuellem Aufbau und produziert daraus 20-30 neue Hook-/Headline-Varianten für DEINE Brands.

Hermes-Bausteineads_library_search (Meta-Ads-MCP, real in dieser Umgebung) + browser_navigate/browser_vision als Fallback für Screenshots + vision_analyze (Bildverstehen) + execute_code (pipeline in einem Turn) + Skill als wiederverwendbares Playbook + Cron (frische Session pro Lauf).

Wie es läuftCron 1×/Tag → ads_library_search zieht aktive Ads je Keyword/Konkurrent → vision_analyze klassifiziert jedes Creative (Hook-Kategorie, Pain-Point, CTA, visuelles Motiv) → execute_code aggregiert in Tabelle → LLM generiert N neue On-Brand-Hooks pro Cluster → Output als Markdown/CSV in Notion (notion-create-pages MCP) oder per Telegram-Push.

WertBei ~100k EUR/Mo Spend ist Creative-Velocity der Haupthebel — du startest jeden Morgen mit einem frischen, datenbasierten Hook-Pool statt mit leerem Blatt. Ein Winning-Hook mehr/Woche bei 0,1 Punkt besserer Hookrate bewegt vierstellige Summen/Monat.

Aufwand & Reife~1 Tag (Skill schreiben + Cron). Heute lauffähig — Meta-Ads-MCP und vision_analyze sind in dieser Umgebung real verfügbar.

StolperfalleToken-Kosten: Vision auf jedem gescrapten Creative summiert sich — auf günstiges Aux-Vision-Modell (Gemini Flash via OpenRouter, auxiliary.vision) routen, sonst läuft das auf Opus teuer.

On-Brand Background/Lifestyle-Batch-Generator (FAL × Brand-DNA-Skill)

Workaround

Was es tutErzeugt im Batch 30-50 On-Brand Lifestyle-/Hintergrund-Szenen pro Produkt (Gym, Küche, Morning-Routine für Collagen) in konsistentem Brand-Look, als Background-Layer für Static-Ads und Thumbnails — Iron-Brothers- vs. Pur-Look getrennt.

Hermes-Bausteineimage_generate (FAL: flux-2-pro für Photorealism / recraft-v4-pro für Brand-Systeme / nano-banana-pro für Text-im-Bild) + ein Brand-DNA-Skill (Farbwelt, Mood, Prompt-Bausteine als Markdown-Playbook) + delegate_task für paralleles Fan-out + execute_code für die Schleife.

Wie es läuftSkill /brand-bg iron-brothers lädt die Brand-Prompt-Tokens → execute_code baut Prompt-Matrix (Szene × Aspect-Ratio × Variation) → delegate_task fächert 40 image_generate-Calls parallel auf → Bilder lokal gespeichert (FAL-URLs sind temporär!) → vision_analyze filtert Off-Brand-Ausreißer automatisch raus → finaler Ordner.

WertStock-/Agentur-Backgrounds kosten Zeit und Geld; hier 40 brand-konforme Assets für ~1-2 EUR FAL-Kosten in Minuten. Direkt einsetzbar als Background-Pool für deinen Supamoe-Creative-Engine.

Aufwand & Reife~0,5 Tag (Brand-Skill ist die eigentliche Arbeit). Voll lauffähig heute.

Stolperfalleimage_generate ist text-to-image only — das Produkt selbst kann es NICHT realistisch reinrendern (kein Produkt-Composite). Es liefert Backgrounds/Szenen; das Produkt-Packshot musst du danach compositen (siehe nächster Play).

Static-Ad → Motion-Ad Animator (video_generate auf bestehende Creatives)

Workaround

Was es tutNimmt deine bestehenden Best-Performer-Static-Ads (Produktfoto/Packshot) und animiert sie zu 3-5s Motion-Clips (Zoom, Parallax, Produkt-Reveal) für Reels/Stories-Platzierungen — ohne Neuproduktion.

Hermes-Bausteinevideo_generate mit image_url (animiert ein Still; Backend wie Kling/Veo je nach Config) + vision_analyze (wählt animations-geeignete Frames) + Skill als Reel-Recipe + optional delegate_task für Batch.

Wie es läuftInput = Ordner mit Winning-Statics → vision_analyze prüft Eignung (Produkt klar freigestellt?) → video_generate(image_url=…, prompt="slow push-in, subtle product highlight") pro Asset → 4:5 + 9:16 Varianten → Output-Ordner für direkten Upload via ads_create_ad_video/Pool.

WertMotion schlägt Static auf Reels/Stories regelmäßig in Hookrate; aus 10 vorhandenen Statics werden 20 Motion-Varianten ohne Editor-Kosten. Reaktiviert bereits validierte Creatives in neuem Format = niedrigstes Risiko/höchste Trefferquote.

Aufwand & Reife~0,5 Tag. Lauffähig, sobald ein Video-Gen-Backend konfiguriert ist (video_generate nimmt image_url real — verifiziert).

StolperfalleVideo-Gen-Backend muss konfiguriert/bezahlt sein (Veo/Kling via FAL oder Grok-Imagine via xAI-OAuth); Kosten pro Clip deutlich höher als Bild — nur auf validierte Statics anwenden, nicht blind im Batch.

UGC-Skript- & Storyboard-Fabrik (Angle → Skript → Shotlist → Voiceover-Draft)

Workaround

Was es tutMacht aus einem Produkt-Angle ein komplettes UGC-Paket: 3 Skript-Varianten (Hook/Problem/Solution/CTA), Shotlist, B-Roll-Liste und einen TTS-Voiceover-Draft zum Vorhören — pro Brand-Voice getrennt.

Hermes-BausteineSkill ugc-script (Playbook mit deiner Brand-Voice + Hook-Frameworks) + text_to_speech (10 TTS-Provider, Voiceover-Preview) + ads_insights_performance_trend (zieht reale Winning-Angles aus dem Account als Input) + execute_code für strukturierten Output.

Wie es läuft/ugc-script collagen-angle="joint pain" → Skill lädt Brand-Voice → LLM generiert 3 Skript-Varianten + Shotlist → text_to_speech rendert Hook-Zeile als Audio-Preview → Paket als Markdown + MP3 → Telegram-Push an dich/Creator. Reale Performance-Daten via ads_insights_* priorisieren, welche Angles überhaupt verskriptet werden.

WertSkript-Briefing für Creator ist der zeitfressende Engpass — hier von 30 Min/Skript auf Minuten. Brand-Voice bleibt konsistent über alle Creator. Skaliert UGC-Output ohne Texter.

Aufwand & Reife~0,5 Tag (Brand-Voice-Skill ist der Wert). Heute voll lauffähig.

StolperfalleBrand-Voice-Qualität = Skill-Qualität; ein generischer Skill liefert generische Skripte. Einmalige saubere Kuratierung des Playbooks nötig, sonst „AI-Sound".

Creative-Fatigue-Watchdog → Auto-Variantenbrief (no_agent-Polling + Trigger)

Workaround

Was es tutÜberwacht laufende Ads auf Fatigue (Frequency hoch, CTR/Hookrate fällt) und löst bei Schwellwert automatisch einen Variantenbrief aus: was am müden Creative ändern (neuer Hook, neuer Background, neues Format) — bevor der CPA wegläuft.

Hermes-BausteineCron im no_agent-Mode (Zero-LLM-Polling, $0 bis Trigger feuert) + ads_insights_performance_trend/ads_insights_anomaly_signal (Meta-Ads-MCP) + bei Trigger normaler Agent-Turn mit vision_analyze aufs müde Creative + image_generate für sofortige Background-Alternativen.

Wie es läuftno_agent-Cron pollt alle 6h Frequency/CTR-Delta je Ad → unter Schwelle passiert nichts ($0) → bei Fatigue-Signal feuert echte Session: vision_analyze liest das müde Creative, LLM schlägt 5 konkrete Varianten vor, image_generate baut sofort neue Backgrounds → Brief + Assets per Telegram-Push.

WertFatigue zu spät erkannt = direkt verbranntes Budget bei 100k/Mo. Automatischer Frühwarn-Brief hält Refresh-Zyklen kurz und CPA stabil — der teuerste Fehler im Performance-Marketing wird systematisch abgefangen.

Aufwand & Reife~1 Tag (Schwellwert-Logik + Brief-Skill). Lauffähig — no_agent-Cron und die ads_insights_*-Tools sind real.

StolperfalleSingle-Owner-Gateway: läuft sauber als DEIN internes Ops-Tool, aber nicht als Multi-Brand-Mandantenlösung für Kunden — pro Account/Brand eigenes Hermes-Profil nötig (~/.hermes/-Profile), kein Mandanten-Layer.

Supamoe-Creative-Engine-Co-Pilot (Hermes als Batch-Generator hinter deinem SaaS)

Workaround

Was es tutHermes als headless Batch-Backend, das für Supamoe Trajektorien fährt: nimmt N Produkt×Angle-Kombinationen und produziert pro Kombo Hook+Background+Skript als strukturierten Output — zum Befüllen/Testen deines Creative-Pools at scale.

Hermes-BausteineBatch-Processing (batch_runner.py, JSONL rein → ShareGPT-Trajektorien raus) + OpenAI-kompatibler API-Server (Hermes als Endpoint, den dein Worker callt) + execute_code (Multi-Step in einem Turn) + die Skills aus den Plays oben als Bausteine.

Wie es läuftSupamoe-Worker schreibt JSONL (Produkt, Angle, Brand) → Batch-Runner fährt jede Zeile als isolierte Agent-Session durch die Creative-Skills → strukturierte Outputs (Hook/Background-Prompt/Skript) zurück in deine DB. Oder synchron: dein Worker callt Hermes' OpenAI-kompatiblen Endpoint pro Request.

WertDu dogfoodst Supamoes Pipeline an echten Brands und kannst Creative-Generierung at scale benchmarken, bevor du Modelle/Prompts in den Production-Worker gießt — direkter Input für deine eigene Roadmap.

Aufwand & Reife~2-3 Tage (Integration + Trajektorien-Auswertung). Lauffähig, aber Integrationsarbeit.

StolperfallePre-1.0 (v0.15.2, ~900 Commits/Woche) — Breaking Changes sind real; Version pinnen und Hermes als entkoppeltes Batch-Tool behandeln, nicht als harte Production-Dependency im Hot-Path deines SaaS.

🏷️

Katalog, Merchandising & PDP — Hermes im D2C-Shop

Mit Hermes lassen sich PDP-Anreicherung, Feed-Hygiene (Google/Meta Catalog) und Pricing-Intelligence als selbstlaufende Ops-Pipelines bauen — Shopify-MCP + web_extract + execute_code (Feed-Transforms) + image_generate + vision tragen das heute real. Single-owner-Gateway und token-Hunger sind die echten Grenzen, aber bei internem Ops-Einsatz (genau dein Fall) sind die irrelevant — die eine harte Hürde ist, dass execute_code nur auf Linux/macOS läuft, du also einen VPS- oder Docker-Backend brauchst statt des Windows-Hosts.

5 Plays

Catalog-Feed-Doctor (Meta + Google) — der Dauerläufer

Workaround

Was es tutZieht täglich die Catalog-Diagnostics aus Meta, kreuzt sie gegen den Shopify-Produktstamm, findet jedes disapproved/missing-field/falsch-gemappte Produkt und repariert die Quelle (Shopify-Metafeld/Feld) automatisch — statt dass tote Produkte still aus deinem DPA/Advantage+-Catalog fallen.

Hermes-BausteineCron + MCP(Meta-Ads: ads_catalog_get_diagnostics, ads_catalog_get_product_feed_details, ads_catalog_get_products) + MCP(Shopify Admin) + execute_code (Diff-Logik in einem Turn) + Messaging-Gateway (Telegram deliver_only für den Report).

Wie es läuftCron 06:00 → frische Session → ads_catalog_get_diagnostics für jeden Catalog → execute_code joint die disapproved/zero-impression-SKUs gegen Shopify-Felder (GTIN fehlt, google_product_category leer, availability falsch, Bild < 500px) → Shopify-MCP schreibt die Korrektur ins Produkt/Metafeld zurück → Push „14 SKUs gefixt, 3 brauchen manuell ein Bild" nach Telegram.

WertBei ~100k EUR/Mo Spend läuft ein erheblicher Teil über DPA/Advantage+ Shopping — jede stillschweigend disapproved Best-Seller-Variante ist direkter Umsatzverlust. Tägliche Auto-Heilung statt monatlichem Zufallsfund = realistisch 1–3% Catalog-Coverage zurück, plus du sparst die wöchentliche Catalog-Manager-Stunde.

Aufwand & Reife1–2 Tage. Heute lauffähig — die Meta-Ads-MCP-Catalog-Tools (ads_catalog_*) existieren real, Shopify-MCP via offizielle Skill/Server. Voraussetzung: execute_code-Backend auf Linux/Docker.

StolperfalleMeta-Ads-MCP-Schreibrechte auf Catalog-Feeds sind begrenzt — manche Korrekturen musst du an der Quelle (Shopify) machen, nicht im Catalog selbst; der Loop heilt also die Quelle, nicht den Feed direkt. Token-Kosten skalieren mit Katalog-Größe, daher die SKU-Diff in execute_code (ein Turn) statt LLM-per-Produkt.

Bulk-PDP-Rewrite mit Voice-of-Customer-Injektion

Workaround

Was es tutSchreibt für jede PDP Titel, Bullets, Description und SEO-Meta neu — aber nicht generisch, sondern gefüttert mit echten Review-/Reddit-/Amazon-Q&A-Phrasen deiner Kategorie, sodass die Copy in der Kundensprache spricht (genau die Angles, die bei Collagen auf Meta konvertieren).

Hermes-BausteineMCP(Shopify Admin: Produkte lesen/schreiben) + web_extract/firecrawl (Reviews + Amazon-Q&A scrapen) + execute_code (Batch über alle SKUs) + Skills (eigene pdp-rewrite SKILL.md als wiederverwendbares Playbook) + delegate_task (Fan-out: ein Subagent pro Produktgruppe parallel).

Wie es läuftTrigger manuell oder Cron → web_extract zieht Top-Reviews + „People also ask" für die Kategorie → execute_code clustert die wiederkehrenden Benefit-/Einwand-Phrasen → delegate_task fächert auf (z.B. 5 Subagents, je 40 Produkte) → jeder schreibt Titel/Bullets/Description mit den VoC-Phrasen + sauberer Keyword-Dichte → Shopify-MCP schreibt zurück, optional erst in ein „draft"-Metafeld zur Freigabe.

WertPDP-Copy-Refresh über 200+ SKUs ist sonst Agentur-Arbeit für 4-stellige Beträge oder wochenlang intern. Hier: ein Lauf. Die VoC-Injektion hebt Conversion messbar (gleiche Sprache wie deine Winning-Ad-Angles → konsistente Message-Match von Ad → PDP), was direkt deinen Meta-ROAS stützt, weil die Landingpage die Ad-Versprechen einlöst.

Aufwand & Reife2–3 Tage inkl. eigener Skill. Heute lauffähig. Der „draft-Metafeld + manuelle Freigabe"-Schritt ist empfohlen, nicht Pflicht.

StolperfalleToken-hungrigster Play hier — 200 PDPs × Rewrite ist real teuer; lös es über delegate_task mit günstigerem Modell pro Leaf-Agent und Caching der VoC-Cluster, nicht über das Frontier-Modell für jeden Bullet.

Hero-Image- & A+-Modul-Fabrik (vision-geprüft)

Workaround

Was es tutGeneriert für PDPs ohne saubere Lifestyle-/Infografik-Assets neue On-White-Hero-Shots, Benefit-Infografiken und Vergleichs-Module aus dem vorhandenen Produktbild — und lässt vision jedes Ergebnis gegen eine Checkliste prüfen (Produkt korrekt, Text lesbar, Markenfarben), bevor es live geht.

Hermes-Bausteineimage_generate (FAL.ai — Nano Banana Pro / FLUX / GPT-Image für produktgenaue Edits) + vision_analyze (QA-Gate) + MCP(Shopify Admin: Bild-Upload zur PDP) + execute_code (Batch über Produkte mit fehlendem 2./3. Bild).

Wie es läuftexecute_code listet PDPs mit < 3 Bildern → pro Produkt image_generate (Referenzbild + Brief: „Benefit-Infografik, Markenfarbe X, kein erfundener Text") → vision_analyze bewertet jedes Ergebnis (0/1 auf 5 Kriterien) → nur bestandene Assets gehen via Shopify-MCP in die Galerie, Rest landet im Review-Ordner → Telegram-Push mit Vorher/Nachher.

WertMehr/bessere PDP-Bilder = direkt höhere PDP-CR und niedrigere CPA, weil dieselben Assets als UGC-Alternative auch in den Ad-Pool wandern können. Spart pro Asset den Designer-Roundtrip (20–40 EUR + Tage Wartezeit) bei zig SKUs.

Aufwand & Reife2 Tage. Heute lauffähig — image_generate (FAL.ai, mehrere Modelle) und vision sind verifizierte Tools. Das vision-QA-Gate ist genau das Pattern, das ihr in Supamoes Creative-Engine schon kennt (SafeImage/onError-Denke), hier nur Ops-seitig.

StolperfalleGenau eure dokumentierte Gotcha #6 — Produkt-Appearance darf NUR aus dem Referenzbild kommen, nie aus LLM-Beschreibung, sonst wird die schwarze Pouch weiß. Das vision-Gate fängt das ab, ersetzt aber kein menschliches Final-Auge bei Hero-Bildern.

Lokalisierungs-Pipeline (DE → EU-Märkte, marktecht)

Workaround

Was es tutÜbersetzt + lokalisiert PDPs für neue Märkte (NL/FR/SE…) nicht wörtlich, sondern marktgerecht inkl. lokaler Maßeinheiten, Claim-Tonalität und Keyword-Recherche im Zielmarkt — und legt die Übersetzungen sauber in Shopify-Markets-Strukturen ab.

Hermes-BausteineMCP(Shopify Admin: Translations/Markets-Felder) + web_search/web_extract (Keyword-Recherche im Zielmarkt) + execute_code (Batch über SKU × Sprache) + Skills (localize-pdp Playbook pro Markt) + delegate_task (ein Subagent pro Sprache parallel).

Wie es läuftTrigger pro Markt → web_search holt die echten Suchbegriffe der Kategorie im Zielland → delegate_task: ein Subagent je Sprache → jeder übersetzt Titel/Bullets/Meta marktgerecht + setzt lokale Keywords → Shopify-MCP schreibt in die jeweiligen Translation-Felder/Market-Pages.

WertMarkteintritt ohne Lokalisierungsagentur. Eine saubere mehrsprachige Katalog-Basis ist Voraussetzung, um Meta-Spend international zu skalieren — ohne sie verbrennst du Budget auf Landingpages, die nicht in der Sprache des Marktes verkaufen. Pro Markt sparst du 4-stellige Agenturkosten und Wochen.

Aufwand & Reife2–4 Tage (pro Markt-Skill etwas Tuning). Heute lauffähig via Shopify-MCP-Translation-Mutationen.

StolperfalleQualität der maschinellen Lokalisierung schwankt pro Sprache — die starken Health-Claims (Collagen) brauchen ggf. marktspezifische Formulierung; setz hier ein draft-/Review-Gate, statt blind live zu pushen. (Compliance bleibt beim Kunden, aber sprachliche Marktechtheit willst du stichprobenartig prüfen.)

Pricing- & Lagerbestands-Watchdog (Zero-LLM bis es brennt)

Workaround

Was es tutÜberwacht Wettbewerberpreise + deine eigene Marge/Verfügbarkeit und alarmiert nur, wenn ein Best-Seller unterboten wird, ein Top-SKU low-stock geht (während er aktiv im Ad-Set läuft) oder eine Preisänderung deinen Ziel-ROAS kippt.

Hermes-BausteineCron im no_agent-Mode (Zero-LLM-Polling, kostet $0 bis ein Trigger feuert) + web_extract/firecrawl_monitor (Wettbewerber-PDP) + MCP(Shopify Admin: Inventar/Preis) + MCP(Meta-Ads: welche SKUs laufen gerade aktiv) + Messaging deliver_only (Direct-Push ohne LLM).

Wie es läuftno_agent-Cron pollt stündlich Wettbewerberpreise + Shopify-Stock → reine Schwellwertprüfung ohne Modell → erst wenn eine Bedingung kippt (Konkurrent −15%, Stock < X bei aktivem Ad-Set), wird eine echte Agent-Session geweckt, die Kontext zieht (welche Kampagne, welcher Hebel) und dir eine konkrete Handlungsempfehlung pusht.

WertDu verbrennst Meta-Budget, wenn ein beworbener Best-Seller out-of-stock geht oder preislich unterboten wird — der Klick ist bezahlt, die Conversion verloren. Ein Watchdog, der genau diese „Spend läuft, aber Produkt kann nicht konvertieren"-Momente abfängt, schützt bei 100k/Mo direkt vierstellige Beträge pro Vorfall. Und durch no_agent zahlst du nichts fürs Dauer-Polling.

Aufwand & Reife1–2 Tage. Heute lauffähig — no_agent-Cron und firecrawl_monitor sind real; die „aktive SKU"-Abfrage geht über Meta-Ads-MCP.

StolperfalleWettbewerber-PDPs scrapen ist fragil (Anti-Bot, Layout-Drift) — firecrawl_monitor/browser-Backend hilft, aber rechne mit gelegentlichem Selektor-Bruch; halte die Scrape-Skill pro Konkurrent als eigenes, leicht zu reparierendes Playbook. ---

QuervalidierungAlle genannten Tools sind in der Hermes-Doku verifiziert (web_extract, image_generate/FAL.ai, vision_analyze, execute_code, Cron inkl. no_agent, delegate_task, MCP stdio/HTTP mit Auto-Tool-Discovery, Skills/skill_manage, Messaging deliver_only). Die einzige echte Plattform-Grenze für dich: execute_code läuft nur auf Linux/macOS — auf deinem Windows-Host fällt Hermes auf sequentielle Tool-Calls zurück, daher die Feed-/Batch-Plays auf einem VPS- oder Docker-Backend fahren. Shopify- und Meta-Ads-Anbindung hängt an den jeweiligen MCP-Servern (Shopify offiziell vorhanden; Meta-Ads-MCP-Catalog-Tools ads_catalog_* real, aber mit eingeschränkten Schreibrechten auf Feeds → Quelle in Shopify heilen, nicht den Feed direkt).

💬

Customer Service / Support (Omnichannel) mit Hermes

Hermes' Messaging-Gateway (20+ Plattformen aus EINEM Prozess, per-chat session store) plus MCP(Shopify) und Memory machen aus einem $5-VPS einen omnichannel Support-Brain, der WISMO, Retouren und FAQ in jeder Sprache abfertigt. Die Single-Owner-Gateway-Auth zwingt dich aber zum Bridge-/Co-Pilot-Muster: Hermes als Backend hinter deinem Helpdesk oder als Agent-Assist fürs Team, nicht als roher Kundenkanal mit offener Tür.

5 Plays

WISMO-Resolver als Helpdesk-Backend (Bridge, nicht direkter Kundenkanal)

Riskant / später

Was es tutBeantwortet "Wo ist meine Bestellung?" automatisch über alle Kanäle — zieht Live-Order/Tracking aus Shopify, formuliert die Antwort in der Sprache des Kunden, und gibt nur unklare Fälle ans Team.

Hermes-BausteineMCP(Shopify) für Order/Fulfillment-Lookup + Memory (Mem0/Honcho als Kundenkontext-Provider) + execute_code (eine Pipeline: Order ziehen → Tracking-Status → Antwort bauen in einem Turn) + Messaging-Gateway (Email/WhatsApp/Telegram). Sprache: kein Tool nötig — das LLM antwortet in der Eingangssprache, du sagst es im System-Prompt.

Wie es läuftTrigger = eingehende Nachricht über Gateway ODER ein Webhook aus deinem Helpdesk (Gorgias/Zendesk/Shopify Inbox) leitet das Ticket an Hermes' OpenAI-kompatiblen API-Server. Hermes erkennt Order-Nr/Email → execute_code ruft Shopify-MCP (order, fulfillment, trackingInfo) → baut Antwort ("Paket ist seit gestern bei DHL, Zustellung morgen, hier dein Link") → schreibt sie als Ticket-Reply zurück. Confidence niedrig / kein Match → Eskalations-Tag ans Team.

WertWISMO ist 30-50% aller D2C-Tickets. Bei einem Shop mit ~100k/Mo Spend reden wir über tausende Bestellungen/Monat; 40% der Tickets vollautomatisch beantwortet = ein bis zwei Support-FTE-Äquivalente an Routinelast weg, Antwortzeit von Stunden auf Sekunden. Schnellere First-Response senkt Refund-Quote und WhatsApp-Eskalationen direkt.

Aufwand & Reife2-4 Tage. Heute lauffähig, WENN ein Shopify-MCP-Server läuft (offizieller Shopify-MCP existiert für Storefront/Admin-Reads; Fulfillment-Felder vorher gegen dein Setup grep/test). Gateway + execute_code + Memory sind alle Standard.

StolperfalleSingle-Owner-Gateway-Auth — du kannst NICHT einfach deine Shop-Telefonnummer auf Hermes' WhatsApp-Adapter legen und alle Kunden reinlassen (ein Owner-Account, kein Multi-Tenant-Mandantenmodell). Darum Bridge-Muster: Helpdesk bleibt vorne, Hermes ist das Reasoning-Backend dahinter.

EIN Posteingang über alle Kanäle (Team-Triage-Cockpit)

Riskant / später

Was es tutBündelt Telegram, WhatsApp, Email, Instagram-DMs etc. in einen einzigen Hermes-Prozess, der jedes eingehende Ticket vor-klassifiziert (Intent, Sprache, Dringlichkeit, Sentiment) und mit gezogenem Order-Kontext angereichert an dein Team-Postfach weiterreicht.

Hermes-BausteineMessaging-Gateway (per-chat session store, 20+ Adapter) + before_message Hook (Listen-only/Human-Handover-Policy, Doku-Zeile 14655) + MCP(Shopify) für Kontext-Anreicherung + delegate_task Fan-out (Klassifizieren, Order-Lookup und Übersetzung parallel pro Ticket).

Wie es läuftTrigger = Nachricht auf irgendeinem Kanal. before_message Hook entscheidet pro Chat: Bot antwortet (FAQ/WISMO) oder Mensch übernimmt (Listen-only-Fenster). Bei Handover postet Hermes eine angereicherte Karte in deinen internen Slack/Telegram-Ops-Channel: "DE-Kunde, frustriert, Order #1234 — Lieferung 6 Tage überfällig, Vorschlag: Ersatz + 10% Gutschein." Team antwortet, Hermes hält den per-chat Faden offen.

WertKein Tab-Wechsel zwischen 5 Inboxen, kein manuelles Order-Nachschlagen pro Ticket. Pro Ticket ~2-3 Min Recherche gespart; bei 50 Tickets/Tag = ~2 Std/Tag Team-Zeit. Der before_message Hook ist genau der Hebel, der die Single-Owner-Grenze in ein sauberes Co-Pilot-Modell verwandelt statt sie zu ignorieren.

Aufwand & Reife3-5 Tage (mehr Adapter = mehr Token-Tuning). Gateway, Hook und Delegation sind heute alle da. Instagram/Meta-DMs hängen an Plattform-Adapter-Verfügbarkeit — prüfen, sonst via Email-Bridge einhängen.

StolperfalleToken-hungrig — Gateway zieht 2-3x CLI-Tokens, und Pro-Ticket-Anreicherung mit delegate_task multipliziert das. Bei hohem Volumen ein günstiges Modell (Haiku/lokal) für Klassifikation routen, Top-Modell nur für die Antwort.

Retouren-/Reklamations-Triage mit Vision

Riskant / später

Was es tutKunde schickt Foto eines beschädigten/falschen Produkts; Hermes liest das Bild, validiert gegen die Order, entscheidet nach deiner Policy (Ersatz / Refund / Foto unzureichend) und bereitet die Aktion vor.

Hermes-Bausteinevision_analyze (Schadensbild verstehen) + Skill als Policy-Playbook (Markdown-Retouren-Regeln, auto zu Slash-Command, Curator-gepflegt) + MCP(Shopify) (Order/Produkt-Match, Refund/Replacement-Draft) + Memory (Wiederholungstäter/VIP-Flag).

Wie es läuftTrigger = Bild + Text im Retouren-Kanal. vision_analyze beschreibt den Schaden → Skill /retoure lädt deine Regeln (z.B. "Collagen-Pouch geplatzt → sofort Ersatz, kein Rücksendelabel; falsche Variante → Label + Refund") → MCP matcht gegen Order, prüft Bestelldatum/Reklamationsfenster → Hermes erstellt Refund-/Replacement-Draft und legt ihn dem Team zur Ein-Klick-Freigabe vor.

WertRetouren-Bearbeitung ist teuer und langsam. Auto-Triage + vorbereiteter Draft drückt die Handling-Zeit pro Fall von ~8 Min auf <1 Min Freigabe. Bei einem physischen Produkt (Collagen) mit Bruch-/Falschlieferungs-Quote summiert sich das, und die schnellere Lösung rettet die Wiederkaufrate.

Aufwand & Reife2-3 Tage inkl. Policy-Skill schreiben. Vision + Skills heute lauffähig; Refund-Ausführung hängt an Shopify-MCP-Write-Scope — bis dahin Draft-only und Mensch klickt.

StolperfallePre-1.0 (v0.15.2, ~900 Commits/Woche) — Vision- und MCP-Schemas können sich ändern; Version pinnen, sonst bricht dir die Foto-Pipeline still weg. Refund-Automatik NIE ohne menschliche Freigabe scharf schalten (Betrug/Fehlmatch).

Self-Maintaining FAQ-Brain mit Eskalation

Riskant / später

Was es tutBeantwortet wiederkehrende Produkt-/Versand-/Zahlungsfragen aus einer gepflegten Wissensbasis, eskaliert sauber an einen Menschen wenn unsicher, und lernt neue FAQ-Einträge aus echten gelösten Tickets.

Hermes-BausteineSkills (FAQ als Markdown-Playbooks, Curator pflegt + Agent kann via skill_manage neue schreiben) + Memory (MEMORY.md für stabile Markenfakten) + Messaging-Gateway + before_message Hook (Confidence-Gate → Handover).

Wie es läuftTrigger = Frage ("Ist das Collagen vegan?" / "Liefert ihr nach AT?"). Hermes matcht gegen FAQ-Skill → antwortet in Kundensprache. Kein Match / niedrige Confidence → Hook eskaliert an Team. Wöchentlicher Cron-Job (no_agent zum Sammeln, dann ein Agent-Lauf) scannt gelöste Eskalations-Tickets und schlägt neue FAQ-Skill-Einträge vor, die du freigibst.

WertFAQ ist nach WISMO der zweitgrößte Ticket-Block. 20-30% Deflection ohne Mensch, und das Selbst-Lernen hält die Wissensbasis aktuell ohne manuelle Pflege — die FAQ wächst mit dem Sortiment statt zu veralten.

Aufwand & Reife1-2 Tage Grundaufbau, dann läuft's selbst. Skills + Curator + Cron heute alle vorhanden.

StolperfalleDefault-Backend local = keine Sandbox; ein FAQ-Bot mit terminal/file-Tools im selben Prozess ist eine Angriffsfläche, wenn Kundeneingaben durchrutschen. Für kundenseitige Plays Toolset hart auf web/MCP/vision beschränken — kein shell/file im Support-Agenten.

Eskalations-Watchdog (Zero-LLM SLA-Wächter)

Riskant / später

Was es tutÜberwacht offene Tickets/Antwortzeiten und feuert eine Alarm-Push, sobald ein Ticket eine SLA-Schwelle reißt oder ein VIP/High-Value-Kunde wartet — ohne pro Polling-Lauf einen LLM zu bezahlen.

Hermes-BausteineCron mit no_agent=True (kostet $0 bis ein Trigger feuert, Doku-Zeile 11429) + Webhook-deliver_only (Zero-LLM-Direct-Push) + Messaging-Gateway als Push-Ziel (dein Ops-Telegram).

Wie es läuftno_agent Cron tickt z.B. alle 5 Min, ruft ein Script (Helpdesk-API: offene Tickets älter als X / VIP-Flag) → bei Treffer pusht es die Zeile direkt in deinen Ops-Channel ("3 Tickets >4h offen, davon 1 VIP — Order #5678"). Kein Agent-Turn, bis wirklich was brennt; erst dann optional ein voller Agent-Lauf zur Anreicherung.

WertSLA-Bruch = Refund-Anfragen, schlechte Reviews, Chargebacks. Ein $0-bis-Trigger-Watchdog fängt das ab, ohne deine Token-Rechnung mit Leerlauf-Polling zu fluten — billigster Hebel mit hoher Schutzwirkung.

Aufwand & ReifeWenige Stunden. Heute voll lauffähig, das ist der ausgereifteste Baustein hier (klassischer Watchdog-Use-Case).

Stolperfalleno_agent heißt kein Reasoning — das Script muss die Schwellenlogik selbst tragen (reines if/threshold). Braucht eine Helpdesk-API mit Ticket-Listing; wenn deine Inbox keine API hat, fehlt die Datenquelle. ---

Quer über alle Plays — die ehrliche Architektur-EntscheidungWegen der Single-Owner-Gateway-Auth ist Hermes hier KEIN direkter Kundenkanal, sondern (a) das Reasoning-Backend hinter deinem bestehenden Helpdesk via OpenAI-kompatiblem API-Server, oder (b) Agent-Assist im internen Ops-Channel fürs Team. Der before_message Hook ist der Schlüssel, der "Bot antwortet" vs. "Mensch übernimmt" pro Chat sauber trennt. Für kundenseitige Agenten: Toolset hart beschneiden (kein shell/file), Version pinnen (pre-1.0), und günstiges Modell für Klassifikation/teures nur für die finale Antwort routen, um die 2-3x Gateway-Token-Last zu zähmen.

🔁

Retention, Lifecycle & CRM mit Hermes Agent

Hermes kann den kompletten Post-Purchase- und Win-Back-Stack als autonome Cron-getriebene Pipeline betreiben — Replenishment-Reminder, Review-/UGC-Anfragen, Win-Back-Segmente und Loyalty-Nudges — und sendet outbound über Email (IMAP/SMTP), SMS/Voice (Twilio + Bland.ai/Vapi via telephony Skill) und WhatsApp direkt aus einem Prozess. Die Kundendaten kommen über das offizielle shopify Skill (Admin GraphQL via curl) und execute_code; Klaviyo bleibt der ehrliche Schwachpunkt (kein fertiger MCP — nur REST-via-curl-Workaround).

5 Plays

Supplement-Replenishment-Engine (Collagen-Nachkauf-Radar)

Workaround

Was es tutErkennt automatisch, welche Collagen-/Supplement-Kunden kurz vor dem Aufbrauchen ihrer Dose stehen (Kaufdatum + Packungsgröße = Verbrauchstag), und feuert einen personalisierten Nachkauf-Reminder über den Kanal, den der Kunde nutzt — bevor er zur Konkurrenz wechselt.

Hermes-Bausteinecronjob (täglich) + shopify Skill (Order-/Customer-GraphQL via curl) + execute_code (Python: Verbrauchsmodell rechnen, Segment bilden) + send_message/Email-Gateway + optional Twilio-SMS (telephony Skill).

Wie es läuftTrigger: Cron every 1d 08:00. Schritt 1: Shopify-Skill zieht alle Orders der letzten 90 Tage mit SKU + Menge + Kaufdatum. Schritt 2: execute_code rechnet pro Kunde nachkauf_tag = kaufdatum + (packungen × tage_pro_packung) − 7 und filtert alle, die heute ins 7-Tage-Fenster fallen. Schritt 3: Pro Treffer rendert der Agent eine kurze Mail/SMS mit Direkt-Reorder-Link (Shopify-Cart-Permalink) und sendet via Gateway. Output: Reorder-Welle + Log-Zeile pro Versand.

WertSupplements leben von Wiederkaufrate. Bei ~100k EUR/Mo Spend ist jeder Repeat-Buyer reiner Margenhebel ohne CAC. Wenn die Engine auch nur 5-10% der auslaufenden Kunden zurückholt, die sonst abwandern, ist das bei Collagen (hoher LTV, Abo-fähiges Produkt) ein vier- bis fünfstelliger Monatsbeitrag — und du zahlst 0 EUR Meta-CAC dafür.

Aufwand & Reife~1-2 Tage. Heute lauffähig: Shopify-Skill + Cron + Email-Gateway sind alle real. Twilio-SMS braucht einmalig Twilio-Account-Setup.

StolperfalleDas Verbrauchsmodell ist nur so gut wie deine SKU→Tage-Mapping-Tabelle; die musst du pflegen. Und: Shopify-Skill arbeitet via curl/GraphQL — bei großen Stores Rate-Limits und Pagination im execute_code-Schritt sauber abfangen, sonst bricht der Lauf mittendrin ab. ---

Win-Back-Kaskade mit Voice-Call-Eskalation für High-LTV-Schläfer

Workaround

Was es tutSegmentiert lapsed Customers (z.B. 90/120/180 Tage kein Kauf) und fährt eine mehrstufige Win-Back-Kaskade — Email → WhatsApp/SMS → bei Top-LTV-Kunden sogar ein KI-Voice-Call (Bland.ai/Vapi) mit persönlichem Comeback-Angebot.

Hermes-Bausteinecronjob (wöchentlich) + shopify Skill (LTV/letztes Kaufdatum) + execute_code (LTV-Tiering + Kaskaden-Stufenlogik) + Email/WhatsApp-Gateway + telephony Skill (Bland.ai/Vapi für Outbound-AI-Calls bei Tier-1).

Wie es läuftTrigger: Cron every 1 week. Schritt 1: Shopify-Skill liefert je Kunde last_order, total_spent, order_count. Schritt 2: execute_code bildet Tiers (Tier 1 = LTV > X & lapsed; Tier 2/3 darunter) und ordnet jedem die nächste Kaskaden-Stufe zu (Tag 90 = sanfte Mail, Tag 120 = WhatsApp + Rabatt, Tag 180 Tier-1 = Voice-Call). Schritt 3: Email/WhatsApp via Gateway; für Tier-1-Voice ruft das telephony Skill Bland.ai mit einem Gesprächs-Skript + Kunde-Kontext auf. Output: kanalgestaffelte Reaktivierungs-Welle, dokumentiert pro Kunde.

WertWin-Back-Kunden konvertieren um ein Vielfaches günstiger als kalte Meta-Acquisition. Ein einziger reaktivierter High-LTV-Collagen-Kunde mit Abo-Verhalten ist oft mehr wert als 10 Neukunden. Der Voice-Call-Layer ist ein Differenzierer, den fast kein D2C-Shop fährt — extrem hohe Reaktivierungsquote bei Tier-1.

Aufwand & ReifeEmail/WhatsApp-Stufe: ~2 Tage, heute lauffähig. Voice-Stufe: +1 Tag plus Bland.ai/Vapi-Account und ein getestetes Skript. Erst klein pilotieren (10-20 Tier-1-Kontakte).

StolperfalleWhatsApp läuft über die unofficial Node-Bridge, nicht über die Meta WhatsApp Business API — für hochfrequente Marketing-Blasts ist das ban-anfällig. Win-Back niedrigvolumig und konversationell halten, nicht als Massen-Broadcast missbrauchen. Voice-Calls außerdem rechtlich nur mit Opt-in/Bestandskunden-Bezug. ---

Post-Purchase Review-/UGC-Harvester mit Vision-Qualitätsfilter

Workaround

Was es tutBittet X Tage nach Lieferung automatisch um eine Review und ein Foto/Video des Produkts im Einsatz — und nutzt Vision, um eingehende UGC-Bilder direkt nach Verwertbarkeit für Ads zu bewerten und die Top-Treffer für dein Creative-Team (bzw. Supamoe) zu sortieren.

Hermes-Bausteinecronjob (täglich) + shopify Skill (Fulfillment-/Delivery-Datum) + Email/WhatsApp-Gateway (Anfrage raus) + Email-Gateway inbound + vision_analyze (UGC-Bewertung) + execute_code (Scoring + Ablage).

Wie es läuftTrigger: Cron every 1d. Schritt 1: Shopify-Skill liefert Orders mit Status delivered vor genau N Tagen. Schritt 2: Agent sendet die Review-/UGC-Bitte (mit direktem Foto-Upload-Link oder „antworte einfach mit deinem Foto"). Schritt 3: Eingehende UGC-Mails laufen über den Email-Inbound-Kanal; vision_analyze bewertet jedes Bild (Lichtqualität, Produkt sichtbar, Gesicht/Hände, Ad-Tauglichkeit) und vergibt Score. Schritt 4: execute_code legt Top-Bilder + Metadaten in einen Ordner/Sheet für dein Creative-Team. Output: laufender Review-Strom + kuratierte UGC-Pipeline.

WertUGC ist der teuerste Engpass im Performance-Marketing — frische, authentische Creatives killen Ad-Fatigue. Eine automatische Harvesting-Maschine, die UGC noch vorsortiert, spart dir Agentur-/Briefing-Kosten und füttert direkt Supamoes Creative-Engine. Mehr Reviews = bessere Conversion-Rate auf der PDP = günstigerer Meta-ROAS auf demselben Spend.

Aufwand & Reife~2-3 Tage. Outbound + Vision-Scoring heute lauffähig. Der inbound UGC-Empfang über Email ist real, aber das Foto-Handling (Attachment-Extraktion, Zuordnung zur Order) ist der fummelige Teil — sauber bauen.

StolperfalleVision-Scoring auf jedem eingehenden Bild kostet Tokens; bei Volumen den Lauf batchen und nur Bilder über Mindestauflösung durch Vision schicken. Zuordnung Foto→Order ist nur zuverlässig, wenn der Kunde im selben Thread antwortet — sonst Matching-Heuristik nötig. ---

Loyalty-Tier-Watchdog mit Zero-Token-Push

Workaround

Was es tutÜberwacht VIP-/Loyalty-Schwellen (z.B. „3. Bestellung erreicht" oder „1.000 EUR Lifetime") und schickt dem Kunden automatisch eine Belohnung/Anerkennung — und dir intern eine Heads-up — bei den meisten Läufen komplett ohne LLM-Kosten.

Hermes-Bausteinecronjob mit no_agent=True (Zero-Token-Polling) + shopify Skill im Script + send_message/hermes send mit deliver_only (Zero-LLM-Direct-Push) + Email/WhatsApp-Gateway.

Wie es läuftTrigger: Cron every 1d als no_agent-Job. Das Skript zieht via Shopify-Skill die Lifetime-Werte, vergleicht gegen Schwellen, und für jeden frischen Schwellen-Übertritt rendert es eine fixe Nachricht („Du bist jetzt Gold — hier dein VIP-Code") und pusht sie via deliver_only direkt raus. Kein Agent-Loop, solange nichts triggert. Output: automatische Tier-Upgrades + interner Alert.

WertLoyalty-Recognition zum richtigen Moment erhöht Repeat-Rate und durchschnittliche Order-Frequenz — und kostet im no_agent-Modus praktisch nichts im Betrieb (du zahlst nur, wenn wirklich jemand eine Schwelle reißt). Das ist der billigste Retention-Hebel im Stack, läuft 24/7 ohne Aufsicht.

Aufwand & Reife~1 Tag. no_agent + deliver_only sind beide verifiziert real. Die Tier-Logik ist simple Schwellenarithmetik im Script.

Stolperfalleno_agent/deliver_only heißt: keine LLM-Personalisierung zur Laufzeit — die Nachricht muss vollständig vom Script determiniert sein (Templates mit eingesetzten Werten). Für „echt individuell formulierte" Loyalty-Mails brauchst du den normalen Agent-Modus und zahlst Tokens. Außerdem: De-Dupe-State (wer schon ge-upgradet wurde) muss das Script selbst persistieren, sonst Doppel-Sends. ---

Segment-Health-Cockpit (täglicher CRM-Pulscheck auf dein Telegram)

Workaround

Was es tutLiefert dir jeden Morgen einen kompakten Retention-Report auf Telegram — Repeat-Rate-Trend, Anzahl lapsed Customers nach Tier, fällige Replenishments heute, neue VIPs — damit du CRM steuerst statt nur Meta-Dashboards zu starren.

Hermes-Bausteinecronjob (täglich) + shopify Skill + execute_code (Kennzahlen-Aggregation in einem Turn) + Home-Channel-Delivery auf Telegram; optional ads-MCP (Meta-Ads) für CAC-Gegenüberstellung.

Wie es läuftTrigger: Cron every 1d 07:30. execute_code kollabiert die ganze Analyse in EINEN Turn: Shopify-Orders ziehen, Kohorten/Repeat-Rate/lapsed-Counts/heutige Replenishment-Fälligkeiten rechnen, kurzen Markdown-Report bauen. Optional zieht der Meta-Ads-MCP den aktuellen Blended-CAC dazu, sodass du „Retention-Wert vs. Acquisition-Kosten" nebeneinander siehst. Output: ein Telegram-Briefing, das du beim Kaffee liest.

WertDu steuerst ~100k EUR/Mo Acquisition, aber Retention läuft bei den meisten D2C-Brands blind. Ein täglicher Puls macht abwandernde Kohorten und Replenishment-Lücken sichtbar, bevor sie zu Umsatz-Löchern werden — und zeigt dir, wann sich Retention-Push mehr lohnt als noch mehr Meta-Budget.

Aufwand & Reife~1 Tag für die Shopify-only-Version (heute lauffähig). Die Meta-Ads-Ergänzung hängt davon ab, dass dein Meta-Ads-MCP-Zugang sauber konfiguriert ist.

Stolperfalleexecute_code mit max_tool_calls-Limit (Default 50) — bei großen Stores die Shopify-Pagination im Python-Code bündeln, nicht als 100 Einzel-Tool-Calls, sonst läuft der Turn ins Limit. ---

Ehrlicher Gesamt-Caveat (gilt für alle Plays)Der größte strukturelle Bruch ist Klaviyo — es existiert kein fertiger Klaviyo-MCP oder -Skill in Hermes. Wenn dein CRM-of-record Klaviyo ist, baust du die Anbindung über Klaviyos REST-API via curl/generischem MCP selbst (machbar, aber Eigenbau). Sauberster Pfad heute: Shopify als Datenquelle (offizielles Skill) + Hermes-Gateways als Sende-Layer. Zweitens: das Gateway ist single-owner-authentifiziert — perfekt für dich als Operator, der die Flows intern betreibt, aber es ist KEIN Multi-Tenant-Kundenkanal; jeder Kunde, der zurückschreibt, landet in deinem einen Posteingang. Und drittens: Hermes ist pre-1.0 (v0.15.x, hohe Commit-Frequenz) → Version pinnen und Flows nach Updates retesten, bevor du sie auf echte Kundenlisten loslässt.

📊

Analytics, BI & Reporting mit Hermes Agent für D2C / Performance-Marketing

Hermes kollabiert "Meta-Ads + Shopify-Daten ziehen → rechnen → liefern" in einen einzigen execute_code-Turn und pusht das Ergebnis per Cron auf Telegram — das tägliche Dashboard-Starren wird zur 7-Uhr-Pushnachricht. Parallel laufen no_agent-Watchdogs (Zero-Token bis ein Trigger feuert), die bei Spend-Spike / ROAS-Drop / Conversion-Bruch sofort alarmieren, plus Ad-hoc-Datenfragen in natürlicher Sprache statt SQL-Tickets.

5 Plays

KPI-Morgenbriefing um 7:00 (Meta × Shopify, ein Turn)

Heute lauffähig

Was es tutJeden Morgen ein konsolidiertes Briefing über alle Accounts (Iron Brothers + Pur): Spend, ROAS, CPA, CTR, CPC, AOV, Blended-ROAS (Meta-Spend vs. Shopify-Umsatz), Top-3- und Flop-3-Ads von gestern — als eine Telegram-Nachricht.

Hermes-BausteineCron (every 1d at 07:00) + execute_code (Python in einem Turn) + MCP Meta-Ads (ads_insights_performance_trend, ads_get_ad_entities, ads_get_ad_accounts) + MCP Shopify (shopify-admin-execution, Orders/AOV GraphQL) + Messaging-Gateway (deliver="telegram").

Wie es läuftCron-Trigger 07:00 → frische Session → ein execute_code-Block holt via RPC Meta-Insights (gestern + 7-Tage-Trend) und Shopify-Orders, rechnet Blended-ROAS = Shopify-Revenue / Meta-Spend selbst (nie incoming raw values trusten), formatiert kompaktes Markdown → Gateway pusht nach Telegram. Antwortest du in Telegram ("warum ist CPA bei Collagen hoch?"), läuft die Folgefrage in derselben Session weiter.

WertBei ~100k EUR/Mo Spend ersetzt das 20-30 Min manuelles Ads-Manager-+-Shopify-Zusammenklicken pro Tag = ~10 h/Monat. Wichtiger: Du siehst den Blended-View (den Meta dir nie zeigt) jeden Morgen vor dem ersten Kaffee, statt erst beim Monatsreport.

Aufwand & Reife~0,5-1 Tag. Heute lauffähig — Meta-Ads-MCP und Shopify-Admin-Skill existieren real (liegen mir hier vor); Cron + execute_code sind Kern-Features.

StolperfalleDer vollständige Agent-Turn (nicht no_agent, weil er rechnen/formatieren muss) kostet Tokens — Gateway-Overhead ist real, rechne mit moderatem täglichem LLM-Verbrauch. Halte das Briefing knapp (Zahlen, kein Prosa-Roman), dann bleibt der Turn günstig.

ROAS/Spend-Anomalie-Watchdog (alle 30 Min, Zero-Token bis es brennt)

Heute lauffähig

Was es tutÜberwacht intraday, ob Spend über Budget-Pacing schießt, ROAS unter Schwelle fällt oder die Conversion-Rate bricht (Pixel feuert nicht mehr) — und alarmiert SOFORT, nicht erst im Morgenbriefing.

Hermes-BausteineCron mit no_agent=True (Zero-LLM-Polling, kostet $0 bis ein Trigger feuert) + Watchdog-Script, das die Meta-Graph-API / ads_insights_anomaly_signal abfragt + deliver="telegram". Für den reinen Alert-Push: deliver_only=true (sub-sekunden, zero LLM cost).

Wie es läuftcronjob(action="create", schedule="every 30m", script="roas-watchdog.sh", no_agent=True, deliver="telegram"). Das Script pollt heute-Spend + Conversions, vergleicht gegen Schwellen (z.B. ROAS < 1.5 ODER Spend-Lauf > 130% des erwarteten Tages-Pacings ODER Conversions = 0 in letzter Stunde trotz Spend) → bei Treffer schreibt es die Alarmzeile auf stdout, die direkt nach Telegram geht. Kein Treffer = stille, kostenlose Runde.

WertEin durchgehender Pixel-Bruch oder eine entgleiste Kampagne bei 100k/Mo = ~3.300 EUR/Tag Spend-Risiko. 30-Min-Erkennung statt "morgen früh gesehen" rettet pro Vorfall schnell vierstellige Beträge. Der Watchdog kostet bis zum ersten echten Alarm exakt nichts an LLM-Tokens.

Aufwand & Reife~0,5-1 Tag (Script + Schwellen kalibrieren). Heute lauffähig — no_agent und deliver_only sind in der Doku verifiziert (Zeilen 11429 / 23180).

StolperfalleSchwellen-Tuning ist die eigentliche Arbeit — zu eng = Alert-Fatigue (Wochenend-Tagesmuster ≠ Werktag), zu weit = du verpasst den schleichenden Drop. Plane eine 1-2-wöchige Kalibrierphase mit nachgezogenen Schwellen ein.

Ad-hoc-Datenfragen in natürlicher Sprache (BI-Self-Serve via Telegram)

Heute lauffähig

Was es tutDu fragst per Telegram "Welche 5 Ads hatten letzte Woche den niedrigsten CPA bei Collagen, und wie war deren Hook-Rate?" oder "Vergleich AOV Neukunden vs. Bestandskunden im Mai" — Hermes zieht die Daten, rechnet und antwortet in Sekunden, ohne dass jemand SQL schreibt.

Hermes-BausteineMessaging-Gateway (Telegram, per-Chat-Session) + execute_code (SQL/Pandas in einem Turn) + MCP Meta-Ads (ads_insights_performance_trend, ads_insights_advertiser_context) + MCP Shopify oder direkter Supabase/Postgres-MCP für deine eigenen Daten + Memory (USER.md hält deine Standard-Definitionen: was "Hook-Rate", "Winning", "Neukunde" bei dir bedeuten).

Wie es läuftFrage trifft via Gateway ein → Hermes übersetzt sie in execute_code (holt Insights + Orders per RPC, joint in Pandas, rechnet die Kennzahl) → Antwort als Tabelle/Kurztext zurück nach Telegram. FTS5-Session-Search findet frühere Analysen ("wie letzte Woche, aber für Pur").

WertErsetzt das BI-Ticket-Loop ("ich frag mal die Daten-Person") komplett für 80% der Routinefragen. Spart pro Frage 1-2 h Wartezeit/Kontextwechsel; bei einem datengetriebenen Buyer mit täglichen Fragen schnell 15-20 h/Monat.

Aufwand & Reife~1 Tag Setup (MCP-Wiring + Definitionen in USER.md festschreiben), danach unbegrenzt nutzbar. Heute lauffähig.

StolperfalleGarbage-in-garbage-out bei Definitionen — wenn "Neukunde" oder Attribution nicht sauber in Memory/Prompt definiert ist, rechnet der Agent plausibel-falsch. Definitionen müssen einmal hart fixiert werden (USER.md), sonst driften die Antworten. Und: Free-Text → SQL kann bei mehrdeutigen Fragen danebenliegen — bei Geld-relevanten Zahlen die generierte Query stichprobenartig gegenchecken.

Cohort- / LTV- / Attribution-Report on demand (Sub-Agent-Fan-out)

Heute lauffähig

Was es tutAuf Zuruf ("LTV-Cohort der Mai-Neukunden, 90-Tage-Wiederkaufrate, aufgeschlüsselt nach Erst-Produkt") ein voller Analyse-Report mit Cohort-Tabelle + Charts — die Art Analyse, die sonst tagelang im BI-Backlog liegt.

Hermes-Bausteinedelegate_task (isolierte Sub-Agents, paralleles Fan-out: einer zieht Shopify-Order-History, einer Meta-First-Touch, einer rechnet Cohorts) + execute_code (Pandas-Cohort-Matrix + matplotlib-Chart als PNG) + MCP Shopify/Postgres + Messaging (Report + PNG-Anhang nach Telegram/Email).

Wie es läuftAnfrage → Haupt-Agent fächert via delegate_task 2-3 Sub-Agents parallel auf (jeder mit eigenem Kontext/Toolset) → Sub-Agents liefern Teil-Frames zurück → Haupt-Agent joint, baut Cohort-Heatmap + LTV-Kurve als PNG, schreibt 5-Satz-Interpretation → liefert Report + Bild. Optional als wiederkehrenden Monats-Cron verdrahten.

WertCohort/LTV ist die Analyse mit dem höchsten strategischen Hebel (sagt dir den echten erlaubten CPA) und wird im Tagesgeschäft fast nie gemacht, weil zu aufwendig. Hermes macht sie zur 5-Minuten-Anfrage — direkter Input fürs Budget-Scaling bei 100k/Mo.

Aufwand & Reife~1-2 Tage (Cohort-Logik + Chart-Templating einmal sauber bauen). Heute lauffähig; Fan-out ist Standard (Default 3 parallele Sub-Agents).

StolperfalleToken-hungrigster Play der Liste — mehrere Sub-Agents + große Daten-Frames im Kontext summieren sich. Halte Roh-Daten im execute_code-Scope (Pandas), nicht im LLM-Kontext; gib dem Agenten nur Aggregate zurück, sonst sprengst du Kontext und Kosten.

Wochen-Performance-Report nach Notion (automatischer Stakeholder-Push)

Heute lauffähig

Was es tutJeden Montag ein formatierter Wochenreport (WoW-Deltas Spend/ROAS/CPA/Umsatz, Best/Worst-Creatives, Trend-Kommentar) direkt als Notion-Seite — fertig für dich oder Geschäftsführung, ohne manuelles Reporting.

Hermes-BausteineCron (every monday 08:00) + execute_code (WoW-Berechnung) + MCP Meta-Ads (ads_insights_performance_trend mit 14-Tage-Fenster) + MCP Shopify + MCP Notion (notion-create-pages, notion-update-page) + optional vision_analyze, um die Top-Creative-Thumbnails kurz qualitativ einzuordnen.

Wie es läuftMontag-Trigger → Agent zieht laufende + Vorwoche, rechnet Deltas, identifiziert Top/Flop-Creatives → erstellt/aktualisiert eine Notion-Seite mit Tabellen + Kurz-Narrativ → pingt dich auf Telegram mit dem Notion-Link.

WertKillt das wöchentliche Reporting-Ritual (typisch 2-4 h/Woche = ~12 h/Monat) und liefert einen konsistenten, durchsuchbaren Report-Verlauf in Notion statt verstreuter Screenshots. Saubere historische Spur für Quartals-Reviews.

Aufwand & Reife~1 Tag. Heute lauffähig — Notion-MCP, Meta-Ads-MCP und Cron liegen alle real vor (Notion-Tools in dieser Umgebung verfügbar).

StolperfallePre-1.0-Realität (v0.15.2, ~900 Commits/Woche): Breaking Changes treffen besonders Setups mit mehreren verketteten MCP-Servern (Meta + Shopify + Notion in einem Turn). Version pinnen und vor Updates den Report-Cron einmal manuell testen, sonst bricht der Montagslauf still.

🔭

Competitive & Market Intelligence mit Hermes (D2C / Collagen / ~100k EUR Meta-Spend)

Hermes kann einen 24/7-laufenden Wettbewerbs-Geheimdienst betreiben — Cron-Watchdogs scrapen Konkurrenz-Shops, Ad-Libraries und Reviews kontinuierlich, delegate_task fächert das über zehn Konkurrenten parallel auf, vision liest Creatives und Preisschilder aus Screenshots, und nur echte Signal-Änderungen landen via Gateway auf deinem Telegram. Das ersetzt das, wofür man sonst Tools wie Particl, AdSpy oder Prisync abonniert — selbst gebaut, auf einem $5-VPS, mit Output direkt in deinen Ad-Workflow.

5 Plays

Konkurrenz-Ad-Library-Radar (Creative-Intelligence-Feed)

Heute lauffähig

Was es tutTrackt täglich, welche neuen Ad-Creatives deine Top-Wettbewerber (Collagen-Brands) in der Meta Ad Library schalten, wie lange sie laufen (= Skalierungs-Signal) und welche Hooks/Angles sie nutzen — und liefert dir die Gewinner-Muster, bevor du selbst testest.

Hermes-Bausteinecronjob (täglich) + browser_navigate/browser_screenshot auf die Ad-Library-Such-URL + vision_analyze (liest Hook-Text, Format, Angle aus dem Screenshot) + web_extract; optional der offizielle Meta-Ads-MCP (ads_library_search) statt Browser-Scraping. Output über send_message (Telegram).

Wie es läuftCron feuert 07:00 → browser_navigate öffnet facebook.com/ads/library gefiltert auf die Konkurrenz-Page-ID → Screenshots der ersten ~20 Ads → vision_analyze extrahiert pro Ad {Hook-Text, Format (UGC/Static/Video), erkennbarer Angle, "active since"-Datum} → Diff gegen die Vortags-Liste (in einer SQLite/MEMORY-Datei) → nur NEUE Ads + Ads, die jetzt >14 Tage laufen, werden gemeldet: "Brand X skaliert seit 18 Tagen einen UGC-Hook 'Knee pain at 35?' — Angle: Mobility, nicht Beauty." Wenn du ads_library_search (MCP) hast, ersetzt das den Browser-Schritt durch saubere API-Daten.

WertBei 100k/Monat ist Creative die einzige echte Skalierungs-Stellschraube. Wettbewerber-Ads, die nachweislich >2 Wochen laufen, sind vor-validierte Winning-Angles — du sparst dir 5-stellige Test-Budgets, indem du deren Gewinner adaptierst statt blind zu raten. Ein einziger geklauter Winning-Angle, der bei dir auf 2.0 ROAS landet, ist tausende Euro/Monat wert. Speist direkt deine Supamoe-„Angles"-Stufe.

Aufwand & ReifeBrowser-Variante heute lauffähig, ~1 Tag Setup (Page-IDs sammeln, vision-Prompt tunen, Diff-Logik). MCP-Variante sauberer, falls du den Meta-Ads-MCP anbindest.

StolperfalleDie Ad Library ist JS-lastig und rate-limitet aggressiv; Browser-Scraping bricht bei Layout-Änderungen — pin die Hermes-Version und plane Selektor-Wartung ein. vision_analyze auf 20 Screenshots/Tag/Konkurrent kostet Tokens (aux-Modell auf Gemini Flash legen, nicht Opus).

Preis- & Promo-Watchdog über alle Wettbewerber (Zero-LLM-Polling)

Heute lauffähig

Was es tutPollt stündlich die Produkt-/Preisseiten aller Konkurrenten und schlägt nur an, wenn sich Preis, Rabatt-Code, „Sale"-Badge oder Bundle-Struktur ändert — du erfährst von der Black-Friday-Aktion des Wettbewerbers, bevor sie dir den Tag zerlegt.

Hermes-Bausteinecronjob mit no_agent=True (reines Skript-Polling, $0 bis ein Trigger feuert) + webhook/deliver_only für Zero-LLM-Direct-Push. Eskalation an die volle Agent-Session nur bei erkannter Änderung.

Wie es läuftEin Python/curl-Skript holt stündlich die Preis-JSON/HTML jeder Konkurrenz-PDP, vergleicht Hash/Preisfeld gegen den letzten Stand. Solange nichts sich ändert → kein LLM-Call, kostet nichts. Ändert sich etwas → das Skript pusht direkt per Webhook nach Telegram ("Brand Y: Collagen 1er von 39,90 → 29,90, neuer Code SAVE25"), UND injiziert optional eine Message in eine volle Session, die dann selbst entscheidet, ob du gegensteuern solltest (z.B. eigenes Promo aktivieren via Meta-Ads-MCP ads_update_entity).

WertPromo-Blindheit kostet bei deinem Volumen real Umsatz — wenn ein Wettbewerber 25% rabattiert und du es 3 Tage später merkst, verlierst du in dem Fenster Conversions zu schlechterem CPA. Stündliche Sichtbarkeit + sofortige Reaktion verteidigt CPA und schützt deine Marge. no_agent macht das praktisch gratis im Idle.

Aufwand & ReifeHeute voll lauffähig, ~halber Tag. no_agent-Cron ist explizit für genau diese Watchdog/Threshold-Muster gebaut.

StolperfalleShops mit Bot-Protection (Cloudflare/Shopify-Checkout-Gates) blockieren simples curl-Polling — dann musst du für diese Targets auf den teureren browser_navigate-Pfad hochstufen (kostet wieder Tokens, kein reines no_agent mehr).

Paralleles Wettbewerber-Dossier (delegate_task Fan-out)

Heute lauffähig

Was es tutErstellt auf Knopfdruck ein vollständiges, frisches Intelligence-Dossier über 10+ Konkurrenten gleichzeitig — Sortiment, Bestseller, Preisarchitektur, aktive Ad-Angles, Review-Sentiment — in einer Fraktion der Zeit, die sequenzielles Recherchieren bräuchte.

Hermes-Bausteinedelegate_task(tasks=[...]) mit max_concurrent_children (parallele isolierte Subagents, je 1 Konkurrent) + pro Child web_search/web_extract + browser_* + vision. Aggregation im Parent, Ausgabe als Markdown/Notion via MCP.

Wie es läuftDu triggerst „Dossier Q2 Collagen-Markt". Parent splittet in N Tasks, ein Subagent pro Brand bekommt goal + context (URL, Page-ID, Fokusfragen) → jeder scrapt parallel Shop + Ad-Library + Trustpilot/Reviews, fasst zu einem Standard-Schema zusammen ({Top-5-Produkte, Preisspanne, AOV-Hebel/Bundles, dominante Ad-Angles, häufigste Lob-/Kritik-Themen}) → nur die finale Summary jedes Childs fließt zurück → Parent baut die Vergleichsmatrix und legt sie via notion-create-pages (MCP) ab.

WertWas eine Agentur als „Markt-Audit" für 3–5k EUR verkauft und 2 Wochen braucht, läuft hier in Minuten und ist on-demand wiederholbar — vor jedem Sortiments-/Bundle-Entscheid oder Quartalsplan. Findet White-Space (Angle/Preis-Lücken), den du besetzen kannst.

Aufwand & ReifeHeute lauffähig. Default-Cap ist 3 parallele Children — für 10 Konkurrenten entweder max_concurrent_children hochsetzen oder in Batches fahren.

StolperfalleParallele Subagents teilen sich denselben Docker-Container — gleichzeitige Schreibzugriffe auf denselben Pfad kollidieren; jeder Child muss in ein eigenes Verzeichnis schreiben. Und Fan-out multipliziert Token-Kosten: 10 Children = 10x Recherche-Tokens in einem Turn, plane das ein.

Restock- & Sold-out-Signal-Tracker (Nachfrage-Frühwarnung)

Heute lauffähig

Was es tutÜberwacht Lagerstatus der Konkurrenz-Bestseller und meldet, wenn ein Hero-Produkt ausverkauft geht oder zurückkommt — ein Sold-out beim Marktführer ist ein direktes Kaufabsicht-Umleitungs-Fenster für dich.

Hermes-Bausteinecronjob (no_agent für JSON-Endpoints, browser_navigate für JS-Shops) + web_extract + vision_analyze (liest „ausverkauft"/„nur noch X auf Lager"-Badges aus Screenshots, falls nicht im HTML) + send_message.

Wie es läuftAlle 2–4h: für jede getrackte Konkurrenz-PDP Verfügbarkeit prüfen (Shopify /products/x.js liefert available-Flag direkt; sonst Screenshot + vision) → Zustandswechsel verfügbar↔ausverkauft erkennen → Push: „Marktführer-Collagen ausverkauft seit 6h — Window für aggressives Bidding auf deren Brand-/Kategorie-Keywords." Optional Auto-Trigger: Budget-Shift in deiner Meta-Kampagne via ads_update_entity (MCP).

WertSold-out beim stärksten Wettbewerber = temporär heimatlose Nachfrage. Wer das in Stunden statt Tagen sieht und Spend draufschiebt, fängt Conversions zu gutem CPA ab — bei deinem Volumen sind selbst kurze Fenster vierstellig. Umgekehrt warnt Dauer-Ausverkauf vor eigenen Lieferengpässen in der Kategorie.

Aufwand & ReifeBei Shopify-Konkurrenten (.js-Endpoint) heute trivial und no_agent-tauglich, ~halber Tag. Nicht-Shopify braucht den Browser/vision-Pfad.

Stolperfalle„Ausverkauft" ist nicht immer ehrliches Signal (künstliche Verknappung als Marketing) — der Tracker liefert das Rohsignal, die Interpretation („echt oder Scarcity-Theater?") bleibt bei dir oder einem nachgelagerten Agent-Schritt.

Review-Mining → Angle-Pipeline (Voice-of-Customer-Klau)

Heute lauffähig

Was es tutErntet kontinuierlich die Reviews der Wettbewerber-Bestseller (Trustpilot, Amazon, Shop-Reviews) und destilliert daraus die echten Kauf-Trigger und Schmerzpunkte — als fertige, formulierte Ad-Angles und Hooks für deine Supamoe-Pipeline.

Hermes-Bausteinecronjob (wöchentlich) + browser_*/web_extract für Review-Seiten + Haupt-LLM für Theming/Clustering + skill_manage (Hermes speichert das destillierte Extraktions-/Angle-Playbook als wiederverwendbares Skill). Output als Markdown oder direkt in Supamoe.

Wie es läuftWöchentlich pro Konkurrent: alle neuen Reviews der Top-3-Produkte scrapen → LLM clustert nach {häufigster Kauf-Auslöser, größter Pain/Enttäuschung, überraschende Use-Cases, exakte Kundensprache} → Output: 5–10 formulierte Angle-Kandidaten in O-Ton-Wording ("Endlich keine steifen Finger morgens mehr" als Hook, nicht Marketing-Sprech). Das Gewinner-Extraktionsmuster sichert Hermes per skill_manage als Skill → wird zum Slash-Command, der bei jedem Lauf gleichbleibend gute Angles liefert.

WertVoice-of-Customer ist die höchstkonvertierende Quelle für Hooks — Reviews der Konkurrenz sind ein gratis, vor-validierter Pool an Pains und Wording, das nachweislich Käufer bewegt hat. Speist direkt Supamoes Angle-/Messaging-Stufe und hebt die Hit-Rate deiner Creative-Tests. Negativ-Reviews zeigen zusätzlich, wo du den Wettbewerber im Messaging frontal angreifen kannst ("im Gegensatz zu X bei uns kein Kreide-Nachgeschmack").

Aufwand & ReifeHeute lauffähig, ~1 Tag inkl. Skill-Destillation. Compliance-konform zu deinem 0-Minimum-Kurs: mutige Angles direkt aus echten Kundenaussagen, keine erfundenen Claims.

StolperfalleTrustpilot/Amazon haben striktes Anti-Scraping (Login-Gates, Captcha) — für die robusten Quellen brauchst du ggf. den authentifizierten Firecrawl-/Browser-Pfad oder einen dedizierten Review-MCP, den es evtl. nicht out-of-the-box gibt; rechne mit etwas Beschaffungs-Aufwand für die zugangsgeschützten Plattformen.

📦

Operations, Inventory & Supply — Hermes-Playbook für D2C

Mit Hermes lässt sich der komplette Ops-Backbone eines Shopify-D2C-Shops als event-getriebener Agent betreiben — von Zero-Token-OOS-Watchdogs über Reorder-Vorschläge und Lieferanten-Mails bis zur Fulfillment-/Tracking-Eskalation und einem Daily-Ops-Standup. Die Bausteine (shopify-Skill via GraphQL, Cron mit no_agent, deliver_only-Webhooks, Code Execution, Kanban, Messaging-Gateway) existieren heute und tragen jeden der Plays — der Single-Owner-Gateway ist für interne Ops sogar genau richtig.

6 Plays

OOS- & Stockout-Watchdog für Winning-Produkte (Collagen-Schutz)

Heute lauffähig

Was es tutPollt die Shopify-Inventory-Levels aller Hero-SKUs (allen voran Collagen) gegen Schwellen und feuert sofort einen Alert auf Telegram, sobald ein Produkt unter X Tage-Reichweite fällt — bevor der Meta-Traffic auf eine ausverkaufte PDP läuft.

Hermes-Bausteinecronjob mit no_agent=True (Zero-LLM-Polling) + ein Python-script, das die Shopify Admin GraphQL inventoryLevels abfragt (Pattern aus dem shopify-Skill: Admin API via curl/HTTP) + deliver="telegram". Schwellen-Logik liegt im Skript, der Agent läuft gar nicht.

Wie es läuftCron alle 15 min → Skript zieht availableQuantity pro SKU + 7-Tage-Velocity (aus letzter Order-Query oder Cache-Datei) → rechnet Days-of-Cover → stdout nur, wenn eine SKU unter Schwelle → Hermes liefert die stdout-Zeile 1:1 nach Telegram. Kosten: $0 bis ein Trigger feuert.

WertBei ~100k EUR/Mo Meta-Spend ist eine unbemerkte OOS-Phase auf dem Winning-Product direkt verbranntes Budget — Klicks auf "ausverkauft" konvertieren nicht. Ein einziger vermiedener 6h-Stockout während Prime-Traffic amortisiert den Bau um Größenordnungen. Faustregel: bei ~3.000-4.000 EUR/Tag Spend auf Collagen sind das hunderte EUR/h Schutzwert.

Aufwand & Reife~0,5-1 Tag. Heute lauffähig — der no_agent-Cron-Pfad ist explizit dokumentiert, das Skript ist Standard-GraphQL.

StolperfalleVelocity sauber zu berechnen braucht eine kleine Order-History-Query oder einen Cache; rohe availableQuantity allein gibt keine Reichweite. Kein Hermes-Limit, aber ein Stück Daten-Engineering im Skript.

Reorder-Vorschlag mit Lead-Time-Logik + Lieferanten-Draft

Heute lauffähig

Was es tutBerechnet wöchentlich pro SKU die nötige Nachbestellmenge (Velocity × Lead-Time + Safety-Stock − On-Hand − In-Transit) und legt einen fertig formulierten Reorder-Vorschlag inkl. vorausgefülltem Lieferanten-Mail-Draft zur Freigabe in Telegram.

Hermes-Bausteinecronjob (frische Session/Lauf) mit aktivem Agent + Code Execution (Python mit RPC-Tool-Zugriff kollabiert Inventory-Query + Velocity-Rechnung + Mail-Entwurf in EINEN Turn) + shopify-Skill (Inventory/Orders) + Messaging-Gateway für die Approval-Rückfrage.

Wie es läuftCron Montag 7:00 → Code-Execution-Block zieht 30-Tage-Sales + aktuelle Stocks → rechnet Reorder-Punkt pro SKU → generiert pro fälligem Artikel einen Mail-Draft an den hinterlegten Lieferanten → postet Liste + Drafts nach Telegram → Daniel antwortet "send 2, 5" → Agent versendet nur die freigegebenen via email-Deliver.

WertErsetzt die manuelle Excel-Reorder-Runde (typisch 1-2h/Woche) und senkt das Risiko von Both-Sides-Fehlern: zu spät bestellt = Stockout im Hero-Funnel, zu früh = gebundenes Kapital. Bei einem Single-Hero-Sortiment ist die Reorder-Entscheidung der teuerste Single-Point-of-Failure der ganzen Supply-Chain.

Aufwand & Reife~1-2 Tage (Lead-Times + Safety-Stock-Parameter pro SKU müssen einmal hinterlegt werden). Heute lauffähig.

StolperfalleIn-Transit/offene PO-Mengen kennt Shopify nicht zuverlässig — wenn kein ERP per MCP angebunden ist, muss "In-Transit" in einer kleinen State-Datei gepflegt werden, sonst überbestellt die Logik. Approval-Gate bewusst drinlassen: Agent soll Bestellungen nie autonom rausschicken.

Fulfillment- & Tracking-Eskalation (Stuck-Order-Hunter)

Heute lauffähig

Was es tutFindet Bestellungen, die zu lange unfulfilled hängen oder deren Tracking seit Tagen keinen Scan zeigt ("stuck in transit"), und eskaliert sie gebündelt — bevor der Kunde ein Ticket aufmacht oder eine Chargeback-Frist anläuft.

Hermes-Bausteinecronjob (Agent-Modus) + shopify-Skill (Orders/Fulfillments-Query) + optional shop-app-Skill (Order-Tracking) + web_extract/browse für Carrier-Tracking-Statusabfrage + Telegram-Deliver. Für Volumen: delegate_task Fan-out, ein Subagent prüft je einen Carrier parallel.

Wie es läuftCron täglich 9:00 → Query aller Orders mit fulfillment_status != fulfilled älter 48h + aller fulfilled Orders mit Tracking ohne Bewegung >72h → Agent prüft je Sammel-Tracking den Carrier-Status → gruppiert in "Warehouse-Delay" vs. "Carrier-Stuck" → Telegram-Report mit Order-IDs + empfohlener Aktion (nachhaken / Ersatz / Refund-Vormerkung).

WertStuck-Orders sind die teuerste Form von Customer-Service: ungelöst werden sie zu Refunds, Chargebacks und 1-Sterne-Reviews — Letztere drücken bei Meta-getriebenem Cold-Traffic die Conversion des gesamten Funnels. Frühe Eskalation hält CS-Last und Chargeback-Rate niedrig.

Aufwand & Reife~1-2 Tage. Heute lauffähig; Carrier-Tracking via Browser-Automation funktioniert, ist aber je Carrier-Seite pflegeintensiv.

StolperfalleCarrier-Tracking-Scraping ist fragil (Captchas, Layout-Änderungen) und token-hungriger als der Rest. Sauberer wäre ein Tracking-API-MCP (z.B. AfterShip/Parcel) — den müsste man aber erst anbinden bzw. es muss ein solcher MCP-Server existieren.

Chargeback- & Fraud-Signal-Frühwarnung (deliver_only Webhook)

Heute lauffähig

Was es tutEmpfängt Shopify/Stripe-Risk-Webhooks (High-Risk-Order, eingegangene Chargeback/Dispute) und pusht sie als sofortige Plain-Notification ins Ops-Telegram — ohne LLM-Loop, sub-sekündlich.

Hermes-BausteineHermes-Webhook-Route mit deliver_only: true (rendert das Template direkt, Zero-LLM, sub-second) + deliver: telegram. Für die wenigen Fälle, die echte Recherche brauchen (Order-Historie des Kunden prüfen), eine zweite Route im normalen Agent-Modus.

Wie es läuftShopify Flow / Stripe Radar POSTet bei order.risk = high oder dispute.created an die Hermes-Webhook-URL → deliver_only-Route rendert "⚠️ High-Risk Order {order.id} — {amount} — {reason}" → landet direkt in Telegram. Optional: zweite Route, die bei Dispute den Agent triggert, Kunden-Order-History zieht und Fight/Accept empfiehlt.

WertChargebacks haben harte Antwortfristen und Gebühren (~15-25 EUR je Fall + verlorener Warenwert). Minuten-schnelles Wissen statt Tage-späte Entdeckung entscheidet, ob man den Dispute überhaupt noch fightet. Bei steigendem Meta-Cold-Traffic steigt der Fraud-Anteil — Frühwarnung schützt Marge und das Stripe-Risk-Standing.

Aufwand & Reife~0,5 Tag für die deliver_only-Route (Webhook-Secret + Template). Heute lauffähig — deliver_only ist explizit für genau diesen "Plain-Push ohne Reasoning"-Fall dokumentiert.

StolperfalleDer Webhook-Backend hermes-webhook hat volle Tools inkl. Terminal — die Route muss mit Secret/HMAC abgesichert sein, sonst ist sie ein offener Trigger. deliver_only selbst ist harmlos (kein Agent), aber die Agent-Variante der zweiten Route nicht ungesichert lassen.

Daily-Ops-Standup (ein Report, alle Zahlen)

Heute lauffähig

Was es tutLiefert jeden Morgen einen kompakten Ops-Status: Stock-Reichweiten der Hero-SKUs, offene/stuck Orders, gestrige Refund-/Chargeback-Quote, fällige Reorders — ein Blick statt fünf Dashboards.

Hermes-Bausteinecronjob (Agent-Modus) + Code Execution (eine Python-Pipeline zieht alle Shopify-Queries in EINEM Turn statt fünf Einzel-Tool-Calls) + shopify-Skill + Telegram-Deliver. Optional delegate_task für parallele Teil-Reports.

Wie es läuftCron täglich 7:30 → Code-Execution-Block sammelt programmatisch Inventory + Orders + Refunds via RPC-Tool-Zugriff → aggregiert zu 5 Kennzahlen-Blöcken → Agent formuliert 8-Zeilen-Standup mit den 1-3 Punkten, die heute Handlung brauchen → Telegram. Reine Datenzeilen über no_agent-Cron als günstigere Variante denkbar, wenn kein Prosa-Briefing nötig ist.

WertErsetzt die tägliche manuelle Dashboard-Runde (~20-30 min/Tag = ~10h/Monat). Wichtiger als die Zeit: nichts fällt durch — der eine Tag, an dem man nicht reinschaut, ist der, an dem Collagen leerläuft.

Aufwand & Reife~1 Tag (baut auf den Queries der anderen Plays auf — hoher Wiederverwendungs-Anteil). Heute lauffähig.

StolperfalleIm Agent-Modus ist der Gateway 2-3x token-hungriger als ein CLI-Call; ein einzelner Daily-Standup ist vernachlässigbar, aber bei vielen Cron-Agent-Jobs summiert es sich — Routine-Polling daher in no_agent halten und nur das finale Briefing den Agent reasoning-lassen.

Multi-Brand-Ops-Kanban (Iron Brothers + Pur koordiniert)

Heute lauffähig

Was es tutSammelt alle ausgelösten Ops-Tasks (Reorder fällig, Order stuck, High-Risk) als Karten auf einem SQLite-Task-Board, sodass über beide Brands hinweg nichts doppelt bearbeitet wird oder verloren geht.

Hermes-BausteineKanban (SQLite-Task-Board, Multi-Agent) — die anderen Plays schreiben statt nur zu alerten zusätzlich eine Karte; kanban_decomposer/specify brechen größere Items auf. delegate_task kann Karten parallel abarbeiten.

Wie es läuftStatt nur Telegram-Alert legt jeder Watchdog bei Trigger eine Kanban-Karte (Triage-Spalte) an → Daniel oder ein Subagent zieht sie nach In-Progress → erledigte Reorders/Eskalationen landen in Done mit Audit-Trail. Pro Brand ein Profil/Board, gemeinsame Sicht.

WertBei zwei Brands und Single-Hero-Fokus ist Koordination das Ops-Risiko Nr. 1 — "ich dachte du hast nachbestellt". Ein gemeinsames Board macht Verantwortung explizit und auditierbar; verhindert sowohl Doppel-Bestellungen als auch vergessene Eskalationen.

Aufwand & Reife~0,5-1 Tag, um die bestehenden Alerts zusätzlich als Karten zu schreiben. Heute lauffähig (Kanban ist eingebaut).

StolperfallePre-1.0 (v0.15.2, ~900 Commits/Woche) — Kanban-Schema/CLI kann sich zwischen Releases ändern; Version pinnen und vor Updates die Board-DB sichern, sonst riskiert man Breaking-Changes mitten im Ops-Betrieb.

🧪

CRO & On-Site-Optimierung mit Hermes — D2C-Plays für Iron Brothers/Pur

Hermes klickt mit echter Browser-Automation + Vision durch deinen Shopify-Checkout, sieht visuelle Defekte die Tools wie Hotjar nie melden, und minet Reviews → PDP-Copy — alles als Cron-Jobs die dir morgens fertig in Telegram liegen. Statt einmal im Quartal manuell zu auditen, läuft On-Site-QA und A/B-Auswertung dauerhaft und autonom.

5 Plays

Checkout-Watchdog (täglicher Funnel-Durchklick mit Vision)

Workaround

Was es tutEin Bot legt jeden Morgen ein echtes Produkt in den Warenkorb, durchläuft den kompletten Checkout bis zur Zahlungsseite und prüft visuell, ob jeder Schritt fehlerfrei lädt — Versandkosten, Rabattcode-Feld, Express-Checkout-Buttons (PayPal/Shop Pay), Trust-Badges.

Hermes-BausteineCron + browser_navigate/browser_snapshot/browser_vision (echte Seite klicken) + vision_analyze (Screenshot semantisch bewerten: "ist ein Fehler-Banner sichtbar? fehlt der PayPal-Button?") + Messaging-Gateway (Telegram-Push). Optional delegate_task-Fan-out für DE/AT/CH-Varianten parallel.

Wie es läuftCron 06:00 → Bot navigiert zur Collagen-PDP → "In den Warenkorb" → Checkout → füllt Test-Adresse → stoppt vor Zahlung → macht Screenshots jeder Stufe → Vision vergleicht gegen Soll-Zustand ("alle 3 Express-Buttons da, Versandkosten = X, kein 500er") → bei Abweichung sofort Telegram mit Screenshot, sonst stilles "Checkout grün".

WertBei ~100k/Mo Spend kostet ein 6h unentdeckter Checkout-Bruch (z.B. Shop-Pay-Button weg nach Theme-Update, Rabattfeld kaputt) schnell 1.000-3.000 EUR verbranntes Ad-Budget auf eine tote Seite. Ein einziger gefangener Defekt zahlt das Setup um Faktor 100.

Aufwand & Reife~1 Tag Setup (Test-Bestellung sauber abbrechen/Test-Gateway nutzen). Heute lauffähig — Browser-Backend + Vision sind Standard-Toolsets.

StolperfalleEchte Test-Checkouts brauchen einen Bogus-/Test-Payment-Modus, sonst legst du echte Orders an. Und: Vision-Calls auf Screenshots sind token-teuer — pro Lauf mehrere Bilder, also auxiliary-Vision auf ein günstiges Flash-Modell pinnen, nicht Opus durchballern lassen.

Review-Mining → PDP-Objection-Copy

Workaround

Was es tutHermes zieht die echten Kundenrezensionen (eigene + Amazon/Trustpilot-Konkurrenz) für Collagen, clustert die wiederkehrenden Einwände und Lob-Trigger und schreibt daraus konkrete PDP-Bausteine: FAQ-Antworten, Bullet-Benefits, Above-the-fold-Claims — in deiner Markensprache.

Hermes-Bausteineweb_search + web_extract/Firecrawl (Reviews scrapen) + execute_code (Python: Reviews dedupen, nach Theme clustern, Häufigkeiten zählen — alles in EINEM Turn statt 30 Tool-Calls) + Haupt-LLM für Copy. Optional delegate_task pro Produkt parallel.

Wie es läuftTrigger manuell oder wöchentlicher Cron → scrape Review-Quellen → execute_code clustert ("Geschmack" 40x, "löst sich schlecht auf" 22x, "Wirkung erst nach Wochen" 18x) → LLM mappt Top-Einwände auf PDP-Sektionen → Output: fertige Copy-Blöcke + Priorisierung nach Häufigkeit, direkt in Notion/Markdown.

WertObjection-Handling auf der PDP ist einer der härtesten CR-Hebel. Jeder einwand-killende FAQ-Block, der die CR von 2,4% auf 2,6% hebt, bringt bei 100k Spend fünfstellig/Monat mehr Umsatz — und die Copy taugt 1:1 als Angle-Input für Supamoe.

Aufwand & Reife~0,5 Tag. Heute lauffähig; Firecrawl-MCP ist hier bereits angebunden.

StolperfalleReine Wahrheits-Grenze beachten — Hermes darf etablierte Benefits stark formulieren, aber keine erfundenen Wirk-Studien zitieren. Amazon/Trustpilot haben Anti-Scrape-Maßnahmen; ggf. braucht Firecrawl Retries oder die Quelle wechselt.

A/B-Test-Auswertung mit echter Signifikanz statt Bauchgefühl

Workaround

Was es tutHermes nimmt die Rohzahlen eines laufenden On-Site-Tests (z.B. zwei PDP-Varianten) und rechnet Konversions-Signifikanz, Konfidenzintervalle und benötigte Restlaufzeit aus — und gibt eine klare Stop/Weiterlaufen/Gewinner-Empfehlung statt "sieht besser aus".

Hermes-Bausteineexecute_code (Python mit scipy/statsmodels: Z-Test für Proportionen, Bayesian-Wahrscheinlichkeit, Sample-Size-Rechner — eine Pipeline, ein Turn) + MCP(Shopify) für Order-/Session-Daten oder CSV-Upload. Cron für tägliches Re-Scoring laufender Tests.

Wie es läuftDu wirfst Variant-A/B-Zahlen rein (oder Cron zieht sie aus Shopify) → execute_code rechnet p-Wert + "Wahrscheinlichkeit dass B gewinnt: 91%" + "noch 4 Tage bis Signifikanz bei aktueller Traffic-Rate" → Klartext-Empfehlung nach Telegram.

WertVerhindert die zwei teuersten A/B-Fehler: zu früh auf Rauschen abbrechen (Fehlentscheidung skaliert auf 100k Spend) und ewig auf totem Test sitzen (Opportunitätskosten). Saubere Stats = schnellere, richtige Calls.

Aufwand & Reife~2-3h. Heute lauffähig — reines Python im Sandbox, kein externer Dienst nötig.

StolperfalleGarbage-in-garbage-out: Hermes rechnet korrekt, aber wenn dein Test-Tracking selbst verzerrt ist (Bot-Traffic, ungleiche Allokation), ist auch die saubere Statistik wertlos. Kein Ersatz für sauberes Test-Design.

PageSpeed- & UX-Defekt-Audit über das ganze Sortiment

Workaround

Was es tutHermes lädt jede wichtige Landingpage/PDP, misst Ladezeit + Core Web Vitals und macht parallel einen Vision-Scan auf sichtbare Defekte: kaputte Bilder, überlappender Text auf Mobile, abgeschnittene CTAs, fehlende Preise, broken Layout.

Hermes-Bausteinedelegate_task-Fan-out (mehrere PDPs parallel) + browser_navigate (Mobile-Viewport emulieren) + browser_vision/vision_analyze (visuelle Defekte sehen, die kein Lighthouse-Score zeigt) + execute_code (Lighthouse/CrUX-API-Call, Ergebnisse aggregieren) + web tools für PageSpeed-Insights.

Wie es läuftTrigger wöchentlich → Liste der Top-Seiten → je Seite ein Subagent: Desktop+Mobile laden, LCP/CLS messen, Screenshot Vision-prüfen → Aggregation: Ranking "schlechteste Seiten zuerst" mit konkretem Defekt + Screenshot-Beleg → Report nach Telegram/Notion.

WertMobile-CLS und langsame PDPs killen CR genau auf den Seiten, auf die du Ad-Budget lenkst. Vision fängt das "sieht auf meinem iPhone kaputt aus"-Problem, das numerische Tools strukturell nicht sehen. Bei 100k Spend ist jede 0,1s Ladezeit auf der Top-PDP direkt Geld.

Aufwand & Reife~1 Tag. Heute lauffähig; Mobile-Emulation und Vision sind beide vorhanden.

StolperfalleBrowser-Automation auf vielen Seiten × Vision-Screenshots ist der token-hungrigste Play hier (Gateway-Overhead 2-3x). Frequenz bewusst niedrig halten (wöchentlich statt täglich) und Vision-Modell auf günstig pinnen, sonst frisst der Audit selbst spürbar Budget.

Ad-Klick → Landingpage-Konsistenz-Check (Message-Match)

Workaround

Was es tutHermes zieht deine aktiven Meta-Ads, klickt jeden Ziel-Link wie ein echter Nutzer und prüft per Vision, ob die Landingpage zum Ad-Versprechen passt: richtiges Produkt, beworbener Rabatt auch on-site sichtbar, Hook-Wording wieder aufgegriffen, kein 404/Redirect-Loop.

Hermes-BausteineMCP(Meta-Ads) — ads_get_ad_entities/ads_get_creatives (aktive Ads + Destination-URLs ziehen) + browser_navigate (Link wie User aufrufen) + vision_analyze (Ad-Text vs. Landingpage-Inhalt abgleichen) + Cron + Gateway-Push. Der Meta-Ads-MCP ist hier real angebunden.

Wie es läuftCron täglich → Meta-MCP liefert alle aktiven Ad→URL-Paare → Bot ruft jede URL auf → Vision: "Ad verspricht 20% auf Collagen — ist der Code/Banner on-site? gleiches Produkt? funktioniert der Link?" → Mismatches sofort gemeldet ("Ad X → URL 404", "Rabatt im Ad, aber nicht auf der LP").

WertMessage-Mismatch und tote Links bei laufenden Ads sind direkter Spend-Verlust — du zahlst CPC für Klicks, die auf Verwirrung oder Fehler landen. Bei 100k/Mo und vielen Creatives schleicht sich das ständig ein (Rabatt ausgelaufen, Produkt out-of-stock, URL nicht aktualisiert). Genau die Lücke, die zwischen Media-Buyer und Shop-Team niemand bewacht.

Aufwand & Reife~1 Tag. Lauffähig, sobald der Meta-Ads-MCP mit deinem Werbekonto autorisiert ist.

StolperfalleSingle-Owner-Gateway — dieser Bot hat über den Meta-MCP Zugriff auf dein Live-Werbekonto; das gehört in eine interne, von dir allein kontrollierte Instanz, niemals an einen geteilten/Kunden-Kanal. Und: pre-1.0, also Hermes-Version pinnen, damit ein Update den Job nicht still bricht.

⭐

Reviews, Reputation & Social Proof mit Hermes Agent

Hermes kann deinen kompletten Review- & Reputations-Layer autonom betreiben — cross-platform scrapen (web_extract/browser), negative Reviews per Messaging-Gateway in Sekunden eskalieren, Antwort-Entwürfe schreiben und 5-Sterne-UGC per Vision für Meta-Ads ernten. Cron mit no_agent macht das 24/7 nahezu kostenlos, bis ein echter Trigger feuert.

5 Plays

Negative-Review Sofort-Alert (Sub-Minute-Eskalation)

Workaround

Was es tutErkennt neue 1-2-Sterne-Reviews auf Trustpilot/Amazon/Google/Reviews.io innerhalb von Minuten und pingt dich auf Telegram/WhatsApp mit Quote, Plattform, Direktlink und Schweregrad.

Hermes-BausteineCron (no_agent=True Polling) → bei Treffer LLM-Tick → Messaging-Gateway (Telegram/WhatsApp, deliver_only-Push). Scraping via web_extract / Browser-Automation. Für Trustpilot/Amazon optional Firecrawl-MCP (firecrawl_monitor_create als Change-Watcher).

Wie es läuftCron alle 15 Min → Watchdog-Script holt Review-Listen pro Quelle, difft gegen MEMORY.md-State (zuletzt gesehene Review-ID) → wenn neue Review mit Rating ≤ 2: ein einziger LLM-Tick klassifiziert Schweregrad (Produktfehler vs. Versand vs. Troll) → Push an deinen Chat. State wird zurückgeschrieben.

WertBei ~100k EUR/Mo Spend killt eine sichtbare 1-Stern-Welle auf Trustpilot deine Ad-CTR und CVR direkt (Social Proof ist Pre-Click-Conversion-Treiber). Reaktionszeit von Stunden/Tagen → Minuten. Eine einzige rechtzeitig entschärfte Produktfehler-Welle (Collagen-Charge) zahlt das Setup x-fach.

Aufwand & Reife~0,5-1 Tag. Heute lauffähig — no_agent-Cron + deliver_only sind dokumentierte Features.

StolperfalleTrustpilot/Amazon haben Bot-Schutz; reiner web_extract reicht oft nicht, du brauchst Browser-Backend (kostet Tokens pro Vision-Render) oder einen Firecrawl-Plan. Amazon-Reviews sind ohne Login zunehmend gedrosselt — plane einen authentifizierten Browser-Profile-Pfad ein.

UGC-Harvester für Meta-Ads (5-Sterne → Creative-Pool)

Workaround

Was es tutSammelt automatisch starke 5-Sterne-Reviews + mitgepostete Foto-/Video-UGC, sichtet sie per Vision auf Ad-Tauglichkeit (Gesicht, Produkt sichtbar, Lichtqualität) und legt ad-ready Testimonial-Snippets + Asset-Links für deinen Creative-Pool ab.

Hermes-BausteineBrowser-Automation (UGC-Bilder ziehen) + vision_analyze (Bildverstehen/Qualitäts-Scoring) + fal image_generate (Hintergrund cleanen / Testimonial-Card bauen) + delegate_task (paralleles Fan-out über mehrere Plattformen) + File-Tool (Pool-Export als JSON/CSV).

Wie es läuftWeekly-Cron → delegate_task fächert pro Plattform einen Subagent aus → jeder zieht neue ≥4-Sterne-Reviews mit Medien → Vision scored jedes Asset (0-100: Produkt erkennbar? Authentisch? Nutzbar?) → Top-Picks werden als Testimonial-Card-Layout + Original-Asset abgelegt → direkt einspeisbar in Supamoes Creative-Engine/Pool.

WertUGC-Testimonials sind eines der härtesten Performance-Hebel im D2C-Meta-Spiel. Manuelles UGC-Sichten kostet einen Creative-Strategen mehrere Std/Woche; hier automatisiert + qualitäts-gescort. Direkter Funnel in deinen Ad-Builder — bei deinem Spend-Level ist konstanter frischer Social-Proof-Nachschub bares Geld gegen Creative-Fatigue.

Aufwand & Reife~2-3 Tage. Heute lauffähig, aber Vision-Scoring-Prompt + Pool-Schema brauchen Tuning.

StolperfalleToken-hungrig — Vision auf vielen Bildern + Gateway-Overhead (2-3x CLI) summiert sich; batch die Vision-Calls und gate hart auf Rating ≥4 vor dem Scoring. Rechtlich: UGC-Repost braucht Nutzer-Einwilligung — Hermes erntet/scort, die Freigabe bleibt dein Schritt.

Review-Reply-Drafter mit Approval-Gate

Workaround

Was es tutSchreibt zu jedem neuen Review (positiv wie negativ) einen markengerechten Antwort-Entwurf, schickt ihn dir zum One-Tap-Approve und postet erst nach deinem OK.

Hermes-BausteineCron-Trigger → LLM-Draft (Brand-Voice in USER.md/MEMORY.md gepinnt) → Messaging-Gateway (Telegram-Inline mit Approve/Edit) → bei OK Browser-Automation (form_input/click) zum Posten. Optional Skill als Slash-Command (/review-reply) für Ad-hoc.

Wie es läuftNeue Review erkannt → Hermes lädt Brand-Tone-Spine + Produkt-FAQ aus Memory → generiert Reply (negativ: deeskalieren + Lösung; positiv: kurz, warm, ggf. Cross-Sell) → Push an dich mit „Approve / Edit / Skip" → bei Approve navigiert Browser zur Reply-Box und postet.

WertAntwortrate & Antwortzeit sind harte Trustpilot/Google-Ranking-Faktoren → bessere Profil-Sterne → bessere Ad-Landing-Trust → CVR. Spart deinem Team die mühsame, latenz-kritische Reply-Arbeit; du bleibst im Loop ohne selbst zu tippen.

Aufwand & Reife~2 Tage. Draft + Approval heute lauffähig; das Auto-Posten via Browser ist der fragilste Teil (Selektoren brechen).

StolperfalleBrowser-Posting in Trustpilot/Google-Business-Backends ist UI-fragil und kann Login/2FA triggern — robuster ist „Draft + dein manuelles Paste". Gateway-Auth ist single-owner: gut für dich als Owner, nicht als Multi-Seat-Team-Tool.

Wöchentlicher Sentiment- & Themen-Trend-Report

Workaround

Was es tutAggregiert alle Reviews der Woche cross-platform, clustert wiederkehrende Themen (Geschmack, Versand, Dosierung, Preis), trackt den Sterne-Trend pro Produkt und liefert dir einen Montag-Morgen-Report mit Top-3-Painpoints + Top-3-Lob.

Hermes-BausteineCron (weekly) → Code Execution (programmatisches Python: Scrape + Aggregation + Sentiment-Cluster in EINEM Turn) → Memory (Trend-Historie über Wochen) → Messaging-Gateway (Report-Push) oder Notion-MCP (Report-Page).

Wie es läuftMontag 7:00-Cron → Python-Pipeline zieht 7-Tage-Reviews aller Quellen, normalisiert Ratings, clustert Themen via LLM, vergleicht mit Vorwoche aus Memory → rendert Report (Sterne-Delta, neue negative Themen, Zitate) → Push an Telegram + optional Notion-Page.

WertFrühwarnsystem für Produkt-/Fulfillment-Probleme UND eine Goldgrube für Ad-Angles: die meistgenannten Lob-Themen sind direkt Messaging-Spine-Input für Supamoe-Angles. „Was Kunden wörtlich loben" → deine nächsten Winning-Hooks.

Aufwand & Reife~1-2 Tage. Heute lauffähig; Code-Execution kollabiert die ganze Pipeline in einen Call (token-effizienter als Multi-Step-Agent-Loop).

StolperfallePre-1.0 (v0.15.2, ~900 Commits/Woche) — Code-Execution-API und Tool-Namen können bei Updates brechen; Version pinnen. Sentiment-Cluster-Qualität steht/fällt mit dem Modell (min. 64k Kontext nötig, damit eine ganze Woche reinpasst).

Q&A- & Frage-Monitoring auf Amazon/Shop (Pre-Sale-Conversion-Retter)

Workaround

Was es tutÜberwacht unbeantwortete „Customer Questions" (Amazon-PDP, Shop-Produktseiten) und Review-Kommentare mit Kauf-Blocker-Fragen, alarmiert dich und liefert einen faktenbasierten Antwort-Entwurf aus deiner Produkt-FAQ.

Hermes-BausteineCron (no_agent Polling auf PDP) → Browser-Automation (Q&A-Section laden) → LLM-Draft gegen gepinnte Produkt-FAQ in Memory → Messaging-Push. Shopify-MCP für Shop-seitige Produktdaten/Bestand als Fakten-Quelle.

Wie es läuftCron checkt PDPs → neue unbeantwortete Frage erkannt → Hermes matcht gegen FAQ/Spec-Sheet → wenn faktisch beantwortbar: Draft + Push; wenn nicht (z.B. medizinische Frage): nur Alert „braucht dich". Du approvst, Antwort geht raus.

WertUnbeantwortete PDP-Fragen sind direkte Conversion-Leaks — gerade auf Amazon bei Cold-Traffic aus Meta-Ads. Schnelle, akkurate Antworten heben PDP-CVR messbar. Skaliert über dein ganzes Sortiment ohne Personalaufwand.

Aufwand & Reife~1-2 Tage. Heute lauffähig mit Browser-Backend; Shopify-MCP ist real, Amazon hat keinen offiziellen Q&A-MCP → Browser-Scrape nötig.

StolperfalleEs existiert KEIN sauberer Amazon-Q&A-MCP — du hängst an Browser-Scraping mit Bot-Risiko/Login. Harte CLAUDE.md-Linie beachten: keine erfundenen Fakten/Studien — die FAQ muss die Wahrheits-Quelle sein, der Agent darf nicht halluzinieren.

🏢

E-Commerce Multi-Brand-Ops & selbst-lernende Skalierung mit Hermes

Hermes kann eine Agentur-/Multi-Brand-Operation als persistente Maschine betreiben — ein Profile pro Brand, Kanban als geteiltes Arbeitsboard über alle Mandanten, delegate_task für paralleles Fan-out und ein skill_manage+Curator-Loop, der wiederkehrende Ops-Playbooks über Zeit selbst verbessert. Der echte Hebel liegt bei prozeduralen, wiederholbaren Ops (Reporting, Creative-Pipelines, QA, Onboarding), nicht beim Raten an verrauschten Performance-Daten.

5 Plays

Multi-Brand Morning-Briefing-Fleet (1 Profile pro Brand, parallel)

Heute lauffähig

Was es tutJeden Morgen läuft pro Brand (Iron Brothers, Pur, + Agentur-Mandanten) ein isolierter Agent, zieht Meta-Spend/ROAS/CPA der letzten 24 h + 7-Tage-Trend, flaggt Anomalien und pusht ein fertiges Briefing in den jeweiligen Brand-Kanal — alles aus EINER Hermes-Installation.

Hermes-Bausteinehermes profile create <brand> (eigener SOUL/Memory/Credentials je Brand) + Cron (frische Session pro Lauf) + delegate_task(tasks=[...]) für paralleles Fan-out über Brands + MCP(Meta-Marketing-API) für Insights + Messaging-Gateway (deliver an Telegram/Slack je Brand) + ein selbstgeschriebenes Skill daily-brand-briefing.

Wie es läuftCron 07:00 → Orchestrator-Profile ruft delegate_task mit N Tasks (eine pro Brand) → jeder Subagent lädt sein Brand-Profile, holt via MCP ads_insights_performance_trend + ads_insights_anomaly_signal, vergleicht gegen gespeicherte Baseline aus MEMORY.md, schreibt 5-Zeilen-Briefing → Gateway liefert pro Brand in den richtigen Channel. Anomalie (CPA > Schwelle) = roter Header oben.

WertBei ~100k EUR/Mo Spend allein auf Iron Brothers/Pur ist 1 Tag unentdeckter CPA-Drift schnell vierstellig. Skaliert linear über Mandanten ohne Mehrarbeit — das ist die Agentur-Marge: 10 Brands briefen kostet so viel Henry-Zeit wie 1.

Aufwand & ReifeHeute lauffähig, ~1 Tag. Profiles, Cron, delegate_task, Gateway sind Kern-Features. Einziger Baustein mit Unsicherheit: der Meta-MCP-Server (siehe Stolperfalle).

StolperfalleDu brauchst einen Meta-Marketing-API-MCP-Server. In dieser Session ist ein ads_*-Toolset vorhanden (ads_insights_performance_trend, ads_insights_anomaly_signal etc.), d.h. der Server existiert real — aber pinne ihn und prüfe Rate-Limits; pro-Brand parallele Insights-Calls können in Meta-API-Throttling laufen.

24/7 Zero-LLM Spend-Watchdog (no_agent, kostet $0 bis ein Trigger feuert)

Heute lauffähig

Was es tutAlle 15 Min prüft ein reines Skript Spend-Velocity und ROAS pro aktiver Kampagne; nur wenn eine Schwelle reißt (z.B. Tagesbudget bis Mittag zu 80 % verbrannt bei ROAS < Ziel), feuert ein Sofort-Alert aufs Handy. Sonst: Stille, null Modellkosten.

Hermes-BausteineCron mit no_agent=True (Scheduler ruft nur das Skript, kein LLM) + deliver_only-Route (gerendertes Template = literale Nachricht, sub-second Push) + Meta-API-Call im Skript + Messaging-Gateway (Telegram).

Wie es läuftDu beschreibst Henry in Chat „alle 15 Min: hol Spend+ROAS je aktiver Kampagne, alarmiere wenn Budget-Pacing > 80 % und ROAS < 1.8" → Hermes schreibt ~/.hermes/scripts/spend-watchdog.sh, wählt automatisch no_agent=True, scheduled es. Skript-stdout (nur bei Trigger) geht über deliver_only direkt in den Chat. Kein Agent-Loop, kein Token-Verbrauch im Leerlauf.

WertBei 100k/Mo Spend ist Budget-Pacing-Schutz direkt ROI: eine Kampagne, die nachts mit kaputtem ROAS durchläuft, kann pro Nacht 500–2000 EUR verbrennen. Permanente Wache zum Nulltarif (außer dem $5-VPS), weil der teure LLM erst beim echten Vorfall anfasst.

Aufwand & ReifeHeute lauffähig, halber Tag. no_agent + deliver_only sind in der Doku explizit für genau diesen Watchdog-Fall gebaut.

Stolperfalleno_agent heißt „Skript bestimmt die Nachricht komplett" — der Watchdog kann nur fixe Schwellen prüfen, nicht „interessante" Muster interpretieren. Sobald du Reasoning willst (Ursachenanalyse), musst du auf den normalen LLM-Cron-Pfad wechseln. Außerdem ist das Default-Backend local ohne Sandbox — Watchdog-Skripte mit API-Keys gehören in den Docker-Backend.

Selbst-lernende Creative-Production-Line (Skill + Curator + FAL)

Heute lauffähig

Was es tutEine standardisierte, über Zeit besser werdende Pipeline, die aus Produkt-Referenzbild + Angle batch-weise Static-Ad-Varianten generiert (Hook-Text, Layout, Background-Stil), und das Brand-Playbook („so sieht ein Iron-Brothers-Static aus") als wiederverwendbares Skill speichert, das der Curator pflegt.

Hermes-Bausteineimage_generate via FAL (Nano Banana Pro für Text-Rendering/Reasoning, Recraft V4 Pro für Brand-Systeme, Ideogram V3 für Typografie) + vision_analyze (prüft generierte Ads gegen Brand-Checkliste) + skill_manage (speichert iron-brothers-static-recipe als prozedurales Gedächtnis) + Curator (konsolidiert/pflegt die Skills, archiviert Drift) + Batch-Processing (JSONL: viele Angles parallel).

Wie es läuftInput-JSONL = [Produktbild, Angle, Hook] × N → Batch-Runner gibt jede Zeile in eine isolierte Session → Skill static-recipe liefert das Layout-Playbook → image_generate rendert 3 Varianten → vision_analyze prüft (Produktfarbe korrekt? Hook lesbar? Brand-Safe?) → bestandene Varianten landen im Output-Ordner, Fails werden mit Begründung re-prompted. Lernt der Agent eine bessere Hook-Platzierung, patcht er via skill_manage das Recipe.

WertDirekt deine Supamoe-Domäne, aber als Ops-Maschine: statt 1 Creative manuell, 50 brand-konsistente Varianten/Nacht zu FAL-Materialkosten (Nano Banana Pro $0.15/Bild, Recraft $0.25). Das Skill-Playbook bedeutet: das Wissen „was bei dieser Brand winnt" akkumuliert, statt in jedem Briefing neu erklärt zu werden.

Aufwand & ReifeHeute lauffähig, 1–2 Tage für die Pipeline + Recipe-Skill. Alle Bausteine sind real (11 FAL-Modelle verifiziert). Curator läuft erst nach interval_hours (Default 7 Tage) los — der Lerneffekt ist Wochen-, nicht Minuten-Skala.

StolperfalleBekannte Supamoe-Gotcha gilt 1:1 — Produkt-Appearance (Pouch-Farbe!) darf NUR aus dem Referenzbild kommen, nie aus LLM-Text. vision_analyze als Gate ist Pflicht, sonst kriegst du weiße statt schwarze Pouches. Und der Curator pflegt nur agent-erstellte Skills, nie gebündelte — also keine „automatische" Verbesserung deiner Hand-Recipes ohne skill_manage-Pfad.

Agentur-Onboarding-as-Skill (neuer Mandant in <1 h standardisiert)

Heute lauffähig

Was es tutEin einziges Slash-Command nimmt einen neuen Brand auf: legt Profile an, scraped Website/Brand-Voice, baut Baseline-Memory (Produkte, USPs, Zielgruppe, Competitor-Ads), und richtet die Standard-Cron-Jobs (Briefing + Watchdog) ein — als wiederholbares, versioniertes Playbook.

Hermes-Bausteineskill_manage (das onboard-brand-Skill wird auto zum Slash-Command /onboard-brand) + hermes profile create <brand> --description (Description macht das Profile fürs Kanban-Routing auffindbar) + web (firecrawl/web_extract für Website + Ad-Library-Scrape via ads_library_search) + MEMORY.md/USER.md (Brand-Baseline schreiben) + Cron-Setup im selben Skill.

Wie es läuft/onboard-brand "Neue Brand" url=... → Skill erzeugt Profile → scraped Shop + Meta Ad Library der Brand und Top-3 Wettbewerber → destilliert Brand-Voice + Angles in die Profile-Memory → wired die zwei Standard-Crons → meldet „Brand X live, Briefing 07:00, Watchdog aktiv". Jede Verbesserung am Onboarding patcht das eine Skill → alle künftigen Mandanten profitieren.

WertOnboarding ist die teuerste manuelle Phase jeder Agentur-Skalierung. Von „halber Tag pro Mandant" auf „eine Stunde + Review" — das ist der Unterschied zwischen „10 Brands managebar" und „30 Brands managebar" bei gleichem Henry-Input. Prozedural + wiederholbar = idealer Self-Improving-Skills-Fall.

Aufwand & Reife1–2 Tage fürs erste Skill, dann amortisiert über jeden Mandanten. Profiles, skill_manage→Slash-Command, web-Scrape, Memory-Writes alle verifiziert.

StolperfalleSingle-Owner-Gateway: alle Profiles teilen eine Gateway-Auth/einen Owner — das ist perfekt für DEINE interne Agentur-Ops, aber du kannst damit NICHT jedem Mandanten einen eigenen abgesicherten Self-Service-Kanal geben. Mandanten-Isolation ist auf Profile-Ebene (Memory/Credentials getrennt), nicht auf Tenant-Auth-Ebene.

Kanban-Board als Multi-Brand Ops-Queue mit Role-Pipeline

Heute lauffähig

Was es tutAlle wiederkehrenden Ops-Aufgaben über sämtliche Brands (Creative-Refresh fällig, Budget-Reallokation, Wochenreport, Ad-Disapproval-Fix) leben als Zeilen auf einem geteilten Board; spezialisierte Profile-Worker (analyst, creative, fixer) ziehen Tasks rollenbasiert und übergeben sich Arbeit — überlebt Restarts, jeder Handoff ist eine sichtbare Zeile.

Hermes-BausteineKanban (~/.hermes/kanban.db, kanban_*-Toolset: kanban_list/show/complete/block/comment/create/link) + mehrere Profiles mit --description für Orchestrator-Routing + hermes profile describe für Auto-Routing + Dashboard-Tab fürs Monitoring.

Wie es läuftCron/Watchdog erzeugen Tasks („Brand Pur: 3 Creatives unter ROAS 1.5, Refresh nötig") → Orchestrator routet nach Profile-Description an creative-Worker → der generiert über die Creative-Production-Line neue Varianten, kommentiert das Ergebnis, setzt Task auf complete oder block (braucht Daniels Freigabe) → blockierte Tasks warten sichtbar auf menschlichen Input. Jeder Handoff ist auditierbar.

WertMacht den Unterschied zwischen „Ops im Kopf von Henry" und „Ops als durable System". Bei N Brands ist das die Schicht, die verhindert, dass Aufgaben durchs Raster fallen — und das Block-Pattern hält Daniel als Freigabe-Instanz im Loop, ohne ihn zum Bottleneck jeder Mikro-Aufgabe zu machen.

Aufwand & Reife2–3 Tage (Worker-Profiles + Descriptions + Task-Templates). Kanban ist real und explizit für Multi-Profile-Kollaboration gebaut (geteilte SQLite, jeder Handoff eine Zeile).

StolperfallePre-1.0 (v0.15.2, ~900 Commits/Woche) — Kanban ist eines der neueren Subsysteme; Schema/Tool-Namen können sich brechen, also Version pinnen. Und parallele Worker im selben Docker-Container teilen EINEN Container (collidierende cd/Writes) — pro Worker, der isoliert arbeiten muss, brauchst du ein per-Task-Env-Override, sonst überschreiben sich Brand-Arbeitsverzeichnisse. ---

Wo der Self-Improving-Loop NICHT zieht (ehrlich)Performance-Entscheidungen aus verrauschten Daten — „welcher Angle gewinnt", „wann skalieren" — sind statistisch dünn und kontextabhängig; ein Skill, das daraus eine fixe Regel destilliert, overfittet auf Noise und der Curator zementiert das. Der Loop glänzt bei prozeduralen Ops (Reporting-Format, Creative-Layout-Recipe, Onboarding-Sequenz, QA-Checklisten) — Dinge mit einem objektiv richtigen Ablauf. Halte die Skala-Heuristiken bewusst beim Menschen (Block-Pattern), automatisiere nur die mechanische Ausführung drumherum.

#	Play	Funktion	Wert	Aufwand	Reife
1	Spend/ROAS-Anomalie-Watchdog	`no_agent`-Cron pollt alle 30 Min KPIs, Alert nur bei Schwellen-Bruch	6h-späte CPA-Entgleisung = 500-1.500€ verbrannt; 30-Min-Fang rettet pro Vorfall vierstellig	0,5-1 Tag	HEUTE
2	OOS-/Stockout-Watchdog	Pollt Hero-SKU-Inventory alle 15 Min, Alert vor Stockout	Meta-Traffic auf ausverkaufte PDP = 100% verbranntes Budget; hunderte €/h Schutz	0,5-1 Tag	HEUTE
3	KPI-Morgenbriefing 07:00	`execute_code` joint Meta×Shopify, Blended-ROAS, Top/Flop-Ads → 1 Push	Ersetzt 20-30 Min/Tag (~10h/Mo); Blended-View, den Meta nie zeigt	0,5-1 Tag	HEUTE
4	Konkurrenz-Ad-Library-Radar	Trackt neue/skalierende Wettbewerber-Ads, Vision liest Hook/Angle aus	Ad >14 Tage live = vor-validierter Winning-Angle; spart 5-stellige Test-Budgets	~1 Tag	HEUTE
5	Review-Mining → PDP-Objection-Copy	Firecrawl scrapt Reviews, `execute_code` clustert Einwände → PDP-Copy	CR 2,4%→2,6% = fünfstellig/Mo; Copy 1:1 als Supamoe-Angle-Input	~0,5 Tag	HEUTE
6	Negative-Review Sofort-Alert	`no_agent`-Monitor erkennt neue 1-2-Sterne in Minuten, eskaliert	1-Stern-Welle killt Ad-CTR/CVR (Pre-Click-Social-Proof); Std→Min Reaktion	0,5-1 Tag	HEUTE
7	Supplement-Replenishment-Engine	Cron rechnet Nachkauf-Tag pro Kunde, feuert Reorder-Reminder	Repeat-Buyer = Marge ohne CAC; 5-10% zurückgeholt = vier-/fünfstellig/Mo	1-2 Tage	HEUTE
8	Catalog-Feed-Doctor	Kreuzt Meta-Diagnostics × Shopify, heilt disapproved SKUs an der Quelle	Großteil der 100k läuft über DPA/Advantage+; jede stille Disapproval = Umsatzverlust	1-2 Tage	WORKAROUND (Linux-Backend)
9	Checkout-Watchdog	Browser klickt täglich Funnel durch, Vision prüft jeden Schritt	6h gebrochener Checkout = 1.000-3.000€ auf tote Seite; ein Fund zahlt Setup x100	~1 Tag	WORKAROUND (Test-Payment-Modus)
10	Multi-Brand Briefing-Fleet	1 Profile/Brand, `delegate_task` parallel, Briefing pro Brand-Channel	Agentur-Marge: 10 Brands = so viel Zeit wie 1; linear skalierender Hebel	~1 Tag	HEUTE
11	Win-Back-Kaskade	Email→SMS→KI-Voice-Call (Bland.ai) für High-LTV-Schläfer	Reaktiviert teuerste verlorene Kunden ohne neuen CAC	2-3 Tage	WORKAROUND (Twilio/Voice-Setup)
12	UGC-Harvester	Vision scort 5-Sterne-UGC auf Ad-Tauglichkeit → Creative-Pool	Konstanter Social-Proof-Nachschub gegen Creative-Fatigue; Funnel in Supamoe	2-3 Tage	WORKAROUND (Einwilligung manuell)
13	WISMO-Resolver	Shopify-Order-Lookup, beantwortet "Wo ist meine Bestellung?" als Helpdesk-Backend	WISMO = 30-50% aller Tickets; 40% auto = 1-2 FTE-Routinelast weg	2-4 Tage	RISKANT (Bridge-Muster nötig)
14	Reorder-Vorschlag	`execute_code` rechnet Lead-Time-Bedarf, draftet Lieferanten-Mail	Reorder = teuerster Single-Point-of-Failure der Hero-Supply-Chain	1-2 Tage	HEUTE (In-Transit-State pflegen)
15	Bulk-PDP-Rewrite (VoC)	`delegate_task`-Fan-out schreibt 200+ PDPs mit Kundensprache neu	Sonst 4-stellig Agentur/wochenlang; Message-Match Ad→PDP hebt CR	1-2 Tage	WORKAROUND (Linux-Backend)

Cluster	Urteil	Einsatz-Blocker in einem Satz
1 Paid Acquisition	HEUTE	Nichts Hartes — nur Meta-Rate-Limits beim Polling beachten.
2 Creative-Produktion	WORKAROUND	`image_generate` ist text-only → img2img-Bridge für echte Packshots nötig.
3 Katalog/PDP	WORKAROUND	`execute_code` Linux-only (VPS) + dünne Catalog-Schreibrechte → Quelle heilen.
4 Customer Service	RISKANT	Single-Owner-Gateway ≠ Multi-Tenant → nur als Helpdesk-Bridge, echter Integrationsaufwand.
5 Retention/CRM	WORKAROUND	Klaviyo ohne MCP + WhatsApp-Marketing unofficial/Ban-riskant; Email-Pfad heute.
6 Analytics/BI	HEUTE	Voller Briefing-Turn kostet Token täglich; Linux-Backend für den Join.
7 Competitive Intel	HEUTE	Browser-Ad-Library fragil → MCP-Variante nehmen.
8 Inventory/Supply	HEUTE	In-Transit-State manuell pflegen; sonst sauber.
9 CRO/On-Site	WORKAROUND	Test-Payment-Modus zwingend + Vision token-teuer + pre-1.0-Browser-Drift.
10 Reviews/Reputation	WORKAROUND	Bot-Schutz braucht Auth-Browser; UGC-Repost einwilligungspflichtig.
11 Multi-Brand-Ops	HEUTE	Läuft intern; nur der „selbst-lernende" Auto-Tuning-Teil ist Wunschdenken.

#	Play	Wert-These	Aufwand	Warum Top
1	Spend/ROAS-Anomalie-Watchdog (no_agent, alle 30 Min) ⚡	Eine 6h zu spät gesehene CPA-Entgleisung verbrennt 500–1.500€; bei 3.300€/Tag Spend rettet 30-Min-Erkennung pro Vorfall vierstellig	0,5–1 Tag	Höchster Wert/Aufwand: Zero-LLM bis Trigger, amortisiert in Woche 1, alle Bausteine (no_agent, deliver_only, ads_insights_anomaly_signal) real verifiziert
2	OOS-/Stockout-Watchdog Hero-SKUs (no_agent, alle 15 Min) ⚡	Meta-Traffic auf ausverkaufte Collagen-PDP = 100% verbranntes Budget; hunderte €/h Schutzwert auf dem Winning-Product	0,5–1 Tag	Zero-Token-Schutz des teuersten Funnel-Punkts; Shopify-Skill + no_agent heute lauffähig; einziger Aufwand: Velocity-Cache
3	KPI-Morgenbriefing 07:00 (Meta × Shopify Blended-ROAS, 1 Turn) ⚡	Ersetzt 20–30 Min/Tag Ads-Manager+Shopify-Klicken (~10h/Mo); Blended-View, den Meta nie zeigt, jeden Morgen	0,5–1 Tag	execute_code kollabiert Pull→Rechnen→Push in einen Turn; täglich nutzbar ab Tag 1; sofort spürbarer Zeitgewinn
4	Konkurrenz-Ad-Library-Radar (Creative-Intelligence-Feed)	Ads, die >14 Tage laufen = vor-validierte Winning-Angles; ein geklauter Angle auf 2.0 ROAS = tausende €/Mo; spart 5-stellige Test-Budgets	~1 Tag	Creative ist DER Skalierungshebel bei 100k; ads_library_search real; speist direkt Supamoe-Angle-Pool
5	Supplement-Replenishment-Engine (Nachkauf-Radar)	Repeat-Buyer = reine Marge ohne CAC; 5–10% zurückgeholte auslaufende Collagen-Kunden = vier-/fünfstellig/Mo bei hohem LTV	1–2 Tage	Wiederkaufrate ist Supplement-Kerngeschäft; Shopify+Cron+Email heute real; 0€ Meta-CAC
6	Catalog-Feed-Doctor (Meta+Google DPA-Heilung)	Großteil der 100k läuft über DPA/Advantage+; jede still disapproved Best-Seller-Variante = direkter Umsatzverlust; 1–3% Coverage zurück	1–2 Tage	Täglich Auto-Heilung statt monatlichem Zufallsfund; ads_catalog_* + Shopify-MCP real; hoher stiller Verlust heute
7	Review-Mining → PDP-Objection-Copy ⚡	CR 2,4%→2,6% durch Einwand-killende FAQ = fünfstellig/Mo Mehrumsatz bei 100k; Copy 1:1 als Supamoe-Angle-Input	~0,5 Tag	Niedrigster Aufwand mit echtem CR-Hebel; Firecrawl bereits angebunden; execute_code clustert in 1 Turn
8	Negative-Review Sofort-Alert (Sub-Minute-Eskalation)	Sichtbare 1-Stern-Welle killt Ad-CTR/CVR direkt (Pre-Click-Social-Proof); Reaktionszeit Stunden→Minuten; entschärfte Charge-Welle zahlt x-fach	0,5–1 Tag	no_agent + deliver_only verifiziert; schützt Pre-Click-Conversion; günstig zu bauen
9	Checkout-Watchdog (täglicher Funnel-Durchklick + Vision)	6h unentdeckter Checkout-Bruch (Shop-Pay-Button weg nach Theme-Update) = 1.000–3.000€ auf tote Seite; ein Fund zahlt Setup x100	~1 Tag	Browser+Vision Standard; fängt Defekte, die Hotjar nie meldet; hoher Tail-Risk-Schutz
10	WISMO-Resolver (Helpdesk-Backend, Bridge-Muster)	WISMO = 30–50% aller D2C-Tickets; 40% vollautomatisch = 1–2 Support-FTE-Routinelast weg, Antwortzeit Std→Sek	2–4 Tage	Massiver FTE-Hebel, aber höherer Aufwand + Helpdesk-Bridge nötig (Single-Owner-Gateway)
11	Win-Back-Kaskade (Email→SMS→Voice für High-LTV)	Lapsed High-LTV-Schläfer mit mehrstufiger Kaskade + KI-Voice-Call reaktiviert teuerste verlorene Kunden ohne neuen CAC	2–3 Tage	Hoher LTV-Hebel; Twilio/Bland.ai real; mehr Setup (Tiering + Voice-Account) als Replenishment
12	UGC-Harvester (5-Sterne → Creative-Pool, Vision-Scored)	Konstanter frischer Social-Proof gegen Creative-Fatigue; spart Creative-Strategen Std/Woche; direkter Funnel in Supamoe-Pool	2–3 Tage	Starker Performance-Hebel; Vision-Scoring+Pool-Schema brauchen Tuning; Einwilligung bleibt manuell
13	Multi-Brand Morning-Briefing-Fleet (1 Profile/Brand parallel)	Agentur-Marge: 10 Brands briefen = so viel Zeit wie 1; linear skalierender Hebel über Mandanten	~1 Tag	Profiles+delegate_task real; aber Wert hängt an Multi-Brand-Setup (heute primär 2 Brands)
14	Reorder-Vorschlag (Lead-Time-Logik + Lieferanten-Draft)	Ersetzt 1–2h/Woche Excel-Reorder; Reorder ist teuerster Single-Point-of-Failure der Single-Hero-Supply-Chain	1–2 Tage	execute_code + Shopify real; In-Transit-State-Pflege nötig; Approval-Gate Pflicht
15	Bulk-PDP-Rewrite mit VoC-Injektion	200+ SKU-Copy-Refresh sonst 4-stellig Agentur/wochenlang; VoC-Message-Match Ad→PDP hebt CR	1–2 Tage	Hoher Einmal-Wert; delegate_task-Fan-out real; aber Einmal-Effekt statt Dauerläufer, daher unter Watchdogs

Fünf Hebel machen den Operator aus

Gateway = Omnichannel-Nerv

Cron + no_agent = $0 im Leerlauf

Browser + Vision = Augen im Markt

Skills + Curator = Playbooks

delegate + Kanban = ein Team

Quick Wins — bester Hebel pro Stunde

Spend/ROAS-Anomalie-Watchdog

OOS-/Stockout-Watchdog

KPI-Morgenbriefing 07:00

Review-Mining → PDP-Copy

Negative-Review Sofort-Alert

Alle Cases nach Funktion

Paid Acquisition mit Hermes — Creative-Ops & Campaign-Monitoring für ~100k EUR/Mo Meta-Spend

Spend-Anomalie-Watchdog (Zero-LLM bis es brennt)

Competitor-Ad-Spy Daily Digest (Ad Library + vision)

Auto-Performance-Report (Daily/Weekly, ein Code-Execution-Turn)

Creative-Fatigue-Detector → Kill/Refresh-Vorschlag

Scale-Opportunity-Scout (was verdient mehr Budget?)

Hermes für Creative- & Content-Produktion (D2C / Meta-Ads)

Winning-Ad-Decompiler → Hook/Angle-Batch (Konkurrenz-Scraping + vision_analyze)

On-Brand Background/Lifestyle-Batch-Generator (FAL × Brand-DNA-Skill)

Static-Ad → Motion-Ad Animator (video_generate auf bestehende Creatives)

UGC-Skript- & Storyboard-Fabrik (Angle → Skript → Shotlist → Voiceover-Draft)

Creative-Fatigue-Watchdog → Auto-Variantenbrief (no_agent-Polling + Trigger)

Supamoe-Creative-Engine-Co-Pilot (Hermes als Batch-Generator hinter deinem SaaS)

Katalog, Merchandising & PDP — Hermes im D2C-Shop

Catalog-Feed-Doctor (Meta + Google) — der Dauerläufer

Bulk-PDP-Rewrite mit Voice-of-Customer-Injektion

Hero-Image- & A+-Modul-Fabrik (vision-geprüft)

Lokalisierungs-Pipeline (DE → EU-Märkte, marktecht)

Pricing- & Lagerbestands-Watchdog (Zero-LLM bis es brennt)

Customer Service / Support (Omnichannel) mit Hermes

WISMO-Resolver als Helpdesk-Backend (Bridge, nicht direkter Kundenkanal)

EIN Posteingang über alle Kanäle (Team-Triage-Cockpit)

Retouren-/Reklamations-Triage mit Vision

Self-Maintaining FAQ-Brain mit Eskalation

Eskalations-Watchdog (Zero-LLM SLA-Wächter)

Retention, Lifecycle & CRM mit Hermes Agent

Supplement-Replenishment-Engine (Collagen-Nachkauf-Radar)

Win-Back-Kaskade mit Voice-Call-Eskalation für High-LTV-Schläfer

Post-Purchase Review-/UGC-Harvester mit Vision-Qualitätsfilter

Loyalty-Tier-Watchdog mit Zero-Token-Push

Segment-Health-Cockpit (täglicher CRM-Pulscheck auf dein Telegram)

Analytics, BI & Reporting mit Hermes Agent für D2C / Performance-Marketing

KPI-Morgenbriefing um 7:00 (Meta × Shopify, ein Turn)

ROAS/Spend-Anomalie-Watchdog (alle 30 Min, Zero-Token bis es brennt)

Ad-hoc-Datenfragen in natürlicher Sprache (BI-Self-Serve via Telegram)

Cohort- / LTV- / Attribution-Report on demand (Sub-Agent-Fan-out)

Wochen-Performance-Report nach Notion (automatischer Stakeholder-Push)

Competitive & Market Intelligence mit Hermes (D2C / Collagen / ~100k EUR Meta-Spend)

Konkurrenz-Ad-Library-Radar (Creative-Intelligence-Feed)

Preis- & Promo-Watchdog über alle Wettbewerber (Zero-LLM-Polling)

Paralleles Wettbewerber-Dossier (delegate_task Fan-out)

Restock- & Sold-out-Signal-Tracker (Nachfrage-Frühwarnung)

Review-Mining → Angle-Pipeline (Voice-of-Customer-Klau)

Operations, Inventory & Supply — Hermes-Playbook für D2C

OOS- & Stockout-Watchdog für Winning-Produkte (Collagen-Schutz)

Reorder-Vorschlag mit Lead-Time-Logik + Lieferanten-Draft

Fulfillment- & Tracking-Eskalation (Stuck-Order-Hunter)

Chargeback- & Fraud-Signal-Frühwarnung (deliver_only Webhook)

Daily-Ops-Standup (ein Report, alle Zahlen)

Multi-Brand-Ops-Kanban (Iron Brothers + Pur koordiniert)

CRO & On-Site-Optimierung mit Hermes — D2C-Plays für Iron Brothers/Pur

Checkout-Watchdog (täglicher Funnel-Durchklick mit Vision)

Review-Mining → PDP-Objection-Copy

A/B-Test-Auswertung mit echter Signifikanz statt Bauchgefühl

PageSpeed- & UX-Defekt-Audit über das ganze Sortiment

Ad-Klick → Landingpage-Konsistenz-Check (Message-Match)

Reviews, Reputation & Social Proof mit Hermes Agent

Negative-Review Sofort-Alert (Sub-Minute-Eskalation)

UGC-Harvester für Meta-Ads (5-Sterne → Creative-Pool)

Review-Reply-Drafter mit Approval-Gate

Wöchentlicher Sentiment- & Themen-Trend-Report

Q&A- & Frage-Monitoring auf Amazon/Shop (Pre-Sale-Conversion-Retter)

E-Commerce Multi-Brand-Ops & selbst-lernende Skalierung mit Hermes

Multi-Brand Morning-Briefing-Fleet (1 Profile pro Brand, parallel)

24/7 Zero-LLM Spend-Watchdog (no_agent, kostet $0 bis ein Trigger feuert)

Selbst-lernende Creative-Production-Line (Skill + Curator + FAL)

Agentur-Onboarding-as-Skill (neuer Mandant in <1 h standardisiert)