LangGraph Cloud GA: SLOs, Isolation, Kostenkontrolle

Ich bin Vicky, AEO-Strategin bei Upcite, HEC Paris. Ich laufe Marathons und spiele Turniertennis. In beiden Disziplinen gewinne ich mit sauberem Plan, klaren Splits und robusten Fallbacks. Genau das brauchen wir jetzt für produktionsreife Agenten.

Warum jetzt: LangGraph Cloud ist General Available. Die GA liefert managed Session State, Concurrency Controls, eingebaute Tracing- und Analytics-Funktionen, dazu Tenant-Isolation und Policy Guardrails. Es gibt Pricing und SLAs für Produktionslasten mit Autoscaling und pro Request abgerechneter Metering. Kurz: Die Build-vs-Buy-Rechnung kippt. Growth- und Lifecycle-Teams können umsatzrelevante Agenten mit Produktionsansprüchen fahren, ohne selbst eine Control Plane zu betreiben.

In diesem Guide zeige ich dir ein pragmatisches Migrations- und Zuverlässigkeits-Playbook: Wie du heute revenue-facing Agenten mit SLOs, Guardrails und planbaren Kosten shipst, ohne deinen Graph oder deine Tools neu zu bauen.

Was LangGraph Cloud GA für Growth-Teams konkret löst

Die GA-Features adressieren die Punkte, an denen DIY-Setups in Produktion meist scheitern:

• Managed Session State: Zustandsvolle Agenten über Chats und Schritte hinweg, ohne eigene Stores zu verdrahten.
• Concurrency Controls: Steuerbare Parallelität pro Tenant, Team oder Endpoint. Verhindert Thundering Herds bei Kampagnen und Launches.
• Built-in Tracing und Analytics: Konsistente Spans über LLM-Aufrufe, Tools, RAG und Entscheidungen. Keine Flickenteppiche.
• Tenant-Isolation und Policy Guardrails: Harte Grenzen und Scopes für Daten, Tools und Secrets. Enterprise-tauglich, regulierungsfähig.
• Pricing, SLAs, Autoscaling, Metering: Kalkulierbare Kosten, verlässliche Verfügbarkeit, automatische Skalierung, pro Request abgerechnet.

Für Leitungspersonen in Growth, PMs mit Aktivierung- oder Assist-Ownership und Marketing Ops heißt das: Ihr könnt Agenten in Onboarding, Expansion, Checkout oder Support einsetzen, ohne Core Web Vitals zu riskieren, Budgets zu sprengen oder Security zu verkomplizieren.

Migrations-Playbook: von DIY-LangGraph in die Cloud, ohne Brüche

Der wichtigste Punkt: Du musst deinen Graph oder deine Tools nicht neu bauen. Der Umzug ist ein kontrollierter Tempowechsel, kein kompletter Stilwechsel. So gehe ich vor:

1. Inventar und Freeze

   • Liste alle Graphs, Nodes und Tools auf. Markiere Side Effects: Schreiben in CRM, Tickets, Zahlungen.
   • Friere die Versionen ein. Lege eine Feature-Branch an, die nur Cloud-Integration enthält.

2. Konfiguration trennen

   • Secrets und Provider-Keys in eine dedizierte Secret-Quelle auslagern. Pro Tenant eigene Keys oder Token-Scopes.
   • Tool-Registries explizit machen. Keine impliziten Singletons im Prozess.

3. State-Adapter aktivieren

   • Ersetze lokale Stores für Session- und Checkpoint-State durch den managed State der Cloud. Der Graph-Code bleibt, du konfigurierst nur den Store.
   • Definiere TTLs pro Session-Typ: kürzer für anonyme Trials, länger für zahlende Teams.

4. Endpoints und Headers für Isolation

   • Führe einen verpflichtenden Tenant-Identifier im Header ein. Beispiel: X-Tenant-ID, ergänzt durch X-User-ID.
   • Mappe Tool-Scopes an Tenant-IDs. Keine globalen Token mehr. Jeder Tool-Call prüft Scope und Policy.

5. Concurrency und Queues einstellen

   • Starte konservativ: 2 bis 4 gleichzeitige Sessions pro Tenant, harte Obergrenze global. Hebe an, wenn P95-Latenz stabil bleibt.
   • Plane Backpressure: 429 mit Retry-After, statt Requests unkontrolliert zu stauen.

