Zum Hauptinhalt springen
9 – 17 UHR +49 8031 3508270 LUITPOLDSTR. 9, 83022 ROSENHEIM
DE / EN
Coding-Agent Letta USA CLI, Desktop, Web

Letta Code

Letta Code ist der memory-first Coding-Agent-Harness von Letta mit persistenten, lernenden Agenten, Memory Blocks und Sub-Agenten für Terminal, Desktop und Web.

Lizenz Apache-2.0
Erstveröffentlichung Dezember 2025
Oberflächen Terminal (CLI), Desktop App (macOS, Windows, Linux), Web (chat.letta.com), Messaging (Telegram, Slack, Discord)
Plattformen macOS, Linux, Windows

Die sieben Bausteine bei Letta Code

So setzt Letta Code die Bausteine eines AI Harness um

  1. 1

    Agentenschleife

    Der Letta-Code-Harness treibt langlebige Agenten an, die im Terminal per `letta`, in der Desktop-App oder unter chat.letta.com dieselbe fortlaufende Konversation weiterführen, statt bei jeder Sitzung neu zu starten.

  2. 2

    Werkzeuge und Ausführungsumgebung

    Eingebaute Coding-Werkzeuge, MCP-Server (`/mcp`) und Messaging-Kanäle wie Telegram, Slack und Discord geben dem Agenten Zugriff auf Code, Systeme und Kommunikationswege.

  3. 3

    Kontextmanagement

    MemFS versioniert laut Dokumentation den gesamten Kontext inklusive Memory Blocks über Git; mit `/memory-repository set git@github.com:...` lässt sich der Kontext in ein eigenes Repository synchronisieren.

  4. 4

    Zustand und Gedächtnis

    Agenten schreiben ihr eigenes System-Prompt über Memory Blocks fort und lernen Skills aus Erfahrung; `/sleeptime` konfiguriert periodisches Konsolidieren („Dreaming“), `/palace` zeigt den aktuellen Speicherinhalt.

  5. 5

    Berechtigungen

    Vier Freigabemodi – `strict`, `standard`, `acceptEdits`, `unrestricted` – lassen sich per Flag oder dauerhaft in `.letta/settings.json` mit Allow-/Deny-Regeln konfigurieren; ein Cross-Agent-Memory-Guard schützt fremde Agentenspeicher auch im Unrestricted-Modus.

  6. 6

    Verifikation und Feedback

    Ein Hooks-System – laut Dokumentation zugunsten ereignisgesteuerter „Mods“ in Ablösung – kann an zehn Lebenszyklus-Punkten wie PreToolUse oder Stop eingreifen, Befehle blockieren oder eigene Prüfskripte ausführen.

  7. 7

    Orchestrierung

    Sieben eingebaute Subagenten (u. a. general-purpose, recall, reflection, history-analyzer) laufen laut Dokumentation als eigener Subprozess mit eigenem Kontext; jeder bestehende Letta-Agent kann zudem selbst als Subagent eines anderen Agenten eingesetzt werden.

Modelle und Modellzugang

Welche Modelle der Harness nutzt und über welche Wege sie bezogen werden

Modelle und Modellzugang
Modelle modellunabhängig – frei wählbares LLM je Agent
Bezugswege Anthropic API, OpenAI API, Google Gemini, Mistral, DeepSeek, Amazon Bedrock, Azure OpenAI, Groq, Together AI, Hugging Face, Fireworks, Ollama, LM Studio, eigene OpenAI-kompatible Endpunkte
Freie Modellwahl Ja
Eigener Endpunkt / LLM-Gateway Ja
Eigene OpenAI-kompatible Provider lassen sich über `/connect` mit Basis-URL und API-Schlüssel einrichten, sofern der Endpunkt Chat Completions und Tool-Calling unterstützt.
Funktionen
MCP-Server Sub-Agenten Hooks Skills Plugins / Erweiterungen Sandbox Headless / CI SDK Sitzungen fortsetzen
Betrieb mit herdr
Von herdr unterstützt Ja
Zustandserkennung Screen-Manifest
Integration Session
herdr erkennt Letta Code laut Support-Tabelle über das Terminal-Screen-Manifest und liefert eine Sitzungsintegration.
Mehr zu herdr →

Einsatz im Unternehmen

Datenverarbeitung, Steuerung und Preismodell laut Anbieter

Selbstgehosteter Server oder Letta Cloud

Agenten und ihr Gedächtnis lassen sich in Letta Cloud oder auf einem selbstgehosteten Server betreiben (`letta server`); der Harness selbst ist unter Apache-2.0 quelloffen und läuft laut Dokumentation auf jedem verbundenen Rechner, vom Laptop bis zur GitHub Action.

Identität und Zugriff

Der Zugriff auf Letta Cloud, Remote-Computer und Secrets erfolgt über Login (`/login`); ein eigenständiges Unternehmens-SSO für Letta Code selbst beschreibt die öffentliche Dokumentation nicht.

Admin-Richtlinien

Freigabemodi (`strict`, `standard`, `acceptEdits`, `unrestricted`) und projektweite Allow-/Deny-Regeln in `.letta/settings.json` steuern, welche Werkzeuge automatisch laufen dürfen.

Telemetrie und Kontextversionierung

Zur Telemetrie oder zentralen Nutzungsdatenerfassung äußert sich die öffentliche Dokumentation an dieser Stelle nicht; MemFS versioniert Kontext optional in einem selbst gewählten Git-Repository statt bei Letta.

Preismodell

Der Letta-Code-Harness ist Open Source ohne Lizenzkosten und lässt sich mit eigenen API-Schlüsseln nutzen; Letta Cloud sowie Zusatzfunktionen wie Remote-Computer oder Secrets erfordern laut Dokumentation eine Anmeldung bei Letta.

Stärken
  • Langlebige, stateful Agenten mit persistenter Erinnerung statt zustandsloser Einzelsitzungen
  • Self-Improvement über Memory Blocks und automatisch gelernte, wiederverwendbare Skills
  • Sieben eingebaute Subagenten, zusätzlich beliebige eigene Agenten als Subagenten einsetzbar
  • MemFS versioniert Kontext und Gedächtnis vollständig über Git, auch in ein eigenes Repository
  • Verfügbar als CLI, Desktop-App, Web und Messaging-Integrationen mit gemeinsamem Agentenzustand
  • Programmierbar über eine eigene TypeScript/JavaScript-Agent-SDK für eigene Oberflächen
Grenzen
  • AgentFile-Export/Import (.af) wurde laut Dokumentation entfernt; entsprechende Migrationswege entfallen
  • Viele Zusatzfunktionen wie Remote-Computer, Secrets oder Cloud-Sync erfordern eine Anmeldung bei Letta
  • Kein dediziertes IDE-Plugin dokumentiert; Zugriff erfolgt über CLI, Desktop-App oder Browser

Einsatzbereiche

Typische Aufgaben für diesen Harness

Persistente Entwickler-Agenten, die Projektkonventionen über viele Sessions hinweg lernen
Immer erreichbare Agenten, die proaktiv arbeiten und über Slack oder Telegram ansprechbar sind
Multi-Agenten-Setups, in denen spezialisierte Agenten sich gegenseitig als Subagenten aufrufen
Programmierbare, langlebige Agenten in eigenen Anwendungen über die Letta Agent SDK

AI Harnesses sind die Software-Schicht, die aus einem Sprachmodell einen arbeitsfähigen Agenten macht. Letta Code ist der memory-first Coding-Agent-Harness von Letta: Statt bei jeder Sitzung neu zu beginnen, führen Letta-Code-Agenten ein persistentes Gedächtnis, lernen Skills aus Erfahrung und schreiben ihr eigenes System-Prompt fort. Stand: 20. September 2026.

Was ist Letta Code?