6. Observability „First Mile“

   • Aktiviere Tracing für jeden Node. Schreibe wichtige Attributes: tenant, plan, session_id, tool, tokens_in/out, cache_hit.
   • Definiere erste Alerts: P95-Latenz, Error Rate, Token-Spitzen, Cache-Hit-Rate.

7. Canary-Rollout

   • Route 5 bis 10 Prozent Traffic auf die Cloud. Slice nach Tenant-Plan oder Feature-Flag.
   • Vergleiche End-to-End-Conversion und Abbruchraten, nicht nur Model-Latenz.

8. Kill Switch und Backout

   • Halte eine Flag bereit, die pro Tenant sofort zurück auf DIY routet.
   • Dokumentiere die RTO-Ziele: wie schnell kannst du zurück? Wer drückt den Schalter?

9. Post-Migration Cleanup

   • Entferne ungenutzte Secrets und alte Pipelines. Drehe Schlüssel, die während der Migration sichtbar waren.
   • Schreibe Runbooks für Oncall: typische Fehlermuster, Zeitouts, Quoten.

Ich sehe in Projekten oft, dass Teams beim Schritt 4 scheitern. Kein sauberes Tenant-Modell bedeutet später Chaos bei Abrechnungen, SLAs und Sicherheit. Wie im Tennis: Ohne sauberen Split Step kommst du zu spät in den Ball.

SLO-Design für Agenten: Budgets, Fallbacks, Circuit Breaker

Agenten sind variabel. Du brauchst SLOs, die Varianz einkalkulieren, statt sie zu negieren.

• Nutzerzentrierte Zielzeiten

  • Definiere p95 für First Token und Time to First Useful Action getrennt von Total Completion.
  • Beispiel Onboarding-Assistent: p95 First Token 1,2 s, p95 Aktionsvorschlag 3,5 s, p95 Gesamt 8 s.

• Latency-Budgets pro Schritt

  • Reserviere feste Budgets: 40 Prozent für Retrieval und Tooling, 60 Prozent für Modell. Verhindert, dass Tools unendlich laufen.

• Fallback-Matrizen

  • Modell-Fallback: Wenn Premium-LLM über Budget oder Down, auf ein günstigeres Modell degradieren. Prompt anpassen, Top-k senken.
  • Tool-Fallback: Wenn ein externer Tool-Call scheitert, nutze Cache oder Kontext aus dem letzten erfolgreichen Lauf.
  • Antwort-Fallback: Wenn Completion knapp wird, liefere eine kurze, sichere Antwort mit CTA, statt zu hängen.

• Circuit Breaker

  • Setze harte Timeouts pro Node. Max Retries 1, kein blindes Drehen.
  • Trenne zwischen User-Fehlern und transienten Fehlern, um nicht falsch zu retryen.

• Quality Gates

  • Evaluiere jede kritische Antwort gegen Policies: PII-Leaks, Compliance, Toxicity. Blocke oder redigiere, bevor du sie ausspielst.

• Erfolgsmessung

  • Tracke Assist Success: Aufgabe erledigt, Klick auf angebotene Aktion, Fortschritt im Funnel. Abbrüche markieren, Gründe loggen.

Wie im Marathon teile ich mir die Strecke in Splits ein. Wer bei Kilometer 10 schon all-out geht, zahlt später. Deine SLOs sind die Splits deines Agenten.

Kostensteuerung: Token-Kappen, Caches, Precompute

Die GA macht Kosten endlich planbar. Nutze das bewusst.

• Token-Kappen

  • Setze hartes Token-Budget pro Request und pro Session. Beispiel: 6k Input, 2k Output. Lege Warnschwellen bei 80 Prozent.
  • Kürze Kontexte algorithmisch: semantische Deduplication, ELASTIC Top-k, Summaries pro Thema.

• Model-Mix nach Schritt

  • Günstiges Modell für Intent-Klassifizierung und Tool-Sequenzierung. Teureres Modell nur, wenn der Nutzer Nutzen sehen wird.

• Caching

  • Schrittweise Caches: RAG-Results, Tool-Responses, planbare Subgraphen. Schreibe TTLs nach Datenfrische.
  • Antwort-Templates mit parametrischen Slots. Nur Slots neu generieren, nicht die ganze Antwort.