Letta Code wird von Letta entwickelt, gegründet von den Autoren von MemGPT und dem Sleep-Time-Compute-Ansatz (heute „Dreaming“ genannt). Das Projekt ist auf GitHub unter letta-ai/letta-code als Open Source unter der Apache-2.0-Lizenz verfügbar. Installiert wird der Harness per npm install -g @letta-ai/letta-code; danach startet letta im Projektverzeichnis eine Sitzung, letta --new-agent --personality tutorial einen geführten Einstieg. Neben der CLI stehen eine Desktop-App für macOS, Windows und Linux sowie ein Web-Zugang unter chat.letta.com zur Verfügung, inklusive mobiler Nutzung.

Letta Code als AI Harness

Der zentrale Unterschied zu klassischen Coding-Harnessen: Agenten sind laut Dokumentation langlebig und „mehr wie Personen als wie Werkzeuge“. Sie lernen über Memory Blocks – Bausteine des System-Prompts, die der Agent selbst liest und umschreibt – sowie über gelernte Skills aus globalen (~/.letta), projektbezogenen (.agents/skills) und agenteneigenen Quellen. MemFS versioniert diesen gesamten Kontext über Git und lässt sich mit /memory-repository set in ein eigenes GitHub-Repository synchronisieren. Für komplexe Aufgaben stehen sieben eingebaute Sub-Agenten bereit (general-purpose, fork, recall, reflection, history-analyzer, memory, init), die als eigener Subprozess mit eigenem Kontext laufen; auch jeder andere bestehende Letta-Agent lässt sich als Sub-Agent einsetzen. Vier Freigabemodi – strict, standard, acceptEdits, unrestricted – steuern, welche Werkzeugaufrufe automatisch bestätigt werden.

Modelle und Modellzugang

Letta Code ist ausdrücklich modellunabhängig: Über /connect lassen sich API-Schlüssel für Anthropic, OpenAI, Google Gemini, Mistral, DeepSeek, Amazon Bedrock, Azure OpenAI und weitere Provider hinterlegen, /model wechselt das aktive Modell. Für einen eigenen Endpunkt unterstützt Letta Code laut Dokumentation OpenAI-kompatible Provider mit frei wählbarer Basis-URL und API-Schlüssel, sofern dieser Chat Completions und Tool-Calling beherrscht. Damit lässt sich der Modellzugriff grundsätzlich über einen zentralen Proxy wie unser AI Gateway führen, indem dessen OpenAI-kompatibler Endpunkt als Basis-URL eingetragen wird.

Einsatz im Unternehmen: Datenschutz und Governance

Agenten und ihr Gedächtnis lassen sich entweder in Letta Cloud betreiben oder vollständig selbst hosten: letta server startet den Apache-2.0-lizenzierten App-Server auf einem beliebigen Rechner, vom Laptop über eine GitHub Action bis zur eigenen VM. Freigabemodi und projektweite Allow-/Deny-Regeln in .letta/settings.json regeln automatisierte Werkzeugausführung, ein Cross-Agent-Memory-Guard schützt fremde Agentenspeicher. Zu Telemetrie oder zentraler Nutzungsdatenerfassung macht die öffentliche Dokumentation an dieser Stelle keine Angaben. Unabhängig vom Betriebsmodell gilt: Quellcode und Konversationsinhalte gehen an den jeweils gewählten Modellanbieter – das gehört vorab ins eigene Verarbeitungsverzeichnis, insbesondere wenn Letta Cloud statt eines selbstgehosteten Servers genutzt wird.

Letta Code mit herdr orchestrieren

herdr ist eine Terminal-Runtime für mehrere gleichzeitig laufende Coding-Agenten. Laut herdr-Dokumentation erkennt es Letta Code über das Terminal-Screen-Manifest und liefert darüber eine Sitzungsintegration, die Letta-Code-Sitzungen neben anderen unterstützten Harnesses im selben Multi-Agenten-Überblick sichtbar macht.

Einordnung: Entwickler-Harness und Unternehmens-Harness

Letta Code richtet sich an Entwickler, die langlebige, lernende Agenten in Terminal, IDE-naher Desktop-App oder Browser einsetzen wollen. Für Fachanwender im gesamten Unternehmen ist CompanyGPT der passende Harness: Werkzeuge über MCP-Server, Kontext über companyRAG, Rollen aus Entra ID oder Keycloak und Audit-Logs. Unser AI Gateway liefert dafür die gemeinsame Kosten- und Governance-Schicht über verschiedene Harnesses und Modellanbieter hinweg. Weitere Agent-Harnesses finden Sie in unserer Harness-Übersicht. Wenn Sie prüfen möchten, wie sich ein memory-first Agent wie Letta Code in Ihre Entwicklungsumgebung und Ihr Datenschutzkonzept einfügt, unterstützen wir Sie gerne.

Vom Entwickler-Harness zum Unternehmens-Harness

Coding-Harnesses sind Werkzeuge für Entwickler. Für Fachanwender, Kostenkontrolle und Governance braucht es zwei weitere Schichten.

CompanyGPT – der Harness für Fachanwender

CompanyGPT gibt beliebigen Sprachmodellen Werkzeuge über MCP-Server, Integrationen und n8n, Unternehmenswissen über companyRAG, Rollen aus Entra ID oder Keycloak sowie Audit-Logs – betrieben in Ihrer Azure-Umgebung oder souverän auf STACKIT.

CompanyGPT entdecken
AI Gateway – Kosten und Governance für alle Agenten

Das AI Gateway bündelt die Modellzugriffe Ihrer Tools und Coding-Agenten hinter einer OpenAI-kompatiblen API: Authentifizierung über Entra ID, Budgets und Kostenstellen pro Team, Nutzer und Agent, Guardrails und lückenlose Protokollierung.

AI Gateway ansehen

Häufig gestellte Fragen

Was ist Letta Code?

Letta Code ist ein memory-first Coding-Agent-Harness von Letta: Agenten sind langlebig, behalten Gedächtnis und Identität über Sitzungen hinweg und schreiben ihr eigenes System-Prompt über Memory Blocks fort. Nutzbar über Terminal, Desktop-App, Browser und Messaging-Integrationen.

Ist Letta Code Open Source?

Ja. Das Repository `letta-ai/letta-code` steht laut GitHub unter der Apache-2.0-Lizenz; auch der zugehörige App-Server lässt sich selbst hosten.

Welche Modelle unterstützt Letta Code?

Letta Code ist modellunabhängig und unterstützt laut Dokumentation mehr als 35 Provider, darunter Anthropic, OpenAI, Google Gemini, Mistral, DeepSeek, Amazon Bedrock und Azure OpenAI, sowie eigene OpenAI-kompatible Endpunkte über `/connect`.

Was sind Memory Blocks bei Letta Code?

Memory Blocks sind Bausteine des System-Prompts, die ein Letta-Code-Agent selbst liest und umschreibt, um Projektwissen, Konventionen und Präferenzen dauerhaft zu speichern. Sie unterscheiden Letta Code von Harnesses, die bei jeder Sitzung ohne gespeichertes Gedächtnis neu starten.

Funktioniert Letta Code mit herdr?

Ja. herdr erkennt Letta Code über das Terminal-Screen-Manifest und liefert darüber eine Sitzungsintegration im Multi-Agenten-Überblick.

Was ist der Unterschied zwischen Letta Code und dem Letta-Server?

Letta Code ist der Agent-Harness mit Terminal-, Desktop- und Web-Oberfläche. Der frühere eigenständige Letta-Server (ehemals das MemGPT-Projekt) ist laut Repository inzwischen im `letta-ai/letta-code`-Quellcode aufgegangen, der Harness, App-Server, Kanäle und Laufzeit gemeinsam enthält.

Coding-Agenten sicher im Unternehmen einführen

Wir unterstützen bei Auswahl, Modellbezug in der EU, Berechtigungskonzept und Kostenkontrolle.