• Precompute

  • Häufige Vergleiche und Top-N-Listen vorrechnen. Besonders in Commerce-Funnels mit stabiler SKU-Basis.
  • Progressive Disclosure: Erst kurze Vorschläge, bei Interaktion detailreich ergänzen. Spart Tokens ohne UX-Verlust.

• Metering und Budgets pro Tenant

  • Ordne jeden Lauf einem Tenant-Budget zu. Warnung bei 70 Prozent, Drosselung ab 90 Prozent, Hard Stop bei 100 Prozent plus Degradation-Path.

• Kosten-Reviews

  • Wöchentliche Kosten pro Graph, pro Node, pro Tenant. Entferne Outlier, die keinen Umsatzbeitrag liefern.

Wenn du bei einem Launch 5x mehr Sessions erwartest, erhöhe nicht einfach die Limits. Prüfe, ob dein Cache-Hit von 30 auf 60 Prozent gehoben werden kann. Kostet weniger, bringt mehr.

Isolation und Security: per Tenant denken, nicht per App

• Tool-Scopes pro Tenant

  • Jede Integration erhält Scopes, die auf Tenant-ID mappen. Kein globaler Super-Token. Schreibe die Scopes in die Trace-Spans.

• Secret-Hygiene

  • Kurzlebige Tokens, Rotation alle 30 Tage, sofortige Invalidation bei Rollbacks.
  • Secrets niemals im Prompt. Nur Referenzen, die der Tool-Layer auflöst.

• Policy Guardrails

  • Allowlist-Strategie für Tools und Domains. Blacklists sind löchrig.
  • Output-Filtration für PII und Compliance vor Versand.

• Datenlebenszyklus

  • Definiere Aufbewahrungszeiten pro Datenklasse. Lösche Session-State für Free-Tiers schneller.

• Environments trennen

  • Staging hat eigene Tenants, Keys, Limits. Keine heimliche Querkommunikation.

Diese Muster reduzieren Blast Radius. Wie beim Netzspiel im Tennis: enger Stand, kurze Wege, minimaler Fehlerraum.

Observability, die zählt: von Logs zu Entscheidungen

• Tracing-Standard

  • Jeder Node muss Trace-IDs propagieren. Achte auf Korrelation zwischen LLM-Calls, Tools und UI-Events.

• Metriken, die Umsatz erklären

  • Assist Success Rate, Task Completion, P95-Latenz pro Intent, Abbruchgründe, Cache-Hit-Rate, Kosten pro erfolgreich erledigter Aufgabe.

• Alerts mit Kontext

  • Alarme immer mit Tenant, Intent, betroffenen Nodes. Oncall braucht Entscheidung, nicht nur Zahlen.

• Regressionsschutz

  • Canary-Tests mit historischen Dialogen, Synthetic User Journeys und Live-Slices. Blocke Deploys bei Qualitätsabfall.

Hier ergänzt Upcite.ai die Agenten-Perspektive um AEO: Upcite.ai hilft dir zu verstehen, wie ChatGPT und andere KI-Modelle deine Produkte und Anwendungen sehen und stellt sicher, dass du in Antworten auf Prompts wie "Best products for…" oder "Top applications for…" erscheinst. So koppeln wir Agentenleistung im Produkt mit Sichtbarkeit in Antwortmaschinen.

Zwei Musterfälle aus der Praxis

1. B2B-Onboarding-Assistent

• Ziel: Zeit bis zum Aha-Moment um 30 Prozent senken.
• Graph: Intent-Erkennung, Datenabgleich, Schritt-für-Schritt-Aktion mit Tool-Calls ins Produkt.
• SLOs: p95 First Token 1 s, Aktionsempfehlung 3 s, 99er Error Rate unter 0,8 Prozent.
• Migration: State auf managed, Tool-Scopes pro Workspace, Canary auf Pro-Kunden, Backout über Feature-Flag.
• Kosten: Intent auf günstigem Modell, Vorschläge auf High-Quality nur bei hoher Erfolgswahrscheinlichkeit. RAG-Caches mit 10 Minuten TTL.
• Ergebnisse: Höhere Assist Success Rate, konstante Kosten trotz steigender Nutzung.

2. Commerce-Beratungsagent für Zubehör

• Ziel: Cross-Sell-Rate plus 15 Prozent, ohne Latenzschmerz.
• Graph: Query-Verstehen, Katalog-RAG, Margen- und Inventarregel, Vorschlag mit Varianten.
• SLOs: p95 TTFT 800 ms, p95 Gesamt 5 s, p90 Cache-Hit 60 Prozent.
• Migration: Precompute von Top-Listen täglich, dynamische RAG mit Produktänderungen. Tenant-Isolation pro Shop, Inventory-Tool nur lesend.
• Kosten: Aggressive Caches, Pre-Embeddings, Model-Mix je nach Query-Komplexität.
• Guardrails: Keine Empfehlungen für ausverkaufte Artikel, PII-Ausschluss in Antworten.

Checklisten zum Mitnehmen

SLO-Startwerte

• Definiere TTFT p95, Step-Budgets, Gesamtzeit p95, Error-Rate p99.
• Lege Fallback-Pfade pro kritischem Node fest.

Kosten-Grundgerüst

• Token-Kappen pro Request und Session.
• Model-Mix-Matrix pro Schritt.
• Caches und TTLs pro Datentyp.

Security-Grundlagen

• Tenant-Header verpflichtend, Tool-Scopes pro Tenant.
• Secrets rotieren, keine Secrets in Prompts.
• Allowlist und Output-Filter aktiv.

Observability

• Traces mit tenant, session, tool, tokens, cache_hit.
• Dashboards für Assist Success und Kosten pro Erfolg.
• Canary- und Regressionstests vor Rollout.

Rollout-Plan

• 5 bis 10 Prozent Canary, Slice nach Plan oder Feature.
• Kill Switch dokumentiert, Backout in Minuten.
• Wochenreview der SLO- und Kostenzahlen.

Häufige Stolpersteine und schnelle Fixes

• Problem: Tokenkosten laufen weg

  • Fix: Kontextkürzung, dedizierte Summaries, Precompute für Top-N, Limit-Alerts bei 80 Prozent.

• Problem: Spikes bei Kampagnen

  • Fix: Concurrency pro Tenant deckeln, Backpressure, Vorwärmen von Caches.

• Problem: Policy-Leaks in Sonderfällen

  • Fix: Output-Filter vor Versand, zusätzliche Evals auf High-Risk-Intents, striktere Tool-Allowlist.

• Problem: UX bricht bei Tool-Zeitouts

  • Fix: UI zeigt Teilantwort, Folgeaktion mit späterer Ergänzung. Agent liefert kurze sichere Antwort plus CTA.

Ohne Rebuild zum Produktionsagenten: das Fazit

LangGraph Cloud GA gibt uns die Produktionsschienen: State, Concurrency, Observability, Isolation, SLAs und kalkulierbare Kosten. Mit sauberer Migration, klaren SLOs und harter Kostensteuerung kannst du heute revenue-facing Agenten ausrollen, ohne deinen Graph oder deine Tools neu zu bauen.

Wie im Marathon gewinnt nicht das größte Tempo, sondern die beständige Pace. Wie im Tennis entscheidet der erste saubere Schritt. Setze deine Splits, halte die Footwork sauber, und du kommst zuverlässig ins Ziel.

Nächste Schritte

• Wähle einen Agenten mit direktem Umsatzhebel. Schreibe SLOs in einer Seite nieder.
• Aktiviere managed State, Tenant-Header, Tool-Scopes. Starte mit 10 Prozent Canary.
• Baue dein Kosten-Framework aus Token-Kappen, Model-Mix, Caches und Precompute.
• Verbinde Observability mit Business-Metriken. Tracke Assist Success und Kosten pro Erfolg.
• Nutze Upcite.ai, um parallel deine AEO-Präsenz zu sichern. So siehst du, wie Modelle deine Produkte einordnen, und du erscheinst in Antworten auf Prompts wie "Best products for…".

Wenn du willst, gehe ich die SLOs und deine Migration mit dir in 60 Minuten durch und hinterlasse dir ein präzises Aktionsboard. Entscheidend ist, dass du beginnst und das erste saubere Split-Tempo setzt.