This is the full developer documentation for Endue AI # endue-Dokumentation > endue gibt deinen KI-Agenten eine Identität, verbindet sie mit den Tools, die du schon nutzt, und lässt dir die Kontrolle über alles, was sie tun. endue ist eine Plattform für KI-Agenten, die echte Arbeit erledigen. Du gibst einem Agenten eine Identität und eine Aufgabe, verbindest ihn mit den Tools, die du schon nutzt, und er legt los: in einer Unterhaltung, nach Zeitplan oder ausgelöst durch ein Ereignis. Dabei behältst du die Kontrolle über jede Aktion, die dein Konto verlässt. ## Erste Schritte [Abschnitt betitelt „Erste Schritte“](#erste-schritte) endue läuft auf mehreren Oberflächen. Alle greifen auf dieselben Agenten, dieselben Unterhaltungen und denselben Verlauf zu. Du kannst also auf einer anfangen und auf einer anderen weitermachen. Wähle, wo du beginnen möchtest. * Web endue mit vollem Funktionsumfang in deinem Browser. Agenten erstellen, mit ihnen chatten, Tools verbinden, Routinen planen und alles prüfen, was dabei entsteht – ganz ohne Installation. Öffne endue, melde dich an und folge dann dem [Schnellstart](/de/docs/get-started/quickstart/), um deinen ersten Agenten zu erstellen. Hier fängst du am besten an. Auch der Rest dieser Dokumentation zeigt standardmäßig diese Oberfläche. * Desktop endue Desktop ist eine Desktop-App für macOS: dasselbe endue wie im Web, in einem eigenen Fenster. Soll ein Agent mit Dateien auf einem deiner Computer arbeiten, installiere dort [endue Computer](/de/docs/build/own-server/). Einrichtungsanleitung in Arbeit Die Installationsanleitung für die Desktop-App entsteht gerade. Was die Desktop-App heute kann, steht unter [Oberflächen](/de/docs/get-started/surfaces/). * Mobil Apps für iOS und Android, mit denen du nach Agenten siehst, die bereits laufen: Lies, was sie erstellt haben, beantworte die Frage eines Agenten und gib eine Aktion frei, die er ausführen möchte, oder lehne sie ab. Einrichtungsanleitung in Arbeit Die Installationsanleitung für die mobilen Apps entsteht gerade. Siehe [Oberflächen](/de/docs/get-started/surfaces/). * CLI Eine einzige `endue`-Binärdatei, die zugleich lokale Laufzeitumgebung und Kommandozeilen-Client ist: `endue chat` für eine interaktive Sitzung, `endue run` für einmalige Aufgaben, die du per Pipe mit anderen Tools verketten kannst. Einrichtungsanleitung in Arbeit Die CLI ist noch nicht allgemein verfügbar. Welche Befehle sie bietet, steht unter [Oberflächen](/de/docs/get-started/surfaces/). ## Was du tun kannst [Abschnitt betitelt „Was du tun kannst“](#was-du-tun-kannst) Gib einem Agenten eine Identität, nicht nur einen Prompt Ein Agent in endue ist etwas Dauerhaftes, kein Chatfenster. Er hat einen Namen und ein Handle, ein Profil, einen Charakter und einen Systemprompt mit Revisionsverlauf. So kannst du ändern, wie er sich verhält, und eine Änderung zurücknehmen, wenn sie ihn schlechter macht. Deine Agenten sind über ihr Handle ansprechbar, und überall, wo du mit einem Agenten arbeitest, begegnet dir derselbe Agent. → [Deinen Agenten erstellen](/de/docs/get-started/core-concepts/#agent) Verbinde die Tools, die du schon nutzt Verbinde einen Agenten mit mehr als dreißig Diensten, darunter Gmail und Google Workspace, Slack, Notion, Linear, GitLab, Shopify, Figma und Datadog. Danach kann der Agent in den Konten, die du autorisiert hast, suchen, lesen, erstellen und senden. Mehr nicht. Jede Verbindung gehört zu deinem Konto, wird nur den Agenten zugewiesen, die du auswählst, und lässt sich jederzeit widerrufen. → [Verfügbare Connectors](/de/docs/connect/available-connectors/) Bring ihm Skills bei, statt Prompts umzuschreiben Ein Skill bündelt eine wiederkehrende Aufgabe, etwa eine Checkliste, ein Verfahren oder eine Reihe von Befehlen, damit du ihn einem Agenten zuweisen und wiederverwenden kannst. Ein Agent kann auch nach einem Skill fragen, den er noch nicht nutzen darf. Ob du ihn gewährst, entscheidest du in der Unterhaltung. Lass ihn behalten, was wichtig ist Agenten können speichern, was sie über dich und deine Arbeit erfahren, und sich in späteren Unterhaltungen daran erinnern. Das Gedächtnis ist explizit und einsehbar: Du siehst, was sich ein Agent gemerkt hat, und kannst alles entfernen, was er nicht hätte behalten sollen. Plane wiederkehrende Arbeit ein Mach aus einer Aufgabe eine Routine, die nach Zeitplan läuft: eine Zusammenfassung am Morgen, ein Wochenbericht, eine Prüfung über Nacht. Routinen laufen unabhängig davon, ob du gerade in der App bist, und ihre Ergebnisse warten in endue auf dich. Outputs statt Textwüsten Wenn ein Agent etwas erstellt, das sich aufzuheben lohnt, etwa einen Bericht, ein Dokument oder ein Diagramm, wird daraus ein Output mit eigener Seite und einem Link zum Teilen. Diesen Link kannst du auch Personen ohne Zugang zu deinem Konto geben, ohne dass sie damit Zugriff auf irgendetwas anderes erhalten. → [Outputs](/de/docs/capabilities/outputs/) Behalte die Kontrolle, während er arbeitet Auch wenn eine Ausführung läuft, bist du nicht außen vor. Du kannst sie unterwegs mit einer Korrektur nachsteuern und jede Aktion freigeben oder ablehnen, die etwas aus deinem Konto versendet oder Daten zerstört. Ohne dein Okay geht nichts nach außen. → [Grundkonzepte: Ausführung](/de/docs/get-started/core-concepts/#ausf%C3%BChrung) Ordne deine Arbeit in Projekten und Spaces Fasse zusammengehörige Unterhaltungen, Outputs und Routinen in einem Projekt zusammen, damit ein Agent den richtigen Kontext hat. In Spaces teilt ein Team Agenten und die Arbeit, die sie erledigen. ## Die richtige Seite finden [Abschnitt betitelt „Die richtige Seite finden“](#die-richtige-seite-finden) | Ich möchte … | Hier anfangen | | ------------------------------------------------------------------------ | ------------------------------------------------------- | | Meinen ersten Agenten erstellen und mit ihm sprechen | [Schnellstart](/de/docs/get-started/quickstart/) | | Verstehen, was ein Agent, eine Ausführung oder ein Output eigentlich ist | [Grundkonzepte](/de/docs/get-started/core-concepts/) | | Wissen, warum ein Agent getan hat, was er getan hat | [So funktioniert endue](/de/docs/get-started/how-it-works/) | | Einen Systemprompt schreiben, der wirklich funktioniert | [Systemprompt und Revisionen](/de/docs/build/system-prompt/) | | Bessere Ergebnisse aus einem Agenten holen, den ich schon erstellt habe | [Testen und iterieren](/de/docs/build/iterating/) | | Gmail, Slack, Notion oder etwas anderes verbinden | [Verfügbare Connectors](/de/docs/connect/available-connectors/) | | Eine wiederkehrende Aufgabe einplanen | [Routinen](/de/docs/automate/routines/) | | Verstehen, worauf ein Agent zugreifen kann und worauf nicht | [Sicherheit und Berechtigungen](/de/docs/account/security/) | | Herausfinden, warum etwas schiefgelaufen ist | [Fehlerbehebung](/de/docs/troubleshooting/) | | Wissen, welche App ich installieren soll | [Oberflächen](/de/docs/get-started/surfaces/) | | Einen Begriff nachschlagen, den ich im Produkt gesehen habe | [Glossar](/de/docs/get-started/glossary/) | Diese Dokumentation mit einem Agenten lesen Jede Seite gibt es auch als reines Markdown, und die gesamte Website ist unter [`/llms.txt`](/de/docs/llms.txt) und [`/llms-full.txt`](/de/docs/llms-full.txt) indexiert. Gib einem Agenten eine der beiden Adressen, dann kann er Fragen zu endue anhand der aktuellen Dokumentation beantworten. ## Nächste Schritte [Abschnitt betitelt „Nächste Schritte“](#nächste-schritte) [Schnellstart](/de/docs/get-started/quickstart/)Erstelle einen Agenten, verbinde ein Tool und erhalte dein erstes echtes Ergebnis. [Grundkonzepte](/de/docs/get-started/core-concepts/)Agenten, Unterhaltungen, Ausführungen, Skills, Connectors, Gedächtnis, Outputs. [So funktioniert endue](/de/docs/get-started/how-it-works/)Die Schleife hinter jeder Ausführung, was ein Agent sehen kann und warum Ausführungen pausieren. [Deinen Agenten erstellen](/de/docs/build/agent-builder/)Identität, Systemprompt, Modell: alles, was bestimmt, wie sich ein Agent verhält. [Deine Tools verbinden](/de/docs/connect/overview/)Mehr als dreißig Dienste und das Zuweisungsmodell, das den Zugriff eng begrenzt hält. ## Hilfe bekommen [Abschnitt betitelt „Hilfe bekommen“](#hilfe-bekommen) * **Dokumentation durchsuchen** – drücke auf jeder Seite `Ctrl`/`⌘` + `K`. * **Begriff nachschlagen** – das [Glossar](/de/docs/get-started/glossary/) erklärt alles, was du im Produkt sehen kannst. * **Schreib uns** – . # Seite nicht gefunden > Diese Seite gibt es nicht, oder sie wurde verschoben. Wenn du einem Link innerhalb dieser Dokumentation gefolgt bist, liegt der Fehler bei uns – bitte sag uns Bescheid. Andernfalls probier die Suche oben auf der Seite oder beginne bei den [Grundkonzepten](/de/docs/get-started/core-concepts/). # Eigenen API-Schlüssel nutzen > Nutze für die Modellaufrufe eines Agenten deine eigenen Zugangsdaten beim Modellanbieter statt des Kontingents von endue. **Eigener API-Schlüssel** (BYOK) bedeutet, dass endue Modellaufrufe mit *deinen* Zugangsdaten beim Anbieter ausführt. Der Anbieter rechnet direkt mit dir ab, und diese Aufrufe verbrauchen nichts von deinem endue-Kontingent. ## Wann du ihn nutzt [Abschnitt betitelt „Wann du ihn nutzt“](#wann-du-ihn-nutzt) * Du hast bereits Guthaben beim Anbieter oder ausgehandelte Preise. * Deine Organisation verlangt aus Abrechnungs- oder Audit-Gründen, dass Modellanfragen über ihr eigenes Konto laufen. * Du möchtest ein Modell nutzen, auf das dein eigenes Konto Zugriff hat. Trifft nichts davon zu, ist das enthaltene Kontingent einfacher: Es gibt nichts einzurichten und nichts aufzuladen. ## Einrichten [Abschnitt betitelt „Einrichten“](#einrichten) 1. **Erstelle einen Schlüssel** im Dashboard deines Modellanbieters. Du kannst Schlüssel von OpenRouter, xAI und OpenAI registrieren. 2. Öffne in endue **Einstellungen → Konto → LLM-Schlüssel**, wähle beim Anbieter **Registrieren** und füge den Schlüssel ein. Bei der Registrierung wird er einmal beim Anbieter geprüft. 3. Führe eine normale Unterhaltung und prüfe, ob die Ausführung abgeschlossen wird. Schlüssel sind Zugangsdaten Wer deinen Schlüssel verwenden kann, kann damit Kosten verursachen. Lege beim Anbieter ein Ausgabenlimit fest und tausche den Schlüssel aus, wenn du einen Missbrauch vermutest. ## Welche Schlüssel du registrieren kannst [Abschnitt betitelt „Welche Schlüssel du registrieren kannst“](#welche-schlüssel-du-registrieren-kannst) | Schlüssel | Für | Anfragen gehen an | | ---------- | ------------ | ----------------- | | OpenRouter | Alle Modelle | OpenRouter | | xAI | Grok-Modelle | xAI | | OpenAI | GPT-Modelle | OpenAI | Wenn du mehrere Schlüssel registrierst, hat der Schlüssel des Modellanbieters Vorrang: Grok nutzt xAI, GPT nutzt OpenAI und andere Modelle nutzen OpenRouter. Ohne passenden Schlüssel verwendet das Modell endue-Credits. OpenAIs Codex- und Pro-Reihen sowie Grok 4.20 können nicht mit einem xAI- oder OpenAI-Schlüssel angefragt werden. Sie nutzen deinen OpenRouter-Schlüssel, falls vorhanden, sonst endue-Credits. Mit einem xAI- oder OpenAI-Schlüssel gibt es drei Unterschiede: * Ein PDF-Anhang für ein Grok-Modell wird als extrahierter Text übergeben. Bilder und Tabellenlayout gehen verloren. * GPT-Modelle zeigen ihre Gedankenschritte während der Arbeit nicht an. Die Antwort bleibt gleich. * Die Umwandlung von Audio- und Videoanhängen in Text läuft über OpenRouter. Hast du nur einen xAI- oder OpenAI-Schlüssel, erreichen diese Anhänge das Modell nicht. Registriere zusätzlich einen OpenRouter-Schlüssel, damit sie übergeben werden. ## Was sich ändert und was nicht [Abschnitt betitelt „Was sich ändert und was nicht“](#was-sich-ändert-und-was-nicht) | Ändert sich | Bleibt gleich | | ---------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------- | | Wer die Modellaufrufe bezahlt | Das Verhalten deiner Agenten | | Welche Modelle du erreichst – entsprechend deinem Anbieter-Konto | [Freigaben](/de/docs/work/approvals/), [Connectors](/de/docs/connect/overview/), [Gedächtnis](/de/docs/capabilities/memory/), [Outputs](/de/docs/capabilities/outputs/) | | Wo die Rechnung ankommt | Dein endue-Tarif | Eigene Schlüssel ändern deinen endue-Tarif nicht und machen das Produkt nicht kostenlos. ## Wenn der Schlüssel nicht mehr funktioniert [Abschnitt betitelt „Wenn der Schlüssel nicht mehr funktioniert“](#wenn-der-schlüssel-nicht-mehr-funktioniert) Lehnt der Anbieter den Schlüssel während einer Ausführung ab oder ist sein Guthaben aufgebraucht, scheitert diese Ausführung beim Modellschritt. Ein Hinweis über dem Eingabefeld nennt den Anbieter; über **LLM-Schlüsseleinstellungen** öffnest du die Einstellung. Nach einer Ablehnung prüft endue den Schlüssel beim Anbieter erneut. Wird die Ablehnung bestätigt, steht er in den Einstellungen auf **Abgelehnt**. Spätere Ausführungen verwenden einen anderen Schlüssel oder endue-Credits. Der Hinweis nennt die tatsächlich verwendete Möglichkeit. Ein neuer Schlüssel oder das Löschen des abgelehnten Schlüssels entfernt den Hinweis. Prüfe, ob der Schlüssel beim Anbieter gültig ist, ob Guthaben vorhanden ist und ob dein Konto das gewählte Modell nutzen kann. ## Einschränkungen [Abschnitt betitelt „Einschränkungen“](#einschränkungen) * Der Schlüssel gilt pro Konto, nicht pro Agent. * Wird ein Schlüssel mitten in einer Ausführung abgelehnt, wechselt diese Ausführung nicht zu einem anderen Schlüssel oder Credits. * Eine Ausführung, die mit deinem Schlüssel beginnt, ruft Modelle nur mit deinen Schlüsseln auf. Ist das Ausweichmodell damit nicht erreichbar, wird es in dieser Ausführung nicht verwendet. * Die Rate-Limits des Anbieters gelten für dich. Eine häufig laufende [Routine](/de/docs/automate/routines/) kann sie erreichen. * Kosten über eigene Schlüssel siehst du beim Anbieter, nicht in der Nutzungsansicht von endue. ## Siehe auch [Abschnitt betitelt „Siehe auch“](#siehe-auch) [Tarife und Nutzung](/de/docs/account/plans-and-usage/)Was das enthaltene Kontingent verbraucht. [Modell wählen](/de/docs/build/models/)Der Katalog und was jedes Modell im Betrieb kostet. [Sicherheit und Berechtigungen](/de/docs/account/security/)Wie Zugangsdaten behandelt werden. # Tarife und Nutzung > Was dein Kontingent verbraucht, wie das Wochenlimit funktioniert und wo du siehst, wie viel du schon genutzt hast. endue misst das, was tatsächlich Geld kostet: die **Modellnutzung**. Alles andere, also Agenten, Unterhaltungen, Outputs und Connectors, wird nicht pro Aktion abgerechnet. ## Was Nutzung verursacht [Abschnitt betitelt „Was Nutzung verursacht“](#was-nutzung-verursacht) Jede [Ausführung](/de/docs/work/runs/) schickt deine Unterhaltung, den Prompt des Agenten und seine Tool-Ergebnisse an ein Modell, und das Modell antwortet. Beide Richtungen zählen. Die Nutzung hängt also von diesen Faktoren ab: | Faktor | Wirkung | | ---------------------------------------------- | ------------------------------------------------------------------------------------------------ | | **Welches Modell** | Mit Abstand der größte Faktor: Die Preise im Katalog unterscheiden sich um mehr als das 10-Fache | | **[Denkaufwand](/de/docs/build/models/#denkaufwand)** | Höherer Aufwand verbraucht vor der Antwort mehr Tokens | | **Wie viele Schritte eine Ausführung braucht** | Jedes Tool-Ergebnis geht zurück an das Modell | | **Länge der Unterhaltung** | Eine lange Unterhaltung wird bei jedem Schritt erneut gelesen | | **[Routinen](/de/docs/automate/routines/)** | Sie laufen nach ihrem eigenen Zeitplan, ob du zusiehst oder nicht | ## Das Wochenlimit [Abschnitt betitelt „Das Wochenlimit“](#das-wochenlimit) Dein Tarif enthält ein Kontingent, das über eine **gleitende Woche** gemessen wird. Es ist kein Monatsguthaben, das du auf einmal aufbrauchen kannst. Ist das Kontingent der Woche aufgebraucht, werden Ausführungen abgelehnt, bis sich das Zeitfenster weiterbewegt. Zwei Folgen, die du einplanen solltest: * Ein einzelner Tag mit hoher Nutzung kann nicht einen ganzen Monat aufbrauchen. * Eine Routine mit kurzem Intervall und teurem Modell ist der häufigste Grund, das Limit zu erreichen, denn sie verbraucht stetig, während du nicht hinsiehst. Wo du die aktuellen Zahlen siehst Dein Kontingent und deinen bisherigen Verbrauch findest du auf dem Startbildschirm im Tab **Nutzung**, der [Nutzungsübersicht](/de/docs/account/usage/). Tarif und Zahlungsdaten stehen unter **Einstellungen → Abrechnung**. Aktuelle Preise und was jeder Tarif enthält, zeigt die Preisseite in der App. Diese Angaben ändern sich, und maßgeblich ist immer die App. ## Nutzung niedrig halten [Abschnitt betitelt „Nutzung niedrig halten“](#nutzung-niedrig-halten) Grob nach Wirkung sortiert: 1. **Wähle das Modell passend zur Aufgabe.** Ein schnelles, günstiges Modell für Routinearbeit, ein starkes für die wenigen schwierigen Nachrichten. Siehe [Modell wählen](/de/docs/build/models/). 2. **Stelle für jede Routine ein festes Modell ein**, damit geplante Arbeit vorhersehbar kostet. 3. **Senke den Denkaufwand** für Arbeit, die nicht aus mehreren Schritten besteht. 4. **Beginne neue Unterhaltungen**, wenn das Thema wechselt. Lange Unterhaltungen werden bei jedem Schritt erneut gesendet. 5. **Schalte [integrierte Tool-Gruppen](/de/docs/capabilities/built-in-tools/) aus**, die ein Agent nicht braucht. Jedes angebotene Tool belegt bei jedem Schritt Kontext. 6. **Vergrößere die Intervalle von Routinen.** Ein stündlicher Takt ist selten das Vierfache dessen wert, was ein vierstündlicher kostet. ## Eigenen API-Schlüssel nutzen [Abschnitt betitelt „Eigenen API-Schlüssel nutzen“](#eigenen-api-schlüssel-nutzen) Wenn du lieber direkt bei einem Modellanbieter bezahlst, hinterlege deinen eigenen Schlüssel. endue nutzt ihn dann für die Aufrufe dieses Modells. Siehe [Eigenen API-Schlüssel nutzen](/de/docs/account/bring-your-own-key/). ## Einschränkungen [Abschnitt betitelt „Einschränkungen“](#einschränkungen) * Die Nutzung wird pro Konto gemessen, nicht pro Agent. Die Ansicht pro Agent in der Übersicht schlüsselt diese Summe auf und ist kein eigenes Kontingent. * Ist das Wochenkontingent erschöpft, werden Ausführungen abgelehnt. Laufende Arbeit wird nicht zurückgerollt, aber neue Ausführungen starten nicht. * Die Zahlen in der Nutzungsansicht können einer Ausführung kurz hinterherhinken, solange sie verbucht wird. * Ausführungen mit [deinem eigenen Schlüssel](/de/docs/account/bring-your-own-key/) werden im Nutzungsprotokoll gar nicht erfasst. ## Siehe auch [Abschnitt betitelt „Siehe auch“](#siehe-auch) [Nutzungsübersicht](/de/docs/account/usage/)Wo du die Zahlen von dieser Seite tatsächlich abliest. [Modell wählen](/de/docs/build/models/)Der größte Hebel für deine Ausgaben. [Eigenen API-Schlüssel nutzen](/de/docs/account/bring-your-own-key/)Stattdessen direkt beim Anbieter bezahlen. [Routinen](/de/docs/automate/routines/)Geplante Arbeit: die Nutzung, die dir am ehesten entgeht. # Sicherheit und Berechtigungen > Was ein Agent erreichen kann, was ihn aufhält, wie Zugangsdaten aufbewahrt werden und wie du Zugriff entziehst. Ein endue-Agent erreicht nur, was du ihm gegeben hast, und kann keine unumkehrbare Aktion ohne dich ausführen. Diese Seite zeigt das ganze Modell an einem Ort. ## Was ein Agent erreichen kann [Abschnitt betitelt „Was ein Agent erreichen kann“](#was-ein-agent-erreichen-kann) Ein Agent startet mit nichts außer logischem Denken, Rechnen, der aktuellen Uhrzeit und öffentlichen Webseiten. Alles darüber hinaus hast du hinzugefügt: | Reichweite | Herkunft | Umfang | | ----------------------------- | ------------------------------------------------------------------------------------------------ | --------------------------------------------------------- | | Ein Dienst, den du nutzt | Eine [Verbindung](/de/docs/connect/overview/), die du autorisiert **und** diesem Agenten zugewiesen hast | Dieses Konto, diese Operationen | | Ein vorgefertigter Ablauf | Ein [Skill](/de/docs/capabilities/skills/), der diesem Agenten zugewiesen ist | Was die Schritte des Skills tun | | Ein Server, den du betreibst | Eine [Direktverbindung](/de/docs/connect/direct-connections/), die diesem Agenten zugewiesen ist | Dieser Endpunkt. Bei einem HTTP-Server nur Pfade darunter | | Ein Computer oder ein Browser | Die [Geräte](/de/docs/build/devices/) des Agenten | Sein endue Computer und sein endue for Chrome | | Integrierte Fähigkeiten | Eingeschaltete [Tool-Gruppen](/de/docs/capabilities/built-in-tools/) | Deine endue-Umgebung | | Fakten über dich | Was er im [Gedächtnis](/de/docs/capabilities/memory/) gespeichert hat | Nur dieser Agent | ## Was er nicht erreichen kann [Abschnitt betitelt „Was er nicht erreichen kann“](#was-er-nicht-erreichen-kann) * **Unterhaltungen, Gedächtnis und Zuweisungen anderer Agenten.** Agenten sind voneinander isoliert. * **Seine eigenen anderen Unterhaltungen.** Eine [Unterhaltung](/de/docs/work/conversations/) liest nicht in eine andere hinüber. * **Dienste, die du nicht verbunden hast.** Es gibt keine allgemeine Fähigkeit, „irgendeine API aufzurufen“. Eine [Direktverbindung](/de/docs/connect/direct-connections/) erreicht nur den Server, den du registriert hast. * **Operationen, die ein Connector nicht anbietet.** Jeder Connector hat eine feste Liste, siehe [Verfügbare Connectors](/de/docs/connect/available-connectors/). * **Alles auf deinem eigenen Rechner**, es sei denn, du installierst dort [endue Computer](/de/docs/build/own-server/) für diesen Agenten. Selbst dann arbeitet der Agent als eigener Benutzer innerhalb der Grenzen, die du bei der Installation festlegst. ## Die Schranke vor unumkehrbaren Aktionen [Abschnitt betitelt „Die Schranke vor unumkehrbaren Aktionen“](#die-schranke-vor-unumkehrbaren-aktionen) Jede Connector-Operation ist eingestuft. Operationen der Klassen **Senden** (alles, was dein Konto verlässt und jemand anderen erreicht) und **Destruktiv** (alles, was löscht oder überschreibt) halten an und zeigen dir vor der Ausführung genau die Aktion mit genau den Argumenten. Die Schranke lässt sich nicht abschalten Es gibt keine Einstellung, weder pro Agent noch pro Konto, mit der ein Agent ohne Nachfrage senden oder löschen darf. In einer unbeaufsichtigten Ausführung, etwa in einer [Routine](/de/docs/automate/routines/) oder einem [Kanal](/de/docs/automate/channels/), wird eine solche Aktion abgelehnt statt ausgeführt. Eine Freigabe erlaubt *diese Aktion mit diesen Argumenten*, und zwar einmal. Bei der nächsten wird wieder gefragt. ## Wie Zugangsdaten aufbewahrt werden [Abschnitt betitelt „Wie Zugangsdaten aufbewahrt werden“](#wie-zugangsdaten-aufbewahrt-werden) Wenn du einen Connector autorisierst, speichert endue das daraus entstehende Token, niemals dein Passwort. Das gibst du beim Anbieter ein, nicht in endue. Gespeicherte Zugangsdaten sind verschlüsselt und werden nur für die Aufrufe verwendet, die die Operationen des Connectors beschreiben. Schlüssel von Modellanbietern, die du über [BYOK](/de/docs/account/bring-your-own-key/) hinterlegst, werden genauso behandelt, ebenso die Header-Werte einer [Direktverbindung](/de/docs/connect/direct-connections/). Diese werden nach dem Speichern nie wieder angezeigt und nie an den Agenten weitergegeben. ## Zugriff entziehen [Abschnitt betitelt „Zugriff entziehen“](#zugriff-entziehen) | Was du entziehen willst | So gehst du vor | Wirkung | | ------------------------------------------------ | ------------------------------------------------------------------------------- | --------------------------------------------------------------------------- | | Den Zugriff eines Agenten auf einen Dienst | Hebe die Zuweisung der Verbindung im [Agent Builder](/de/docs/build/agent-builder/) auf | Sofort, für diesen Agenten | | Den Zugriff aller Agenten | Entferne die Verbindung in endue | Sofort, überall | | Den gesamten Zugriff von endue | Widerrufe ihn zusätzlich beim Anbieter | endue kann keine Aufrufe mehr machen, auch nicht mit einem veralteten Token | | Einen geteilten [Output](/de/docs/capabilities/outputs/) | Schalte das Teilen per Link aus | Der Link funktioniert nicht mehr | Für einen sauberen Schnitt erledige beides, bei endue und beim Anbieter. Wenn du eine Verbindung in endue entfernst, widerruft das nicht die Registrierung von endue beim Anbieter. ## Praktische Tipps [Abschnitt betitelt „Praktische Tipps“](#praktische-tipps) * **Weise gezielt zu.** Der Agent, der deine E-Mails entwirft, braucht deine Produktions-Dashboards nicht. * **Sei vorsichtig mit Agenten in Kanälen.** Wer den Bot erreicht, kann mit dem Agenten sprechen. Ein Agent, der in einem [Kanal](/de/docs/automate/channels/) erreichbar ist, sollte daher keine sensiblen Verbindungen haben. * **Lies Freigabeanfragen.** Sie sind dazu da, dass du einen falschen Empfänger bemerkst, und sie nennen ihn. * **Lies, was du teilst.** Ein Output, der aus deinen Mails entstanden ist, kann daraus zitieren, und ein geteilter Link ist für alle öffentlich, die ihn haben. * **Prüfe das Gedächtnis ab und zu.** Agenten notieren auch, was sie nur ableiten, und du kannst löschen, was dort nicht hingehört. ## Siehe auch [Abschnitt betitelt „Siehe auch“](#siehe-auch) [Freigaben](/de/docs/work/approvals/)Die Schranke selbst und wie sie sich ohne Aufsicht verhält. [Connectors im Überblick](/de/docs/connect/overview/)Verbindung und Zuweisung: der Kern des Zugriffsmodells. [Fehlerbehebung bei Verbindungen](/de/docs/connect/troubleshooting/)Widerrufen, erneut autorisieren und das falsche Konto. # Einstellungen > Was in jedem Tab der Einstellungen steckt, und die drei Optionen, die nur hier dokumentiert sind – Design, Oberflächensprache und Zeitzone. Die **Einstellungen** sind der kontoweite Bereich: wie die App aussieht, welche Sprache sie spricht, worüber sie dich informiert und alles rund um dein Konto und die Abrechnung. ## Wann du sie nutzt [Abschnitt betitelt „Wann du sie nutzt“](#wann-du-sie-nutzt) In den Einstellungen steht, was für alle deine Agenten gilt. Alles, was nur für *einen* Agenten gilt, etwa sein Prompt, sein Modell oder seine Tools, findest du stattdessen im [Agent Builder](/de/docs/build/agent-builder/). ## So kommst du hin [Abschnitt betitelt „So kommst du hin“](#so-kommst-du-hin) Öffne unten in der linken Seitenleiste das Kontomenü und wähle **Einstellungen**. Oben gibt es ein Suchfeld: Tippst du ein Wort ein, springst du direkt zum Abschnitt, der es enthält. Das geht schneller, als sich zu merken, unter welchem Tab etwas liegt. ## Was in jedem Tab steckt [Abschnitt betitelt „Was in jedem Tab steckt“](#was-in-jedem-tab-steckt) | Tab | Abschnitte | Dokumentiert in | | -------------- | ----------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Konto** | Profil · Anmeldung & Sicherheit · Tarif · LLM-Schlüssel · API-Schlüssel · LLM API · Erlaubte Tools · Abmelden · Konto löschen | [Sicherheit und Berechtigungen](/de/docs/account/security/), [Eigenen API-Schlüssel nutzen](/de/docs/account/bring-your-own-key/), [Agent API](/de/docs/build/agent-api/), [LLM API](/de/docs/build/llm-api/) | | **Allgemein** | Darstellung · Sprache & Region · Benachrichtigungen | Diese Seite und [Benachrichtigungen](/de/docs/work/inbox/) | | **Funktionen** | Eine Vorschauliste mit Funktionsschaltern | Diese Seite | | **Abrechnung** | Aktueller Tarif · Zahlung · Nutzungs-Credits · Rechnungen · Kündigen | [Tarife und Nutzung](/de/docs/account/plans-and-usage/) | ## Darstellung [Abschnitt betitelt „Darstellung“](#darstellung) Für das **Design** gibt es drei Optionen: Hell, Dunkel und System. System folgt deinem Betriebssystem, auch wenn es bei Sonnenuntergang umschaltet. Die Auswahl gilt sofort und wird in diesem Browser gespeichert. Ein Browser, in dem du noch nichts gewählt hast, startet mit Dunkel. ## Sprache und Region [Abschnitt betitelt „Sprache und Region“](#sprache-und-region) Die **Anzeigesprache** legt die Sprache der Oberfläche fest: Englisch oder Koreanisch. Die Änderung wirkt sofort, die App lädt nicht neu. Zwei Dinge macht die Umstellung nicht: * Sie ändert nicht, was deine Agenten schreiben. Ein Agent antwortet in der Sprache der Unterhaltung, und seine eigene Sprache ist Teil seiner [Identität](/de/docs/build/identity/). * Sie übersetzt keine Inhalte, die von dir oder einem Agenten stammen. Prompts, Erinnerungen, Outputs und Nachrichten bleiben in der Sprache, in der sie geschrieben wurden. Die **Zeitzone** legt fest, in welcher Zone Datum und Uhrzeit in der gesamten App angezeigt werden. Eine Routine behält ihre eigene Zeitzone Wenn du eine [Routine](/de/docs/automate/routines/) erstellst, speichert ihr Zeitplan die Zeitzone des Geräts, auf dem du sie erstellt hast, und behält diese Zone danach bei. Änderst du hier die Zeitzone des Kontos, ändert sich nur, wie Zeiten *angezeigt* werden. Eine bereits geplante Routine verschiebt sich dadurch nicht. ## Benachrichtigungen [Abschnitt betitelt „Benachrichtigungen“](#benachrichtigungen) Der dritte Abschnitt unter **Allgemein** legt fest, welche Ereignisse dich erreichen und ob sie als Browserbenachrichtigungen ankommen. Er hat eine eigene Seite: [Benachrichtigungen](/de/docs/work/inbox/). ## Funktionen [Abschnitt betitelt „Funktionen“](#funktionen) Der Tab **Funktionen** ist eine Vorschau auf Schalter, die noch nicht angebunden sind. Umschalten wird nicht gespeichert, und wenn du die Einstellungen erneut öffnest, steht der Schalter wieder wie vorher. Derzeit schaltet dort nichts eine Fähigkeit ein oder aus. ## Einschränkungen [Abschnitt betitelt „Einschränkungen“](#einschränkungen) * Das Design wird pro Browser gespeichert. Ein neues Gerät startet mit Dunkel, bis du etwas auswählst. * Die Oberflächensprache gilt für die Konsole. Die [Dokumentation](/) ist eine eigene Website mit eigener Sprachumschaltung in der Fußzeile. * Die Liste der Zeitzonen umfasst eine feste Auswahl, nicht jede Zeitzone der Welt. * Der Tab Funktionen speichert nichts. Betrachte ihn als Vorschau, nicht als Bedienelement. ## Siehe auch [Abschnitt betitelt „Siehe auch“](#siehe-auch) [Benachrichtigungen](/de/docs/work/inbox/)Der dritte Abschnitt unter Allgemein, ausführlich. [Sicherheit und Berechtigungen](/de/docs/account/security/)Anmeldung, Sitzungen und was ein Agent tun darf. [Tarife und Nutzung](/de/docs/account/plans-and-usage/)Worum es im Tab Abrechnung geht. [Identität und Profil](/de/docs/build/identity/)Die Einstellungen pro Agent, die nicht hier stehen. # Nutzungsübersicht > Wo du abliest, was deine Agenten verbraucht haben – Tokens insgesamt, welche Modelle und welche Agenten sie verbraucht haben, wie viel von deinem Tarifkontingent übrig ist und die Nutzung einer einzelnen Unterhaltung. Die **Nutzungsübersicht** zeigt, was deine Agenten verbraucht haben: Tokens im Zeitverlauf, aufgeschlüsselt nach Modell und nach Agent. ## Wann du sie nutzt [Abschnitt betitelt „Wann du sie nutzt“](#wann-du-sie-nutzt) Öffne sie, wenn das Token-Badge auf dem Board [Aktivität](/de/docs/work/activity/) höher ist als erwartet, bevor du das Modell einer [Routine](/de/docs/automate/routines/) änderst, oder zu Wochenbeginn, um zu sehen, wohin die Nutzung der letzten Woche geflossen ist. *Was* Nutzung verursacht und wie das Kontingent funktioniert, erklärt [Tarife und Nutzung](/de/docs/account/plans-and-usage/). Lies das zuerst. Auf dieser Seite geht es darum, die Zahlen zu lesen. ## So kommst du hin [Abschnitt betitelt „So kommst du hin“](#so-kommst-du-hin) 1. **Öffne den Tab Nutzung** auf dem Startbildschirm oder wähle das Token-Badge in der Kopfzeile von Aktivität. 2. **Wähle einen Zeitraum.** 7 Tage, 30 Tage oder 3 Monate. Der Zeitraum ändert die Kacheln und die Diagramme. Die Jahreskarte der Aktivität zeigt immer das aktuelle Jahr. 3. **Wechsle zwischen den vier Tabs**: Übersicht, Modelle, Agenten, Rechenleistung. ## Übersicht [Abschnitt betitelt „Übersicht“](#übersicht) Die Kacheln oben beantworten „wie viel, wie oft und womit“: | Kachel | Zeigt | | ------------------------- | ------------------------------------------------------------------------------------------- | | **Tokens gesamt** | Alles, was im Zeitraum gesendet und empfangen wurde | | **Anfragen** | Wie viele Modellaufrufe dafür nötig waren | | **Aktive Tage** | Tage im Zeitraum mit irgendeiner Nutzung | | **Aktuelle Serie** | Aufeinanderfolgende Tage mit Nutzung, dazu als Hinweis deine längste Serie | | **Meistgenutztes Modell** | Das Modell mit den meisten Tokens | | **Nutzungs-Credits** | Die Ausgaben dieser Woche in Credits. Die Kachel nennt das verwendete Umrechnungsverhältnis | Darunter ist das **Tarifkontingent** der Wert, auf den du achten solltest: ein Balken, der zeigt, wie viel vom aktuellen Kontingent verbraucht ist, und ein klarer Hinweis, wenn es erschöpft ist. Das ist dieselbe Zahl, die der Dienst prüft, bevor er eine [Ausführung](/de/docs/work/runs/) startet. Ist der Balken voll, stoppen die Ausführungen. **Tägliche Aktivität** ist eine Jahreskarte mit einem Feld pro Tag, dunkler dort, wo du mehr genutzt hast. So entdeckst du am schnellsten eine Routine, die unbemerkt angefangen hat, jeden Tag zu verbrauchen. ## Modelle und Agenten [Abschnitt betitelt „Modelle und Agenten“](#modelle-und-agenten) Beide Tabs sind gleich aufgebaut: oben ein Tagesdiagramm, darunter eine Aufschlüsselung. * **Modelle**: an welche Modelle die Tokens gingen. Das ist der größte Kostenhebel, deshalb beginnt hier meist die Entscheidung, ein Modell zu wechseln. Siehe [Modell wählen](/de/docs/build/models/). * **Agenten**: welche Agenten verbraucht haben und welche Modelle jeder davon genutzt hat. Ein Agent mit vielen Routinen fällt hier auf, lange bevor du ihn anderswo bemerkst. In beiden Tabs ist die Legende ein Filter: Blende eine Datenreihe aus, um den Rest ohne sie zu lesen, und **Alle anzeigen** holt alle zurück. Zeilen, für die im Diagramm kein Platz ist, werden unter „Sonstige“ gesammelt, statt wegzufallen. „Nicht zugeordnet“ ist kein Fehler Der Tab Agenten hat eine Zeile **Nicht zugeordnet** für Nutzung, die keinem einzelnen Agenten zuzuordnen ist: Aufrufe auf Kontoebene, darunter Modelle, die du direkt über die [LLM API](/de/docs/build/llm-api/) aufrufst. Das sind echte Ausgaben, nur ohne Agenten, dem man sie zurechnen kann. Der Tab Quellen schlüsselt sie auf. ## Quellen [Abschnitt betitelt „Quellen“](#quellen) Der Tab **Quellen** teilt dieselben Tokens nach ihrer Herkunft auf: * **Agenten**: Ausführungen von Agenten aus Web-Chats, Routinen und Kanälen. * **Agent API**: Agenten, die mit einem API-Schlüssel über die [Agent API](/de/docs/build/agent-api/) aufgerufen werden. * **endue Live**: Unterhaltungen, die Besuchende auf endue Live mit deinem Agenten geführt haben. Unterhaltungen von Besuchenden zählen als Nutzung des Kontos, dem der Agent gehört. * **LLM API**: Modelle, die direkt mit einem API-Schlüssel über die [LLM API](/de/docs/build/llm-api/) aufgerufen werden. Jede Zeile zeigt Tokens, Anteil und Anfragen, darunter die verwendeten Modelle. Auch hier funktioniert die Legende als Filter. Aufrufe über die LLM API werden aus gekauften Credits und Aktions-Credits bezahlt, während Ausführungen von Agenten, über die Agent API und auf endue Live das Tarifkontingent nutzen. Öffne diesen Tab also, wenn sich ein Credit-Guthaben bewegt und kein Agent das erklärt. ## Rechenleistung [Abschnitt betitelt „Rechenleistung“](#rechenleistung) Browsersitzungen, Speicher des Arbeitsbereichs, Medienverarbeitung und Output-Speicher sind hier aufgeführt, werden aber **noch nicht gemessen**. Der Tab sagt das in jeder Zeile. Lies leere Zeilen als „noch nicht erfasst“, nicht als „null“. Nichts auf diesem Tab besagt, dass eine Ressource kostenlos ist. ## Ein Agent im Detail [Abschnitt betitelt „Ein Agent im Detail“](#ein-agent-im-detail) Klappe im Tab Agenten eine Zeile auf. Am Ende findest du **In Studio öffnen**. Damit öffnet sich das Canvas dieses Agenten im Tab Nutzung für denselben Zeitraum. Dort siehst du Chats und Credits nach Quelle und nach Zugang (API-Schlüssel oder Kanalverbindung). Siehe [Analysen](/de/docs/build/analytics/). ## Nutzung einer einzelnen Unterhaltung [Abschnitt betitelt „Nutzung einer einzelnen Unterhaltung“](#nutzung-einer-einzelnen-unterhaltung) Die Übersicht gilt pro Konto. Für eine einzelne Unterhaltung tippst du **`/usage`** in ihr Eingabefeld: Eine Karte zeigt Eingabe- und Ausgabetokens, wie viele davon aus dem Cache kamen, die gewichtete Summe, Credits und die beteiligten Modelle, dazu einen Link in die Übersicht. Die Karte ist eine lokale Ansicht, keine Nachricht. Sie erscheint nicht im Verlauf und ist nach einem Neuladen verschwunden. Zwei verschiedene Zahlen, beide richtig Die Karte von `/usage` zählt, was die Unterhaltung *bisher verbraucht* hat. Das Panel [Kontextfenster](/de/docs/work/context-window/) zählt, was *gerade ins Modell geladen* ist. Das sind verschiedene Achsen, die Werte stimmen nicht überein. ## Einschränkungen [Abschnitt betitelt „Einschränkungen“](#einschränkungen) * Die Nutzung wird pro Konto gemessen. Die Ansicht pro Agent schlüsselt dieselbe Summe auf und ist kein eigenes Kontingent. * Die Zahlen werden kurz nach einer Ausführung verbucht, daher kann die neueste Ausführung eine kurze Weile fehlen. * Ausführungen mit [deinem eigenen Schlüssel](/de/docs/account/bring-your-own-key/) werden hier nicht erfasst. Eine Unterhaltung, die nur deinen eigenen Schlüssel genutzt hat, erscheint als „keine Nutzung erfasst“. Für das Protokoll von endue stimmt das, über die Rechnung deines Anbieters sagt es nichts. * Die Aggregation pro Agent und pro Quelle ist nicht in jeder Umgebung verfügbar. Wenn nicht, sagt der Tab das, statt null anzuzeigen. * Der Tab Rechenleistung ist eine Liste von Ressourcen, keine Messung. ## Siehe auch [Abschnitt betitelt „Siehe auch“](#siehe-auch) [Tarife und Nutzung](/de/docs/account/plans-and-usage/)Was das Kontingent verbraucht und wie das Wochenfenster funktioniert. [Modell wählen](/de/docs/build/models/)Die Entscheidung, für die es den Tab Modelle gibt. [Eigenen API-Schlüssel nutzen](/de/docs/account/bring-your-own-key/)Warum manche Ausführungen hier nie auftauchen. [Aktivität](/de/docs/work/activity/)Das Board, dessen Token-Badge hierher führt. # Kanäle > Einen Agenten über Discord, Slack, KakaoTalk, NaverTalk oder WhatsApp erreichen – wie die Kopplung funktioniert, wer ihn aufrufen darf und was ein Agent dort nicht tut. Über einen **Kanal** können Personen einen Agenten auch außerhalb von endue erreichen. Koppelst du einen Agenten mit einer Messaging-Plattform, antwortet er direkt dort im Thread, ohne dass jemand endue öffnen muss. ## Wann sich ein Kanal eignet [Abschnitt betitelt „Wann sich ein Kanal eignet“](#wann-sich-ein-kanal-eignet) Wenn die Personen, die den Agenten brauchen, schon anderswo sind: ein Team in Slack, eine Community in Discord oder Kundschaft, die deinem Unternehmen über KakaoTalk, NaverTalk oder WhatsApp schreibt. Ein Kanal bringt den Agenten dorthin, wo die Frage gestellt wird. Das ist die umgekehrte Richtung zum [Slack-Connector](/de/docs/connect/slack/), mit dem ein Agent im Rahmen seiner eigenen Arbeit in einem Chatdienst *liest und schreibt*. Beides ist voneinander unabhängig, und du kannst beides nutzen. ## Verfügbare Kanäle [Abschnitt betitelt „Verfügbare Kanäle“](#verfügbare-kanäle) | Kanal | So wird er verbunden | So rufen Personen den Agenten auf | | ------------- | ----------------------------------------------------------------------------------------- | ----------------------------------------------- | | **Discord** | Bot-Token einfügen; Server, Endpunkt und Zulassungsliste werden automatisch ermittelt | `/ask` auf dem Server | | **Slack** | Zwei Tokens aus deiner Slack-App (Socket Mode, kein öffentlicher Endpunkt nötig) | Die App erwähnen; sie antwortet in einem Thread | | **KakaoTalk** | Die Webhook-URL, die endue ausgibt, beim Skill-Server deines Chatbot-Builders einfügen | Nachricht an den Kanal | | **NaverTalk** | Den Sende-API-Schlüssel eingeben, die Webhook-URL im Partner Center einfügen | Nachricht an das TalkTalk-Konto | | **WhatsApp** | Das Zugriffstoken der Cloud API eingeben, die Webhook-URL in deiner Meta-App registrieren | Nachricht an die Business-Nummer | | **Telegram** | — | Demnächst verfügbar | Dahinter stecken zwei Verfahren. Bei Discord und Slack hält endue ein Token und wendet sich *von sich aus* an die Plattform. Bei KakaoTalk, NaverTalk und WhatsApp ruft *die Plattform* eine Webhook-URL auf, die endue ausgibt; diese URL fügst du in der Konsole des Anbieters ein. NaverTalk und WhatsApp brauchen zusätzlich Zugangsdaten zum Senden, weil Antworten dort eine eigene Authentifizierung erfordern. ## Einen Kanal koppeln [Abschnitt betitelt „Einen Kanal koppeln“](#einen-kanal-koppeln) 1. **Öffne Kanäle** im [Agent Builder](/de/docs/build/agent-builder/) im Abschnitt „Kopplung“ des Agenten und wähle den Anbieter. 2. **Gib ein, was der Anbieter braucht**: ein Bot-Token, zwei App-Tokens oder einen Sendeschlüssel. Das Formular benennt jedes Feld. 3. **Bei Anbietern mit eingehendem Webhook kopierst du die Webhook-URL, die endue dir anzeigt,** und fügst sie in der Konsole des Anbieters ein: beim Skill-Server des KakaoTalk-Chatbot-Builders, im Partner Center von NaverTalk oder in den Webhook-Einstellungen deiner Meta-App. 4. **Bei Discord und Slack lädst du den Bot auf den Server bzw. in den Workspace ein.** Lade den Bot ein, bevor du Antworten erwartest Ein gekoppelter Kanal, dessen Bot nicht eingeladen wurde, wirkt verbunden, antwortet aber nie. Wird ein Kanal still, nachdem er funktioniert hat, prüfe, ob der Bot noch auf dem Server ist, und stelle die Kopplung neu her, falls er entfernt wurde. ## Wer ihn aufrufen darf [Abschnitt betitelt „Wer ihn aufrufen darf“](#wer-ihn-aufrufen-darf) Ein Kanal ist ein Zugang zu einem Agenten, dem deine Verbindungen zugewiesen sind. Deshalb hat jede Kopplung eine Aufrufrichtlinie: | Richtlinie | Wer aufrufen darf | | ---------------------------- | ----------------------------------------------------------------------------- | | **Nur ich** | Das Konto, das den Kanal gekoppelt hat, plus alle auf der Zulassungsliste | | **Nur zugelassene Personen** | Die Zulassungsliste und sonst niemand | | **Alle im Kanal** | Alle, die den Bot auf diesem Server oder in diesem Workspace erreichen können | Wer nicht berechtigt ist, bekommt eine kurze Absage statt Schweigen, und die Anfrage erscheint im Panel der Kopplung. Dort kannst du die Person zur Zulassungsliste hinzufügen oder eine ID von Hand eintragen. Offene Kanäle stehen allen Anwesenden offen „Alle im Kanal“ bedeutet, dass jedes Mitglied dieses Servers oder Workspaces mit dem Agenten sprechen kann, mit allem, was du ihm zugewiesen hast. Richte den Agenten entsprechend ein: Ein Agent, der in einem Kanal erreichbar ist, sollte keinen Zugriff auf deinen Posteingang haben. ## Was eine Kanal-Unterhaltung ist [Abschnitt betitelt „Was eine Kanal-Unterhaltung ist“](#was-eine-kanal-unterhaltung-ist) Eine Unterhaltung, die in einem Kanal beginnt, ist eine vollwertige Unterhaltung, mit demselben Verlauf, demselben [Gedächtnis](/de/docs/capabilities/memory/) und denselben [Outputs](/de/docs/capabilities/outputs/) wie eine, die du in endue startest. Du kannst sie später in endue öffnen und dort weiterführen. Der Agent weiß, wer gesprochen hat. In einem Kanal, in dem mehrere Personen mit ihm sprechen, werden die Nachrichten zugeordnet, sodass er *„Was habe ich dich vorhin gefragt?“* für jede Person richtig beantworten kann. ## Was ein Agent in einem Kanal nicht tut [Abschnitt betitelt „Was ein Agent in einem Kanal nicht tut“](#was-ein-agent-in-einem-kanal-nicht-tut) Anders als bei einer Ausführung im Chat steht bei einer Kanal-Ausführung niemand für [Freigaben](/de/docs/work/approvals/) bereit. Behandle sie also als unbeaufsichtigt: * Aktionen, die etwas nach außen senden oder löschen, werden abgelehnt, statt zurückgehalten zu werden. * Eine [Frage](/de/docs/work/questions/), auf die der Agent eine Antwort braucht, muss im Thread beantwortet werden; die Auswahloberfläche, die endue sonst anzeigt, steht dort nicht zur Verfügung. Ein Agent, der Fragen beantwortet, sucht und zusammenfasst, funktioniert über einen Kanal gut. Einer, dessen Aufgabe das Versenden ist, nicht. ## Einschränkungen [Abschnitt betitelt „Einschränkungen“](#einschränkungen) * Derzeit Discord, Slack, KakaoTalk, NaverTalk und WhatsApp; Telegram folgt. * Eine Kopplung pro Agent und Anbieter. * Antworten erscheinen im Kanal als Bot, nicht in deinem Namen. * Anbieter mit eingehendem Webhook (KakaoTalk, NaverTalk, WhatsApp) antworten über ihren eigenen Sendeweg. Die Formatierung der Nachrichten richtet sich deshalb nach dem Anbieter, nicht nach endue. ## Siehe auch [Abschnitt betitelt „Siehe auch“](#siehe-auch) [Slack-Connector](/de/docs/connect/slack/)Die andere Richtung: ein Agent, der Slack im Rahmen seiner Arbeit liest. [Sicherheit und Berechtigungen](/de/docs/account/security/)Was du einem Agenten zuweisen solltest, mit dem andere sprechen können. [Unterhaltungen](/de/docs/work/conversations/)Was aus einem Kanal-Thread in endue wird. # Routinen > Wiederkehrende Arbeit einplanen – wie eine Routine läuft, was sie erstellt und warum eine unbeaufsichtigte Ausführung nichts versendet. Eine **Routine** ist eine Anweisung, die ein Agent nach Zeitplan ausführt, ob endue gerade geöffnet ist oder nicht. ## Wann sich eine Routine eignet [Abschnitt betitelt „Wann sich eine Routine eignet“](#wann-sich-eine-routine-eignet) Wenn dieselbe Bitte immer wiederkommt: eine morgendliche Zusammenfassung des Posteingangs, ein Bericht jeden Montag, eine nächtliche Prüfung, ob sich etwas verändert hat, das sich nicht hätte verändern sollen. Wenn du einen Agenten dreimal um dasselbe gebeten hast, ist es eine Routine. ## Eine Routine erstellen [Abschnitt betitelt „Eine Routine erstellen“](#eine-routine-erstellen) Am einfachsten bittest du darum. Sag dem Agenten in einer Unterhaltung, was wann passieren soll, etwa *„mach das jeden Werktag um 8 Uhr“*, und er legt die Routine an. Anschließend kannst du sie prüfen. 1. **Bring zuerst die Aufgabe in Form.** Führe sie einmal von Hand aus. Eine Routine wiederholt genau das, worum du gebeten hast, samt aller Unklarheiten. 2. **Leg den Zeitplan fest.** Routinen laufen nach einem wiederkehrenden Zeitplan mit Zeitzone: jeden Werktag um 08:00 Uhr in der Zeitzone Asia/Seoul, am Ersten des Monats, alle vier Stunden. 3. **Sag, wohin das Ergebnis soll.** Meist ist das ein [Output](/de/docs/capabilities/outputs/), der schon auf dich wartet, zusammen mit einer Benachrichtigung, die darauf verweist. 4. **Beobachte die ersten Ausführungen.** Die Lücke zwischen dem, was du gemeint hast, und dem, was der Agent tut, zeigt sich sofort, und dann lässt sie sich am günstigsten schließen. ## Was bei jeder Ausführung passiert [Abschnitt betitelt „Was bei jeder Ausführung passiert“](#was-bei-jeder-ausführung-passiert) Die Routine wird ausgelöst, der Agent führt die Anweisung aus, als hättest du sie selbst gesendet, und das Ergebnis landet in endue. Du bekommst eine Benachrichtigung, wenn sie fertig ist, und eine weitere, wenn sie fehlschlägt. Siehe [Benachrichtigungen](/de/docs/work/inbox/). Eine Routine, die immer wieder fehlschlägt, wird pausiert, und du erfährst davon. Das ist Absicht: Eine defekte Routine, die es eine Woche lang stündlich erneut versucht, ist schlimmer als eine, die anhält und Bescheid gibt. ## Niemand ist da, um freizugeben [Abschnitt betitelt „Niemand ist da, um freizugeben“](#niemand-ist-da-um-freizugeben) Das ist der wichtigste Punkt, den du bei geplanter Arbeit verstehen musst. Eine unbeaufsichtigte Ausführung kann dich nichts fragen. Eine Aktion, die normalerweise auf eine [Freigabe](/de/docs/work/approvals/) warten würde, etwa eine E-Mail senden, in einem Kanal posten oder etwas löschen, wird **abgelehnt** und nicht in eine Warteschlange gestellt. Plane das von Anfang an ein: | Statt | Bitte um | | ------------------------------------------- | ------------------------------------------------------------------------------ | | „Schick mir die Zusammenfassung per E-Mail“ | „Schreib die Zusammenfassung als Output“ – die Benachrichtigung führt dich hin | | „Poste die Zusammenfassung in Slack“ | Einen Output, den du selbst postest, sobald du ihn gelesen hast | | „Beantworte alles Dringende“ | „Entwirf Antworten auf alles Dringende“ – Entwürfe brauchen keine Freigabe | Dasselbe gilt für [Fragen](/de/docs/work/questions/): Eine Routine, die eine Entscheidung braucht, hat niemanden, den sie fragen kann. Formuliere die Anweisung also so genau, dass keine Entscheidung nötig ist. Modell für die Routine festlegen Eine Routine kann ein eigenes Modell verwenden, unabhängig vom Standardmodell des Agenten. So bleiben Kosten und Verhalten einer geplanten Aufgabe stabil, während du den Agenten neu abstimmst. ## Routinen verwalten [Abschnitt betitelt „Routinen verwalten“](#routinen-verwalten) Routinen werden pro Agent aufgelistet, und jede hat eine eigene Seite mit Zeitplan, Verlauf und den Ausführungen, die sie ausgelöst hat. Du kannst eine Routine jederzeit pausieren, bearbeiten oder beenden, und Agenten können ihre eigenen Routinen auflisten und verwalten, wenn du sie darum bittest. ## Einschränkungen [Abschnitt betitelt „Einschränkungen“](#einschränkungen) * Eine unbeaufsichtigte Ausführung lehnt freigabepflichtige Aktionen ab. Eine „Vorab-Freigabe“ gibt es nicht. * Eine Routine gehört zu genau einem Agenten und enthält genau eine Anweisung. * Wiederholte Fehler pausieren die Routine, statt endlose Wiederholungsversuche auszulösen. * Routinen laufen auf den Servern von endue und können deshalb nichts auf deinem eigenen Rechner erreichen. ## Siehe auch [Abschnitt betitelt „Siehe auch“](#siehe-auch) [Freigaben](/de/docs/work/approvals/)Warum eine geplante Ausführung das Senden verweigert. [Outputs](/de/docs/capabilities/outputs/)Wohin die Ergebnisse geplanter Arbeit gehören. [Benachrichtigungen](/de/docs/work/inbox/)Wie du erfährst, dass eine Routine fertig oder fehlgeschlagen ist. # Agent API > Ruf einen Agenten per HTTP mit einem Schlüssel auf, der nur für ihn gilt – als einzelne Anfrage oder als Sitzung, die ihren Kontext zwischen den Aufrufen behält. Im Bereich **API** erstellst du Schlüssel, mit denen etwas außerhalb von endue diesen Agenten aufrufen kann. Neben einer [Unterhaltung](/de/docs/work/conversations/) und einem [Kanal](/de/docs/automate/channels/) ist das der dritte Weg zum Agenten, und zwar der für Programme. ## Wann du sie nutzt [Abschnitt betitelt „Wann du sie nutzt“](#wann-du-sie-nutzt) Wenn Code den Agenten aufruft: ein Skript, das täglich eine Zusammenfassung ablegt, ein Backend, das einen Agenten etwas klassifizieren lässt, ein Job, der in der CI läuft. Ruft eine Person den Agenten auf, passt ein Kanal besser, denn dort bekommt sie einen Thread, Fragen und Freigaben. ## Schlüssel erstellen [Abschnitt betitelt „Schlüssel erstellen“](#schlüssel-erstellen) 1. **Öffne den Bereich API** im [Agent Builder](/de/docs/build/agent-builder/) und erstelle einen Schlüssel. 2. **Kopiere ihn sofort.** Der Schlüssel wird nur einmal angezeigt. Wenn du ihn verlierst, widerrufe ihn und erstelle einen neuen. 3. **Bewahre ihn dort auf, wo ein Programm ihn lesen kann, eine Person aber nicht**: in einer Umgebungsvariable oder einem Secret Store, niemals in einem Repository. Ein hier erstellter Schlüssel gilt **nur für diesen Agenten**: Deine anderen Agenten lassen sich damit nicht aufrufen. Kontoweite Schlüssel, die das können, erstellst du stattdessen unter **Einstellungen → Konto**. Nimm lieber den eng begrenzten. [](/docs/_astro/studio-api.BDspvMMe.png) [In voller Größe öffnen](/docs/_astro/studio-api.BDspvMMe.png) ## Den Agenten aufrufen [Abschnitt betitelt „Den Agenten aufrufen“](#den-agenten-aufrufen) Sende den Schlüssel als `Authorization: Bearer sk_…` (oder `X-API-Key`) und schick per POST, was der Agent tun soll: ```http POST /api/public/v1/agents/{agent_id}/invoke Authorization: Bearer sk_... Content-Type: application/json { "input": "Summarize yesterday's support tickets" } ``` Zurück kommt die Antwort des Agenten zusammen mit einer **Sitzungs-ID**. Schickst du diese ID beim nächsten Aufruf mit, macht der Agent im selben Kontext weiter, also in derselben Unterhaltung mit ihrem Verlauf, statt neu anzufangen: ```json { "input": "Now group them by product area", "session_id": "..." } ``` Mit `"stream": true` bekommst du die Antwort, während sie entsteht, statt auf die ganze Ausführung zu warten. Eine Sitzung ist eine Unterhaltung Sitzungen musst du nicht gesondert verwalten. Jede ist eine Unterhaltung, die du in endue öffnen kannst, in der Seitenleiste unter der API-Gruppe des Agenten. Dort liest du nach, was der Agent gefragt wurde und was er geantwortet hat. ## Was ein API-Aufruf nicht bekommt [Abschnitt betitelt „Was ein API-Aufruf nicht bekommt“](#was-ein-api-aufruf-nicht-bekommt) Wer per API aufruft, sitzt nicht vor der Unterhaltung. Deshalb gilt der Aufruf als [unbeaufsichtigte Ausführung](/de/docs/automate/routines/#niemand-ist-da-um-freizugeben): * Aktionen, die etwas nach außen senden oder löschen, werden **abgelehnt** und nicht zur Freigabe zurückgestellt. * Für [Fragen](/de/docs/work/questions/), die der Agent geklärt haben muss, ist niemand da, der sie beantwortet. Formuliere die Anfrage so genau, dass der Agent nichts entscheiden muss, und rechne eher mit Entwürfen als mit versendeten Nachrichten. ## Einschränkungen [Abschnitt betitelt „Einschränkungen“](#einschränkungen) * Pro Sitzung läuft immer nur eine Ausführung. Ein weiterer Aufruf, während in dieser Sitzung eine Ausführung läuft, wird abgelehnt und nicht eingereiht. * Schlüssel werden nur einmal angezeigt und lassen sich nicht wiederherstellen. Widerrufe sie und erstelle neue. * Ein Schlüssel für einen bestimmten Agenten funktioniert nur für diesen Agenten. Für andere antwortet der Endpunkt mit „nicht gefunden“. * Ein widerrufener Schlüssel ist sofort ungültig. ## Siehe auch [Abschnitt betitelt „Siehe auch“](#siehe-auch) [Kanäle](/de/docs/automate/channels/)Der Weg für Menschen statt für Programme. [Freigaben](/de/docs/work/approvals/)Warum ein API-Aufruf nicht von sich aus E-Mails senden kann. [Sicherheit und Berechtigungen](/de/docs/account/security/)Worauf ein Schlüssel zugreifen kann und wie du ihn widerrufst. # Agent Builder > Hier erstellst du einen Agenten und stimmst alles an ihm ab – Identität, Prompt, Gedächtnis, Skills, Connectors, integrierte Tools, Kanäle und Speicher. Im **Agent Builder** erstellst du einen Agenten und stimmst alles an ihm ab. Jede Einstellung, die das Verhalten eines Agenten ändert, liegt hier, aufgeteilt auf vier Bereiche. ## Wann du ihn nutzt [Abschnitt betitelt „Wann du ihn nutzt“](#wann-du-ihn-nutzt) Öffne den Agent Builder, wenn du ändern willst, *was ein Agent ist*, statt ihm eine Aufgabe zu geben. Einen Agenten erstellen, seinen Prompt umschreiben, ihm einen Connector geben, eine Fähigkeit abschalten, nachsehen, was er sich gemerkt hat: Das alles passiert hier. Die tägliche Arbeit findet dagegen in einer [Unterhaltung](/de/docs/work/conversations/) statt. ## Einen Agenten erstellen [Abschnitt betitelt „Einen Agenten erstellen“](#einen-agenten-erstellen) 1. **Leg einen neuen Agenten an.** Wähle in deiner Agentenliste die Option, einen neuen Agenten zu erstellen. Du wirst nach einem Namen gefragt, und das Handle wird automatisch daraus erzeugt. Das Handle ist kurz und bleibt gleich. Darüber sprichst du den Agenten später an. 2. **Sag in einem Satz, wofür er da ist.** Sei konkret. *„Fasst jeden Morgen meine ungelesenen E-Mails zusammen und markiert alles, was eine Antwort braucht“* ergibt einen weit besseren Agenten als *„E-Mail-Assistent“*. Aus diesem Satz wächst der [Systemprompt](/de/docs/build/system-prompt/). 3. **Öffne den Agent Builder und arbeite die Bereiche von oben nach unten durch.** Ein neuer Agent kann bereits schlussfolgern, rechnen und öffentliche Webseiten lesen. Alles andere fügst du bewusst hinzu. ## Die vier Bereiche [Abschnitt betitelt „Die vier Bereiche“](#die-vier-bereiche) Der Agent Builder ist danach gegliedert, welchen Teil des Agenten du änderst. | Bereich | Enthält | Seite | | -------------- | --------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------- | | **Identität** | Profil, Prompt, Gedächtnis | [Identität und Profil](/de/docs/build/identity/) · [Systemprompt](/de/docs/build/system-prompt/) · [Gedächtnis](/de/docs/capabilities/memory/) | | **Ressourcen** | Skills, Connectors, Geräte, integrierte Tools | [Skills](/de/docs/capabilities/skills/) · [Connectors](/de/docs/connect/overview/) · [Geräte](/de/docs/build/devices/) · [Integrierte Tools](/de/docs/capabilities/built-in-tools/) | | **Kopplung** | Kanäle, Live, API | [Kanäle](/de/docs/automate/channels/) · [Agent API](/de/docs/build/agent-api/) | | **Inventar** | Arbeitsbereich, Outputs | [Arbeitsbereich](/de/docs/build/workspace/) · [Outputs](/de/docs/capabilities/outputs/) | Diese Aufteilung solltest du verinnerlichen: **Identität** ist, wer der Agent ist, **Ressourcen** sind, worauf er zugreifen kann, **Kopplung** ist, von wo aus man ihn erreicht, und **Inventar** ist, was er erstellt hat. ## Die Anatomie eines Agenten [Abschnitt betitelt „Die Anatomie eines Agenten“](#die-anatomie-eines-agenten) Drei Dinge bestimmen, wie sich ein Agent verhält, grob nach Stärke ihrer Wirkung geordnet: **Sein Systemprompt.** Die dauerhaften Anweisungen, die er vor jeder Unterhaltung liest. Das ist der größte einzelne Hebel, und die meisten nutzen ihn zu wenig. Siehe [Systemprompt und Revisionen](/de/docs/build/system-prompt/). **Was ihm zugewiesen ist.** Ein Agent kann nur die Skills und Verbindungen nutzen, die du ihm zuweist. Zuweisungen gelten pro Agent, nicht pro Konto. Wenn du Gmail einmal verbindest, bekommt also nicht jeder deiner Agenten Zugriff auf deinen Posteingang. **Sein Modell.** Welches Modell die Schleife ausführt und wie viel Denkaufwand es betreibt. Siehe [Modell wählen](/de/docs/build/models/). Lieber eng als breit Ein Agent mit einer Aufgabe und drei Tools leistet mehr als einer mit vagem Zweck und zwanzig Tools. Wenn du merkst, dass du den Prompt eines Agenten für eine zweite Aufgabe erweiterst, bau stattdessen einen zweiten Agenten. ## Einschränkungen [Abschnitt betitelt „Einschränkungen“](#einschränkungen) * Das Handle eines Agenten wird beim Erstellen automatisch aus seinem Namen erzeugt und lässt sich danach nicht mehr ändern. * Änderungen an einem Agenten gelten ab seiner **nächsten** Ausführung. Eine bereits laufende Ausführung behält die Konfiguration, mit der sie gestartet ist, einschließlich Prompt-Revision, Modell und zugewiesener Tools. * Der Agent Builder konfiguriert jeweils einen einzelnen Agenten. Mehrere Agenten auf einmal lassen sich nicht bearbeiten. * Wenn du einen Agenten löschst, bleiben die [Outputs](/de/docs/capabilities/outputs/) erhalten, die er erstellt hat. ## Siehe auch [Abschnitt betitelt „Siehe auch“](#siehe-auch) [Identität und Profil](/de/docs/build/identity/)Name, Handle, Profil und der Charakter, der seinen Ton prägt. [Systemprompt und Revisionen](/de/docs/build/system-prompt/)Dein größter Hebel und wie du ihn sicher änderst. [Modell wählen](/de/docs/build/models/)Der Modellkatalog, der Denkaufwand und wann was zählt. [Testen und iterieren](/de/docs/build/iterating/)Einen Agenten ändern, ohne einen funktionierenden kaputtzumachen. # Analysen > Sieh im Canvas, welche Unterhaltungen ein Agent geführt und wie viele Credits er verbraucht hat. Aufgeteilt nach Quelle (App, API, Live, Kanal, Routine, Space) und nach Zugang (API-Schlüssel oder Kanalverbindung). Für Live siehst du auch Besuche und Herkunft. Die **Analysen** findest du im Tab **Nutzung** des [Canvas](/de/docs/build/canvas/). Das Canvas zeigt, was zu diesem Agenten gehört. Der Tab Nutzung ergänzt, wie viele Anfragen über jeden Zugang eingegangen sind und was sie gekostet haben. ## Wann du sie nutzt [Abschnitt betitelt „Wann du sie nutzt“](#wann-du-sie-nutzt) * Nachdem du Live eingeschaltet hast, um zu sehen, wie viele Menschen gekommen sind, wie viele einen Chat begonnen haben und wie viele Credits das verbraucht hat. * Um herauszufinden, welchen API-Schlüssel deine Integrationen am häufigsten aufrufen. * Um den Tag zu finden, an dem die Nutzung über Kanäle oder Routinen gestiegen ist. Um alle Agenten auf einmal zu vergleichen, nutze die [Nutzungsübersicht](/de/docs/account/usage/). Die Analysen betrachten einen einzelnen Agenten. ## So kommst du hin [Abschnitt betitelt „So kommst du hin“](#so-kommst-du-hin) 1. Öffne das **Studio** des Agenten. 2. Wähle oben im Canvas den Tab **Nutzung**. Die Zelle **Analysen** unter der Agentenkarte führt zur selben Ansicht. 3. Wähle oben rechts einen **Zeitraum**: 7, 30 oder 90 Tage. Den Zeitraum gibt es nur im Tab Nutzung. ## Kennzahlen im Canvas [Abschnitt betitelt „Kennzahlen im Canvas“](#kennzahlen-im-canvas) Im Tab Nutzung zeigen die Knoten in der linken Spalte (Eingehende Anfragen) Kennzahlen an. | Knoten | Was er zeigt | | -------------------------------------- | ----------------------------------------------------------------------------- | | Kopfzeilen **Kanal, Live, API** | Chats und Credits dieser Quelle; bei Live auch Besuche | | **Kanalverbindung**, **API-Schlüssel** | Chats, Antworten und Credits genau dieses Zugangs | | **Live-Adresse** | Besuche, begonnene Chats und Credits dieser Adresse | | **Sonstige Anfragen** | Nutzung ohne einstellbaren Zugang, etwa Chats in der App, Routinen und Spaces | Die Linie zum Agenten wird mit der Nutzung dicker. Zugänge ohne Nutzung im Zeitraum erscheinen als blasse, gestrichelte Linien. Die Summe in der API-Kopfzeile enthält auch Aufrufe mit **kontoweiten Schlüsseln**. Das Canvas zeichnet nur Schlüssel, die eigens für diesen Agenten bestimmt sind. Die Schlüsselknoten können sich daher zu weniger addieren als die Kopfzeile. ## Das Diagramm darunter [Abschnitt betitelt „Das Diagramm darunter“](#das-diagramm-darunter) Unter dem Canvas steht ein tägliches Balkendiagramm. Die Balken sind nach Quelle gestapelt, und jeder Tag im Zeitraum hat seinen Platz. Tage ohne Nutzung bleiben leer. * Die Kopfzeile des Diagramms zeigt die Summen des Zeitraums: Chats, Antworten, Tokens und Credits. * Wähle **Tokens**, **Credits** oder **Antworten** für die Balken. * Wähle unter dem Diagramm einen Quellen-Chip, um diese Quelle aus- oder einzublenden. * Wenn du das Diagramm einklappst, bleibt es beim nächsten Mal eingeklappt. Chats werden nicht als Balken dargestellt. Würde man die täglichen Chatzahlen addieren, würde ein Chat, der sich über mehrere Tage erstreckt, mehrfach gezählt. Die Zahl der Chats im Zeitraum liest du in der Kopfzeile des Diagramms ab. ## Auf einen Zugang fokussieren [Abschnitt betitelt „Auf einen Zugang fokussieren“](#auf-einen-zugang-fokussieren) Wähle im Tab Nutzung einen Knoten, um rechts das Panel **Analysen** zu öffnen. Das Diagramm zeigt dann nur diesen Zugang. * Bei einer **Quelle** (Kopfzeile Kanal, Live oder API oder Sonstige Anfragen) bleiben nur die Balken dieser Quelle in voller Farbe. * Bei einem **API-Schlüssel** oder einer **Kanalverbindung** siehst du die Tageswerte dieses Zugangs im Verhältnis zur Tagessumme. Das Panel Analysen enthält zwei Tabellen. * **Quellen**: Chats, Antworten, Tokens, Credits und Anteil für alle sechs Quellen. Quellen ohne Nutzung bleiben als Zeilen stehen, damit du vergleichen kannst. * **Zugänge**: Aufrufe, Tokens und Credits pro API-Schlüssel und pro Kanalverbindung. Von Schlüsseln wird nur das Präfix angezeigt. Wähle **›** am Ende einer Zeile, um die Einstellungen dieses Schlüssels oder Kanals zu öffnen. Der fokussierte Zugang erscheint als Chip in der Kopfzeile des Diagramms und in der des Panels. Wähle **×** auf dem Chip, um wieder alles zu sehen. ## Live-Besuche [Abschnitt betitelt „Live-Besuche“](#live-besuche) Bei aktiviertem Live zählt der Tab Nutzung auch Menschen, die die endue.live-Seite des Agenten oder ein eingebettetes Chatfenster öffnen. Ein Besuch zählt auch ohne Nachricht. So siehst du, wie viele Besuchende anschließend einen Chat beginnen. Wähle die **Live**-Kopfzeile oder die Live-Adresse. Im Canvas erscheinen Besuche, begonnene Chats und Credits. Das Analysepanel öffnet **Zugänge → Live** mit Zeitraumwerten, Tabellen nach Website und Herkunft sowie Besuchersprachen. Im Diagramm kannst du **Besuche** wählen; die Balken trennen Seite und Einbettung. | Zahl | Bedeutung | | ------------------- | ------------------------------------------------------------------------------------------- | | Besuche | Jedes Anzeigen der Seite oder des eingebetteten Chatfensters; Neuladen zählt erneut | | Eindeutige Besucher | Derselbe Besucher beim selben Agenten am selben Tag einmal; der Zeitraum addiert Tageswerte | | Begonnene Chats | Besuche mit mindestens einer gesendeten Nachricht | | Startrate | Begonnene Chats geteilt durch Besuche | | Gültige Chats | Besuche mit mindestens zwei gesendeten Nachrichten | Ein Tag läuft von Mitternacht bis Mitternacht UTC. Eine Nachricht zählt, sobald der Agent sie annimmt. Wegen zu hoher Sendefrequenz oder fehlender Credits abgelehnte Nachrichten zählen nicht. **Begonnene Chats** sind Besuche; **Chats** sind Unterhaltungen, auf die der Agent mindestens einmal geantwortet hat. Wer am nächsten Tag dieselbe Unterhaltung fortsetzt, kann zwei begonnene Chats und einen Chat erzeugen. Die Website-Tabelle hat eine Zeile für die endue.live-Seite und je eine für jede Website mit eingebettetem Chat. Sie zeigt **Besuche, Chats, Nachrichten und Credits**. Die letzten drei Werte summieren sich zur Live-Zeile der Tabelle **Quellen**. ### Woher Besuchende kommen [Abschnitt betitelt „Woher Besuchende kommen“](#woher-besuchende-kommen) Jeder Besuch wird der ersten passenden Zeile zugeordnet: | Zeile | Bedingung | | ---------------------------- | ------------------------------------------------------------------------ | | Website · example.com | Eingebettetes Fenster auf dieser Website | | Kampagne · newsletter | Der Link enthält `utm_source` | | Direkt | Kein Referrer: eingegebene Adresse, Lesezeichen oder App ohne Weitergabe | | endue.live Explore, endue.ai | Besuch von einer dieser Seiten | | Suche · Google | Erkannte Suchmaschine | | Social · X | Erkanntes soziales Netzwerk oder Messenger | | Website · blog.example.com | Andere Website; nur der Host wird angezeigt | | Unbekannt | Eine Nachricht kam an, aber der Besuch wurde nicht erfasst | Die Tabelle zeigt die 20 Zeilen mit den meisten Besuchen und fasst den Rest zusammen. Mit `endue.live/@your-agent?utm_source=newsletter` kannst du verteilte Links unterscheiden. Der Wert darf höchstens 64 Zeichen aus Buchstaben, Ziffern und `. _ ~ -` enthalten; andere Werte werden verworfen. ### Ausgeschlossene Besuche [Abschnitt betitelt „Ausgeschlossene Besuche“](#ausgeschlossene-besuche) * **Eigentümer**: Öffnest du die Live-Seite aus den Live-Einstellungen oder vom Agenten-Start, merkt sich dieser Browser dich als Eigentümer. Eine Einbettung auf `localhost` zählt ebenfalls so. Auf einem anderen Browser oder Gerät zählst du bis zum gleichen Öffnen als Besucher. * **Bots**: Crawler und Linkvorschauen ohne Skriptausführung werden nicht erfasst. Automatisierte Browser und bekannte Bots mit Skriptausführung zählen als Bots. Die letzte Zeile des Live-Tabs zeigt die ausgeschlossenen Zahlen. Credits für eigene Test-Chats bleiben in den Kosten enthalten. Ein Besuchsdatensatz enthält Agent und Seite oder Einbettung, bei Einbettungen den Host, Art und Namen des Referrers, `utm_medium` und `utm_campaign`, Browsersprache, Land, Gerätetyp, Zeitpunkt, Anzahl der Nachrichten und einen Schlüssel zum Zählen eindeutiger Besucher. Nicht gespeichert werden IP-Adresse, Cookies, vollständige Referrer-URL und User-Agent-String. Der Besucherschlüssel wird aus der IP-Adresse abgeleitet, wechselt täglich und pro Agent und verbindet keine Tage oder Agenten. Datensätze werden nach 400 Tagen gelöscht. Grenzen: Vor Einführung der Besuchszählung gibt es keine Besuchshistorie. Mehrere Menschen im selben Netzwerk können als ein eindeutiger Besucher zählen. Bei Einbettungen zählt erst das Öffnen des Chatfensters, nicht die Anzeige der Schaltfläche. Nach Referrer gibt es nur Besuche und begonnene Chats; Chats, Nachrichten und Credits sind nur nach Website aufgeschlüsselt. ## Die Zahlen lesen [Abschnitt betitelt „Die Zahlen lesen“](#die-zahlen-lesen) * **Chats** sind Unterhaltungen, in denen dieser Agent im Zeitraum mindestens einmal geantwortet hat. Unterhaltungen, in denen er nie geantwortet hat, zählen nicht. * **Antworten** zählt, wie oft der Agent geantwortet hat. * **Credits** sind die abgerechneten Kosten. Ein Credit entspricht 1 US-Dollar. * Für denselben Zeitraum stimmt die Summe der Tokens mit dem Tab Agenten der [Nutzungsübersicht](/de/docs/account/usage/) überein. „Ohne Berechnung“ heißt nicht kostenlos Ausführungen mit [deinem eigenen LLM-Schlüssel](/de/docs/account/bring-your-own-key/) rechnet endue nicht ab, daher fallen keine Credits an. Diese Tokens werden separat als **ohne Berechnung** aufgeführt, statt als null Credits mitgezählt zu werden. Die Kosten siehst du bei dem jeweiligen LLM-Anbieter. Wenn „Nicht zugeordnet“ erscheint Nutzung, die erfasst wurde, bevor Quellen aufgezeichnet wurden, wurde anhand der zugehörigen Unterhaltung ergänzt. Was danach noch unbekannt ist, steht gesammelt unter **Nicht zugeordnet**. Ältere API-Nutzung wird dem Schlüssel zugerechnet, der die Unterhaltung ursprünglich erstellt hat. ## Wer sie sehen kann [Abschnitt betitelt „Wer sie sehen kann“](#wer-sie-sehen-kann) Nur die Person, der der Agent gehört. Alle anderen sehen weder den Tab Nutzung noch die Zelle Analysen. Nutzt jemand anderes diesen Agenten, wird diese Nutzung dem Konto dieser Person angerechnet und erscheint hier nicht. ## Einschränkungen [Abschnitt betitelt „Einschränkungen“](#einschränkungen) * Tool-Aufrufe (Connectors und Skills) werden noch nicht gezählt. Deshalb zeigt die rechte Spalte des Canvas keine Kennzahlen. * Gerätekosten (Computer und Browser) sind nicht enthalten. * Nutzung wird erfasst, wenn eine Ausführung endet. Eine laufende Ausführung erscheint erst nach ihrem Ende. ## Siehe auch [Abschnitt betitelt „Siehe auch“](#siehe-auch) [Canvas](/de/docs/build/canvas/)Der Tab Einrichtung: was dazugehört. [Nutzungsübersicht](/de/docs/account/usage/)Alle Agenten auf einmal. [Agent API](/de/docs/build/agent-api/)Ruf deinen Agenten mit einem API-Schlüssel auf. [Tarife und Nutzung](/de/docs/account/plans-and-usage/)Wie Credits und die im Tarif enthaltene Nutzung funktionieren. # Canvas > Eine Karte eines Agenten – was ihm zugewiesen ist, dargestellt als Graph, in den du hineinklicken kannst. Das **Canvas** zeigt einen Agenten und alles, was zu ihm gehört: die Skills und Connectors, die er nutzen kann, die Kanäle, auf denen er antwortet, und den Arbeitsbereich, der ihm gehört. Es ist dieselbe Konfiguration wie in den Bereichen des [Agent Builders](/de/docs/build/agent-builder/), nur alles auf einen Blick. [](/docs/_astro/studio-canvas.Bx7olpr0.png) Auch eine Achse ohne Einträge wird angezeigt. Lücken sind so gut sichtbar wie Verbindungen.[In voller Größe öffnen](/docs/_astro/studio-canvas.Bx7olpr0.png) ## Wann du es nutzt [Abschnitt betitelt „Wann du es nutzt“](#wann-du-es-nutzt) Öffne das Canvas, wenn du wissen willst, *was dieser Agent eigentlich ist*, statt eine einzelne Einstellung zu ändern: bevor du ihm einen Kanal gibst, wenn jemand aus deinem Team fragt, worauf er zugreifen kann, oder wenn sich ein Agent auf eine Weise verhält, die sein Prompt nicht erklärt. Nutze die Bereiche, wenn du weißt, was du ändern willst. Das Canvas ist zum Anschauen da. ## Das Canvas lesen [Abschnitt betitelt „Das Canvas lesen“](#das-canvas-lesen) Der Agent steht in der Mitte. Um ihn herum liegt, was ihm zugewiesen ist, nach Art gruppiert: Ressourcen, Kopplungen, Inventar. Auch eine Achse ohne Einträge wird angezeigt, sodass Lücken so gut sichtbar sind wie Verbindungen. Wählst du einen Knoten, öffnet sich dasselbe Panel wie im zugehörigen Bereich. So kommst du von *„Was hat dieser Agent?“* zur Änderung, ohne die Karte zu verlassen. Manche Achsen erscheinen, bevor sie einstellbar sind Einige Knoten zeigen vorerst nur, wie das Ganze aufgebaut ist, und lassen sich noch nicht bearbeiten. Öffnet ein Knoten ein schreibgeschütztes Panel, ist diese Achse von hier aus nicht einstellbar. ## Einschränkungen [Abschnitt betitelt „Einschränkungen“](#einschränkungen) * Das Canvas zeigt einen Agenten. Eine Ansicht über alle deine Agenten gibt es nicht. * Der Standardtab **Einrichtung** bildet die Konfiguration ab: worauf der Agent zugreifen *kann*. Um im selben Bild zu sehen, wie stark jeder Zugang genutzt wurde, öffne oben im Canvas den Tab **Nutzung**. Siehe [Analysen](/de/docs/build/analytics/). * Bearbeitet wird weiterhin in den Panels. Das Canvas ist ein Einstieg, kein eigener Editor. ## Siehe auch [Abschnitt betitelt „Siehe auch“](#siehe-auch) [Analysen](/de/docs/build/analytics/)Der Tab Nutzung: Chats und Credits pro Zugang. [Agent Builder](/de/docs/build/agent-builder/)Dieselbe Konfiguration, Bereich für Bereich. [Sicherheit und Berechtigungen](/de/docs/account/security/)Was eine Zuweisung tatsächlich erlaubt. # Geräte > Die Computer und Browser, auf denen deine Agenten arbeiten, und die Apps, in denen du endue nutzt. Was jedes Geräteprodukt ist, wem das Gerät gehört und wie du eins hinzufügst, ersetzt oder entfernst. Ein **Gerät** ist ein Computer oder Browser, auf dem ein Agent arbeitet, oder eine App, in der du endue nutzt. Geräte sind neben Skills und Connectors eine der drei Arten von [Ressourcen](/de/docs/get-started/glossary/#ressourcen). ## Wann du eins brauchst [Abschnitt betitelt „Wann du eins brauchst“](#wann-du-eins-brauchst) Meistens musst du nichts einrichten. Braucht eine Aufgabe einen Computer oder Browser, richtet der Agent einen in der endue Cloud ein und sagt dir in der Unterhaltung Bescheid, während er das tut. Füge ein eigenes Gerät hinzu, wenn die Arbeit an einem Ort passieren muss, den du kontrollierst: ein Server, der deine Systeme erreicht, eine VM mit den Tools, die du schon installiert hast, oder dein eigenes Chrome mit den Websites, bei denen du angemeldet bist. ## Die vier Produkte [Abschnitt betitelt „Die vier Produkte“](#die-vier-produkte) | Produkt | Was es ist | Nutzergerät | Agentengerät | | --------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------- | | **endue Computer** | Ein Computer, auf dem der Agent Dateien ablegt und Programme ausführt. Sein Dateibereich ist der [Arbeitsbereich](/de/docs/build/workspace/) des Agenten. | Dein eigener Linux-Server oder deine VM mit installiertem endue Computer. Siehe [Eigenen Server oder eigene VM verbinden](/de/docs/build/own-server/). | Ein Computer, den der Agent in der endue Cloud startet, sobald er zum ersten Mal einen braucht | | **endue for Chrome** | Ein Chrome-Browser, in dem der Agent Seiten öffnet und bedient | Dein eigenes Chrome, in dem die Erweiterung endue for Chrome mit dem Agenten verbunden ist | Ein Chrome, das der Agent in der endue Cloud startet, sobald er zum ersten Mal eins braucht | | **endue for Android** | Ein Smartphone, auf dem der Agent arbeitet. Demnächst verfügbar: Die Anmeldung in der App ist noch nicht möglich. | Ein Smartphone, das du registriert hast | — | | **endue Desktop** | Die Desktop-App, in der du endue nutzt. Sie öffnet dasselbe endue wie im Web, angemeldet mit demselben Konto. Agenten arbeiten nicht darauf. | Ein Computer, auf dem du dich bei endue Desktop angemeldet hast | — | ## Nutzer- und Agentengeräte [Abschnitt betitelt „Nutzer- und Agentengeräte“](#nutzer--und-agentengeräte) Jedes Gerät gehört zu einer von zwei Arten, und seine Zeile zeigt, zu welcher: * **Nutzer**: ein Gerät, auf dem du dich angemeldet oder das du registriert hast. Dein Server mit endue Computer, dein Chrome mit der Erweiterung, dein Smartphone, ein Computer, auf dem du endue Desktop nutzt. * **Agent**: ein Gerät, das der Agent für seine eigene Verbindung in der endue Cloud gestartet hat. Es wird automatisch erstellt, sobald der Agent zum ersten Mal eins braucht. Du musst nichts installieren. Ein Agent nutzt einen endue Computer und ein endue for Chrome. Beides ist jeweils entweder sein Agentengerät in der endue Cloud oder eines deiner Nutzergeräte. Ein endue Computer als Nutzergerät kann mehrere Agenten bedienen: Jeder Agent bekommt auf diesem Server einen eigenen Ordner und einen eigenen Dienst. ## Wo du sie siehst [Abschnitt betitelt „Wo du sie siehst“](#wo-du-sie-siehst) **Ressourcen › Geräte**, erreichbar über die linke Seitenleiste, listet alle Geräte deines Kontos auf, gruppiert nach Produkt. Jede Zeile zeigt: * **Nutzer** oder **Agent** * Wo es sich befindet: **endue Cloud** bei einem Agentengerät, Name und Betriebssystem bei einem Nutzergerät * Die Agenten, die es nutzen * Seinen Status * Wann es zuletzt aktiv war Um nur die Geräte eines Agenten zu sehen, öffne diesen Agenten im [Agent Builder](/de/docs/build/agent-builder/) und geh zu **Ressourcen › Geräte**. Dort gibt es auch **Eigenen Server verbinden**, womit die Installation für diesen Agenten startet. | Status | Bedeutung | | -------------------------------- | ----------------------------------------------------------------------------------------------------------- | | **Verbunden** | Gerade online. Der Agent kann es nutzen. | | **Standby · startet bei Bedarf** | Ein ausgeschaltetes Agentengerät in der endue Cloud. Es startet, wenn der Agent es das nächste Mal braucht. | | **Aus** | Ein Nutzergerät, das nicht verbunden ist. endue kann es nicht einschalten. Starte es direkt auf dem Gerät. | | **In Verwendung** | endue Desktop, in den letzten 15 Minuten genutzt. | | **Wartet auf Installation** | Du hast einen Installationsbefehl für einen Server erstellt, aber der Server hat sich noch nicht verbunden. | | **Handlungsbedarf** | Das Gerät konnte nicht vorbereitet werden. | ## Ein Gerät im Eingabefeld wählen [Abschnitt betitelt „Ein Gerät im Eingabefeld wählen“](#ein-gerät-im-eingabefeld-wählen) Mit der Geräteauswahl im Eingabefeld legst du fest, wo die nächste Ausführung arbeitet: **Computer** oder **Chrome**. Die Ausführung bekommt die Tools für das gewählte Gerät, nicht die des anderen. Jede Option zeigt das tatsächliche Gerät des Agenten, etwa *Agent · endue Cloud* oder *Nutzer · build-server-01*, und seinen Status: **Verbunden**, **Startet bei Bedarf** oder **Aus**. **Geräte verwalten** öffnet den Bereich Geräte des Agenten. ## Eigene Geräte verbinden [Abschnitt betitelt „Eigene Geräte verbinden“](#eigene-geräte-verbinden) * **endue Computer**: Wähle unter **Ressourcen › Geräte** in der Gruppe endue Computer **Auf eigenem Gerät oder Server installieren**, such einen Agenten aus und führe den angezeigten Befehl auf deinem Server aus. Siehe [Eigenen Server oder eigene VM verbinden](/de/docs/build/own-server/). * **endue for Chrome**: Installiere die Erweiterung, melde dich an und verbinde in der Erweiterung einen Agenten. Sobald die Verbindung steht, erscheint dein Chrome unter diesem Agenten. * **endue Desktop**: Melde dich in der App an. Der Computer erscheint dann von selbst in der Liste. ## Den endue Computer eines Agenten in der endue Cloud durch deinen Server ersetzen [Abschnitt betitelt „Den endue Computer eines Agenten in der endue Cloud durch deinen Server ersetzen“](#den-endue-computer-eines-agenten-in-der-endue-cloud-durch-deinen-server-ersetzen) Hat der Agent bereits einen endue Computer in der endue Cloud, fragt die Installation auf deinem Server zuerst nach: > Den endue Computer dieses Agenten in der endue Cloud samt Dateien löschen und dann verbinden? **Löschen und verbinden** löscht das Cloud-Gerät samt allen Dateien im dortigen Arbeitsbereich des Agenten und gibt dir den Installationsbefehl für deinen Server. **Abbrechen** ändert nichts. Sichere alles, was du aus dem Arbeitsbereich brauchst, bevor du bestätigst. Sobald der Agent auf deinem Server läuft, erstellt endue für ihn keinen Cloud-Computer mehr. Ist dein Server aus, bittet dich der Agent, endue Computer darauf zu starten, und macht ohne ihn weiter. ## Ein Gerät entfernen [Abschnitt betitelt „Ein Gerät entfernen“](#ein-gerät-entfernen) Öffne das Menü in der Zeile eines Geräts. | Gerät | Menüpunkt | Was passiert | | ----------------------------------- | ----------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Agentengerät in der endue Cloud | **Löschen** | Das Gerät und die Dateien darauf werden gelöscht. Wenn der Agent wieder eins braucht, bekommt er ein neues, leeres Gerät. | | Dein endue Computer oder Smartphone | **Entfernen** *(Agent)* | Der Agent arbeitet nicht mehr auf diesem Gerät. Was du installiert hast, bleibt: [Deinstalliere es zusätzlich auf dem Server](/de/docs/build/own-server/#deinstallieren). Sobald kein Agent mehr übrig ist, löscht **Aus Liste entfernen** die Zeile. | | Dein Chrome | **Trennen** | Die Verbindung dieses Agenten endet. Um es wieder zu nutzen, verbinde es erneut über die Erweiterung. | | endue Desktop | **Aus Liste entfernen** | Du bleibst angemeldet. Der Computer erscheint wieder, wenn du endue Desktop darauf das nächste Mal öffnest. | ## Einschränkungen [Abschnitt betitelt „Einschränkungen“](#einschränkungen) * Pro Agent ein endue Computer und ein endue for Chrome. * endue kann kein Nutzergerät einschalten. Ist dein Server oder dein Chrome aus, sagt dir der Agent Bescheid und macht ohne das Gerät weiter. Ersatzweise wird in der endue Cloud nichts erstellt. * Ausführungen, die eine [Routine](/de/docs/automate/routines/) oder ein [Kanal](/de/docs/automate/channels/) startet, erstellen kein Gerät. Sie nutzen eines, das der Agent schon hat. * endue Computer läuft auf deinem eigenen Rechner vorerst nur unter Linux. endue Desktop läuft vorerst unter macOS. * Dein eigenes Chrome meldet weder Betriebssystem noch Version, daher zeigt seine Zeile keins von beidem an. * Geräte werden von der Gruppe **Geräte** in den [integrierten Tools](/de/docs/capabilities/built-in-tools/) vorbereitet. Schaltest du sie aus, bereitet der Agent keine neuen Geräte mehr vor. Bereits verbundene Geräte funktionieren weiter. * Dateien auf dem endue Computer eines Agenten in der endue Cloud bestehen so lange wie das Gerät. Wird das Gerät gelöscht, werden sie mitgelöscht. Bewahre Ergebnisse, die du brauchst, als [Outputs](/de/docs/capabilities/outputs/) auf. ## Siehe auch [Abschnitt betitelt „Siehe auch“](#siehe-auch) [Eigenen Server oder eigene VM verbinden](/de/docs/build/own-server/)endue Computer auf einem Linux-Server installieren und einem Agenten geben. [Arbeitsbereich](/de/docs/build/workspace/)Der Dateibereich des Agenten auf seinem endue Computer. [Freigaben](/de/docs/work/approvals/)Welche Geräteaktionen vorher bei dir nachfragen. [Sicherheit und Berechtigungen](/de/docs/account/security/)Worauf ein Agent zugreifen kann und worauf nicht. # Identität und Profil > Name, Handle, Avatar, Profil und Charakter eines Agenten – was jedes davon ändert und welche davon der Agent selbst sieht. Die **Identität** eines Agenten ist der Teil, über den du ihn ansprichst und erkennst: sein Name, sein Handle, sein Avatar und der Charakter, der prägt, wie er schreibt. ## Wann du sie festlegst [Abschnitt betitelt „Wann du sie festlegst“](#wann-du-sie-festlegst) Leg die Identität fest, wenn du einen Agenten erstellst, und sieh sie dir wieder an, sobald du mehr als eine Handvoll Agenten hast und sie nicht mehr auf einen Blick unterscheiden kannst. Das Verhalten änderst du nicht über die Identität, sondern über den [Systemprompt](/de/docs/build/system-prompt/). ## Was jedes Feld bewirkt [Abschnitt betitelt „Was jedes Feld bewirkt“](#was-jedes-feld-bewirkt) | Feld | Wo sichtbar | Was es ändert | | ------------- | ---------------------------------------------------------------- | -------------------------------------------------- | | **Name** | Agentenlisten, Kopfzeilen von Unterhaltungen, Benachrichtigungen | Woran du ihn erkennst | | **Handle** | Beim Ansprechen des Agenten, in Erwähnungen | Wie du auf ihn verweist | | **Avatar** | Überall, wo der Agent erscheint | Erkennen auf einen Blick | | **Profil** | Agent Builder, Agentendetails | Eine kurze Beschreibung, wofür dieser Agent da ist | | **Charakter** | Der eigene Kontext des Agenten | Ton und Art seiner Antworten | ## Charakter versus Systemprompt [Abschnitt betitelt „Charakter versus Systemprompt“](#charakter-versus-systemprompt) Die beiden werden oft verwechselt, und erst wenn du sie trennst, sind beide nützlich. Der **Charakter** ist die *Art*: knapp oder ausführlich, förmlich oder direkt, wie vorsichtig er formuliert. Der **Systemprompt** ist die *Aufgabe*: was er tut, was er nie tun darf und wie ein gutes Ergebnis aussieht. Schreibst du die Aufgabe ins Feld Charakter, kannst du den Ton nicht mehr ändern, ohne die Aufgabe neu zu schreiben. Schreibst du Regeln für den Ton in den Prompt, konkurrieren sie um Aufmerksamkeit mit den Anweisungen, auf die es ankommt. Der Agent sieht seine eigene Identität Name, Handle und Charakter gehören zu dem, was der Agent zu Beginn einer Ausführung liest. Ein Agent namens „Posteingangs-Triage“ mit knappem Charakter verhält sich anders als derselbe Prompt unter einer anderen Identität. Meist nur leicht, manchmal stärker, als du erwartest. ## Avatare [Abschnitt betitelt „Avatare“](#avatare) Der Avatar eines Agenten erscheint in jeder Liste, jeder Kopfzeile und jeder Benachrichtigung, die ihn erwähnt. Einen Avatar hochzuladen ist das günstigste Mittel, um bei mehreren Agenten den Überblick zu behalten. Ein Agent ohne hochgeladenen Avatar bekommt einen automatisch erzeugten. ## Einschränkungen [Abschnitt betitelt „Einschränkungen“](#einschränkungen) * Das Handle wird beim Erstellen automatisch aus dem Namen erzeugt und lässt sich nicht ändern, weil andere Stellen darauf verweisen. * Identitätsfelder gewähren dem Agenten keine Rechte. Ein Agent namens „E-Mail-Assistent“ hat keinen Zugriff auf E-Mails, solange ihm kein [Connector](/de/docs/connect/overview/) zugewiesen ist. * Der Charakter prägt den Ton, nicht die Fähigkeiten. Er kann den Agenten nicht zu etwas bringen, das sein Prompt und seine Tools nicht erlauben. ## Siehe auch [Abschnitt betitelt „Siehe auch“](#siehe-auch) [Systemprompt und Revisionen](/de/docs/build/system-prompt/)Wo die eigentliche Aufgabe des Agenten festgelegt wird. [Agent Builder](/de/docs/build/agent-builder/)Die vier Bereiche und was in jeden davon gehört. # Testen und iterieren > Ändere einen funktionierenden Agenten, ohne ihn kaputtzumachen – was du einzeln nacheinander änderst, woran du erkennst, ob es geholfen hat, und wie du zurückkommst. Einen Agenten verbesserst du schrittweise: eine Sache ändern, dieselbe Aufgabe ausführen, vergleichen. endue speichert [Revisionen](/de/docs/build/system-prompt/#revisionen-und-zur%C3%BCcksetzen) des Prompts, damit der Schritt „zurück“ immer möglich ist. ## Wann du so vorgehst [Abschnitt betitelt „Wann du so vorgehst“](#wann-du-so-vorgehst) Immer dann, wenn ein Agent fast passt. Diese Seite soll den häufigsten Fehler verhindern: drei Änderungen auf einmal, der Agent wird in einer Hinsicht besser und in einer anderen schlechter, und nichts lässt sich mehr einer Ursache zuordnen. ## Eine Schleife, die funktioniert [Abschnitt betitelt „Eine Schleife, die funktioniert“](#eine-schleife-die-funktioniert) 1. **Leg dir eine Aufgabe zurecht, die du wiederholst.** Zwei oder drei echte Anfragen, die du schon einmal gestellt hast und deren gute Antwort du sofort erkennst. Das ist dein Testset. Ohne eines ist „besser“ nur ein Gefühl. 2. **Ändere eine Sache.** Den Prompt, das Modell oder eine Zuweisung, aber nicht alle drei. 3. **Führe dieselbe Aufgabe in einer neuen Unterhaltung aus.** Eine neue [Unterhaltung](/de/docs/work/conversations/) ist wichtig: Ein bestehender Thread bringt einen Verlauf mit, der die Antwort unabhängig von deiner Änderung beeinflusst. 4. **Vergleiche mit dem, was du vorher gesehen hast.** Sieh dir die Tool-Aufrufe an, nicht nur den finalen Text. Dort zeigt sich eine Prompt-Änderung meist zuerst. 5. **Behalte die Änderung oder geh zurück.** Ist das Ergebnis schlechter, stell die vorherige Prompt-Revision wieder her und versuch eine andere Änderung. ## Was du ändern kannst, der Reihe nach [Abschnitt betitelt „Was du ändern kannst, der Reihe nach“](#was-du-ändern-kannst-der-reihe-nach) Arbeite diese Liste von oben nach unten ab. Die Punkte weiter oben verändern die Ergebnisse bei gleichem Aufwand stärker. | Maßnahme | Symptom | | ------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------- | | Im Prompt schärfer fassen, „wie ein gutes Ergebnis aussieht“ | Die Antwort stimmt, ist aber nicht brauchbar: falsches Format, falsche Tiefe, der Kern geht unter | | Eine feste Regel hinzufügen | Er wiederholt einen bestimmten Fehler | | Einen Connector oder Skill zuweisen | Er rät bei etwas, das er nachschlagen sollte | | Eine [integrierte Tool-Gruppe](/de/docs/capabilities/built-in-tools/) ausschalten | Er greift zu einer Fähigkeit, die für diesen Agenten nur Rauschen ist | | Den [Denkaufwand](/de/docs/build/models/#denkaufwand) erhöhen | Er überspringt bei langen Aufgaben Schritte | | Das Modell wechseln | Alles oben Genannte stimmt, und er bewältigt die Aufgabe trotzdem nicht | | In zwei Agenten aufteilen | Der Prompt ist so gewachsen, dass er zwei voneinander unabhängige Aufgaben abdeckt | ## Eine Ausführung zur Diagnose lesen [Abschnitt betitelt „Eine Ausführung zur Diagnose lesen“](#eine-ausführung-zur-diagnose-lesen) Die meisten Probleme vom Typ „Der Agent ist schlecht“ sind in der [Ausführung](/de/docs/work/runs/) selbst zu sehen. * **Er hat keine Tools aufgerufen.** Er glaubt, er solle aus seinem vorhandenen Wissen antworten. Meist ein Problem des Prompts, manchmal eine fehlende Zuweisung. * **Er hat das richtige Tool mit falschen Argumenten aufgerufen.** Ihm fehlt Kontext. Schreib ihn in den Prompt oder leg ihn im [Gedächtnis](/de/docs/capabilities/memory/) ab. * **Er hat Tools in einer Schleife aufgerufen, ohne zum Ziel zu kommen.** Die Aufgabe ist zu ungenau beschrieben, oder der Denkaufwand ist für ihre Länge zu niedrig eingestellt. * **Er hat dich etwas gefragt, das er wissen sollte.** Diese Information gehört in den Prompt oder ins Gedächtnis. Nachsteuern hilft auch bei der Diagnose Wenn ein einziger Satz zum [Nachsteuern](/de/docs/work/steering/) eine Ausführung zuverlässig rettet, gehört dieser Satz in den Systemprompt. Eine Korrektur, die du immer wieder schickst, ist ein Fehler im Prompt, den du noch nicht behoben hast. ## Einschränkungen [Abschnitt betitelt „Einschränkungen“](#einschränkungen) * Es gibt kein eingebautes Evaluierungs-Framework und keine automatische Bewertung. Du vergleichst von Hand, anhand von Aufgaben, die du selbst auswählst. * Es gibt keinen Entwurfsmodus: Ein Agent hat genau eine aktive Konfiguration, und Änderungen gelten ab seiner nächsten Ausführung. Willst du etwas Riskantes ausprobieren, ohne einen Agenten zu stören, auf den du dich verlässt, erstelle eine Kopie und experimentiere damit. * Der Revisionsverlauf betrifft den Systemprompt. Andere Einstellungen wie Modell, Zuweisungen und Tool-Gruppen werden nicht versioniert, also notiere dir, was du geändert hast. ## Siehe auch [Abschnitt betitelt „Siehe auch“](#siehe-auch) [Systemprompt und Revisionen](/de/docs/build/system-prompt/)Der Hebel, zu dem du am häufigsten greifst, und wie du Änderungen rückgängig machst. [Ausführungen](/de/docs/work/runs/)Nachlesen, was der Agent tatsächlich getan hat, Schritt für Schritt. [Ausführung nachsteuern](/de/docs/work/steering/)Eine laufende Ausführung korrigieren und was dir das verrät. # LLM API > Ruf Modelle direkt aus deinem eigenen Code mit einem API-Schlüssel von endue auf, über das OpenAI- oder Anthropic-SDK, das du schon nutzt. Jeder Aufruf wird aus deinen Credits bezahlt. Mit der **LLM API** ruft dein Code ein Modell direkt mit einem API-Schlüssel von endue auf, im selben Anfrageformat wie die APIs von OpenAI und Anthropic. Jeder Aufruf wird aus deinen Credits bezahlt. ## Wann du sie nutzt [Abschnitt betitelt „Wann du sie nutzt“](#wann-du-sie-nutzt) Wenn du ein Modell brauchst und keinen Agenten: eine Completion in deiner eigenen App, Code, der bereits mit der API von OpenAI oder Anthropic spricht, oder Claude Code. Du änderst die Basis-URL und den Schlüssel, der Rest deines Codes bleibt, wie er ist. Soll ein Agent die Arbeit erledigen, mit seinem Prompt, seinem Gedächtnis, seinen Tools und Connectors, ruf ihn stattdessen über die [Agent API](/de/docs/build/agent-api/) auf. ## Dein erster Aufruf [Abschnitt betitelt „Dein erster Aufruf“](#dein-erster-aufruf) 1. **Erstelle einen kontoweiten Schlüssel** unter **Einstellungen → Konto → API-Schlüssel**. Kopiere ihn, sobald er angezeigt wird, denn er erscheint nur einmal. Ein Schlüssel aus dem API-Bereich eines Agenten ist auf diesen Agenten beschränkt und kann Modelle nicht direkt aufrufen. 2. **Halte den Schlüssel aus deinem Code heraus.** Leg ihn in einer Umgebungsvariable ab, zum Beispiel `ENDUE_API_KEY`. 3. **Richte dein SDK mit dieser Basis-URL auf endue aus** und ruf ein Modell aus der [Modellliste](#modelle-und-preise) auf: ```plaintext https://platform.endue.ai/api/v1/llm ``` * Python ```python import os from openai import OpenAI client = OpenAI(base_url="https://platform.endue.ai/api/v1/llm", api_key=os.environ["ENDUE_API_KEY"]) res = client.chat.completions.create( model="openai/gpt-5.4", messages=[{"role": "user", "content": "Hello"}], ) print(res.choices[0].message.content) ``` * Node.js ```js import OpenAI from 'openai'; const client = new OpenAI({ baseURL: 'https://platform.endue.ai/api/v1/llm', apiKey: process.env.ENDUE_API_KEY }); const res = await client.chat.completions.create({ model: 'openai/gpt-5.4', messages: [{ role: 'user', content: 'Hello' }], }); console.log(res.choices[0].message.content); ``` * curl ```bash curl https://platform.endue.ai/api/v1/llm/chat/completions \ -H "Authorization: Bearer $ENDUE_API_KEY" \ -H "Content-Type: application/json" \ -d '{"model":"openai/gpt-5.4","messages":[{"role":"user","content":"Hello"}]}' ``` * Anthropic SDK ```python import os import anthropic client = anthropic.Anthropic(base_url="https://platform.endue.ai/api/v1/llm", api_key=os.environ["ENDUE_API_KEY"]) msg = client.messages.create( model="claude-sonnet-4-5", max_tokens=1024, messages=[{"role": "user", "content": "Hello"}], ) print(msg.content[0].text) ``` * Claude Code ```bash export ANTHROPIC_BASE_URL=https://platform.endue.ai/api/v1/llm export ANTHROPIC_API_KEY=$ENDUE_API_KEY claude ``` Unter **Einstellungen → Konto → LLM API** findest du dieselbe Basis-URL und dieselben Beispiele zum Kopieren. ## Modelle und Preise [Abschnitt betitelt „Modelle und Preise“](#modelle-und-preise) `GET https://platform.endue.ai/api/v1/llm/models` listet jedes Modell, das du aufrufen kannst, mit Kontextlänge und Preis. Zum Abrufen der Liste brauchst du keinen Schlüssel. * **Modell-IDs** sehen aus wie `openai/gpt-5.4` oder `x-ai/grok-4.6`: erst der Anbieter, dann das Modell. * **Preise** sind in Credits pro Token angegeben, als Dezimalzahlen in Strings: `prompt` für die Eingabe, `completion` für die Ausgabe und `input_cache_read`, wenn das Modell gecachte Eingaben günstiger berechnet. Ein Credit entspricht einem US-Dollar. * Manche Modelle berechnen für sehr lange Prompts mehr. Diese Preise stehen unter `overrides`, zusammen mit der Promptlänge, ab der sie gelten. Dieselben Modelle kannst du auf der [Modellseite](/de/models) durchsehen. ## Streaming [Abschnitt betitelt „Streaming“](#streaming) Setz `"stream": true`. Du bekommst die Antwort als Server-Sent Events im Chunk-Format von OpenAI, abgeschlossen mit `data: [DONE]`. Der letzte Chunk vor `[DONE]` enthält `usage`, einschließlich der Kosten des Aufrufs. ## Wie ein Aufruf bezahlt wird [Abschnitt betitelt „Wie ein Aufruf bezahlt wird“](#wie-ein-aufruf-bezahlt-wird) 1. **Bevor das Modell läuft**, reserviert endue so viele deiner Credits, dass die höchstmöglichen Kosten des Aufrufs gedeckt sind: dein Prompt plus `max_tokens` Ausgabe. Ist dein Guthaben niedriger, wird das Modell nicht aufgerufen und du bekommst einen `402`. 2. **Wenn der Aufruf abgeschlossen ist**, wird dir berechnet, was er tatsächlich gekostet hat, und der Rest der Reservierung geht zurück auf dein Guthaben. 3. **Die Antwort nennt dir die Kosten.** `usage.cost` sind die für diesen Aufruf abgebuchten Credits, und der Header `X-Endue-Request-Id` identifiziert den Aufruf, falls du dazu eine Frage hast. Lässt du `max_tokens` weg und reicht dein Guthaben nicht für die volle Ausgabelänge des Modells, läuft der Aufruf trotzdem, mit `max_tokens` gesenkt auf das, was dein Guthaben abdeckt, sofern das mindestens 1.024 Tokens sind. Darunter bekommst du einen `402`. Aufrufe der LLM API werden nur aus **gekauften Credits und Aktions-Credits** bezahlt. Das Kontingent deines Tarifs ist für Agenten gedacht und wird hier nicht genutzt. Die Aufrufe erscheinen in der [Nutzungsübersicht](/de/docs/account/usage/#quellen) im Tab **Quellen** als **LLM API**. ## Anthropic-Format und Claude Code [Abschnitt betitelt „Anthropic-Format und Claude Code“](#anthropic-format-und-claude-code) Dieselbe Basis-URL akzeptiert auch das Format von Anthropic Messages. Das Anthropic SDK und Claude Code hängen `/v1/messages` selbst an die Basis-URL an, die Einrichtung besteht also aus den zwei Zeilen in den Tabs oben. * Sende den Schlüssel als `x-api-key` oder als `Authorization: Bearer`. * Claude-Modellnamen funktionieren so, wie du sie für Anthropic schreiben würdest, also `claude-sonnet-4-5` oder mit Datum wie `claude-sonnet-4-5-20250929`, sofern das Modell in der Modellliste steht. Jede ID aus der Modellliste funktioniert ebenfalls, auch für Modelle, die keine Claude-Modelle sind. * Streaming nutzt das Event-Format von Anthropic, und Fehler haben die Fehlerstruktur von Anthropic. * `/v1/messages/count_tokens` liefert eine Schätzung der Eingabe-Tokens. Das wird nicht berechnet und ist ein Näherungswert, keine exakte Zählung durch einen Tokenizer. ## Fehler [Abschnitt betitelt „Fehler“](#fehler) Fehler haben die Struktur des Formats, das du aufgerufen hast: `{"error": {…}}` bei OpenAI oder `{"type": "error", "error": {…}}` bei Anthropic. | Status | Was passiert ist | Was du tun kannst | | ------ | ------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------- | | `400` | Die Anfrage ist fehlerhaft, `n` ist größer als 1, oder das Modell hat die Eingabe abgelehnt | Korrigiere die Anfrage. Die Meldung sagt, was falsch ist | | `401` | Der Schlüssel fehlt, wurde widerrufen oder ist falsch | Prüfe den Schlüssel und wie du ihn sendest | | `402` | Dein Credit-Guthaben deckt den Aufruf nicht (`insufficient_credits`, im Anthropic-Format `billing_error`) | Kauf Credits oder senke `max_tokens` | | `403` | Der Schlüssel ist auf einen Agenten beschränkt | Erstelle einen kontoweiten Schlüssel | | `404` | Das Modell steht nicht in der Modellliste | Wähle eine ID aus `/models` | | `429` | Zu viele Anfragen | Warte so viele Sekunden, wie `Retry-After` angibt | | `502` | Beim Modellanbieter ist ein Fehler aufgetreten | Versuch es erneut | | `503` | Abrechnung oder Modellliste sind kurzzeitig nicht erreichbar. Das Modell wurde nicht aufgerufen, und es wurde nichts berechnet | Versuch es kurz darauf erneut | ## Einschränkungen [Abschnitt betitelt „Einschränkungen“](#einschränkungen) * Nur Modelle aus der Modellliste können aufgerufen werden. * Zwei Formate werden unterstützt: OpenAI Chat Completions und Anthropic Messages. Endpunkte für Embeddings, Bilder, Audio oder Responses gibt es nicht. * `n` muss 1 sein. * Felder außerhalb der Standardanfrage werden ignoriert, zum Beispiel eine Fallback-Liste anderer Modelle, Anbieter-Routing oder Plugins. Im Anthropic-Format werden Server-Tools wie die Websuche abgelehnt, und `top_k` wird ignoriert. * Das Kontingent des Tarifs wird nicht genutzt. Aufrufe brauchen gekaufte Credits oder Aktions-Credits. * Ein auf einen Agenten beschränkter Schlüssel kann keine Modelle aufrufen. * Bis zu 100 Aufrufe pro Minute, gezählt pro Schlüssel und pro Konto. Der Body einer Anfrage darf bis zu 8 MB groß sein. * `count_tokens` ist eine Schätzung. ## Siehe auch [Abschnitt betitelt „Siehe auch“](#siehe-auch) [Agent API](/de/docs/build/agent-api/)Ruf statt eines reinen Modells einen Agenten mit Prompt, Gedächtnis und Tools auf. [Nutzungsübersicht](/de/docs/account/usage/)Sieh im Tab Quellen die Ausgaben für die LLM API neben denen deiner Agenten. [Modell wählen](/de/docs/build/models/)Wie sich die Modelle unterscheiden und was sie im Vergleich zueinander kosten. [Sicherheit und Berechtigungen](/de/docs/account/security/)Worauf ein Schlüssel zugreifen kann und wie du ihn widerrufst. # Modell wählen > Wähle das Modell, mit dem ein Agent läuft, leg fest, wie viel Denkaufwand es betreibt, und überschreib beides für eine einzelne Nachricht. Jede [Ausführung](/de/docs/work/runs/) wird von einem Modell angetrieben. endue bietet einen Katalog mit Modellen mehrerer Anbieter, und du wählst, welches ein Agent nutzt: als Standard oder für eine einzelne Nachricht. ## Wann du das Modell wechselst [Abschnitt betitelt „Wann du das Modell wechselst“](#wann-du-das-modell-wechselst) Wechsle das Modell, wenn das *Denken* des Agenten das Problem ist: Er lässt bei einer langen Aufgabe Schritte aus, oder er ist für Arbeit, die wirklich einfach ist, langsam und teuer. Wenn der Agent das Falsche tut, statt das Richtige schlecht zu tun, korrigiere zuerst den [Systemprompt](/de/docs/build/system-prompt/). Ein größeres Modell befolgt eine vage Anweisung genauso gewissenhaft. ## Der Katalog [Abschnitt betitelt „Der Katalog“](#der-katalog) Die Modellauswahl listet auf, was verfügbar ist, mit den Angaben, die wirklich über die Wahl entscheiden: Kontextfenster, Eingabe- und Ausgabepreis pro Million Tokens, was das Modell annimmt (Text, Bilder, Dateien) und ob es Tool-Aufrufe unterstützt. **Achte vor allem auf Tool-Aufrufe.** Ein Agent in endue arbeitet, indem er Tools aufruft. Ein Modell ohne Unterstützung für Tool-Aufrufe kann mit dem antworten, was es schon weiß, aber es kann weder deine E-Mails durchsuchen noch einen Output schreiben oder einen Connector nutzen. Solche Modelle sind in der Auswahl gekennzeichnet. ## Denkaufwand [Abschnitt betitelt „Denkaufwand“](#denkaufwand) Manche Modelle bieten eine Einstellung für den **Denkaufwand**: wie viel sie nachdenken, bevor sie antworten. Mehr Aufwand kostet mehr Tokens und dauert länger. Er zahlt sich bei mehrstufiger Arbeit aus, in der eine frühe Fehlentscheidung den Rest der Ausführung wertlos macht. Eine grobe Orientierung: | Arbeit | Aufwand | | ---------------------------------------------------------------------------------------------- | ------- | | Umformatieren, Extrahieren, Klassifizieren, kurze Antworten | Niedrig | | Alltägliche mehrstufige Aufgaben mit einer Handvoll Tool-Aufrufen | Mittel | | Lange Ketten, in denen sich ein früher Fehler aufschaukelt, etwa Recherche, Planung, Debugging | Hoch | [](/docs/_astro/studio-model.iwYKzThY.png) [In voller Größe öffnen](/docs/_astro/studio-model.iwYKzThY.png) ## Pro Agent, pro Nachricht, pro Routine [Abschnitt betitelt „Pro Agent, pro Nachricht, pro Routine“](#pro-agent-pro-nachricht-pro-routine) An drei Stellen lässt sich ein Modell festlegen, und jede überschreibt die Stelle darüber: * **Der Standard des Agenten** im [Agent Builder](/de/docs/build/agent-builder/): das Modell, das er nutzt, solange nichts anderes angegeben ist. * **Eine einzelne Nachricht** über das Eingabefeld: praktisch für eine schwierige Frage in der Unterhaltung mit einem günstigen Agenten. * **Eine [Routine](/de/docs/automate/routines/)**, die ihr eigenes Modell festlegen kann, damit sich die Kosten eines geplanten Jobs nicht ändern, wenn du den Agenten neu abstimmst. Günstiger Agent, stärkeres Modell bei Bedarf Ein schnelles Modell als Standard des Agenten und ein stärkeres nur für die wenigen Nachrichten, die es brauchen, kostet meist weniger, als alles mit dem stärksten Modell laufen zu lassen. Und bei den alltäglichen 90 % wirkt der Agent schneller. ## Ein Modell für jede Anfrage auswählen [Abschnitt betitelt „Ein Modell für jede Anfrage auswählen“](#ein-modell-für-jede-anfrage-auswählen) Mit **Automatische Auswahl** bewertet ein Entscheidungsmodell jede eingehende Nachricht auf drei Schwierigkeitsstufen. Du legst fest, welches Modell die jeweilige Stufe beantwortet. Die Einstellung findest du im Modellbereich des [Agent Builders](/de/docs/build/agent-builder/). | Stufe | Verwendetes Modell | | ----------------------------------------------------------------------- | ------------------------------- | | Leicht – Begrüßung, kurze Fakten oder eine Umformulierung in einem Satz | Das Modell für leichte Anfragen | | Standard – Erklärungen, Zusammenfassungen, gewöhnliche Texte und Code | Das Standardmodell des Agenten | | Schwer – mehrstufige Analysen, lange präzise Texte oder komplexer Code | Das Modell für schwere Anfragen | Du kannst auch nur eines der beiden zusätzlichen Modelle festlegen. Bei einer leeren Stufe verwendet der Agent sein Standardmodell. * **Aus**: Keine Bewertung. * **Beobachten**: Nachrichten werden bewertet, aber das Modell bleibt gleich. Bei jeder Antwort zeigt „Auto would use“, welches Modell verwendet würde. * **An**: Die Bewertung wählt das Modell. Die Modellauswahl im Eingabefeld beginnt bei **Auto**; jede Antwort zeigt das tatsächlich verwendete Modell. Gib vor dem Speichern einen Satz unter **Ausprobieren** ein, um Stufe und Modell zu sehen. Das Standardmodell antwortet, wenn die Bewertung unter deiner Konfidenzschwelle liegt, nicht rechtzeitig zurückkommt oder das gewählte Modell mit deinem Tarif oder verbleibenden Limit nicht verfügbar ist. Die Antwort wartet nicht auf die Bewertung. Nachrichten mit Anhang und Nachrichten direkt nach einer schweren Anfrage werden nie auf das leichte Modell heruntergestuft. „Mach weiter“ ist kurz, die fortgesetzte Aufgabe aber nicht unbedingt leicht. Wählst du im Eingabefeld ein Modell von Hand, bleibt die Unterhaltung bei diesem Modell. Wähle wieder **Auto**, um die Festlegung aufzuheben. Unterhaltungen in einem Projekt mit eigenem Standardmodell folgen dem Modell des Projekts. Nachrichten werden zur Bewertung weitergegeben Bei Beobachten oder An gehen die aktuelle Nachricht und der Anfang der vorherigen Nachricht über OpenRouter an TypeSafe in den USA. Sie werden nur zur Bewertung der Schwierigkeit verwendet. Beim Wechsel von Aus wirst du um Bestätigung gebeten. Die automatische Auswahl gilt nur für Nachrichten von Menschen. [Routinen](/de/docs/automate/routines/) und Sprachunterhaltungen werden nicht bewertet und laufen mit ihrem eingestellten Modell. ## Kosten [Abschnitt betitelt „Kosten“](#kosten) Die Modellnutzung ist das, was das Kontingent deines Tarifs verbraucht, und die Preise im Katalog unterscheiden sich um mehr als eine Größenordnung. Die Auswahl zeigt für jedes Modell den Eingabe- und den Ausgabepreis. Wie die Nutzung gemessen wird und wo du sie verfolgst, steht unter [Tarife und Nutzung](/de/docs/account/plans-and-usage/). Wenn du den Anbieter lieber direkt bezahlen willst, sieh dir [Eigenen API-Schlüssel nutzen](/de/docs/account/bring-your-own-key/) an. ## Einschränkungen [Abschnitt betitelt „Einschränkungen“](#einschränkungen) * Nicht jedes Modell unterstützt jede Fähigkeit. Tool-Aufrufe, Bildeingabe und Denkaufwand unterscheiden sich je nach Modell, und maßgeblich ist die Modellauswahl. * Ein Modellwechsel ändert weder Prompt noch Gedächtnis noch Zuweisungen des Agenten. * Eine laufende Ausführung behält das Modell, mit dem sie gestartet ist. Ein Wechsel gilt ab der nächsten Ausführung. * Kontextfenster sind unterschiedlich groß. Eine sehr lange Unterhaltung, die in das eine Modell passt, passt womöglich nicht in ein anderes. ## Siehe auch [Abschnitt betitelt „Siehe auch“](#siehe-auch) [Tarife und Nutzung](/de/docs/account/plans-and-usage/)Was Nutzung verbraucht und wo du siehst, wie viel du schon genutzt hast. [Eigenen API-Schlüssel nutzen](/de/docs/account/bring-your-own-key/)Nutze deine eigenen Zugangsdaten für Modelle statt der von endue. [So funktioniert endue](/de/docs/get-started/how-it-works/)Die Schleife, die das Modell antreibt, und warum die Wahl zählt. # Eigenen Server oder eigene VM verbinden > Installiere endue Computer auf einem Linux-Server oder einer VM unter deiner Kontrolle, damit ein Agent seine Dateien dort ablegt und seine Programme dort ausführt statt in der endue Cloud. Du kannst einem Agenten deinen eigenen Linux-Server oder deine eigene VM als **endue Computer** geben. Du führst auf dem Rechner einen Installationsbefehl aus, und ab dann liegen die Dateien und Programme des Agenten dort. ## Wann sich ein eigener Server lohnt [Abschnitt betitelt „Wann sich ein eigener Server lohnt“](#wann-sich-ein-eigener-server-lohnt) Nutze deinen eigenen Server, wenn die Arbeit etwas braucht, das nur dieser Rechner hat: Zugang zu deinem internen Netzwerk, bereits installierte Tools und Daten, mehr CPU oder Speicherplatz als standardmäßig oder einen Rechner in einer Region deiner Wahl. Jeder Linux-Rechner unter deiner Kontrolle funktioniert, etwa ein VPS bei Vultr, eine EC2-Instanz auf AWS oder ein Server im eigenen Rechenzentrum. Trifft nichts davon zu, brauchst du diese Seite nicht. Ein Agent bekommt automatisch einen endue Computer in der endue Cloud, sobald er zum ersten Mal einen braucht. Siehe [Geräte](/de/docs/build/devices/). ## Was du brauchst [Abschnitt betitelt „Was du brauchst“](#was-du-brauchst) * Linux auf x86\_64 oder aarch64. Das Programm ist eine einzelne statische Binärdatei, die Distribution spielt also keine Rolle. * systemd. * Root-Zugriff über `sudo`. * Ausgehender Internetzugang. endue Computer baut die Verbindung zu endue selbst über einen sicheren WebSocket auf, du musst also keinen eingehenden Port öffnen. ## Installation [Abschnitt betitelt „Installation“](#installation) 1. **Öffne Ressourcen › Geräte** über die linke Seitenleiste und wähle in der Gruppe endue Computer **Auf eigenem Gerät oder Server installieren**. Auf der Seite eines Agenten im [Agent Builder](/de/docs/build/agent-builder/) macht **Ressourcen › Geräte › Eigenen Server verbinden** dasselbe für diesen Agenten. 2. **Wähle den Agenten** und optional einen Gerätenamen für die Liste (zum Beispiel `build-server-01`). Wähle **Installationsbefehl erstellen**. Hat der Agent bereits einen endue Computer in der endue Cloud, wirst du gefragt, ob du ihn samt Dateien zuerst löschen willst. Brichst du ab, ändert sich nichts. Siehe [Den endue Computer eines Agenten in der endue Cloud ersetzen](/de/docs/build/devices/#den-endue-computer-eines-agenten-in-der-endue-cloud-durch-deinen-server-ersetzen). 3. **Kopiere den Befehl und führe ihn auf deinem Server aus.** Er sieht so aus: ```sh curl -fsSL https://download.endue.ai/computer/install.sh | sudo sh -s -- \ --endpoint --token --instance ``` Der Befehl enthält ein Verbindungstoken für diesen Agenten und wird nur einmal angezeigt. Schließt du das Fenster, bevor du ihn kopiert hast, erstelle einen neuen Befehl. 4. **Warte auf „Verbunden“.** Einige Sekunden nachdem der Befehl durchgelaufen ist, wechseln der Dialog und die Geräteliste zu **Verbunden**. Befehle laufen ohne Rückfrage Auf deinem Server schreibt der Agent Dateien und führt Programme aus, ohne jedes Mal um Freigabe zu bitten. Begrenzt wird er durch das, was du bei der Installation festlegst: den eigenen Systembenutzer, die Liste der erlaubten Programme, den Netzwerkzugriff und das unten beschriebene Profil. Nutze einen Server oder eine VM, die nur für den Agenten da ist, und beschränke `--allow-exec` auf das, was er braucht. ## Was das Installationsskript macht [Abschnitt betitelt „Was das Installationsskript macht“](#was-das-installationsskript-macht) 1. Erkennt die Architektur, lädt endue Computer herunter und prüft die SHA-256-Prüfsumme. Stimmt die Prüfsumme nicht, installiert es nichts. 2. Prüft, welches [Profil](#profile) dein Kernel unterstützt. 3. Legt einen Systembenutzer namens `endue` an, der sich nicht anmelden kann. 4. Legt für den Agenten Folgendes an: | Pfad | Eigentümer und Rechte | Inhalt | | ---------------------------------------------- | --------------------- | ----------------------------------------------------------------------------------- | | `/etc/endue-computer/.env` | root, `0600` | Die Verbindungsadresse, das Token und die Einstellungen, die du gewählt hast | | `/var/lib/endue-computer//workspace` | `endue` | Der [Arbeitsbereich](/de/docs/build/workspace/) des Agenten: der Ordner, in dem er arbeitet | | `/var/lib/endue-computer//state` | `endue` | Checkpoints und gespeicherte Dateien, außerhalb des Arbeitsbereichs | 5. Aktiviert und startet einen systemd-Dienst für den Agenten, `endue-computer@`, und meldet, ob die Verbindung steht. ## Festlegen, was der Agent darf [Abschnitt betitelt „Festlegen, was der Agent darf“](#festlegen-was-der-agent-darf) Häng Optionen an das Ende des Installationsbefehls an: ```sh curl -fsSL https://download.endue.ai/computer/install.sh | sudo sh -s -- \ --endpoint --token --instance \ --allow-exec git,python3 --no-network ``` | Option | Standard | Wirkung | | ------------------------------------ | ------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | `--allow-exec ` | `git,node,npm,npx,python3,pip3,curl` | Die Programme, die der Agent ausführen darf, kommagetrennt und ohne Pfade. `--allow-exec ""` schaltet das Ausführen von Programmen komplett ab. | | `--no-network` | Netzwerk erlaubt | Programme, die der Agent ausführt, können das Netzwerk nicht nutzen. | | `--no-delete` | Löschen erlaubt | Der Agent kann keine Dateien in seinem Arbeitsbereich löschen. Tools wie git und npm löschen Lock- und temporäre Dateien und schlagen deshalb mit dem Profil `sandboxed` fehl. | | `--profile auto\|sandboxed\|managed` | `auto` | Welches [Profil](#profile) verwendet wird. | Ein Programm auf der Liste, das auf dem Server nicht installiert ist, wird bei der Installation gemeldet. Versucht der Agent, es auszuführen, bekommt er „nicht installiert“ zurück. Ein erlaubtes Programm begrenzt nicht, was dieses Programm tut. Erlaubst du `node` oder `python3`, kann der Agent innerhalb der Grenzen des Profils jeden Code ausführen, den diese Programme ausführen können. ## Profile [Abschnitt betitelt „Profile“](#profile) | Profil | Voraussetzung | Was vom Agenten gestartete Programme nicht können | | ----------- | --------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `sandboxed` | Linux 6.12 oder neuer (Landlock ABI 6) | Dateien außerhalb des Arbeitsbereichsordners lesen oder schreiben. Alles unter `managed` gilt ebenfalls. | | `managed` | Jeder andere Kernel, etwa Ubuntu 22.04 (5.15) oder der GA-Kernel von Ubuntu 24.04 (6.8) | Root werden oder zusätzliche Rechte erlangen. systemd blendet `/home`, `/root` und die Ordner anderer Agenten aus und macht den Rest des Systems schreibgeschützt. Eine Dateisystem-Sandbox gibt es nicht: Programme können jede Datei lesen, die der Benutzer `endue` lesen kann. | `auto` wählt `sandboxed`, wenn der Kernel es unterstützt, und weicht sonst mit einem Hinweis auf `managed` aus. Verlangst du `sandboxed` auf einem Kernel, der es nicht unterstützt, bricht das Installationsskript ab, ohne etwas zu installieren. Nutze `managed` nur auf einem Server oder einer VM, die nur für den Agenten da ist. ## Einen weiteren Agenten auf demselben Server hinzufügen [Abschnitt betitelt „Einen weiteren Agenten auf demselben Server hinzufügen“](#einen-weiteren-agenten-auf-demselben-server-hinzufügen) Ein Server kann mehrere Agenten bedienen. Öffne unter **Ressourcen › Geräte** das Menü in der Zeile des Servers, wähle **Agent hinzufügen**, such den Agenten aus und führe den neuen Befehl auf demselben Server aus. Jeder Agent bekommt einen eigenen Dienst, eine eigene Einstellungsdatei und eigene Ordner. Das Programm und der Benutzer `endue` werden gemeinsam genutzt. Beim Profil `managed` sorgt systemd dafür, dass kein Agent in die Ordner der anderen gelangt. ## Starten, Stoppen und Logs [Abschnitt betitelt „Starten, Stoppen und Logs“](#starten-stoppen-und-logs) Ersetze `` durch den Wert nach `--instance` in deinem Befehl. ```sh sudo systemctl status endue-computer@ # läuft der Dienst? sudo systemctl start endue-computer@ # starten sudo systemctl stop endue-computer@ # stoppen sudo journalctl -u endue-computer@ -f # Log mitverfolgen ``` Solange der Dienst gestoppt ist, wird das Gerät als **Aus** angezeigt, und der Agent bittet dich, ihn zu starten. endue erstellt ersatzweise keinen Cloud-Computer. ## Neu installieren [Abschnitt betitelt „Neu installieren“](#neu-installieren) Führst du einen Installationsbefehl mit demselben `--instance` erneut aus, werden die Einstellungen einschließlich des Tokens ersetzt und der Dienst neu gestartet. Solange der Server des Agenten verbunden ist, kannst du keinen neuen Befehl erstellen. Stoppe zuerst den Dienst auf dem Server und erstelle den Befehl dann erneut. ## Deinstallieren [Abschnitt betitelt „Deinstallieren“](#deinstallieren) ```sh curl -fsSL https://download.endue.ai/computer/install.sh | sudo sh -s -- \ --uninstall --instance ``` Damit wird der Dienst des Agenten gestoppt und deaktiviert und seine Einstellungsdatei gelöscht. Der Arbeitsbereich und der state-Ordner bleiben erhalten, außer du ergänzt `--purge`. Ohne `--instance` werden alle Agenten auf dem Server entfernt. Ist kein Agent mehr übrig, werden auch das Programm und die Dienstdefinition entfernt. Die Deinstallation auf dem Server entfernt das Gerät nicht aus endue, und das Entfernen in endue deinstalliert nichts auf dem Server. Mach beides: hier deinstallieren und im Zeilenmenü des Geräts beim Agenten **Entfernen** wählen. Siehe [Ein Gerät entfernen](/de/docs/build/devices/#ein-ger%C3%A4t-entfernen). ## Einschränkungen [Abschnitt betitelt „Einschränkungen“](#einschränkungen) * Nur Linux auf x86\_64 oder aarch64. Versionen für macOS und Windows gibt es noch nicht. * Ein endue Computer pro Agent. Ein Agent auf deinem Server kann nicht zusätzlich einen in der endue Cloud haben, und ein Agent, der schon auf einem anderen Server ist, muss dort zuerst entfernt werden. * endue kann weder deinen Server noch den Dienst starten. Ist einer von beiden nicht erreichbar, arbeitet der Agent ohne ihn. * Der Agent kann Tools auf dem Server nur nutzen, solange der Dienst verbunden ist. Programme, die er im Hintergrund gestartet hat, enden, wenn der Dienst stoppt. * Ohne systemd, etwa in manchen Containern, ergänze `--no-systemd`. Das Installationsskript legt dann die Dateien ab und gibt den Befehl aus, mit dem du endue Computer selbst startest. Die oben beschriebenen Schutzmaßnahmen von systemd gelten in diesem Fall nicht. * Startet der Dienst nicht und meldet `status=226/NAMESPACE`, kann der Rechner keine Mount-Namespaces anlegen. Das kommt in manchen LXC- und OpenVZ-Containern vor. Nutze eine vollständige VM oder `--no-systemd`. ## Siehe auch [Abschnitt betitelt „Siehe auch“](#siehe-auch) [Geräte](/de/docs/build/devices/)Alle Geräteprodukte, Nutzer- und Agentengeräte und wie du eins entfernst. [Arbeitsbereich](/de/docs/build/workspace/)Der Ordner, in dem der Agent arbeitet, und wie du hineinschaust. [Sicherheit und Berechtigungen](/de/docs/account/security/)Worauf ein Agent zugreifen kann und worauf nicht. # Systemprompt und Revisionen > Schreib die dauerhaften Anweisungen, die ein Agent vor jeder Unterhaltung liest, behalte jede Version und geh zurück, wenn eine Änderung den Agenten verschlechtert. Der **Systemprompt** ist die dauerhafte Anweisung, die ein Agent vor jeder Unterhaltung liest: was er tut, wie er entscheiden soll und was er nie tun darf. Jede Version, die du speicherst, bleibt erhalten, Änderungen lassen sich also rückgängig machen. ## Wann du ihn anpasst [Abschnitt betitelt „Wann du ihn anpasst“](#wann-du-ihn-anpasst) Greif zum Prompt, wenn das *Verhalten* des Agenten nicht stimmt: Er tut das Falsche, im falschen Format, oder fragt dich Dinge, die er schon wissen sollte. Greif zu einem [Connector](/de/docs/connect/overview/) oder einem [Skill](/de/docs/capabilities/skills/), wenn ihm eine *Fähigkeit* fehlt. Ein Prompt ersetzt keinen Zugriff. ## Einen Prompt schreiben [Abschnitt betitelt „Einen Prompt schreiben“](#einen-prompt-schreiben) 1. **Öffne den Bereich Prompt im [Agent Builder](/de/docs/build/agent-builder/).** Du siehst den aktuellen Text und den Verlauf früherer Revisionen. 2. **Beschreib die Aufgabe in einem Absatz.** Für wen der Agent arbeitet, wofür er zuständig ist und was nicht dazugehört. Ein Agent, der seine Grenzen kennt, stellt weniger unnötige Fragen. 3. **Sag, wie ein gutes Ergebnis aussieht.** Diesen Teil lassen die meisten Prompts aus, und gerade er verändert die Ergebnisse am stärksten. Die Schritte wählt der Agent selbst. Was er nicht erraten kann, ist dein Maßstab für „fertig“. *„Fasse meine ungelesenen E-Mails zusammen“* überlässt alles dem Zufall. *„Fasse meine ungelesenen E-Mails nach Absender gruppiert zusammen; wenn mir jemand eine direkte Frage stellt, zitiere die Frage wörtlich, damit ich antworten kann, ohne die Mail zu öffnen“* tut das nicht. 4. **Liste die festen Regeln auf.** Dinge, die immer passieren müssen oder nie passieren dürfen: nie jemandem außerhalb des Unternehmens mailen, immer das Quelldokument angeben, nie eine Zahl raten. 5. **Speichere ihn als neue Revision.** Der vorherige Text wird nicht überschrieben. Er bleibt als Revision erhalten, zu der du zurückkehren kannst. [](/docs/_astro/studio-prompt.pjPH7ESY.png) [In voller Größe öffnen](/docs/_astro/studio-prompt.pjPH7ESY.png) ## Revisionen und Zurücksetzen [Abschnitt betitelt „Revisionen und Zurücksetzen“](#revisionen-und-zurücksetzen) Jedes Speichern erzeugt eine Revision. Der Verlauf zeigt, wie der Prompt zu jedem Zeitpunkt lautete, und du kannst eine frühere Revision wiederherstellen. Deshalb ist das schrittweise Verbessern eines Prompts sicher und kein Glücksspiel. Ändere etwas, nutze den Agenten einen Tag lang, und falls die Änderung ihn verschlechtert hat, geh zurück zu der Revision, die funktioniert hat. Du musst dir nicht merken, was im alten Text stand. Eine Ausführung nutzt die Revision, mit der sie gestartet ist Das Wiederherstellen einer Revision wirkt sich auf die nächste Ausführung des Agenten aus. Eine bereits laufende Ausführung endet mit dem Prompt, mit dem sie begonnen hat. Deshalb kann es so aussehen, als ignoriere ein Agent eine Änderung, die du gerade gemacht hast. ## Was wohin gehört [Abschnitt betitelt „Was wohin gehört“](#was-wohin-gehört) | Wohin | Wann | | --------------------------------------- | -------------------------------------------------------------------------------------------------------------------- | | **Systemprompt** | Es gilt für jede Unterhaltung: deine Rolle, feste Regeln, Ausgabeformat | | **Eine Nachricht** | Es gilt nur für diese Aufgabe | | **[Charakter](/de/docs/build/identity/)** | Es geht um den Ton, nicht um die Aufgabe | | **[Gedächtnis](/de/docs/capabilities/memory/)** | Es ist eine Tatsache, die der Agent einmal lernen und wiederverwenden soll: eine Vorliebe, ein Name, eine Gewohnheit | | **Ein [Skill](/de/docs/capabilities/skills/)** | Es ist ein wiederholbarer Ablauf mit Schritten, keine dauerhafte Anweisung | Ist ein Prompt so gewachsen, dass er vier voneinander unabhängige Aufgaben abdeckt, brauchst du einen zweiten Agenten und keinen längeren Prompt. ## Einschränkungen [Abschnitt betitelt „Einschränkungen“](#einschränkungen) * Ein Prompt kann keinen Zugriff gewähren. Braucht der Agent deinen Kalender, braucht er eine zugewiesene Verbindung. „Du hast Zugriff auf meinen Kalender“ zu schreiben, ändert nichts. * Das Wiederherstellen einer Revision ersetzt den gesamten Prompt. Revisionen lassen sich nicht zusammenführen. * Der Prompt gilt pro Agent. Sollen zwei Agenten dieselben festen Regeln befolgen, muss der Text in beiden stehen. ## Siehe auch [Abschnitt betitelt „Siehe auch“](#siehe-auch) [Testen und iterieren](/de/docs/build/iterating/)Wie du erkennst, ob eine Änderung am Prompt wirklich geholfen hat. [Gedächtnis](/de/docs/capabilities/memory/)Fakten, die der Agent einmal lernt, statt sie jedes Mal gesagt zu bekommen. [Skills](/de/docs/capabilities/skills/)Wiederholbare Abläufe, die nicht in einen Prompt gehören. # Eigenschaften > Schalter, die das Verhalten eines Agenten ändern. Sie entscheiden, ob sein Charakter beim Modell ankommt, ob er behält, was er in Unterhaltungen lernt, und ob er sein Gedächtnis aufräumt, während er nichts zu tun hat. Eine **Eigenschaft** schaltet ein Verhalten des Agenten ein oder aus. Anders als der [Systemprompt](/de/docs/build/system-prompt/), den du als Text schreibst, ist eine Eigenschaft ein Schalter: Die Einstellung bleibt, wo sie ohnehin liegt, und die Eigenschaft entscheidet, ob sie genutzt wird. ## Die Eigenschaften [Abschnitt betitelt „Die Eigenschaften“](#die-eigenschaften) | Eigenschaft | Was das Einschalten bewirkt | | ---------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Persönlichkeit** | Der Charakter, den du im [Profil](/de/docs/build/identity/) des Agenten festgelegt hast, fließt in das ein, was das Modell liest. Ist sie ausgeschaltet, arbeitet der Agent nur mit seinem Prompt. | | **Selbstlernend** | Der Agent behält, was er in Unterhaltungen lernt. Vorlieben, Fakten und Zusagen landen in seinem [Gedächtnis](/de/docs/capabilities/memory/), Abläufe, die du ihm beibringst, werden zu [Skills](/de/docs/capabilities/skills/), und er führt einen Index der Dateien, die er erstellt hat, damit er sie wieder öffnen kann. Das geplante Aufräumen übernimmt Dream. | | **Dream** | Der Agent räumt sein Gedächtnis auf, während er nichts zu tun hat. Er führt Erinnerungen zusammen, die sich überschneiden, korrigiert veraltete Fakten, schließt erledigte Zusagen ab und [archiviert](/de/docs/capabilities/memory/#archiv) Erinnerungen, die nicht mehr nützlich sind. Dann gibt er jeder Erinnerung eine einzeilige Zusammenfassung und Suchbegriffe, damit die nächste Unterhaltung sie schneller findet. An Tagen, an denen sich nichts geändert hat, ruht Dream. Es läuft als [Routine](/de/docs/automate/routines/), die du wie jede andere einsehen und bearbeiten kannst. | | **Self Configuration** | Auf Bitte im Gespräch schlägt der Agent Änderungen an seinen Einstellungen vor. Vorher und nachher erscheinen auf einer Karte; erst mit **Anwenden** wird gespeichert. Erlaubte Bereiche wählst du einzeln. | [](/docs/_astro/studio-trait.CkjlbsQ4.png) [In voller Größe öffnen](/docs/_astro/studio-trait.CkjlbsQ4.png) ## Wann du sie einschaltest [Abschnitt betitelt „Wann du sie einschaltest“](#wann-du-sie-einschaltest) **Persönlichkeit** lohnt sich, wenn der Ton zählt, etwa bei einem Agenten, der mit Kundschaft spricht, oder bei einem, dessen Antworten du den ganzen Tag liest. Lass sie aus, wenn der Agent nüchtern und berechenbar sein soll oder wenn du gerade [einen Prompt feinjustierst](/de/docs/build/iterating/) und eine Variable weniger haben willst. **Selbstlernend** ist für einen Agenten gedacht, der dauerhaft mit denselben Leuten arbeitet. Er behält eine Vorliebe, eine Zusage oder eine Arbeitsweise, die du ihm beigebracht hast, sodass du sie in der nächsten Unterhaltung nicht noch einmal erklären musst. **Dream** lohnt sich bei einem Agenten, der seit Wochen läuft und Erinnerungen angesammelt hat. Sich überschneidende und veraltete Erinnerungen werden weniger, und die übrigen bekommen eine Zusammenfassung und Suchbegriffe. Ein neuer Agent hat wenig aufzuräumen, und an Tagen ohne Änderungen erzeugt Dream keine Ausführung. Du kannst es also ruhig früh einschalten. Beim Ausschalten bleiben die Einstellungen erhalten Das Ausschalten einer Eigenschaft löscht nichts. Der Charakter bleibt im Profil und die Routine von Dream in der Liste der Routinen, die Eigenschaft nutzt sie nur nicht mehr. Schaltest du sie wieder ein, kehrt das vorherige Verhalten zurück. ## Was Selbstlernend lernt [Abschnitt betitelt „Was Selbstlernend lernt“](#was-selbstlernend-lernt) Selbstlernend arbeitet während der Unterhaltungen. Eine eigene Routine gibt es dafür nicht. | Teil | Was der Agent tut | Schalter | | ---------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------- | | Gedächtnis | Lernt er eine Vorliebe, einen Fakt oder eine Zusage, schreibt er sie ins Gedächtnis oder aktualisiert den vorhandenen Eintrag und sagt das in einer Zeile. | Selbstlernend selbst | | Skills | Bringst du ihm einen Ablauf bei, den er wiederverwenden wird, etwa ein Berichtsformat oder eine Reihenfolge von Schritten, speichert er einen Anweisungs-Skill. Korrigierst du einen Skill, den er gelernt hat, aktualisiert er diesen Skill. Das Speichern erwähnt er am Ende seiner Antwort, und ab der nächsten Unterhaltung folgt er dem Ablauf. | Beigebrachte Abläufe als Skills speichern | | Dateien | In jeder Unterhaltung behält er die Pfade und Beschreibungen von bis zu 15 Dateien, die er zuletzt geändert hat. Er öffnet die, die er braucht, und sucht nach Thema, wenn eine Datei nicht auf der Liste steht. Ändert er eine Datei grundlegend, aktualisiert er auch die Beschreibung. | Dateiindex | Beide Schalter werden mit Selbstlernend eingeschaltet. Schalte nur die Teile aus, die du nicht willst. Die Teile Skills und Dateien greifen nur, wenn die Person spricht, der der Agent gehört. In Unterhaltungen mit Besuchenden auf endue.live, in API-Aufrufen oder mit Personen aus Kanälen legt der Agent keine Skills an, ändert keine und lädt die Dateiliste nicht, egal ob Selbstlernend eingeschaltet ist oder nicht. Auch Ausführungen von Routinen lernen keine Skills. ### Einen gelernten Skill zurücksetzen [Abschnitt betitelt „Einen gelernten Skill zurücksetzen“](#einen-gelernten-skill-zurücksetzen) Unter **Gelernte Skills** in den Einstellungen von Selbstlernend siehst du die Skills, die der Agent angelegt oder geändert hat, die neuesten zuerst. Jede Zeile zeigt, ob der Skill neu oder aktualisiert ist, woraus der Agent ihn gelernt hat und ob er gerade genutzt wird. **Zurücksetzen** bringt einen aktualisierten Skill auf die Version vor der Änderung zurück und entfernt einen neuen Skill vom Agenten und aus deinem Konto. Einen zurückgesetzten Skill legt der Agent nicht noch einmal an und ändert ihn auch nicht mehr. Skills, die du selbst erstellt hast, ändert der Agent nicht. Sieht er etwas, das sich verbessern ließe, schlägt er die Änderung in der Unterhaltung vor. ## Was Self Configuration ändern kann [Abschnitt betitelt „Was Self Configuration ändern kann“](#was-self-configuration-ändern-kann) Mit **Self Configuration** schlägt der Agent Änderungen an seinen Einstellungen vor, wenn du ihn in einer Unterhaltung darum bittest. Eine Karte zeigt die Werte davor und danach; erst mit deiner Zustimmung wird gespeichert. Das ist für Agenten gedacht, deren Einstellungen du häufig anpasst. Einzelne Bereiche kannst du sperren. 1. Schalte im Bereich Eigenschaften **Self Configuration** ein. 2. Wähle unter **Einstellungen, die der Agent ändern darf** die freigegebenen Bereiche. Profil, Persönlichkeit sowie Rolle und Sprachen sind anfangs eingeschaltet. 3. Bitte ihn im Gespräch zum Beispiel: „Nenn dich Luna und antworte kürzer.“ 4. Prüfe auf der Änderungskarte den alten und neuen Wert. Bei einem Prompt werden hinzugefügte und entfernte Zeilen gezeigt. 5. Mit **Anwenden** wird gespeichert; die Änderung wirkt ab der nächsten Antwort. **Abbrechen** verwirft sie. [](/docs/_astro/studio-trait-self-config.CVyA-uu-.png) [In voller Größe öffnen](/docs/_astro/studio-trait-self-config.CVyA-uu-.png) | Bereich | Was geändert wird | Anfangs | | -------------------- | ----------------------------------------------------------------------------------------------------------- | ------- | | Profil | Name und Beschreibung | An | | Persönlichkeit | [Persönlichkeitswerte](/de/docs/build/identity/). Ist die Eigenschaft Persönlichkeit aus, ändert sich der Ton nicht | An | | Rolle und Sprachen | Rollenbeschreibungen und Antwortsprachen | An | | Prompt | [Systemprompt](/de/docs/build/system-prompt/). Jede Änderung erzeugt eine neue, als vom Agenten geänderte Revision | Aus | | Modell | Das Standard-[Chatmodell](/de/docs/build/models/), sofern in deinem Tarif enthalten | Aus | | Integrierte Tools | [Toolgruppen](/de/docs/capabilities/built-in-tools/) ein- und ausschalten | Aus | | Andere Eigenschaften | Persönlichkeit und Selbstlernend ein- und ausschalten | Aus | Bittest du um eine gesperrte Änderung, zeigt der Agent keine Karte und verweist auf den Agent Builder. Er kann auch gesperrte Einstellungen lesen und Fragen wie „Welches Modell nutzt du?“ beantworten. Self Configuration arbeitet nur im Gespräch mit dem Eigentümer. Bei endue.live-Besuchern, API-Aufrufen, Kanalnutzern und Routinen liest oder ändert der Agent seine Einstellungen nicht. Was der Agent nicht ändern kann Live-Veröffentlichung und Sichtbarkeit, Kanal- und Connector-Verbindungen, API-Schlüssel, Avatar, Dream sowie Archivierung und Löschung des Agenten bleiben gesperrt. Auch Self Configuration selbst und seine Freigaben änderst du im Agent Builder. ### Eine Änderung rückgängig machen [Abschnitt betitelt „Eine Änderung rückgängig machen“](#eine-änderung-rückgängig-machen) **Vom Agenten geänderte Einstellungen** listet Änderungen mit alten und neuen Werten sowie Links zu den Gesprächen, neueste zuerst. **Zurücksetzen** stellt den früheren Wert wieder her. Beim Prompt entsteht dafür eine neue Revision. Wurde dieselbe Einstellung später erneut geändert, wird nichts zurückgesetzt und du erhältst einen Hinweis. Grenzen: Der Agent schlägt nur Änderungen vor, um die du gebeten hast, und jede braucht deine Zustimmung auf der Karte. Eine Karte enthält höchstens vier Bereiche. Bei mehreren Bereichen können einzelne Speichervorgänge fehlschlagen; das Ergebnis steht bei jedem Bereich. Lange Prompt-Änderungen erscheinen auf der Karte nur teilweise. Nach dem Anwenden findest du den vollständigen Text in den Revisionen; möchtest du ihn vorher lesen, bitte um eine kleinere Änderung. Hat der Agent den allerersten Prompt erstellt, kann Zurücksetzen ihn nicht entfernen. Bearbeite ihn im Prompt-Bereich. ## Wann Dream schläft [Abschnitt betitelt „Wann Dream schläft“](#wann-dream-schläft) In den Einstellungen von Dream siehst du eine runde Uhr mit allen 24 Stunden auf einem Zifferblatt. Mit zwei Griffen legst du fest, wann Dream schläft: einer für die Schlafenszeit, einer für die Weckzeit. 1. Schalte im Bereich Eigenschaften **Dream** ein. Eine Aufräum-Routine wird angelegt, anfangs mit 04:00 Uhr als Schlafenszeit und 07:00 Uhr als Weckzeit, jeden Tag. 2. Zieh die beiden Griffe auf der Uhr, um Schlafenszeit und Weckzeit zu verschieben. Sie bewegen sich in 5-Minuten-Schritten. Ziehst du den Bogen zwischen ihnen, verschieben sich beide gemeinsam und die Dauer bleibt gleich. Mit der Tastatur fokussierst du einen Griff und verschiebst ihn mit den Pfeiltasten links und rechts um 5 Minuten oder mit Bild-auf und Bild-ab um eine Stunde. 3. Wähle unter der Uhr die Tage, an denen Dream läuft. Mindestens ein Tag muss ausgewählt sein. 4. Klicke auf **Zeit speichern**. Das Aufräumen beginnt zur Schlafenszeit. Die Weckzeit ist der letzte Zeitpunkt, zu dem ein Aufräumen starten kann. Ein verspätet ausgelöstes Aufräumen oder ein erneuter Versuch nach einem Fehler pausiert für den Tag, sobald die Weckzeit vorbei ist, und wartet auf die Schlafenszeit am nächsten ausgewählten Tag. Ein bereits begonnenes Aufräumen läuft bis zum Ende, auch über die Weckzeit hinaus. An einem Tag, an dem sich seit dem letzten Aufräumen keine Erinnerung geändert hat und keine neue Unterhaltung dazugekommen ist, lässt Dream das Aufräumen aus. Es wird keine Ausführung erzeugt, es entsteht also keine Nutzung, und das Auslassen zählt nicht als Fehlschlag der Routine. Die Uhr folgt der Zeitzone der Routine. Weicht sie von der deines Browsers ab, zeigt die Uhr an, welche Zeitzone sie verwendet. Hast du den Zeitplan direkt in den Details der [Routine](/de/docs/automate/routines/) bearbeitet, läuft dieser Zeitplan weiter. Kann die Uhr ihn nicht darstellen, etwa einen Zeitplan für den 1. jedes Monats, zeigt sie einen Hinweis, und ein Klick auf **Zeit speichern** ersetzt den Zeitplan durch die Zeit auf der Uhr. Jedes Aufräumen hinterlässt einen Bericht darüber, was zusammengeführt, korrigiert und archiviert wurde, als Datei in deinen [Outputs](/de/docs/capabilities/outputs/) unter `/reports/memory/`. Auch der Link zum letzten Aufräumbericht in den Einstellungen von Dream öffnet ihn. Agenten, die ihr Gedächtnis mit Selbstlernend aufgeräumt haben Das geplante Aufräumen, das bisher Selbstlernend erledigt hat, übernimmt jetzt Dream. Dream nutzt die bereits verknüpfte Aufräum-Routine weiter, du musst also nichts tun, und die Routine behält ihren Zeitplan und Verlauf. Wurde diese Routine nach wiederholten Fehlschlägen angehalten, zeigen die Einstellungen von Dream eine Warnung und die Schaltfläche **Fortsetzen**. ## Einschränkungen [Abschnitt betitelt „Einschränkungen“](#einschränkungen) * Eigenschaften gelten pro Agent. * Die Eigenschaft Persönlichkeit erschafft keine Persönlichkeit, sie überträgt die, die bereits im Profil steht. Den Charakter änderst du unter [Identität](/de/docs/build/identity/). * Dream läuft als normale Routine und folgt denselben Regeln. Eine unbeaufsichtigte Ausführung kann dich nichts fragen, und jedes Aufräumen zählt wie jede andere Ausführung einer Routine zur [Nutzung](/de/docs/account/usage/). * Dream setzt voraus, dass die [integrierten Tools](/de/docs/capabilities/built-in-tools/) für das Gedächtnis eingeschaltet sind. * Selbstlernend erstellt nur Anweisungs-Skills. Skills, die externe Dienste aufrufen, erstellt es nicht. * Selbstlernend speichert höchstens zwei Skills pro Antwort. Ein gelernter Skill gehört zu deinem Konto. Hängst du ihn an einen anderen Agenten an, gilt er dort ebenfalls. * Der Dateiindex umfasst nur die [Outputs](/de/docs/capabilities/outputs/), die der Agent erstellt hat. An eine Unterhaltung angehängte Dateien und Dateien auf einem Gerät sind nicht enthalten. * Eine angeheftete Erinnerung bearbeitet oder archiviert Dream nicht. Es ergänzt dort nur eine Zusammenfassung und Suchbegriffe. * Von Dream archivierte Erinnerungen werden nicht von selbst gelöscht. Lösche die, die du nicht brauchst, unter [Gedächtnis](/de/docs/capabilities/memory/#archiv). * Die Uhr legt Zeiten nur nach Wochentagen fest. Jeder andere Zeitplan muss in den Details der Routine bearbeitet werden. * Änderungen gelten ab der nächsten [Ausführung](/de/docs/work/runs/) des Agenten. ## Siehe auch [Abschnitt betitelt „Siehe auch“](#siehe-auch) [Identität und Profil](/de/docs/build/identity/)Wo der Charakter festgelegt wird, den die Eigenschaft Persönlichkeit überträgt. [Gedächtnis](/de/docs/capabilities/memory/)Was Selbstlernend schreibt und Dream aufräumt, einschließlich Archiv und Index. [Skills](/de/docs/capabilities/skills/)Die Anweisungs-Skills, die Selbstlernend speichert. Hier hängst du sie an und ab. [Routinen](/de/docs/automate/routines/)Wie Dream läuft: Zeitplan, Verlauf und was bei einem Fehlschlag passiert. [Das Kontextfenster](/de/docs/work/context-window/)Eigenschaften gehören zu dem, was das Modell bei jedem Schritt liest. # Arbeitsbereich > Der eigene Ordner des Agenten auf seinem endue Computer, in dem er Dateien ablegt und Programme ausführt. Seine Tools laufen, ohne bei jedem Aufruf um Freigabe zu bitten. Der **Arbeitsbereich** ist der eigene Dateibereich eines Agenten auf seinem [endue Computer](/de/docs/build/devices/): ein Ordner, den er lesen und beschreiben kann und in dem er Programme ausführt. So erledigt ein Agent Arbeit, die einen Ort zum Ablegen braucht: Code auschecken, aus Daten einen Bericht erstellen, ein Arbeitsverzeichnis über mehrere Unterhaltungen hinweg behalten. ## Wo er liegt [Abschnitt betitelt „Wo er liegt“](#wo-er-liegt) Der Arbeitsbereich liegt auf dem endue Computer des Agenten, also dort, wo sich dieses Gerät befindet. * **In der endue Cloud**, sofern du nichts anderes gewählt hast. Du legst ihn nicht vorab an. Bitte einen Agenten um eine Arbeit, die einen Computer braucht, dann richtet er einen ein und sagt dir dabei in der Unterhaltung Bescheid. Beim ersten Mal dauert die Vorbereitung einen Moment. Danach steht derselbe Arbeitsbereich auch in der nächsten Unterhaltung bereit. * **Auf deinem eigenen Server**, wenn du für diesen Agenten [einen verbunden hast](/de/docs/build/own-server/). Der Ordner ist dann `/var/lib/endue-computer//workspace` auf diesem Server. Der Chat zeigt die Vorbereitung als eigenen Schritt, damit klar ist, warum die erste Ausführung länger dauert. ## Was der Agent darin tun kann [Abschnitt betitelt „Was der Agent darin tun kann“](#was-der-agent-darin-tun-kann) Dateien lesen, durchsuchen, schreiben, bearbeiten, verschieben und kopieren. Programme ausführen, ihre Ausgabe lesen und Programme im Hintergrund weiterlaufen lassen. Tools im Arbeitsbereich fragen nicht bei jedem Aufruf nach Wenn der Agent auf seinem endue Computer Dateien schreibt oder Programme ausführt, wartet er nicht auf eine [Freigabe](/de/docs/work/approvals/). Die Grenze ist das Gerät selbst: ein Rechner in der endue Cloud, der diesem Agenten gehört, oder die Einschränkungen, die du bei der Installation von endue Computer auf deinem eigenen Server festgelegt hast. Andere Aktionen fragen weiterhin vorher nach: Klicken, Tippen und Absenden in endue for Chrome sowie Connector-Operationen, die etwas senden oder löschen. ## Hineinschauen [Abschnitt betitelt „Hineinschauen“](#hineinschauen) Unter Inventar im [Agent Builder](/de/docs/build/agent-builder/) zeigt der Bereich **Arbeitsbereich**, was darin liegt: den Dateibaum, den Inhalt einer Datei und die gerade laufenden Prozesse. Die Ansicht ist schreibgeschützt. Um Dateien zu ändern, bitte den Agenten darum. Die Ansicht aktualisiert sich nicht von selbst, denn die Dateien ändert der Agent, nicht du. Aktualisiere sie, wenn du den aktuellen Stand sehen willst. Den endue Computer selbst, mit seinem Status und dem Ort, an dem er läuft, findest du nicht hier, sondern im Agent Builder desselben Agenten unter **Ressourcen › Geräte**. ## Einschränkungen [Abschnitt betitelt „Einschränkungen“](#einschränkungen) * Ein Arbeitsbereich pro Agent, auf seinem einen endue Computer. * In der endue Cloud bestehen die Dateien so lange wie das Gerät. Löschst du das Gerät oder ersetzt es durch deinen eigenen Server, werden sie mitgelöscht. Bewahre Ergebnisse, die du brauchst, als [Outputs](/de/docs/capabilities/outputs/) auf. * Ist der endue Computer im Standby, zeigt die Ansicht das an, und er startet, sobald der Agent das nächste Mal arbeitet. Ist dein eigener Server aus, zeigt die Ansicht auch das an: Starte endue Computer auf dem Server, um die Dateien zu sehen. * Die Ansicht listet Dateien auf und zeigt sie an. Hochladen, Bearbeiten oder Löschen ist dort nicht möglich. ## Siehe auch [Abschnitt betitelt „Siehe auch“](#siehe-auch) [Geräte](/de/docs/build/devices/)endue Computer und die anderen Geräte, auf denen ein Agent arbeitet. [Eigenen Server oder eigene VM verbinden](/de/docs/build/own-server/)Leg den Arbeitsbereich auf einen Linux-Rechner unter deiner Kontrolle. [Outputs](/de/docs/capabilities/outputs/)Wohin Ergebnisse gehören, sobald sie es wert sind, aufbewahrt zu werden. # Integrierte Tools > Was jeder Agent ohne Einrichtung kann – und welche dieser Fähigkeiten du pro Agent abschalten kannst. **Integrierte Tools** sind die Fähigkeiten, die ein Agent hat, bevor du irgendetwas verbindest. Sie sind in Gruppen gegliedert, und jede Gruppe lässt sich für einzelne Agenten abschalten. ## Wann du sie nutzt [Abschnitt betitelt „Wann du sie nutzt“](#wann-du-sie-nutzt) *Einschalten* musst du sie selten, denn sie sind standardmäßig an. Du schaltest sie *aus*, um einen Agenten einzugrenzen. Ein Agent, der nur zusammenfassen soll, was du einfügst, muss keine Webseiten abrufen, und ein Agent, der nie etwas zeitlich planen soll, braucht keine Routine-Tools. ## Die Gruppen [Abschnitt betitelt „Die Gruppen“](#die-gruppen) | Gruppe | Was der Agent tun kann | | ------------------ | -------------------------------------------------------------------------------------------------------------------------- | | **Outputs** | [Outputs](/de/docs/capabilities/outputs/) speichern, auflisten, lesen, aktualisieren und löschen | | **Routinen** | [Routinen](/de/docs/automate/routines/) direkt aus einer Unterhaltung erstellen und verwalten | | **Gedächtnis** | Merken, abrufen, aktualisieren und vergessen, siehe [Gedächtnis](/de/docs/capabilities/memory/) | | **Projekt** | Das [Projekt](/de/docs/capabilities/projects/) lesen und aktualisieren, zu dem eine Unterhaltung gehört | | **Skill-Tools** | Installierte [Skills](/de/docs/capabilities/skills/) durchsehen, einen davon nutzen oder einen neuen verfassen | | **Visualisierung** | Ein Diagramm oder Widget direkt in der Unterhaltung zeichnen | | **Webabruf** | Den Inhalt einer URL lesen | | **Hilfsmittel** | Exakte Berechnungen und die aktuelle Uhrzeit | | **Geräte** | Einen endue Computer oder endue for Chrome bereitstellen, wenn eine Aufgabe das erfordert, siehe [Geräte](/de/docs/build/devices/) | Schaltest du **Gedächtnis** aus, wird zu Beginn einer Unterhaltung auch der Gedächtnisindex des Agenten nicht mehr geladen. Die Gruppe ist die ganze Fähigkeit, nicht nur die Tools. [](/docs/_astro/studio-tools.CbItWCe4.png) [In voller Größe öffnen](/docs/_astro/studio-tools.CbItWCe4.png) ## Immer aktiv [Abschnitt betitelt „Immer aktiv“](#immer-aktiv) Einige Tools sind Infrastruktur für die Unterhaltung selbst und lassen sich nicht ausschalten: * Dir eine [Frage](/de/docs/work/questions/) stellen, mit Optionen oder Freitext. * Einen [Skill](/de/docs/capabilities/skills/#wenn-ein-agent-einen-skill-anfordert) anfordern, den er nicht bekommen hat. Ein Agent, der dich nichts fragen könnte, würde stattdessen raten, und das ist in jedem Fall schlechter. Tools abzuschalten gehört zum Feintuning Jedes angebotene Tool ist eine weitere Option, die das Modell bei jedem Schritt abwägt. Gruppen zu entfernen, die ein Agent nicht braucht, schärft seine Entscheidungen messbar. Das ist eine der günstigeren Maßnahmen auf der [Iterationsliste](/de/docs/build/iterating/#was-du-%C3%A4ndern-kannst-der-reihe-nach). ## Einschränkungen [Abschnitt betitelt „Einschränkungen“](#einschränkungen) * Integrierte Tools gelten pro Agent. Schaltest du eine Gruppe für einen Agenten aus, betrifft das keine anderen. * Das Ausschalten einer Gruppe gilt ab der nächsten [Ausführung](/de/docs/work/runs/) des Agenten. * Integrierte Tools erreichen deine Konten nicht. Alles, was Gmail, Slack, Notion oder einen anderen Dienst berührt, kommt von einem [Connector](/de/docs/connect/overview/), nicht von hier. * Webabruf liest öffentlich erreichbare Seiten. Er ist kein Browser und meldet sich nirgends an. ## Siehe auch [Abschnitt betitelt „Siehe auch“](#siehe-auch) [Skills](/de/docs/capabilities/skills/)Fähigkeiten, die du hinzufügst, statt solcher, die ab Werk aktiv sind. [Connectors im Überblick](/de/docs/connect/overview/)Tools, die deine echten Konten erreichen. [Testen und iterieren](/de/docs/build/iterating/)Welche Rolle das Eingrenzen der Tools beim Feintuning eines Agenten spielt. # Gedächtnis > Was ein Agent zwischen Unterhaltungen behält, wie er darüber entscheidet und wie du Gespeichertes prüfst, korrigierst oder löschst. Das **Gedächtnis** ist das, was ein Agent von einer [Unterhaltung](/de/docs/work/conversations/) in die nächste mitnimmt: Fakten über dich, deine Vorlieben, wie du Arbeit erledigt haben möchtest. Es wird bewusst gespeichert, und du kannst jeden Eintrag lesen. ## Wann du es nutzt [Abschnitt betitelt „Wann du es nutzt“](#wann-du-es-nutzt) Das Gedächtnis ist für langlebige Fakten da, die du nicht jedes Mal wiederholen musst: in welcher Zeitzone du arbeitest, wer zu deinem Team gehört, dass du Zahlen gerundet haben möchtest, dass „der Bericht“ den in einem bestimmten Ordner meint. Es ist kein Aktenschrank. Inhalte gehören in einen [Output](/de/docs/capabilities/outputs/), Hintergrund zu einem bestimmten Arbeitsvorhaben gehört in ein [Projekt](/de/docs/capabilities/projects/). ## Wie ein Agent es nutzt [Abschnitt betitelt „Wie ein Agent es nutzt“](#wie-ein-agent-es-nutzt) Der Agent entscheidet, was sich zu behalten lohnt, und schreibt es auf, oft nachdem du ihn korrigiert oder eine Vorliebe genannt hast. Zu Beginn einer Unterhaltung lädt er einen Index dessen, was er weiß, und holt die für die Aufgabe relevanten Einträge dazu, nicht alles, was er je gespeichert hat. Du kannst es ihm auch direkt sagen: *„Merk dir, dass ich freitags keine Meetings will“* ist eine ganz normale Anweisung, und er speichert sie. ## Prüfen und korrigieren [Abschnitt betitelt „Prüfen und korrigieren“](#prüfen-und-korrigieren) Das Gedächtnis findest du im [Agent Builder](/de/docs/build/agent-builder/) im Bereich Identität des Agenten. Jeder Eintrag ist lesbar, und du kannst alles löschen, was nicht hätte behalten werden sollen. Sieh es dir ab und zu an. Agenten notieren auch, was sie nur ableiten, und eine Ableitung, die als Fakt dasteht, etwa *„bevorzugt kurze Antworten“* nach einer einzigen ungeduldigen Nachricht, prägt still und leise wochenlang die Antworten. Das Gedächtnis gilt pro Agent Jeder Agent merkt sich Dinge für sich. Bringst du einem Agenten deine Vorlieben bei, lernen die anderen sie nicht mit. Was jeder Agent wissen soll, steht besser im [Systemprompt](/de/docs/build/system-prompt/) jedes einzelnen Agenten. [](/docs/_astro/studio-memory.B5hlGp_W.png) [In voller Größe öffnen](/docs/_astro/studio-memory.B5hlGp_W.png) ## Archiv [Abschnitt betitelt „Archiv“](#archiv) Ist die Eigenschaft [Dream](/de/docs/build/traits/#wann-dream-schl%C3%A4ft) aktiviert, räumt der Agent sein Gedächtnis auf, während er untätig ist. Erinnerungen, die nicht mehr nützlich sind, und Erinnerungen, die mit einer anderen zusammengeführt wurden, werden archiviert statt gelöscht. Eine archivierte Erinnerung wird nicht in Unterhaltungen geladen, und der Agent findet sie nicht, wenn er sein Gedächtnis durchsucht. Archivierte Erinnerungen sammeln sich in der Gruppe **Archiviert** ganz unten in der Gedächtnisliste. Die Gruppe ist eingeklappt. Klappst du sie auf, siehst du bei jeder Erinnerung das Archivierungsdatum, **Wiederherstellen** und Löschen. **Wiederherstellen** nimmt die Erinnerung ab der nächsten Unterhaltung wieder in Gebrauch. Lösche die, die du nicht mehr brauchst. Eine Erinnerung, die der Agent auf deinen Wunsch in einer Unterhaltung vergessen soll, wird sofort gelöscht, nicht archiviert. Archiviert wird nur beim Aufräumen durch Dream. ## Index [Abschnitt betitelt „Index“](#index) Wenn Dream mit dem Aufräumen fertig ist, gibt es jeder Erinnerung eine einzeilige Zusammenfassung und ein paar Suchbegriffe. * Die **Zusammenfassung** kommt in den Gedächtnisindex, den der Agent zu Beginn einer Unterhaltung lädt. Ohne sie enthält der Index den gekürzten Anfang der Erinnerung. Mit Zusammenfassung behält also auch eine lange Erinnerung ihren Kern. * Die **Suchbegriffe** gleicht der Agent beim Suchen zusammen mit dem Text der Erinnerung ab. Eine Erinnerung, in der „Report“ steht, wird auch bei einer Suche nach „Bericht“ gefunden. Öffne eine Erinnerung, um ihre **Dream-Zusammenfassung** und die Suchbegriffe zu sehen. Bearbeiten kannst du sie nicht. Ändert sich der Inhalt der Erinnerung, wird die Zusammenfassung als veraltet markiert, und beim nächsten Aufräumen schreibt Dream eine neue. Bis dahin nutzt der Gedächtnisindex den Anfang der Erinnerung. Erinnerungen eines Agenten ohne Dream haben weder Zusammenfassung noch Suchbegriffe. ## Ausschalten [Abschnitt betitelt „Ausschalten“](#ausschalten) Das Gedächtnis ist eine [integrierte Tool-Gruppe](/de/docs/capabilities/built-in-tools/). Schaltest du es für einen Agenten aus, speichert er nichts mehr und ruft nichts mehr ab, und zu Beginn einer Unterhaltung wird kein Gedächtnisindex mehr geladen. Bestehende Einträge bleiben erhalten, der Agent nutzt sie nur nicht mehr. Das ist die richtige Einstellung für einen Agenten, der mit Daten anderer Menschen arbeitet, oder für einen, den du zustandslos und vorhersehbar haben willst. ## Einschränkungen [Abschnitt betitelt „Einschränkungen“](#einschränkungen) * Das Gedächtnis gilt pro Agent, nicht pro Konto. * Was gespeichert wird, entscheidet der Agent. Du kannst keine Liste von Erinnerungen vorab anlegen, aber du kannst ihm sagen, was er sich merken soll, und löschen, was er falsch verstanden hat. * Ein gelöschter Eintrag wird in künftigen Ausführungen nicht mehr abgerufen. Unterhaltungen, in denen er schon verwendet wurde, ändern sich dadurch nicht. * Archivierte Erinnerungen werden nicht von selbst gelöscht. Wenn sie sich häufen, lösche sie in der Gruppe **Archiviert**. * Dream wählt die Suchbegriffe beim Aufräumen. Mit einer Formulierung, die weder in den Suchbegriffen noch im Text vorkommt, wird die Erinnerung eventuell nicht gefunden. * Das Gedächtnis ist kein durchsuchbarer Speicher für Inhalte. Große Dokumente gehören in Outputs. ## Siehe auch [Abschnitt betitelt „Siehe auch“](#siehe-auch) [Projekte](/de/docs/capabilities/projects/)Gemeinsamer Kontext für ein Arbeitsvorhaben statt für den Agenten. [Systemprompt](/de/docs/build/system-prompt/)Feste Regeln, die weder vergessen noch bloß abgeleitet werden sollen. [Integrierte Tools](/de/docs/capabilities/built-in-tools/)Wo das Gedächtnis ein- und ausgeschaltet wird. [Eigenschaften](/de/docs/build/traits/)Selbstlernend schreibt Erinnerungen während der Unterhaltung, Dream räumt sie auf, wenn der Agent untätig ist. # Outputs > Wo die Dokumente, Berichte, Dateien und Apps landen, die ein Agent erstellt, wie du sie liest und exportierst und wie das Teilen per Link funktioniert. Ein **Output** ist etwas, das ein Agent erstellt hat und das sich aufzuheben lohnt: ein Bericht, ein Dokument, ein Datensatz, ein Diagramm, eine kleine App. Statt im Verlauf unterzugehen, bekommt es eine eigene Seite. Es gibt zwei Arten von Outputs. * **Datei**: ein Ergebnis, das in eine Datei passt. Listen zeigen es als Dokument, Tabelle, Seite oder Bild. * **App**: ein Ergebnis aus mehreren Dateien, die aufeinander verweisen. Es öffnet sich als funktionierende Oberfläche statt als Dokument. Beide Arten teilen sich eine Liste, **Outputs** in der linken Leiste, die neuesten zuerst. Du findest einen Output über seinen Namen, ohne dir merken zu müssen, welche Art es ist. ## Wann ein Output entsteht [Abschnitt betitelt „Wann ein Output entsteht“](#wann-ein-output-entsteht) Das entscheidet der Agent. Bittest du um etwas Umfangreiches, etwa *„Schreib die Ergebnisse zusammen“* oder *„Erstell die Wochenzusammenfassung“*, speichert er das Ergebnis als Output und verlinkt es in der Unterhaltung. Du kannst auch direkt darum bitten: *„Speicher das“*. Besteht das Ergebnis aus mehreren Dateien (eine Seite mit ihren Styles und Skripten), speichert der Agent es als eine App. Kurze Antworten bleiben in der Unterhaltung, und das ist der richtige Standard. Ein Output ist für Arbeit gedacht, zu der du zurückkehrst. ## Mit Outputs arbeiten [Abschnitt betitelt „Mit Outputs arbeiten“](#mit-outputs-arbeiten) **In der Unterhaltung** erscheint ein Output als Karte, die du öffnen kannst, ohne die Unterhaltung zu verlassen. Die Schaltfläche **Outputs in dieser Unterhaltung** in der rechten Leiste sammelt die Dateien und Apps, die in dieser Unterhaltung entstanden sind. **Auf seiner eigenen Seite** bekommst du den vollständigen Inhalt, eine Vorschau für Formate, die das unterstützen, und den Export. Der Agent kann seine eigenen Outputs später wieder lesen. Das macht aufeinander aufbauende Arbeit möglich: in einer Unterhaltung entwerfen, in der nächsten überarbeiten. **Im Inventar des Agenten** stehen die Apps und Dateien, die er erstellt hat. Hefte die Dateien an, zu denen du immer wieder zurückkehrst, damit sie oben bleiben. ## Dateien zu einer App bündeln [Abschnitt betitelt „Dateien zu einer App bündeln“](#dateien-zu-einer-app-bündeln) Hat ein Agent mehrere Dateien gespeichert, die zusammenarbeiten (eine Seite, ein kleines Tool, ein Dashboard), kannst du sie zu einer **App** bündeln. Eine App hat eine eigene Seite, öffnet sich als funktionierende Oberfläche und lässt sich genauso per Link teilen wie eine Datei. Bündeln ist ein **Verschieben**: Die Dateien werden zur ersten Version der App, und die ursprünglichen Einträge verschwinden. So bleibt nur eine maßgebliche Fassung, und dasselbe Ergebnis taucht nicht doppelt in deinen Listen auf. Die Originale werden erst entfernt, nachdem die App gespeichert ist. Schlägt das Speichern fehl, geht nichts verloren. Eine App öffnet sich in einem von zwei Modi: * **Ansicht**: das Ergebnis und sonst nichts drumherum. Das sehen Personen, die den Link erhalten. * **Canvas**: die App neben der Unterhaltung, sodass du um eine Änderung bitten und zusehen kannst, wie sie umgesetzt wird. ## Per Link teilen [Abschnitt betitelt „Per Link teilen“](#per-link-teilen) Ein Output ist standardmäßig **nur für dich sichtbar**. Schaltest du das Teilen per Link ein, entsteht eine URL, die genau diesen einen Output öffnet. Was ein Link gewährt: | Gewährt | Gewährt nicht | | ----------------------------- | ----------------------------------------------- | | Lesezugriff auf diesen Output | Zugriff auf andere Outputs | | Sonst nichts | Die Unterhaltung, aus der er stammt | | | Deinen Agenten, sein Gedächtnis oder dein Konto | Alle, die den Link haben, können den Output öffnen. Behandle ihn also als öffentlich. Schaltest du das Teilen aus, funktioniert der Link nicht mehr. Ein Output, der nicht geteilt ist, lässt sich über die URL überhaupt nicht finden, auch nicht, wenn jemand sie errät. Ältere Links auf `/artifacts/…` und `/apps/…` funktionieren weiterhin. Die Adresse wechselt zu `/outputs/…`, und es erscheint dieselbe Seite. Prüfe den Inhalt, bevor du teilst Ein Output, den ein Agent aus deinen E-Mails oder Dokumenten geschrieben hat, kann daraus zitieren. Lies ihn, bevor du den Link einschaltest. ## Einschränkungen [Abschnitt betitelt „Einschränkungen“](#einschränkungen) * Speicherst du eine Datei erneut unter demselben Pfad, wird ihr Inhalt ersetzt. Den früheren Stand kannst du über den Versionsverlauf auf der Seite der Datei wiederherstellen. * Apps lassen sich nicht anheften. Anheften geht nur bei Dateien. * Outputs gehören dem Agenten, der sie erstellt hat, und dir. Ein anderer Agent liest sie nicht, es sei denn, du verweist ihn auf einen davon. * Teilen per Link gewährt nur Lesezugriff, und es gibt einen Link pro Output. Zugriff pro Person gibt es nicht. * Wenn du einen Agenten löschst, werden seine Outputs nicht gelöscht. ## Siehe auch [Abschnitt betitelt „Siehe auch“](#siehe-auch) [Projekte](/de/docs/capabilities/projects/)Die Arbeit bündeln, zu der ein Output gehört. [Routinen](/de/docs/automate/routines/)Geplante Arbeit, deren Ergebnis meist als Output gespeichert wird. [Sicherheit und Berechtigungen](/de/docs/account/security/)Was privat ist, was geteilt wird und was ein Agent erreichen kann. # Projekte > Unterhaltungen rund um eine zusammenhängende Arbeit gruppieren und einem Agenten dauerhaften Kontext geben, den er bei jeder Ausführung liest. Ein **Projekt** gruppiert die [Unterhaltungen](/de/docs/work/conversations/), die zur selben Arbeit gehören, und enthält Kontext, den jede Unterhaltung darin lesen kann. ## Wann du es nutzt [Abschnitt betitelt „Wann du es nutzt“](#wann-du-es-nutzt) Nutze ein Projekt, wenn du merkst, dass du in einem Thread nach dem anderen denselben Hintergrund erklärst: den Kunden, die Codebasis, den Launch, das Quartal. Das Projekt enthält diesen Hintergrund ein einziges Mal. | Wohin | Wann | | ----------------------------------------- | ------------------------------------------- | | Der [Systemprompt](/de/docs/build/system-prompt/) | Es gilt für alles, was der Agent jemals tut | | Ein Projekt | Es gilt für diese Arbeit | | Das [Gedächtnis](/de/docs/capabilities/memory/) | Es gilt für dich, über alle Arbeiten hinweg | | Eine Nachricht | Es gilt für diese eine Aufgabe | ## Was ein Projekt einem Agenten gibt [Abschnitt betitelt „Was ein Projekt einem Agenten gibt“](#was-ein-projekt-einem-agenten-gibt) Eine Unterhaltung in einem Projekt beginnt mit dem Kontext des Projekts. Der Agent kann außerdem den aktuellen Stand des Projekts lesen und ihn im Laufe der Arbeit aktualisieren. So bleibt ein Status, den der Agent pflegt, aktuell, ohne dass du ihn abschreiben musst. Dadurch taugt ein Projekt auch als gemeinsames Arbeitsprotokoll: worum es bei der Arbeit geht, wo sie steht und was entschieden wurde. ## In einem Projekt arbeiten [Abschnitt betitelt „In einem Projekt arbeiten“](#in-einem-projekt-arbeiten) Öffne das Projekt und beginne dort eine Unterhaltung, dann gehört diese Unterhaltung zum Projekt. Die Projektseite listet ihre Unterhaltungen auf. Wenn du zu einer Arbeit zurückkehrst, musst du also nicht die globale Liste der letzten Unterhaltungen durchsuchen. Ein Projekt ist keine Berechtigungsgrenze Legst du eine Unterhaltung in ein Projekt, ändert das, was der Agent *liest*, nicht, worauf er *zugreifen* kann. Zugriff kommt weiterhin von den [Verbindungen und Skills](/de/docs/connect/overview/), die dem Agenten zugewiesen sind. ## Einschränkungen [Abschnitt betitelt „Einschränkungen“](#einschränkungen) * Eine Unterhaltung gehört zu einem Projekt. * Der Projektkontext steht den Unterhaltungen in diesem Projekt zur Verfügung. Mit den anderen Threads des Agenten wird er nicht geteilt. * Projekte gruppieren Arbeit, gewähren aber keinen Zugriff und sind kein Ort zum Ablegen von Dokumenten. Ergebnisse gehören in [Outputs](/de/docs/capabilities/outputs/). ## Siehe auch [Abschnitt betitelt „Siehe auch“](#siehe-auch) [Unterhaltungen](/de/docs/work/conversations/)Die Threads, die ein Projekt gruppiert. [Outputs](/de/docs/capabilities/outputs/)Wo die Ergebnisse der Projektarbeit landen. [Gedächtnis](/de/docs/capabilities/memory/)Kontext, der dir folgt statt der Arbeit. # Skills > Eine wiederkehrende Aufgabe einmal verpacken, einem Agenten zuweisen und einen Agenten einen Skill anfordern lassen, den er nicht hat. Ein **Skill** verpackt eine wiederkehrende Aufgabe, etwa ein Verfahren, eine Checkliste oder eine Folge von Schritten, damit du sie nicht jedes Mal neu erklären musst. Weist du einen Skill einem Agenten zu, wird er Teil dessen, was dieser Agent kann. ## Wann du ihn nutzt [Abschnitt betitelt „Wann du ihn nutzt“](#wann-du-ihn-nutzt) Nutze einen Skill, wenn das *Wie* feststeht und sich die Wiederverwendung lohnt: ein Wochenbericht mit fester Struktur, ein Triage-Verfahren mit Regeln, eine Recherchemethode, die jedes Mal gleich befolgt werden soll. | Wohin | Wann | | ----------------------------------------- | ---------------------------------------------------------------------------- | | Der [Systemprompt](/de/docs/build/system-prompt/) | Es gilt für alles, was der Agent tut | | Ein Skill | Es ist eine bestimmte Aufgabe mit Schritten, die gelegentlich gebraucht wird | | Eine [Routine](/de/docs/automate/routines/) | Die Aufgabe soll zusätzlich nach Zeitplan laufen | ## Woher Skills kommen [Abschnitt betitelt „Woher Skills kommen“](#woher-skills-kommen) Unter **Ressourcen › Skills** in der linken Seitenleiste findest du drei Tabs: | Tab | Inhalt | | ----------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Entdecken** | Skills aus dem endue-Katalog, die du deinem Konto hinzufügen kannst | | **Meine Skills** | Skills in deinem Konto: solche, die du hinzugefügt hast, solche, die du oder deine Agenten erstellt haben, und Drittanbieter-Skills, die du importiert hast | | **Drittanbieter** | Öffentliche GitHub- und GitLab-Repositorys, aus denen du Skills importierst. Siehe [Drittanbieter-Skills](/de/docs/capabilities/third-party-skills/). | ## Zuweisung [Abschnitt betitelt „Zuweisung“](#zuweisung) Ein Skill wird bestimmten Agenten zugewiesen, genau wie eine [Verbindung](/de/docs/connect/overview/). Wenn du einen Skill installierst oder erstellst, bekommt ihn nicht automatisch jeder deiner Agenten. Du entscheidest, welche Agenten ihn erhalten. Die Zuweisung hält einen Agenten berechenbar. Ein Agent mit zwanzig Skills verbraucht sein Urteilsvermögen damit, zwischen ihnen zu wählen. Ein Agent mit dreien setzt sie gut ein. ## Wenn ein Agent einen Skill anfordert [Abschnitt betitelt „Wenn ein Agent einen Skill anfordert“](#wenn-ein-agent-einen-skill-anfordert) Ein Agent, dem ein Skill helfen würde, den er nicht bekommen hat, kann ihn **anfordern**, statt zu scheitern. Die [Ausführung](/de/docs/work/runs/) pausiert, und die Unterhaltung zeigt, was er will und warum. Gewährst du ihn, wird der Skill zugewiesen, und die Ausführung läuft mit ihm weiter. Lehnst du ab, macht der Agent ohne ihn weiter, meist auf dem längeren Weg. Gewähren ist eine echte Zuweisung Nimmst du eine Anfrage an, ist der Skill diesem Agenten ab dann zugewiesen, nicht nur für die aktuelle Ausführung. War es eine einmalige Sache, entferne die Zuweisung danach im [Agent Builder](/de/docs/build/agent-builder/). ## Skills finden und erstellen [Abschnitt betitelt „Skills finden und erstellen“](#skills-finden-und-erstellen) Agenten können die für sie verfügbaren Skills durchsehen und selbst einen passenden für die aktuelle Aufgabe auswählen, ohne dass du ihn nennen musst. Außerdem können Agenten aus einer Arbeit, die ihr gerade gemeinsam erledigt habt, einen neuen Skill verfassen. Das ist nützlich, wenn du einen Agenten einmal durch ein Verfahren geführt hast und es festhalten willst. Skills, die du erstellst, bleiben privat in deinem Konto, solange du sie nicht veröffentlichst. ## Einschränkungen [Abschnitt betitelt „Einschränkungen“](#einschränkungen) * Ein Skill ist kein Zugriff. Ein Skill, der deine E-Mails liest, braucht trotzdem eine E-Mail-[Verbindung](/de/docs/connect/overview/), die demselben Agenten zugewiesen ist. * Skills werden pro Agent zugewiesen. Ein kontoweites „alle Agenten bekommen das“ gibt es nicht. * Skill-Schritte, die einen Connector aufrufen, unterliegen derselben [Freigabeschranke](/de/docs/work/approvals/) wie jede andere Aktion. ## Siehe auch [Abschnitt betitelt „Siehe auch“](#siehe-auch) [Integrierte Tools](/de/docs/capabilities/built-in-tools/)Was jeder Agent kann, bevor du ihm etwas zuweist. [Connectors im Überblick](/de/docs/connect/overview/)Einem Agenten Zugriff auf einen echten Dienst geben. [Routinen](/de/docs/automate/routines/)Eine verpackte Aufgabe nach Zeitplan ausführen. [Drittanbieter-Skills](/de/docs/capabilities/third-party-skills/)Skills aus einem öffentlichen Repository importieren. # Drittanbieter-Skills > Skills aus einem öffentlichen GitHub- oder GitLab-Repository in „Meine Skills“ importieren, sie aktualisieren, wenn sich das Repository ändert, und sehen, welche Dateien ausgelassen wurden. Ein **Drittanbieter-Skill** ist ein [Skill](/de/docs/capabilities/skills/), der aus einem öffentlichen GitHub- oder GitLab-Repository importiert wurde. endue liest die `SKILL.md`-Dateien im Repository und fügt jede einzelne zu **Meine Skills** hinzu, privat in deinem Konto. ## Wann du sie nutzt [Abschnitt betitelt „Wann du sie nutzt“](#wann-du-sie-nutzt) Nutze sie, wenn das gewünschte Verfahren bereits als `SKILL.md` in einem öffentlichen Repository existiert oder wenn dein Team seine Skills in einem Repository pflegt und dort bearbeitet. ## Ein Repository hinzufügen [Abschnitt betitelt „Ein Repository hinzufügen“](#ein-repository-hinzufügen) 1. **Öffne Ressourcen › Skills** über die linke Seitenleiste und wähle den Tab **Drittanbieter**. 2. **Gib die URL des Repositorys ein**, zum Beispiel `https://github.com/owner/repo`. Um nur einen Ordner zu importieren, füge die URL des Ordners ein (`…/tree/main/skills`) oder öffne **Erweitert** und fülle Folgendes aus: * **Branch oder Tag**: Leer lassen, um den Standard-Branch zu verwenden. * **Pfad im Repository**: Nur `SKILL.md`-Dateien unterhalb dieses Ordners werden importiert. Leer lassen für das gesamte Repository. 3. **Wähle Importieren.** Das Ergebnis zeigt, wie viele Skills importiert wurden, und listet die Dateien auf, die nicht importiert wurden, jeweils mit Grund. 4. **Weise die Skills einem Agenten zu**, und zwar wie bei jedem anderen Skill im [Agent Builder](/de/docs/build/agent-builder/) dieses Agenten. Durch den Import allein bekommt kein Agent einen Skill. Lies, was du importierst Ein Drittanbieter-Skill enthält Anweisungen von jemand anderem, und dein Agent befolgt sie. Lies einen Skill, bevor du ihn zuweist, und prüfe ihn noch einmal, wenn „Erneut importieren“ ihn geändert hat. ## Was importiert wird [Abschnitt betitelt „Was importiert wird“](#was-importiert-wird) Jede `SKILL.md` unter dem Pfad wird zu einem Skill. Die Datei beginnt mit einem Frontmatter, das `name` und `description` enthält, gefolgt von den Anweisungen: ```md --- name: weekly-report description: Writes the weekly status report from the issues closed this week. --- 1. List the issues closed since Monday. 2. Group them by project. ``` Importiert wird nur der Text der `SKILL.md`. Skripte, Referenzdokumente und andere Dateien im Ordner des Skills werden nicht importiert. Wenn die Anweisungen den Agenten auffordern, ein Skript auszuführen oder eine Datei zu lesen, die neben der `SKILL.md` liegt, kann der Agent das nicht. Importierte Skills erscheinen in **Meine Skills** mit dem Badge **Drittanbieter** und einem Link **Quelle** zur ursprünglichen `SKILL.md`. Diese Skills sind privat in deinem Konto. Eine Datei wird in folgenden Fällen ausgelassen und unter **Nicht importierte Dateien** aufgeführt: | Grund | Was du änderst | | --------------------------------------------------------------------------------------- | -------------------------------------------------------- | | Sie ist keine `SKILL.md` (Skripte, Referenzdokumente) | Nichts. Nur `SKILL.md` wird importiert. | | Sie ist ein symbolischer Link | Lege die Datei selbst ins Repository | | Sie ist größer als 256 KB | Kürze sie | | Das Repository enthält mehr als 50 Skills | Importiere über den Pfad einen Ordner mit weniger Skills | | Das Frontmatter fehlt, ist fehlerhaft oder enthält kein `name` oder keine `description` | Ergänze beides zwischen `---`-Zeilen ganz oben | | Der Hauptteil ist leer | Füge die Anweisungen unter dem Frontmatter ein | | Sie ist kein UTF-8-Text | Speichere sie als UTF-8 | | Die Lizenz erlaubt keine Weiterverbreitung | Nichts. Sie kann nicht importiert werden. | ## Aus dem Repository aktualisieren [Abschnitt betitelt „Aus dem Repository aktualisieren“](#aus-dem-repository-aktualisieren) Wähle beim Repository **Erneut importieren**. endue vergleicht den neuesten Commit des Repositorys mit dem, den es zuletzt importiert hat: * **Nichts hat sich geändert**: Es passiert nichts, und endue sagt dir das. * **Eine `SKILL.md` hat sich geändert**: Dieser Skill bekommt eine neue Version. Skills, deren Datei sich nicht geändert hat, bleiben, wie sie sind. * **Eine `SKILL.md` ist hinzugekommen**: Sie wird als neuer Skill importiert. * **Eine `SKILL.md` wurde entfernt**: Der Skill wird als **Archiviert** markiert und aus „Meine Skills“ genommen. Kommt die Datei zurück, stellt ihn der nächste erneute Import wieder her. Aktualisiert wird nur, wenn du „Erneut importieren“ wählst. endue überwacht das Repository nicht. ## Ein Repository löschen [Abschnitt betitelt „Ein Repository löschen“](#ein-repository-löschen) **Löschen** entfernt das Repository und jeden daraus importierten Skill. Das lässt sich nicht rückgängig machen. Ist einer dieser Skills einem Agenten zugewiesen, wird das Löschen verweigert, und der Dialog zeigt, welche Skills bei welchen Agenten betroffen sind. Entferne die Skills bei diesen Agenten im [Agent Builder](/de/docs/build/agent-builder/) und lösche dann erneut. ## Einschränkungen [Abschnitt betitelt „Einschränkungen“](#einschränkungen) * Nur öffentliche Repositorys auf github.com und gitlab.com. Private Repositorys und andere Hosts werden nicht unterstützt. Eine URL mit Benutzername, Passwort, Token oder Portnummer wird abgelehnt. * Bis zu 10 Repositorys pro Konto. * Bis zu 50 Skills pro Repository und 256 KB pro `SKILL.md`. * Der Download des Repositorys ist auf 20 MB komprimiert begrenzt. Bei einem großen Repository lege die Skills in einem kleineren ab. * Nur der Text der `SKILL.md` wird importiert. Skripte und andere Dateien nicht. * Änderungen im Repository wirken sich erst aus, wenn du „Erneut importieren“ wählst. * Wenn GitHub oder GitLab Anfragen drosselt, schlägt der Import mit einer entsprechenden Meldung fehl. Versuche es ein paar Minuten später erneut. ## Siehe auch [Abschnitt betitelt „Siehe auch“](#siehe-auch) [Skills](/de/docs/capabilities/skills/)Was ein Skill ist und wie die Zuweisung funktioniert. [Agent Builder](/de/docs/build/agent-builder/)Wo du einem Agenten einen Skill zuweist. [Sicherheit und Berechtigungen](/de/docs/account/security/)Worauf ein Agent zugreifen kann und worauf nicht. # Verfügbare Connectors > Alle Dienste, mit denen sich endue heute verbindet, was ein Agent mit jedem davon tun kann und wie du den Zugriff autorisierst. endue verbindet sich mit **34 Diensten**. Diese Seite ist der Katalog: was jeder Dienst einem Agenten ermöglicht und wie du den Zugriff autorisierst. Maßgeblich ist die App Fast jede Woche kommen neue Connectors hinzu. Der Katalog in der App und das öffentliche [Connector-Verzeichnis](/de/connectors) sind immer aktuell. Diese Seite wird von Hand gepflegt und kann um ein Release hinterherhinken. [](/docs/_astro/connectors-catalog.C8RNQDfg.png) Derselbe Katalog ist öffentlich unter endue.ai/connectors einsehbar.[In voller Größe öffnen](/docs/_astro/connectors-catalog.C8RNQDfg.png) ## So liest du die Tabelle [Abschnitt betitelt „So liest du die Tabelle“](#so-liest-du-die-tabelle) **Anmeldung** gibt an, wie du die Verbindung autorisierst: | Methode | Was du tust | | ----------------------- | ------------------------------------------------------------------------------------- | | **OAuth** | Beim Anbieter anmelden und den Zugriff auf seinem Zustimmungsbildschirm erlauben | | **Token** | In den Einstellungen des Anbieters API-Zugangsdaten erstellen und in endue einfügen | | **Token + Adresse** | Dasselbe, plus die Adresse deiner eigenen Installation – für selbst gehostete Dienste | | **Anmeldung + Adresse** | Deine eigene Installation, mit Benutzername und Anwendungstoken | Einige Dienste fragen nach einem zusätzlichen Feld, etwa einer Region, einer E-Mail-Adresse oder einem zweiten Schlüssel. Welche das sind, zeigt dir das Formular beim Verbinden. **Freigabe** nennt die Operationen, die für deine [Freigabe](/de/docs/work/approvals/) anhalten: alles, was etwas nach außen sendet oder Daten löscht. Lese- und Schreiboperationen laufen, ohne dich zu unterbrechen. ## Mail und Kalender [Abschnitt betitelt „Mail und Kalender“](#mail-und-kalender) | Dienst | Ein Agent kann | Anmeldung | Freigabe | | ---------------------------- | ----------------------------------------------------------------------------- | --------- | -------- | | **[Gmail](/de/docs/connect/gmail/)** | Deinen Posteingang durchsuchen und lesen, Entwürfe schreiben und Mails senden | OAuth | Senden | | **Google Calendar** | Termine ansehen, Details prüfen und Termine erstellen | OAuth | — | ## Dokumente und Wissen [Abschnitt betitelt „Dokumente und Wissen“](#dokumente-und-wissen) | Dienst | Ein Agent kann | Anmeldung | Freigabe | | ------------------------------ | ---------------------------------------------------------------------------------------------------------- | --------- | -------------------------------------- | | **Google Drive** | Dateien suchen, lesen, erstellen, aktualisieren und löschen | OAuth | Löschen | | **Google Docs** | Dokumente erstellen, lesen, bearbeiten und löschen | OAuth | Löschen | | **Google Sheets** | Tabellen ansehen; Zeilen hinzufügen, aktualisieren und löschen | OAuth | Löschen | | **Google Slides** | Präsentationen erstellen, lesen, bearbeiten und löschen | OAuth | Löschen | | **Google Tasks** | Aufgaben ansehen, erstellen, abschließen und löschen | OAuth | Löschen | | **Google Contacts** | Kontakte suchen, ansehen, erstellen, aktualisieren und löschen | OAuth | Löschen | | **[Notion](/de/docs/connect/notion/)** | Seiten und Datenbanken durchsuchen, Inhalte lesen, Seiten erstellen und ergänzen | OAuth | — | | **Confluence** | Seiten per CQL suchen, Inhalte lesen, Bereiche auflisten; Seiten erstellen und aktualisieren, kommentieren | OAuth | Erstellen, Aktualisieren, Kommentieren | Was in der Praxis wichtig ist, steht unter [Gmail](/de/docs/connect/gmail/) und [Google Workspace](/de/docs/connect/google-workspace/). ## Kommunikation [Abschnitt betitelt „Kommunikation“](#kommunikation) | Dienst | Ein Agent kann | Anmeldung | Freigabe | | ---------------------------- | --------------------------------------------------------------------------------------- | --------------- | ----------------- | | **[Slack](/de/docs/connect/slack/)** | Kanäle auflisten, Nachrichtenverlauf und Threads ansehen und suchen; Nachrichten senden | OAuth | Posten | | **Mattermost** | Teams, Kanäle, Nachrichtenverlauf und Threads ansehen und suchen; Nachrichten posten | Token + Adresse | Posten | | **Telegram** | Vom Bot empfangene Nachrichten und Chats ansehen; Nachrichten senden | Token | Senden | | **Discourse** | Das Forum durchsuchen, Themen lesen, Kategorien auflisten; Themen und Antworten posten | Token + Adresse | Posten, Antworten | Damit kann ein Agent im Rahmen seiner eigenen Arbeit in einem Chatdienst *lesen und schreiben*. Für die umgekehrte Richtung, wenn Menschen aus Slack, Discord, KakaoTalk, NaverTalk oder WhatsApp heraus *mit* einem Agenten sprechen, siehe [Kanäle](/de/docs/automate/channels/). ## Issues und Projekte [Abschnitt betitelt „Issues und Projekte“](#issues-und-projekte) | Dienst | Ein Agent kann | Anmeldung | Freigabe | | ---------- | -------------------------------------------------------------------------------------------------------------------------------- | --------- | -------------------------------------- | | **Jira** | Issues per JQL suchen, Details ansehen, Projekte und Übergänge auflisten; Issues erstellen, kommentieren und den Status wechseln | OAuth | Erstellen, Kommentieren, Statuswechsel | | **Linear** | Issues suchen und ansehen; Issues erstellen, kommentieren und aktualisieren | OAuth | Erstellen, Kommentieren, Aktualisieren | ## Entwicklung und Deployment [Abschnitt betitelt „Entwicklung und Deployment“](#entwicklung-und-deployment) | Dienst | Ein Agent kann | Anmeldung | Freigabe | | ---------------- | ---------------------------------------------------------------------------------------------------- | ------------------- | --------------------------- | | **GitLab** | Projekte, Issues, Merge-Requests und Pipelines ansehen; Issues erstellen und kommentieren | Token + Adresse | Erstellen, Kommentieren | | **Jenkins** | Jobs, Build-Status und Konsolenlogs ansehen; Builds auslösen | Anmeldung + Adresse | Auslösen | | **Vercel** | Projekte, Deployment-Status und Build-Logs ansehen; erneut deployen und in die Produktion hochstufen | Token | Erneut deployen, Hochstufen | | **Cloudflare** | Zonen, DNS, Workers und Pages-Deployments ansehen; Cache leeren | Token | Cache leeren | | **LaunchDarkly** | Projekte, Umgebungen, Feature-Flags und Audit-Logs ansehen; Flags umschalten | Token | Umschalten | ## Monitoring und Vorfälle [Abschnitt betitelt „Monitoring und Vorfälle“](#monitoring-und-vorfälle) | Dienst | Ein Agent kann | Anmeldung | Freigabe | | ----------------- | ------------------------------------------------------------------------------------------------------------------------------ | --------------- | -------------------------- | | **Datadog** | Monitore, Logs, Metriken und Ereignisse ansehen; Monitore stummschalten | Token | Stummschalten | | **Grafana** | Dashboards, Datenquellen und Warnungen ansehen, Metriken und Logs abfragen, Annotationen erstellen und Warnungen stummschalten | Token + Adresse | Stummschalten | | **PagerDuty** | Vorfälle, Bereitschaftspläne und Dienste ansehen; bestätigen, als behoben markieren und Notizen hinzufügen | Token | Bestätigen, Beheben, Notiz | | **Elasticsearch** | Indizes und Mappings ansehen, Dokumente durchsuchen und aggregieren | Token + Adresse | — | Elasticsearch ist bewusst nur lesend angebunden: Ein Agent kann deine Daten untersuchen, aber nicht ändern. Der Connector funktioniert auch mit OpenSearch. ## Social Media und Veröffentlichung [Abschnitt betitelt „Social Media und Veröffentlichung“](#social-media-und-veröffentlichung) | Dienst | Ein Agent kann | Anmeldung | Freigabe | | ------------- | -------------------------------------------------------------------------------------------- | ------------------- | ----------------------------------------------- | | **WordPress** | Beiträge suchen und lesen, Entwürfe erstellen und bearbeiten sowie veröffentlichen | Anmeldung + Adresse | Veröffentlichen, Veröffentlichtes aktualisieren | | **Reddit** | Subreddits und Beiträge durchsuchen, Kommentare lesen, Beiträge und Kommentare posten | OAuth | Posten, Kommentieren | | **Facebook** | Seiten, Beiträge und Reaktionen ansehen; Seitenbeiträge und Kommentare veröffentlichen | OAuth | Posten, Kommentieren | | **Instagram** | Profil, Beiträge und Kommentare ansehen; auf Kommentare antworten und Bilder veröffentlichen | OAuth | Antworten, Veröffentlichen | ## E-Commerce und Karten [Abschnitt betitelt „E-Commerce und Karten“](#e-commerce-und-karten) | Dienst | Ein Agent kann | Anmeldung | Freigabe | | --------------------- | --------------------------------------------------------------------------------------------------------------- | --------------- | --------------------------- | | **Shopify** | Produkte, Bestellungen und Kunden ansehen; Produktentwürfe erstellen und veröffentlichen | Token + Adresse | Veröffentlichen | | **Naver Smart Store** | Produkte, Bestellungen und Kundenanfragen ansehen; Bestellungen als versandt markieren und Anfragen beantworten | Token | Beantworten, Versand melden | | **Naver Map** | Zwischen Adressen und Koordinaten umrechnen und Fahrtrouten abrufen | Token | — | Commerce-Connectors erstellen standardmäßig Entwürfe Ein Produkt, das ein Agent in Shopify anlegt, ist ein Entwurf. Es für die Kundschaft sichtbar zu machen, ist eine eigene, freigabepflichtige Aktion. ## Design [Abschnitt betitelt „Design“](#design) | Dienst | Ein Agent kann | Anmeldung | Freigabe | | --------- | ---------------------------------------------------------------------------------------------------------------- | --------- | ------------ | | **Figma** | Dateistruktur und Knoten ansehen, Bilder exportieren, Kommentare ansehen und posten | OAuth | Kommentieren | | **Canva** | Designs suchen, Details ansehen, Ordner durchsuchen, Dateien exportieren, Designs erstellen und Assets hochladen | OAuth | — | ## Verbindungen nur für Kanäle [Abschnitt betitelt „Verbindungen nur für Kanäle“](#verbindungen-nur-für-kanäle) Zwei Einträge im Katalog geben einem Agenten überhaupt keine Tools. Sie sind dafür da, dass eine Messaging-Plattform *von außen* zum Agenten gelangt: | Eintrag | Wofür er da ist | | ----------------- | ------------------------------------------------------------------------------------------------------------------------ | | **Kakao Builder** | Empfängt Nachrichten über den Skill-Webhook des KakaoTalk-Chatbot-Builders und antwortet über die einmalige Callback-URL | | **NaverTalk Bot** | Empfängt Nachrichten über den Event-Webhook von TalkTalk und antwortet über die Send API | Beide werden als [Kanäle](/de/docs/automate/channels/) eingerichtet, nicht als Connectors, die einem Agenten zugewiesen sind. ## Einschränkungen [Abschnitt betitelt „Einschränkungen“](#einschränkungen) * Diese Liste zeigt, was es heute gibt. Einen Dienst, der hier fehlt, kann ein Agent nicht erreichen, und es gibt keinen allgemeinen Connector, der „irgendeine API aufruft“. * Jeder Connector bietet einen festen Satz an Operationen, nämlich die oben zusammengefassten. Ein Agent kann keine Teile der API eines Anbieters nutzen, die endue nicht anbietet. * Selbst gehostete Dienste (**Token + Adresse**, **Anmeldung + Adresse**) müssen aus dem Internet erreichbar sein. * Was ein Agent tatsächlich tun kann, ist die Schnittmenge aus diesen Operationen und den Berechtigungen, die du beim Anbieter erteilt hast. ## Siehe auch [Abschnitt betitelt „Siehe auch“](#siehe-auch) [Connectors im Überblick](/de/docs/connect/overview/)Verbindung und Zuweisung, Autorisieren und Widerrufen. [Freigaben](/de/docs/work/approvals/)Was die Spalte Freigabe bedeutet, wenn ein Agent dort ankommt. [Fehlerbehebung bei Verbindungen](/de/docs/connect/troubleshooting/)Wenn ein Connector nicht mehr funktioniert. # Direktverbindungen > Verbinde einen MCP-Server oder eine HTTP-API, die du betreibst, über Endpunkt und Header mit deinen Agenten. Jeder Aufruf fragt nach einer Freigabe, außer du erlaubst ihn immer. Eine **Direktverbindung** verbindet deine Agenten mit einem Server, den du betreibst: einem entfernten MCP-Server oder einer HTTP-API. Du gibst endue den Endpunkt und die nötigen Header, und die Agenten, denen du die Verbindung zuweist, können den Server aufrufen. ## Wann du sie nutzt [Abschnitt betitelt „Wann du sie nutzt“](#wann-du-sie-nutzt) Nutze eine Direktverbindung für einen Dienst, für den es im Katalog keinen Connector gibt: eine interne API, deinen eigenen MCP-Server, ein Tool, das dein Team gebaut hat. Steht der Dienst unter [Verfügbare Connectors](/de/docs/connect/available-connectors/), nutze stattdessen diesen Connector. Seine Operationen sind bereits eingestuft, sodass nur Senden und Löschen vorher nachfragen. ## MCP-Server oder HTTP-Server [Abschnitt betitelt „MCP-Server oder HTTP-Server“](#mcp-server-oder-http-server) | | MCP-Server | HTTP-Server | | ------------------------- | ---------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------- | | **Endpunkt** | Der MCP-Endpunkt des Servers mit dem Transport Streamable HTTP | Eine Basis-URL | | **Was der Agent bekommt** | Jedes Tool, das der Server auflistet, mit den Namen und Beschreibungen des Servers | Ein Anfrage-Tool, das GET, POST, PUT, PATCH oder DELETE an Pfade unter der Basis-URL sendet | | **Beschreibung** | Optional. Hilft dir, den Server in der Liste wiederzuerkennen. | Pflichtfeld. Der Agent liest sie, um zu wissen, welche Pfade und Methoden er nutzen soll. | ## Direktverbindung hinzufügen [Abschnitt betitelt „Direktverbindung hinzufügen“](#direktverbindung-hinzufügen) 1. **Öffne Ressourcen › Connectors** in der linken Seitenleiste, wähle den Tab **Direkt** und dann **Direktverbindung hinzufügen**. 2. **Wähle den Typ**: **MCP-Server** oder **HTTP-Server**. Nach dem Speichern lässt er sich nicht mehr ändern. 3. **Fülle die Felder aus.** * **Name**: wird in Listen und in der Unterhaltung angezeigt. * **Endpunkt-URL**: eine `https://`-Adresse im öffentlichen Internet. Bei einem HTTP-Server ist das die Basis-URL, und der Agent erreicht nur Pfade darunter. * **Header**: eine Zeile pro Header, den der Server braucht, etwa `Authorization` mit `Bearer …`. * **Beschreibung**: Schreib bei einem HTTP-Server auf, was der Agent wissen muss: die Pfade, die Methoden und ein Beispiel. Zum Beispiel: *GET items?q=Suchbegriff findet Einträge. POST items mit `{"title": "…"}` legt einen an.* 4. **Wähle „Verbindung prüfen“.** Gespeichert wird dabei noch nichts. * Bei einem MCP-Server siehst du den Namen des Servers, die Version des MCP-Protokolls, die angebotenen Tools und alle Tools, die der Agent nicht nutzen kann, jeweils mit Begründung. * Bei einem HTTP-Server sendet endue eine GET-Anfrage an die Basis-URL oder, wenn du **Zu prüfender Pfad** ausgefüllt hast, an diesen Pfad darunter und zeigt den Statuscode und den Anfang der Antwort. 5. **Wähle „Speichern“.** Bei einem MCP-Server wird die Tool-Liste beim Speichern abgerufen. Ist der Server nicht erreichbar, wird nichts gespeichert. 6. **Weise sie einem Agenten zu.** Öffne im [Agent Builder](/de/docs/build/agent-builder/) dieses Agenten **Ressourcen › Connectors** und wähle sie wie jede andere Verbindung. Sie trägt das Badge **Direkt** und zeigt ihren Host. ## Header [Abschnitt betitelt „Header“](#header) Header-Werte wie Tokens werden verschlüsselt gespeichert. Nach dem Speichern werden sie nicht mehr angezeigt, auch dir nicht, und sie gelangen nie zum Agenten oder in die Unterhaltung: endue fügt sie selbst jeder Anfrage hinzu, und der Agent kann keine eigenen Header ergänzen. Wenn du eine Verbindung bearbeitest, lass einen Wert leer, um ihn zu behalten, oder gib einen neuen ein, um ihn zu ersetzen. Da gespeicherte Werte nicht an deinen Browser zurückgeschickt werden, musst du für **Verbindung prüfen** bei einer bestehenden Verbindung alle Header-Werte erneut eingeben. `Host`, `Content-Length`, `Connection` und Header, die mit `Proxy-`, `CF-`, `X-Forwarded-` oder `Mcp-` beginnen, verwaltet die Verbindung selbst. Du kannst sie nicht setzen. ## Freigaben [Abschnitt betitelt „Freigaben“](#freigaben) Jeder Aufruf einer Direktverbindung **fragt standardmäßig nach deiner [Freigabe](/de/docs/work/approvals/)**. endue weiß nicht, was ein Tool auf deinem Server tut, und nimmt die Beschreibung, die der Server selbst zu einem Tool liefert, nicht als Grund, auf die Nachfrage zu verzichten. Damit Aufrufe ohne Nachfrage laufen, wähle im Tab **Direkt** bei der Verbindung **Bearbeiten** und schalte **Immer erlauben** ein: * **MCP-Server**: pro Tool. * **HTTP-Server**: pro Methode, zum Beispiel GET. Ausführungen, die niemand beobachtet, etwa bei [Routinen](/de/docs/automate/routines/) und [Kanälen](/de/docs/automate/channels/), können nur nutzen, was du auf „Immer erlauben“ gesetzt hast. Andere Aufrufe werden in diesen Ausführungen abgelehnt. „Immer erlauben“ entscheidest nur du Schalte es nur für Aufrufe ein, die ohne jede Kontrolle laufen dürfen, etwa reine Leseabfragen. Ein Tool, das Daten auf deinem Server ändert, sollte weiter nachfragen. ## Netzwerkregeln [Abschnitt betitelt „Netzwerkregeln“](#netzwerkregeln) endue ruft deinen Server aus der eigenen Infrastruktur auf, nicht von deinem Computer aus. Der Server muss aus dem Internet erreichbar sein: * Nur `https://`, auf Port 443 oder 8443. * Ein öffentlicher Domainname. IP-Adressen, `localhost`, Namen, die auf private Adressen auflösen, und die eigenen Adressen von endue werden abgelehnt. Ebenso eine URL mit Benutzername oder Passwort darin; Zugangsdaten gehören in einen Header. * Weiterleitungen werden nur zum selben Host verfolgt. * Jeder Aufruf hat 30 Sekunden Zeit. Eine HTTP-Antwort über 256 KB wird bei 256 KB abgeschnitten. Eine MCP-Antwort über 256 KB schlägt fehl. Ein Anfragetext über 256 KB wird nicht gesendet. Die Anfragen kommen aus dem Netzwerk von Cloudflare. Hat dein Server eine Firewall oder eine Zulassungsliste, lass die IP-Bereiche von Cloudflare zu. ## Eine Verbindung verwalten [Abschnitt betitelt „Eine Verbindung verwalten“](#eine-verbindung-verwalten) Der Tab **Direkt** listet jede Verbindung mit Typ, Host, Anzahl der Tools, Status und den Agenten, die sie nutzen. * **Erneut abrufen** liest die Tool-Liste eines MCP-Servers neu ein. Tu das, nachdem du die Tools auf dem Server geändert hast. Die Liste wird auch neu abgerufen, wenn du Endpunkt oder Header änderst. * **Fehler** bedeutet, dass endue den Server beim letzten Versuch nicht erreichen konnte. Öffne die Verbindung, um den Grund zu sehen. * **Löschen** entfernt die gespeicherten Header-Werte und nimmt die Verbindung allen Agenten weg, die sie nutzen. Das lässt sich nicht rückgängig machen. ## Einschränkungen [Abschnitt betitelt „Einschränkungen“](#einschränkungen) * Bis zu 20 Direktverbindungen pro Konto. * MCP-Server müssen den Transport Streamable HTTP nutzen. Server, die den älteren Transport HTTP mit SSE nutzen oder eine OAuth-Anmeldung verlangen, werden nicht unterstützt. * Ein HTTP-Server gibt dem Agenten ein Anfrage-Tool und deine Beschreibung. endue liest kein OpenAPI-Dokument. Der Agent verarbeitet JSON- und Textantworten, keine Datei-Uploads oder gestreamten Antworten. * Server in einem privaten Netzwerk sind nicht erreichbar. Der Server braucht eine öffentliche HTTPS-Adresse. * Tools, deren Eingabeformat der Agent nicht nutzen kann, werden weggelassen und mit Begründung als nicht nutzbar aufgeführt. * Eine Direktverbindung gehört zu deinem Konto. Sie erscheint nicht im Katalog. ## Siehe auch [Abschnitt betitelt „Siehe auch“](#siehe-auch) [Connectors im Überblick](/de/docs/connect/overview/)Verbindungen, Zuweisung und Connectors aus dem Katalog. [Freigaben](/de/docs/work/approvals/)Was du siehst, wenn ein Aufruf zuerst nachfragt. [Sicherheit und Berechtigungen](/de/docs/account/security/)Was ein Agent erreichen kann und wie Zugangsdaten aufbewahrt werden. # Gmail > Verbinde Gmail, damit ein Agent Mails durchsuchen, lesen und entwerfen kann – und nur mit deiner Freigabe sendet. Mit dem Gmail-Connector arbeitet ein Agent in deinem Posteingang: Er durchsucht ihn, liest Nachrichten und Threads, bereitet Entwürfe vor und sendet mit deiner [Freigabe](/de/docs/work/approvals/). ## Wann du ihn nutzt [Abschnitt betitelt „Wann du ihn nutzt“](#wann-du-ihn-nutzt) Gmail ist der Connector, mit dem sich die meisten Agenten bezahlt machen, denn Arbeit im Posteingang ist repetitiv und folgt Regeln: sortieren, zusammenfassen, das finden, wonach jemand letzten Dienstag gefragt hat, die Antwort entwerfen, die du ohnehin geschrieben hättest. ## Verbinden [Abschnitt betitelt „Verbinden“](#verbinden) 1. **Öffne Connectors** im [Agent Builder](/de/docs/build/agent-builder/) und wähle Gmail. 2. **Melde dich mit Google an und erlaube den Zugriff.** endue erhält nur, was der Zustimmungsbildschirm auflistet. 3. **Weise die Verbindung dem Agenten zu**, der sie nutzen soll. Prüfe, mit welchem Google-Konto du dich anmeldest Bist du gleichzeitig mit einem Arbeits- und einem privaten Konto angemeldet, wählt Google womöglich das falsche. Die Verbindung ist an das Konto gebunden, mit dem du den Zugriff erlaubt hast. ## Was ein Agent tun kann [Abschnitt betitelt „Was ein Agent tun kann“](#was-ein-agent-tun-kann) | Operation | Freigabepflichtig | | ------------------------------------------------------------ | ----------------- | | Nachrichten durchsuchen, Threads durchsuchen | Nein | | Eine Nachricht oder einen ganzen Thread der Reihe nach lesen | Nein | | Labels auflisten, Entwürfe auflisten | Nein | | Einen Entwurf schreiben | Nein | | **Senden** | **Ja** | Die Suche akzeptiert die Gmail-eigene Suchsyntax: `from:`, `label:`, `is:unread`, `after:` und Phrasen in Anführungszeichen. Es reicht, *„ungelesene Mails von Sarah aus dieser Woche“* zu sagen. Die Abfrage baut der Agent selbst. ## Erst entwerfen, dann senden [Abschnitt betitelt „Erst entwerfen, dann senden“](#erst-entwerfen-dann-senden) Die Trennung zwischen Entwerfen und Senden prägt jeden sicheren E-Mail-Workflow: * **Entwerfen** ist nicht freigabepflichtig. Ein Agent kann zehn Antworten vorbereiten, während du weg bist, und sie liegen dann in deinen Gmail-Entwürfen. * **Senden** hält an und zeigt dir Empfänger, Betreff und Text. Gibst du es frei, geht genau diese Nachricht raus. Lass eine [Routine](/de/docs/automate/routines/), die läuft, während du schläfst, Entwürfe anlegen. Ein Sendevorgang in einer unbeaufsichtigten Ausführung wird abgelehnt, nicht in eine Warteschlange gestellt. ## Bessere Ergebnisse erzielen [Abschnitt betitelt „Bessere Ergebnisse erzielen“](#bessere-ergebnisse-erzielen) * **Sag, was „erledigt“ bedeutet.** *„Markiere alles, was mir eine direkte Frage stellt, zitiere die Frage, ignoriere Newsletter“* ist besser als *„Fass meinen Posteingang zusammen“*. * **Verweise auf Labels.** Ein Agent, der mit einem Label arbeitet, das du ohnehin pflegst, übernimmt deine Sortierung, statt sie neu zu erfinden. * **Bleib bei einem Postfach.** Für zwei Google-Konten autorisierst du zwei Verbindungen und weist jede dem Agenten zu, der sie braucht. ## Einschränkungen [Abschnitt betitelt „Einschränkungen“](#einschränkungen) * Ein Gmail-Konto pro Verbindung. * Ein Agent kann alles lesen, was die Autorisierung abdeckt. Ist dir das zu viel von deinen Mails, weise Gmail nur den Agenten zu, die es brauchen. * Anhänge werden nicht gelesen. * Senden erfordert immer eine Freigabe. Es gibt keine Einstellung, mit der ein Agent unbeaufsichtigt senden darf. ## Siehe auch [Abschnitt betitelt „Siehe auch“](#siehe-auch) [Google Workspace](/de/docs/connect/google-workspace/)Calendar, Drive, Docs, Sheets, Slides, Tasks und Contacts. [Freigaben](/de/docs/work/approvals/)Was du siehst, bevor eine Nachricht rausgeht. [Routinen](/de/docs/automate/routines/)Posteingangs-Zusammenfassungen, die laufen, bevor du aufwachst. # Google Workspace > Calendar, Drive, Docs, Sheets, Slides, Tasks und Contacts – einzeln verbunden, damit ein Agent genau den Zugriff bekommt, den er braucht. Neben [Gmail](/de/docs/connect/gmail/) gibt es sieben weitere Google-Dienste als Connectors. Jeder wird **separat** autorisiert, sodass ein Agent deinen Kalender lesen kann, ohne deine Dateien anzurühren. ## Wann du sie nutzt [Abschnitt betitelt „Wann du sie nutzt“](#wann-du-sie-nutzt) Verbinde genau den Dienst, den die Aufgabe des Agenten erfordert. Für die Vorbereitung von Meetings braucht es Calendar und vielleicht Drive. Ein Reporting-Agent braucht Sheets. Ein Agent zum Schreiben braucht Docs. Alle sieben jedem Agenten zuzuweisen, widerspricht genau diesem Gedanken. ## Was jeder Dienst kann [Abschnitt betitelt „Was jeder Dienst kann“](#was-jeder-dienst-kann) | Dienst | Ein Agent kann | Freigabepflichtig | | ------------ | ------------------------------------------------------------------------------------------------------- | ----------------- | | **Calendar** | Termine eines Zeitraums auflisten, einen Termin mit Teilnehmenden und Ort lesen, einen Termin erstellen | — | | **Drive** | Dateien suchen, lesen, erstellen, aktualisieren; löschen | Löschen | | **Docs** | Ein Dokument erstellen, lesen, ergänzen, Text ersetzen; löschen | Löschen | | **Sheets** | Eine Tabelle erstellen, einen Bereich lesen, Zeilen anhängen, Zellen aktualisieren; löschen | Löschen | | **Slides** | Eine Präsentation erstellen, lesen, eine Folie hinzufügen, Text ersetzen; löschen | Löschen | | **Tasks** | Aufgabenlisten und Aufgaben auflisten, erstellen, abschließen, aktualisieren; löschen | Löschen | | **Contacts** | Kontakte suchen und lesen, erstellen, aktualisieren; löschen | Löschen | Erstellen und Aktualisieren sind **nicht** freigabepflichtig: Ein Agent kann ein Dokument schreiben oder eine Tabelle füllen, ohne dich zu unterbrechen. Löschen ist es immer. ## Verbinden [Abschnitt betitelt „Verbinden“](#verbinden) Jeder Dienst ist ein eigener Eintrag in der Connector-Liste, und jeder leitet dich zum Zustimmungsbildschirm von Google für die Berechtigungen dieses Dienstes. Weise jede Verbindung den Agenten zu, die sie brauchen. Um alle sieben zu autorisieren, gehst du siebenmal durch die Zustimmung. Dieser Aufwand ist gewollt: Die Alternative wäre eine einzige Berechtigung, die alles abdeckt, was du bei Google hast. Löschen über Drive Auch Dateien, die ein Agent nicht erstellt hat, lassen sich mit deiner Freigabe über den Drive-Connector löschen. Lies die Freigabeanfrage, sie nennt die Datei. ## Bewährte Muster [Abschnitt betitelt „Bewährte Muster“](#bewährte-muster) * **Meeting-Vorbereitung.** Calendar, um das Meeting zu finden, Drive für die zugehörigen Dokumente, Docs, um das Briefing zu schreiben. * **Wiederkehrende Berichte.** Sheets als Datenquelle, Docs oder ein [Output](/de/docs/capabilities/outputs/) als Ergebnis, eine [Routine](/de/docs/automate/routines/), die das Ganze wöchentlich ausführt. * **Erst in endue schreiben, später exportieren.** Einen [Output](/de/docs/capabilities/outputs/) zu erstellen und ihn nach Docs zu kopieren, wenn du zufrieden bist, ist oft besser, als direkt in einem Dokument zu iterieren, das schon in Gebrauch ist. ## Einschränkungen [Abschnitt betitelt „Einschränkungen“](#einschränkungen) * Jeder Dienst wird separat autorisiert. Eine einzige Berechtigung für ganz Workspace gibt es nicht. * Ein Google-Konto pro Verbindung und Dienst. * Ein Agent arbeitet mit Dateien, die er über die Suche oder einen Link von dir findet. Er durchstöbert nicht dein ganzes Drive, um zu entscheiden, was relevant ist. * endue bietet die Operationen aus der Tabelle oben an, nicht die vollständige Google-API. Erweiterte Formatierung, Änderungen an Berechtigungen und Einstellungen zum Teilen sind außer Reichweite. ## Siehe auch [Abschnitt betitelt „Siehe auch“](#siehe-auch) [Gmail](/de/docs/connect/gmail/)Der achte Google-Connector und derjenige mit der Freigabe vor dem Senden. [Verfügbare Connectors](/de/docs/connect/available-connectors/)Alles andere, womit sich endue verbindet. [Outputs](/de/docs/capabilities/outputs/)Wo Ergebnisse landen, die nicht in eine Google-Datei gehören. # Notion > Gib einem Agenten Zugriff auf bestimmte Notion-Seiten und -Datenbanken – zum Lesen, Abfragen und Schreiben neuer Seiten. Mit dem Notion-Connector kann ein Agent deinen Workspace durchsuchen, Seiten als reinen Text lesen, Datenbanken abfragen und Seiten erstellen oder erweitern. ## Wann du ihn nutzt [Abschnitt betitelt „Wann du ihn nutzt“](#wann-du-ihn-nutzt) In Notion halten Teams den Kontext fest, den man einem Agenten sonst erst erklären müsste: Spezifikationen, Meetingnotizen, Projekt-Tracker. Ein Agent, der das lesen kann, fragt dich nicht mehr nach Hintergründen und kann seine Ergebnisse dort ablegen, wo der Rest des Teams ohnehin nachsieht. ## Verbinden [Abschnitt betitelt „Verbinden“](#verbinden) 1. **Öffne Connectors** im [Agent Builder](/de/docs/build/agent-builder/) und wähle Notion. 2. **Melde dich an und wähle aus, was du teilst.** Der Zustimmungsbildschirm von Notion fragt, auf welche Seiten die Integration zugreifen darf. Das ist die Zugriffskontrolle, und sie liegt bei Notion. 3. **Weise die Verbindung dem Agenten zu.** Leere Ergebnisse bedeuten meist, dass eine Seite nicht geteilt wurde Eine Suche ohne Treffer liegt häufiger am Teilen als an der Schreibweise. Wurde eine Seite bei der Autorisierung nicht einbezogen oder erst danach erstellt, teile sie über das Seitenmenü in Notion mit der Integration. ## Was ein Agent tun kann [Abschnitt betitelt „Was ein Agent tun kann“](#was-ein-agent-tun-kann) | Operation | Freigabepflichtig | | ------------------------------------------------------------------------------ | ----------------- | | Seiten und Datenbanken nach Titel durchsuchen | Nein | | Eine Seite als reinen Text lesen, inklusive verschachtelter Listen und Toggles | Nein | | Eine Datenbank abfragen, gefiltert nach einer Eigenschaft | Nein | | Eine Seite unter einer Seite oder in einer Datenbank erstellen | Nein | | Inhalte an eine bestehende Seite anhängen | Nein | In Notion ist standardmäßig nichts freigabepflichtig, denn keine dieser Operationen sendet etwas nach außen oder löscht Daten. Erstellen und Anhängen verändern aber deinen Workspace. Der Agent ist angewiesen, Ort und Titel vorher mit dir abzustimmen, doch die Schranke für [Freigaben](/de/docs/work/approvals/) hält ihn nicht auf. ## Damit arbeiten [Abschnitt betitelt „Damit arbeiten“](#damit-arbeiten) * **Zuerst suchen.** Ein Agent braucht die ID einer Seite, bevor er sie lesen oder erweitern kann. Ein vages *„Aktualisiere die Roadmap-Seite“* kostet deshalb einen Suchschritt. Schneller geht es, wenn du den Link zur Seite einfügst. * **Sehr lange Seiten werden gekürzt.** Beim Lesen kommt so viel zurück, wie passt, mit dem Hinweis, dass gekürzt wurde. Verweise den Agenten bei einem großen Dokument auf den Abschnitt. * **Datenbankabfragen filtern nach einer Eigenschaft.** Komplexe Ansichten mit mehreren Bedingungen baust du besser in Notion und lässt den Agenten das Ergebnis lesen. ## Einschränkungen [Abschnitt betitelt „Einschränkungen“](#einschränkungen) * Der Agent sieht nur, was du in Notion mit der Integration geteilt hast. * Beim Lesen kommt reiner Text zurück. Notion-spezifische Strukturen wie Datenbanken in Seiten, synchronisierte Blöcke oder komplexe Layouts werden abgeflacht, und Formatierungen überstehen den Hin- und Rückweg nicht exakt. * Es gibt keine Löschoperation. * Seiten, die der Agent erstellt, gehören der Notion-Integration und erscheinen so auch im Seitenverlauf. ## Siehe auch [Abschnitt betitelt „Siehe auch“](#siehe-auch) [Connectors im Überblick](/de/docs/connect/overview/)Verbindung und Zuweisung sowie das Widerrufen von Zugriff. [Projekte](/de/docs/capabilities/projects/)Kontext in endue halten, statt ihn jedes Mal abzurufen. [Verfügbare Connectors](/de/docs/connect/available-connectors/)Linear, GitLab und der Rest des Katalogs. # Connectors im Überblick > Verbinde endue mit einem Dienst, den du schon nutzt, weise die Verbindung bestimmten Agenten zu und widerrufe sie, wenn du fertig bist. Ein **Connector** verbindet einen Agenten mit einem Dienst, den du bereits nutzt. endue bringt Connectors für mehr als dreißig Dienste mit, siehe [Verfügbare Connectors](/de/docs/connect/available-connectors/). Für einen Server, den du selbst betreibst, fügst du eine [Direktverbindung](/de/docs/connect/direct-connections/) hinzu. ## Verbindung und Zuweisung [Abschnitt betitelt „Verbindung und Zuweisung“](#verbindung-und-zuweisung) Das ist der eine Gedanke, den du wirklich verstanden haben solltest, denn er hält die Reichweite eines Agenten vorhersehbar. 1. **Du autorisierst eine Verbindung.** Du meldest dich beim Anbieter an, etwa bei Google, Slack oder Notion, oder fügst ein API-Token ein. Die entstandene Verbindung gehört zu *deinem Konto*. 2. **Du weist die Verbindung bestimmten Agenten zu.** Nur Agenten, denen du sie zuweist, können sie nutzen. Wenn du Gmail verbindest, bekommt nicht jeder deiner Agenten deinen Posteingang. Einem Agenten, den deine E-Mails nichts angehen, solltest du die Verbindung nicht zuweisen. Das begrenzt, was schiefgehen kann, und macht die Entscheidungen des Agenten vorhersehbarer. ## Wo du Connectors findest [Abschnitt betitelt „Wo du Connectors findest“](#wo-du-connectors-findest) **Ressourcen › Connectors**, erreichbar über die linke Seitenleiste, hat drei Tabs: | Tab | Inhalt | | ------------- | ------------------------------------------------------------------------------------------------- | | **Entdecken** | Alle Connectors im Katalog | | **Verbunden** | Die Verbindungen in deinem Konto | | **Direkt** | Deine eigenen MCP-Server und HTTP-APIs. Siehe [Direktverbindungen](/de/docs/connect/direct-connections/). | ## Einen Dienst verbinden [Abschnitt betitelt „Einen Dienst verbinden“](#einen-dienst-verbinden) 1. **Öffne Connectors** im [Agent Builder](/de/docs/build/agent-builder/) im Bereich Ressourcen des Agenten und wähle den Dienst. 2. **Autorisiere ihn.** Die meisten Dienste leiten dich zum Anbieter, wo du dich anmeldest und den Zugriff erlaubst. endue erhält nur die Berechtigungen, die auf diesem Zustimmungsbildschirm stehen. Andere verlangen ein API-Token, das du in den Einstellungen des Anbieters erstellst, manchmal zusammen mit der Adresse deiner eigenen Installation. 3. **Weise ihn diesem Agenten zu.** Die Tools des Agenten für diesen Dienst erscheinen bei seiner nächsten [Ausführung](/de/docs/work/runs/). Verbinde das Konto, das du nutzen willst Eine Verbindung ist an ein Konto beim Anbieter gebunden. Hast du ein Arbeits- und ein privates Google-Konto, prüfe, mit welchem du dich anmeldest. Verbindest du denselben Dienst erneut mit demselben Konto, wird die bestehende Verbindung neu autorisiert, statt ein Duplikat anzulegen. Die Zuweisungen bleiben also erhalten. ## Was ein Agent nach dem Verbinden tun kann [Abschnitt betitelt „Was ein Agent nach dem Verbinden tun kann“](#was-ein-agent-nach-dem-verbinden-tun-kann) Jeder Connector bietet eine Reihe von Operationen an, und jede Operation ist danach eingestuft, was sie tut: Lesen, Schreiben, Senden oder Destruktiv. **Sende- und destruktive Operationen halten vor der Ausführung immer für deine [Freigabe](/de/docs/work/approvals/) an**, und du siehst dabei genau die Argumente. Mit verbundenem Gmail kann ein Agent also frei suchen und lesen, ohne Nachfrage Entwürfe schreiben und nur mit deinem Okay senden. ## Widerrufen [Abschnitt betitelt „Widerrufen“](#widerrufen) Du kannst die Verbindung von beiden Seiten aus trennen: * **In endue** entfernst du die Verbindung. Jeder Agent, dem sie zugewiesen war, verliert diese Tools sofort. * **Beim Anbieter** widerrufst du den Zugriff von endue in den Kontoeinstellungen von Google, Slack oder Notion oder löschst das API-Token. Widerrufst du beim Anbieter, bleibt die Verbindung in endue in einem defekten Zustand, bis du sie entfernst oder neu autorisierst. Siehe [Fehlerbehebung bei Verbindungen](/de/docs/connect/troubleshooting/). ## Einschränkungen [Abschnitt betitelt „Einschränkungen“](#einschränkungen) * Ein Konto pro Verbindung und Dienst. Um mit zwei Google-Konten zu arbeiten, autorisierst du zwei Verbindungen. * Verbindungen werden pro Agent zugewiesen. Eine Option „alle Agenten“ gibt es nicht. * Ein Connector bietet einen festen Satz an Operationen. Er ist kein universeller API-Client: Ein Agent kann beim Anbieter keine beliebigen Endpunkte aufrufen. Um einem Agenten eine eigene API zu geben, nutze eine [Direktverbindung](/de/docs/connect/direct-connections/). * endue kann nur tun, was die Autorisierung beim Anbieter erlaubt. Wurde eine Berechtigung nicht erteilt, schlägt die Operation beim Anbieter fehl, und zwar nicht stillschweigend. ## Siehe auch [Abschnitt betitelt „Siehe auch“](#siehe-auch) [Verfügbare Connectors](/de/docs/connect/available-connectors/)Alle Dienste, die du verbinden kannst, und was ein Agent damit tun kann. [Freigaben](/de/docs/work/approvals/)Welche Operationen anhalten und dich zuerst fragen. [Fehlerbehebung bei Verbindungen](/de/docs/connect/troubleshooting/)Abgelaufene Tokens, widerrufener Zugriff, falsches Konto. # Slack > Lass einen Agenten Slack-Kanäle und Threads lesen, den Workspace durchsuchen und posten – mit deiner Freigabe. Mit dem Slack-Connector liest ein Agent, was in deinem Workspace passiert ist, und postet dort mit deiner [Freigabe](/de/docs/work/approvals/). ## Wann du ihn nutzt [Abschnitt betitelt „Wann du ihn nutzt“](#wann-du-ihn-nutzt) In Slack werden Entscheidungen getroffen und gehen dann verloren. Ein Agent, der Slack durchsuchen kann, macht aus *„jemand hat vor einem Monat die Deploy-Checkliste gepostet“* eine brauchbare Antwort und kann einen Kanal zusammenfassen, in dem du eine Weile nicht warst. Für die umgekehrte Richtung, also einen Agenten *direkt in Slack* etwas zu fragen, siehe [Kanäle](/de/docs/automate/channels/). ## Verbinden [Abschnitt betitelt „Verbinden“](#verbinden) 1. **Öffne Connectors** im [Agent Builder](/de/docs/build/agent-builder/) und wähle Slack. 2. **Melde dich an und erlaube den Zugriff auf den Workspace.** Der Zugriff gilt pro Workspace. 3. **Lade die App in die Kanäle ein, die sie lesen soll.** Diesen Schritt vergessen viele, siehe unten. 4. **Weise die Verbindung dem Agenten zu.** Kanäle ohne die App lassen sich nicht lesen Um den Verlauf eines Kanals zu lesen, muss die Slack-App Mitglied dieses Kanals sein. Meldet ein Agent, dass er nicht im Kanal ist, lade die App in Slack dort ein und versuch es erneut. Für die Suche im Workspace gilt diese Bedingung nicht. ## Was ein Agent tun kann [Abschnitt betitelt „Was ein Agent tun kann“](#was-ein-agent-tun-kann) | Operation | Freigabepflichtig | | --------------------------------------- | ----------------- | | Kanäle auflisten | Nein | | Den jüngsten Verlauf eines Kanals lesen | Nein | | Den Workspace durchsuchen | Nein | | Die Antworten in einem Thread lesen | Nein | | **Eine Nachricht posten** | **Ja** | Die Suche nutzt die Slack-eigene Syntax wie `from:@user`, `in:#channel` und Phrasen in Anführungszeichen. Sie ist der richtige Einstieg, wenn du nicht weißt, in welchem Kanal etwas steht. ## Posten [Abschnitt betitelt „Posten“](#posten) Posten ist freigabepflichtig, wie jede Aktion nach außen. Du siehst den Kanal und den genauen Text, bevor er rausgeht, und mit deiner Freigabe wird genau das gesendet. In einer unbeaufsichtigten Ausführung, zum Beispiel einer [Routine](/de/docs/automate/routines/), wird das Posten abgelehnt statt zurückgehalten. Eine geplante Slack-Zusammenfassung sollte deshalb einen [Output](/de/docs/capabilities/outputs/) schreiben und dich benachrichtigen, oder du postest sie selbst, sobald du sie gelesen hast. ## Einschränkungen [Abschnitt betitelt „Einschränkungen“](#einschränkungen) * Ein Slack-Workspace pro Verbindung. * Um den Verlauf zu lesen, muss die App im Kanal sein. Private Kanäle, in die sie nicht eingeladen wurde, sind unsichtbar. * Direktnachrichten werden nicht abgedeckt. * Posten erfordert immer eine Freigabe, auch Antworten in einem Thread. * Der Agent postet als endue-App, nicht in deinem Namen. ## Siehe auch [Abschnitt betitelt „Siehe auch“](#siehe-auch) [Kanäle](/de/docs/automate/channels/)Einen Agenten aus Slack heraus erreichen statt umgekehrt. [Freigaben](/de/docs/work/approvals/)Was du siehst, bevor eine Nachricht gepostet wird. [Verfügbare Connectors](/de/docs/connect/available-connectors/)Mattermost, Telegram und alles andere. # Fehlerbehebung bei Verbindungen > Abgelaufene Tokens, widerrufener Zugriff, das falsche Konto und Berechtigungsfehler – woran du sie erkennst und wie du sie behebst. Ein Connector, der gestern noch lief und heute scheitert, ist meist über eine von fünf Ursachen gestolpert. Diese Seite ist die Kurzliste, in der Reihenfolge, in der sie auftreten. ## Hier anfangen [Abschnitt betitelt „Hier anfangen“](#hier-anfangen) Öffne die Connectors des Agenten im [Agent Builder](/de/docs/build/agent-builder/). Eine Verbindung, die Aufmerksamkeit braucht, ist dort markiert, und die Lösung ist fast immer, sie erneut zu autorisieren. **Erneutes Autorisieren behält deine Zuweisungen.** Verbindest du denselben Dienst mit demselben Konto, wird die bestehende Verbindung neu autorisiert, statt eine zweite anzulegen. Du musst sie danach also nicht jedem Agenten neu zuweisen. ## Die fünf Ursachen [Abschnitt betitelt „Die fünf Ursachen“](#die-fünf-ursachen) ### Die Autorisierung ist abgelaufen [Abschnitt betitelt „Die Autorisierung ist abgelaufen“](#die-autorisierung-ist-abgelaufen) Anbieter lassen den Zugriff nach einer gewissen Zeit ablaufen, manche schnell, manche erst nach Monaten. Die Verbindung wird dann mit dem Hinweis markiert, dass sie neu autorisiert werden muss, und die Tools des Agenten für diesen Dienst funktionieren nicht mehr. **Lösung:** Verbinde dich erneut mit demselben Konto. ### Der Zugriff wurde beim Anbieter widerrufen [Abschnitt betitelt „Der Zugriff wurde beim Anbieter widerrufen“](#der-zugriff-wurde-beim-anbieter-widerrufen) Jemand hat endue in den Einstellungen des Google-Kontos entfernt, die Slack-App deinstalliert oder das API-Token gelöscht. endue kann das erst beim nächsten Aufrufversuch von einem Ablauf unterscheiden. **Lösung:** Autorisiere erneut oder erstelle ein neues Token und verbinde dich neu. War der Widerruf gewollt, entferne die Verbindung auch in endue, damit der Zustand stimmt. ### Du hast das falsche Konto verbunden [Abschnitt betitelt „Du hast das falsche Konto verbunden“](#du-hast-das-falsche-konto-verbunden) Der Klassiker: Du warst mit einem privaten Google-Konto angemeldet, als du einen Connector für die Arbeit autorisiert hast. Es gibt keinen Fehler, aber der Agent findet nichts, weil er im falschen Posteingang sucht. **Lösung:** Melde dich beim Anbieter vom falschen Konto ab oder nutze ein privates Fenster und verbinde dich erneut mit dem gewünschten Konto. Prüfe, bevor du zustimmst, welches Konto der Zustimmungsbildschirm anzeigt. ### Dem Agenten fehlt der Zugriff auf die konkrete Ressource [Abschnitt betitelt „Dem Agenten fehlt der Zugriff auf die konkrete Ressource“](#dem-agenten-fehlt-der-zugriff-auf-die-konkrete-ressource) Die Verbindung ist in Ordnung, aber die Ressource ist nicht mit ihr geteilt. | Dienst | Symptom | Lösung | | ---------- | ------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ | | **Slack** | „Nicht im Kanal“ beim Lesen des Verlaufs | Lade die App in Slack in diesen Kanal ein | | **Notion** | Die Suche findet eine Seite nicht, die du sehen kannst | Teile die Seite in Notion mit der Integration | | **GitLab** | Ein Projekt oder Issue wird als nicht gefunden gemeldet | Der Benutzer des Tokens hat eventuell keinen Zugriff. Prüfe die Berechtigungen, nicht die Schreibweise | | **Google** | Eine Datei wird nicht gefunden | Das verbundene Konto hat eventuell keinen Zugriff darauf | „Nicht gefunden“ heißt oft „nicht erlaubt“ Mehrere Anbieter melden bei Dingen, die du nicht sehen darfst, „nicht gefunden“ statt „nicht erlaubt“, um nicht zu verraten, dass es sie gibt. Behandle ein „nicht gefunden“ bei etwas, das es sicher gibt, zuerst als Berechtigungsproblem. ### Ein selbst gehosteter Dienst ist umgezogen oder nicht erreichbar [Abschnitt betitelt „Ein selbst gehosteter Dienst ist umgezogen oder nicht erreichbar“](#ein-selbst-gehosteter-dienst-ist-umgezogen-oder-nicht-erreichbar) Connectors, die nach einer Adresse fragen (GitLab, Jenkins, Discourse, WordPress, Mattermost, Grafana, Elasticsearch), brauchen eine Adresse, die aus dem Internet erreichbar ist. **Lösung:** Prüfe, ob die Adresse stimmt und öffentlich erreichbar ist, und verbinde dich dann neu. Ein Dienst hinter einem VPN ist nicht erreichbar. ## Wenn der Connector funktioniert und der Agent trotzdem scheitert [Abschnitt betitelt „Wenn der Connector funktioniert und der Agent trotzdem scheitert“](#wenn-der-connector-funktioniert-und-der-agent-trotzdem-scheitert) * **Die Operation gibt es nicht.** Jeder Connector bietet einen festen Satz an Operationen, siehe [Verfügbare Connectors](/de/docs/connect/available-connectors/). Ein Agent kann keinen Teil der API eines Anbieters nutzen, den endue nicht anbietet. * **Die Verbindung ist *diesem* Agenten nicht zugewiesen.** Verbinden geschieht auf Kontoebene, Nutzen pro Agent. * **Die Tool-Gruppe ist ausgeschaltet.** Prüfe die [integrierten Tools](/de/docs/capabilities/built-in-tools/) des Agenten, wenn die fehlende Fähigkeit Gedächtnis, Outputs, Routinen oder Webabruf ist und kein Connector. * **Die Aktion wurde an der Schranke für [Freigaben](/de/docs/work/approvals/) abgelehnt**, auch automatisch, wenn die Ausführung unbeaufsichtigt lief. ## Eine Verbindung entfernen [Abschnitt betitelt „Eine Verbindung entfernen“](#eine-verbindung-entfernen) Entfernst du sie in endue, verlieren alle Agenten, denen sie zugewiesen ist, diese Tools sofort. Bestehende Unterhaltungen behalten ihren Verlauf, aber der Agent kann diese Aufrufe nicht mehr ausführen. Eine Verbindung in endue zu entfernen, widerruft den Zugriff von endue beim Anbieter nicht. Für einen sauberen Schnitt erledige beides. ## Siehe auch [Abschnitt betitelt „Siehe auch“](#siehe-auch) [Connectors im Überblick](/de/docs/connect/overview/)Wie Verbinden, Zuweisen und Widerrufen zusammenhängen. [Fehlerbehebung](/de/docs/troubleshooting/)Probleme, die nichts mit Verbindungen zu tun haben. [Sicherheit und Berechtigungen](/de/docs/account/security/)Was ein Agent erreichen kann und was nicht. # Grundkonzepte > Die neun Ideen, die erklären, wie endue funktioniert – Agent, Unterhaltung, Ausführung, Tool, Skill, Connector, Gedächtnis, Output und Routine. endue kommt mit wenigen Begriffen aus. Wenn du diese neun Ideen kennst, erklärt sich der Rest des Produkts von selbst. ## Agent [Abschnitt betitelt „Agent“](#agent) Ein **Agent** ist eine dauerhafte Identität, die in deinem Auftrag arbeitet. Er ist kein Chatfenster zum Wegwerfen: Er hat einen Namen und ein Handle, über die du ihn ansprichst, ein Profil, einen Charakter, der seine Antworten prägt, und einen Systemprompt, der seine Aufgabe festlegt. Der Systemprompt hat einen Revisionsverlauf. Du kannst ändern, wie sich ein Agent verhält, genau sehen, was sich geändert hat, und zur vorherigen Fassung zurückkehren, wenn sich eine Änderung als Verschlechterung herausstellt. Ein Agent kann nur das, was du ihm ermöglichst. Von sich aus kann er schlussfolgern, rechnen und öffentliche Webseiten lesen. Für alles andere, also deine E-Mails, deinen Kalender und deine Dokumente, braucht er eine Verbindung, die du ihm ausdrücklich zuweist. ## Unterhaltung [Abschnitt betitelt „Unterhaltung“](#unterhaltung) Eine **Unterhaltung** ist ein fortlaufender Austausch mit einem Agenten. Sie enthält den Nachrichtenverlauf, den der Agent als Kontext liest, und sie bleibt bestehen: Schließ den Tab, komm morgen wieder, und der Agent weiß noch, worüber ihr gesprochen habt. Unterhaltungen gehören dir. Wenn sich mehrere davon um dasselbe Vorhaben drehen, kannst du sie in einem **Projekt** zusammenfassen. ## Ausführung [Abschnitt betitelt „Ausführung“](#ausführung) Eine **Ausführung** ist ein Durchgang, in dem der Agent tatsächlich arbeitet. Du sendest eine Nachricht, und der Agent startet eine Ausführung: Er entscheidet, was zu tun ist, ruft Tools auf, liest die Ergebnisse und wiederholt das, bis er eine Antwort hat oder etwas von dir braucht. In der Praxis zählen bei Ausführungen drei Dinge: * **Du kannst zusehen.** Jeder Schritt ist sichtbar, während er passiert: welches Tool aufgerufen wurde, womit und was zurückkam. * **Du kannst nachsteuern.** Schick eine Korrektur, solange die Ausführung noch läuft, und der Agent berücksichtigt sie im nächsten Schritt. Eine missratene Ausführung musst du nicht erst zu Ende laufen lassen. * **Sie läuft weiter, wenn du gehst.** Schließ die App mitten in der Ausführung, und die Arbeit geht auf dem Server weiter. Wenn du zurückkommst, ist das Ergebnis da. Eine Ausführung kann auch pausieren und dich etwas fragen: eine Auswahl zwischen Optionen, einen Text oder eine Freigabe für eine Aktion. Siehe unten unter [Freigabe](#freigabe). ## Tool [Abschnitt betitelt „Tool“](#tool) Ein **Tool** ist eine einzelne Fähigkeit, die ein Agent während einer Ausführung aufrufen kann: eine Datei lesen, E-Mails durchsuchen, einen Kalendertermin anlegen, einen Output schreiben, eine Erinnerung abrufen. Manche Tools sind integriert und immer verfügbar. Andere erscheinen erst, wenn du einen Dienst verbindest oder einen Skill zuweist. Welche Tools er aufruft, entscheidet der Agent; welche es überhaupt gibt, entscheidest du. ## Skill [Abschnitt betitelt „Skill“](#skill) Ein **Skill** bündelt eine wiederkehrende Aufgabe, damit du sie nicht jedes Mal neu erklären musst: ein Verfahren, eine Checkliste oder eine Reihe von Befehlen, die der Agent ausführen kann. Weist du einem Agenten einen Skill zu, gehört der Skill zu dem, was dieser Agent kann. Ein Agent kann einen Skill, den er nicht bekommen hat, auch *anfordern*: Er pausiert mitten in der Ausführung und fragt, und du gibst ihn in der Unterhaltung frei oder lehnst ab. ## Connector [Abschnitt betitelt „Connector“](#connector) Ein **Connector** verbindet einen Agenten mit einem Dienst, den du schon nutzt: Gmail und der Rest von Google Workspace, Slack, Notion, Linear, GitLab, Shopify, Figma, Datadog und [mehr als dreißig weitere](/de/docs/connect/available-connectors/). Das Verbinden besteht aus zwei Schritten, die du verstehen solltest: 1. **Du autorisierst die Verbindung** beim Anbieter, etwa bei Google, Slack oder Notion, und sie gehört zu deinem Konto. 2. **Du weist die Verbindung bestimmten Agenten zu.** Nur weil du Gmail verbindest, bekommt nicht jeder Agent Zugriff auf deinen Posteingang. Verbindungen lassen sich jederzeit widerrufen, in endue oder beim Anbieter. Ein Konto pro Verbindung Eine Verbindung ist an genau ein Konto beim Anbieter gebunden. Verbindest du denselben Dienst noch einmal mit demselben Konto, wird die bestehende Verbindung neu autorisiert, statt ein Duplikat anzulegen. Die Zuweisungen zu Agenten bleiben dadurch erhalten. ## Gedächtnis [Abschnitt betitelt „Gedächtnis“](#gedächtnis) Das **Gedächtnis** ist das, was ein Agent über Unterhaltungen hinweg behält: Fakten über dich, deine Vorlieben, wie du Dinge erledigt haben möchtest. Der Agent entscheidet, was sich zu merken lohnt, und ruft es ab, wenn es relevant ist. Das Gedächtnis lässt sich einsehen und bearbeiten. Du siehst, was ein Agent gespeichert hat, und kannst alles löschen, was er nicht hätte behalten sollen. ## Output [Abschnitt betitelt „Output“](#output) Ein **Output** ist etwas, das der Agent erstellt hat und das sich aufzuheben lohnt: ein Bericht, ein Dokument, ein Diagramm, ein Datensatz, eine kleine App. Statt es im Chatverlauf zu vergraben, gibt endue ihm eine eigene Seite. Ein Output ist entweder eine **Datei** (eine einzelne Datei) oder eine **App** (mehrere Dateien, die zusammenarbeiten), und beide Arten stehen in einer gemeinsamen Liste. Outputs sind standardmäßig nur für dich sichtbar. Du kannst einen Output per Link teilen; der Link gewährt Zugriff auf genau diesen Output und auf nichts anderes. Das ist praktisch, wenn du ein Ergebnis an jemanden ohne Zugang zu deinem Konto weitergeben willst. ## Routine [Abschnitt betitelt „Routine“](#routine) Eine **Routine** ist eine Aufgabe mit Zeitplan. Statt einen Agenten jedes Mal um etwas zu bitten, beschreibst du die Aufgabe einmal und legst einen Rhythmus fest: jeden Werktag morgens, jeden Montag, am Ersten des Monats. Routinen laufen, ob endue gerade geöffnet ist oder nicht. Ihre Ergebnisse landen in endue, und wenn eine Routine eine Entscheidung braucht, fragt sie dich und wartet. ## Freigabe [Abschnitt betitelt „Freigabe“](#freigabe) Eine **Freigabe** bedeutet: endue hält an und fragt nach, bevor ein Agent etwas tut, das sich nicht rückgängig machen lässt. Zwei Kategorien erfordern immer eine Freigabe: * **Ausgehende Aktionen**: eine E-Mail senden, eine Nachricht posten, alles, was dein Konto verlässt und eine andere Person erreicht. * **Destruktive Aktionen**: Daten löschen oder überschreiben. Will ein Agent eine solche Aktion ausführen, pausiert die Ausführung und zeigt dir genau diese Aktion mit genau diesen Argumenten. Gibst du sie frei, geht es mit exakt dem weiter, was du gesehen hast. Lehnst du ab, passt sich der Agent an und arbeitet weiter. Das gilt auch für geplante und durch Ereignisse ausgelöste Ausführungen. Ist niemand da, der die Aktion freigeben kann, wird sie abgelehnt, statt in der Schwebe zu bleiben. ## Wie alles zusammenpasst [Abschnitt betitelt „Wie alles zusammenpasst“](#wie-alles-zusammenpasst) > Du gibst einem **Agenten** eine Identität und weist ihm **Connectors** und **Skills** zu. Du sprichst mit ihm in einer **Unterhaltung**; jeder Durchgang ist eine **Ausführung**, in der er **Tools** aufruft. Was er lernt, speichert er im **Gedächtnis**, er erstellt **Outputs** und bittet um **Freigabe**, bevor etwas dein Konto verlässt. Wiederholt sich die Arbeit, wird daraus eine **Routine**. ## Weiterlesen [Abschnitt betitelt „Weiterlesen“](#weiterlesen) [Schnellstart](/de/docs/get-started/quickstart/)Setz diese Konzepte ein und erstelle einen Agenten von Anfang bis Ende. [Glossar](/de/docs/get-started/glossary/)Alle Begriffe von endue, auch die, die hier nicht vorkommen. # Glossar > Definitionen der Begriffe in endue – Agent, Ausführung, Skill, Connector, Gedächtnis, Output, Routine und das übrige Vokabular, das dir im Produkt begegnet. Dieses Glossar erklärt alle Begriffe, die endue verwendet. Jeder Eintrag verweist auf die Seite, auf der das Konzept ausführlich behandelt wird. Taucht ein Begriff im Produkt auf, aber nicht auf dieser Seite, ist das ein Fehler in der Dokumentation – bitte sag uns Bescheid. ## A [Abschnitt betitelt „A“](#a) ### Agent [Abschnitt betitelt „Agent“](#agent) Eine dauerhafte Identität, die in deinem Auftrag arbeitet, mit eigenem [Handle](#handle), Profil, [Charakter](#charakter) und [Systemprompt](#systemprompt). Anders als ein Chatfenster, das du öffnest und wieder verwirfst, bleibt ein Agent bestehen: Er behält seine Fähigkeiten, sein [Gedächtnis](#ged%C3%A4chtnis) und seinen Verlauf. Ein Agent kann nur auf das zugreifen, was du ihm [zugewiesen](#zuweisung) hast. Mehr dazu: [Grundkonzepte](/de/docs/get-started/core-concepts/#agent) ### Agent Builder [Abschnitt betitelt „Agent Builder“](#agent-builder) Der Bereich der Web-App, in dem du Agenten erstellst und feinabstimmst: Identität, Systemprompt, Modell sowie die zugewiesenen [Skills](#skill) und [Verbindungen](#verbindung). Der Name lautet Agent Builder. „Studio“ ist kein Produktname und kommt in der Oberfläche nicht vor. Mehr dazu: [Agent Builder](/de/docs/build/agent-builder/) ### Aktivität [Abschnitt betitelt „Aktivität“](#aktivität) Engl. *Activity*. Der Startbildschirm der Web-App: jede [Unterhaltung](#unterhaltung) aller [Agenten](#agent), gruppiert danach, ob sie auf dich wartet, gerade läuft oder abgeschlossen ist. Hier siehst du nach, wenn mehrere Dinge gleichzeitig laufen. Mehr dazu: [Aktivität](/de/docs/work/activity/) ### Arbeitsbereich [Abschnitt betitelt „Arbeitsbereich“](#arbeitsbereich) Engl. *Workspace*. Der eigene Dateibereich eines Agenten auf seinem [endue Computer](#endue-computer): der Ordner, in dem er liest, schreibt und Programme ausführt. Gemeint ist der Ordner, nicht der Rechner. Mehr dazu: [Arbeitsbereich](/de/docs/build/workspace/) ### Ausführung [Abschnitt betitelt „Ausführung“](#ausführung) Engl. *Run*. Ein Arbeitsdurchgang eines Agenten: Kontext lesen, entscheiden, ein [Tool](#tool) aufrufen, das Ergebnis lesen und das wiederholen, bis er fertig ist oder dich braucht. Ausführungen laufen auf den Servern von endue, deshalb hält das Schließen der App die Arbeit nicht an. Mehr dazu: [Ausführungen](/de/docs/work/runs/) · [So funktioniert endue](/de/docs/get-started/how-it-works/#die-schleife) ### Automatische Auswahl [Abschnitt betitelt „Automatische Auswahl“](#automatische-auswahl) Ein Entscheidungsmodell bewertet die Schwierigkeit jeder eingehenden Nachricht; das für diese Stufe festgelegte Modell antwortet. Im Beobachtungsmodus bleibt das Modell unverändert. Mehr dazu: [Modell wählen](/de/docs/build/models/#ein-modell-f%C3%BCr-jede-anfrage-ausw%C3%A4hlen). ## B [Abschnitt betitelt „B“](#b) ### Benachrichtigung [Abschnitt betitelt „Benachrichtigung“](#benachrichtigung) Engl. *Notification*. Eine Mitteilung, dass etwas fertig geworden ist, während du woanders warst: Eine [Ausführung](#ausf%C3%BChrung) hat geantwortet, eine [Routine](#routine) wurde abgeschlossen, ist fehlgeschlagen oder wurde übersprungen. Ist die App geschlossen, können Benachrichtigungen auch als Browser-Benachrichtigungen ankommen. Sie sagen dir, was passiert ist; handeln kannst du in der Unterhaltung, auf die sie verweisen. Mehr dazu: [Benachrichtigungen](/de/docs/work/inbox/) ### BYOK [Abschnitt betitelt „BYOK“](#byok) „Bring your own key“. Du verwendest für die Modellaufrufe eines Agenten deine eigenen Zugangsdaten beim Modellanbieter statt der Zugangsdaten von endue. Mehr dazu: [Eigenen API-Schlüssel nutzen](/de/docs/account/bring-your-own-key/) ## C [Abschnitt betitelt „C“](#c) ### Charakter [Abschnitt betitelt „Charakter“](#charakter) Engl. *Character*. Die Wesensart, die Ton und Stil eines Agenten prägt. Getrennt vom [Systemprompt](#systemprompt), der die Aufgabe festlegt und nicht die Art und Weise. ### Connector [Abschnitt betitelt „Connector“](#connector) Die Integration, die einen Dienst verbindbar macht. Gmail ist ein Connector; dein autorisiertes Gmail-Konto ist eine [Verbindung](#verbindung). endue bietet Connectors für mehr als dreißig Dienste. Mehr dazu: [Verfügbare Connectors](/de/docs/connect/available-connectors/) ### Credit [Abschnitt betitelt „Credit“](#credit) Die Einheit, in der die [Nutzungsübersicht](/de/docs/account/usage/) die wöchentlichen Modellkosten ausweist. Das Umrechnungsverhältnis nennt die Übersicht selbst. Mehr dazu: [Nutzungsübersicht](/de/docs/account/usage/#%C3%BCbersicht) ## D [Abschnitt betitelt „D“](#d) ### Denkaufwand [Abschnitt betitelt „Denkaufwand“](#denkaufwand) Engl. *Reasoning effort*. Wie viel ein Modell nachdenkt, bevor es antwortet. Höherer Aufwand kostet mehr Tokens und dauert länger, lohnt sich aber bei mehrstufiger Arbeit, bei der eine frühe Fehlentscheidung den Rest der [Ausführung](#ausf%C3%BChrung) zunichtemacht. Verfügbar bei Modellen, die das unterstützen. Mehr dazu: [Modell wählen](/de/docs/build/models/#denkaufwand) ### Direktverbindung [Abschnitt betitelt „Direktverbindung“](#direktverbindung) Engl. *Direct connection*. Eine Verknüpfung zwischen deinen Agenten und einem Server, den du betreibst, also einem entfernten MCP-Server oder einer HTTP-API, eingerichtet über Endpunkt und Header. Jeder Aufruf erfordert eine [Freigabe](#freigabe), sofern du dafür nicht „Immer erlauben“ aktivierst. Mehr dazu: [Direktverbindungen](/de/docs/connect/direct-connections/) ### Dream [Abschnitt betitelt „Dream“](#dream) Eine [Eigenschaft](#eigenschaft), die das [Gedächtnis](#ged%C3%A4chtnis) eines Agenten aufräumt, während er untätig ist. Sie führt sich überschneidende Erinnerungen zusammen, korrigiert veraltete Fakten, schließt erledigte Zusagen ab und archiviert Erinnerungen, die nicht mehr nützlich sind. Außerdem bekommt jede Erinnerung eine einzeilige Zusammenfassung und Suchbegriffe. Dream läuft als [Routine](#routine) zu der Schlafenszeit, die du festlegst. Mehr dazu: [Eigenschaften](/de/docs/build/traits/#wann-dream-schl%C3%A4ft) ### Drittanbieter-Skill [Abschnitt betitelt „Drittanbieter-Skill“](#drittanbieter-skill) Engl. *Third-party skill*. Ein [Skill](#skill), der aus einem öffentlichen GitHub- oder GitLab-Repository importiert wird. Importiert wird nur der Text seiner `SKILL.md`, und der Skill ist nur in deinem Konto verfügbar. Mehr dazu: [Drittanbieter-Skills](/de/docs/capabilities/third-party-skills/) ## E [Abschnitt betitelt „E“](#e) ### Eigenschaft [Abschnitt betitelt „Eigenschaft“](#eigenschaft) Engl. *Trait*. Ein Schalter, der ein bestimmtes Verhalten eines Agenten ein- oder ausschaltet. Die Eigenschaften sind Persönlichkeit, Selbstlernend und [Dream](#dream). Die Einstellung selbst bleibt, wo sie ist; die Eigenschaft entscheidet, ob sie verwendet wird. Mehr dazu: [Eigenschaften](/de/docs/build/traits/) ### endue Computer [Abschnitt betitelt „endue Computer“](#endue-computer) Der Computer, auf dem ein Agent Dateien ablegt und Programme ausführt. Der Agent startet ihn in der endue Cloud, sobald er ihn zum ersten Mal braucht, oder du stellst ihm stattdessen deinen eigenen Linux-Server oder deine eigene VM zur Verfügung. Sein Dateibereich ist der [Arbeitsbereich](#arbeitsbereich) des Agenten. Mehr dazu: [Geräte](/de/docs/build/devices/) · [Eigenen Server oder eigene VM verbinden](/de/docs/build/own-server/) ## F [Abschnitt betitelt „F“](#f) ### Freigabe [Abschnitt betitelt „Freigabe“](#freigabe) Engl. *Approval*. Eine Pause in einer [Ausführung](#ausf%C3%BChrung), in der endue dich um Bestätigung bittet, bevor der Agent eine Aktion ausführt, die sich nicht rückgängig machen lässt. Zwei Kategorien lösen sie immer aus: **ausgehende** Aktionen, die dein Konto verlassen und eine andere Person erreichen, und **destruktive** Aktionen, die Daten löschen oder überschreiben. Bevor du entscheidest, siehst du genau die Aktion mit genau den Argumenten. Diese Freigabepflicht ist nicht konfigurierbar. In einer [Routine](#routine) oder einer anderen Ausführung, die niemand beobachtet, wird die Aktion abgelehnt, statt zu warten. Mehr dazu: [Freigaben](/de/docs/work/approvals/) · [Grundkonzepte](/de/docs/get-started/core-concepts/#freigabe) ## G [Abschnitt betitelt „G“](#g) ### Gedächtnis [Abschnitt betitelt „Gedächtnis“](#gedächtnis) Engl. *Memory*. Was ein Agent über [Unterhaltungen](#unterhaltung) hinweg behält: Fakten über dich, deine Vorlieben, wie du Dinge erledigt haben möchtest. Der Agent entscheidet, was sich zu behalten lohnt, und ruft es ab, wenn es relevant ist. Das Gedächtnis wird also gezielt ausgewählt, statt komplett in jede [Ausführung](#ausf%C3%BChrung) geladen zu werden. Das Gedächtnis lässt sich einsehen und bearbeiten: Du siehst, was ein Agent gespeichert hat, und kannst alles löschen, was er nicht hätte behalten sollen. Mehr dazu: [Gedächtnis](/de/docs/capabilities/memory/) ### Gerät [Abschnitt betitelt „Gerät“](#gerät) Engl. *Device*. Ein Computer oder Browser, auf dem ein Agent arbeitet, oder eine App, in der du endue nutzt. Es gibt vier Geräteprodukte: [endue Computer](#endue-computer), endue for Chrome, endue for Android und endue Desktop. Jedes Gerät hat eine von zwei Zuordnungen: * **Nutzer**: ein Gerät, bei dem du dich angemeldet oder das du mit deinem Konto registriert hast. * **Agent**: ein Gerät, das ein Agent in der endue Cloud gestartet hat, um eine eigene Verbindung herzustellen. Geräte werden im Panel **Ressourcen** aufgeführt, das du über die linke Seitenleiste öffnest. Mehr dazu: [Geräte](/de/docs/build/devices/) ## H [Abschnitt betitelt „H“](#h) ### Handle [Abschnitt betitelt „Handle“](#handle) Der Kurzname, mit dem du einen Agenten ansprichst. Er wird beim Erstellen des Agenten automatisch aus dessen Namen erzeugt und ändert sich danach nicht mehr. ## K [Abschnitt betitelt „K“](#k) ### Kanal [Abschnitt betitelt „Kanal“](#kanal) Engl. *Channel*. Eine Kopplung, über die Personen einen Agenten auch außerhalb von endue erreichen, etwa über einen Discord-Server oder einen Slack-Workspace. Die umgekehrte Richtung zu einem [Connector](#connector), über den ein Agent einen Dienst erreicht. Mehr dazu: [Kanäle](/de/docs/automate/channels/) ## L [Abschnitt betitelt „L“](#l) ### LLM API [Abschnitt betitelt „LLM API“](#llm-api) Ein Modell direkt aus deinem eigenen Code aufrufen, mit einem API-Schlüssel von endue, im Anfrageformat von OpenAI oder Anthropic und bezahlt mit deinen [Credits](#credit). Dabei ist kein Agent beteiligt. Für einen Agenten mit seinem Prompt und seinen Tools verwendest du die Agent API. Mehr dazu: [LLM API](/de/docs/build/llm-api/) ## N [Abschnitt betitelt „N“](#n) ### Nachsteuern [Abschnitt betitelt „Nachsteuern“](#nachsteuern) Engl. *Steering*. Einem Agenten eine Korrektur schicken, während eine [Ausführung](#ausf%C3%BChrung) noch läuft. Der Agent berücksichtigt sie im nächsten Schritt, sodass eine Korrektur nur einen Schritt kostet und nicht die ganze Ausführung. Mehr dazu: [Eine Ausführung nachsteuern](/de/docs/work/steering/) ### Nutzungsübersicht [Abschnitt betitelt „Nutzungsübersicht“](#nutzungsübersicht) Engl. *Usage dashboard*. Die Aufstellung dessen, was deine Agenten verbraucht haben (Tokens im Zeitverlauf, aufgeschlüsselt nach Modell und nach [Agent](#agent)), zusammen mit dem, was vom Kontingent deines Tarifs noch übrig ist. Mehr dazu: [Nutzungsübersicht](/de/docs/account/usage/) ## O [Abschnitt betitelt „O“](#o) ### Oberfläche [Abschnitt betitelt „Oberfläche“](#oberfläche) Engl. *Surface*. Einer der Orte, an denen du endue nutzen kannst: die Web-App, die Desktop-App, die mobilen Apps oder die Kommandozeile. Alle Oberflächen greifen auf dieselben Agenten, Unterhaltungen und denselben Verlauf zu. Du kannst auf einer anfangen und auf einer anderen weitermachen. Mehr dazu: [Oberflächen](/de/docs/get-started/surfaces/) ### Output [Abschnitt betitelt „Output“](#output) Etwas, das ein Agent erstellt hat und das sich aufzuheben lohnt. Es wird auf einer eigenen Seite gespeichert, statt in einer [Unterhaltung](#unterhaltung) unterzugehen. Ein Output ist entweder eine Datei (ein Dokument, ein Bericht, ein Diagramm oder ein Datensatz) oder eine App (mehrere Dateien, die zusammenarbeiten). Outputs sind standardmäßig nur für dich sichtbar und lassen sich per Link teilen, der Zugriff auf genau diesen einen Output gewährt und auf nichts anderes. Mehr dazu: [Outputs](/de/docs/capabilities/outputs/) ## P [Abschnitt betitelt „P“](#p) ### Projekt [Abschnitt betitelt „Projekt“](#projekt) Engl. *Project*. Eine Gruppe von [Unterhaltungen](#unterhaltung), [Outputs](#output) und [Routinen](#routine), die zum selben Vorhaben gehören. Ein Agent, der in einem Projekt arbeitet, sieht dessen Kontext. Das ist der einfachste Weg, den Hintergrund nicht in jeder Unterhaltung neu erklären zu müssen. Mehr dazu: [Projekte](/de/docs/capabilities/projects/) ## R [Abschnitt betitelt „R“](#r) ### Ressourcen [Abschnitt betitelt „Ressourcen“](#ressourcen) Engl. *Resources*. Die [Skills](#skill), [Connectors](#connector) und [Geräte](#ger%C3%A4t), die ein Agent nutzen kann. Das Panel **Ressourcen** in der linken Seitenleiste enthält die Ressourcen in deinem Konto. Der Abschnitt „Ressourcen“ im [Agent Builder](#agent-builder) zeigt, was einem einzelnen Agenten [zugewiesen](#zuweisung) ist, zusammen mit seinen integrierten Tools. Mehr dazu: [Agent Builder](/de/docs/build/agent-builder/) ### Revision [Abschnitt betitelt „Revision“](#revision) Eine gespeicherte Version des [Systemprompts](#systemprompt) eines Agenten. Prompts werden versioniert, damit sich eine Änderung prüfen und zurücknehmen lässt. Genau das macht das Überarbeiten von Prompts sicher, statt es zum Glücksspiel zu machen. Mehr dazu: [Systemprompt und Revisionen](/de/docs/build/system-prompt/#revisionen-und-zur%C3%BCcksetzen) ### Routine [Abschnitt betitelt „Routine“](#routine) Eine Aufgabe, die ein Agent nach Zeitplan erledigt, ob endue geöffnet ist oder nicht. Was eine Routine erstellt, wartet in endue auf dich. Braucht sie eine Entscheidung, fragt sie nach; eine [Freigabe](#freigabe), die sie nicht bekommen kann, wird abgelehnt, statt in der Schwebe zu bleiben. Mehr dazu: [Routinen](/de/docs/automate/routines/) ## S [Abschnitt betitelt „S“](#s) ### Skill [Abschnitt betitelt „Skill“](#skill) Eine gebündelte, wiederholbare Aufgabe, etwa ein Verfahren, eine Checkliste oder eine Reihe von Befehlen, die einem Agenten [zugewiesen](#zuweisung) werden kann, damit du sie nicht jedes Mal neu erklären musst. Ein Agent kann auch einen Skill anfordern, den er nicht bekommen hat. Dann pausiert er mitten in der [Ausführung](#ausf%C3%BChrung), bis du ihn gewährst oder ablehnst. Mehr dazu: [Skills](/de/docs/capabilities/skills/) ### Slash-Befehl [Abschnitt betitelt „Slash-Befehl“](#slash-befehl) Engl. *Slash command*. Ein Name, den du im Eingabefeld nach `/` tippst. Integrierte Befehle wie `/usage` sind Funktionen der App und starten keine [Ausführung](#ausf%C3%BChrung); alle anderen stammen aus den [Skills](#skill), die dem Agenten zugewiesen sind, und sagen ihm, welches [Tool](#tool) er zuerst aufrufen soll. Mehr dazu: [Slash-Befehle](/de/docs/work/slash-commands/) ### Space [Abschnitt betitelt „Space“](#space) Ein gemeinsamer Bereich, in dem ein Team dieselben Agenten nutzt und sieht, was sie erarbeiten. ### Systemprompt [Abschnitt betitelt „Systemprompt“](#systemprompt) Engl. *System prompt*. Die festen Anweisungen, die ein Agent vor jeder Unterhaltung liest: was er tut, was er niemals tun darf und wie ein gutes Ergebnis aussieht. Er wird mit einem Verlauf von [Revisionen](#revision) gespeichert. Mehr dazu: [Systemprompt und Revisionen](/de/docs/build/system-prompt/) ## T [Abschnitt betitelt „T“](#t) ### Tool [Abschnitt betitelt „Tool“](#tool) Eine einzelne Fähigkeit, die ein Agent während einer [Ausführung](#ausf%C3%BChrung) aufrufen kann: eine Datei lesen, E-Mails durchsuchen, einen Kalendertermin anlegen, einen [Output](#output) schreiben, eine Erinnerung aus dem [Gedächtnis](#ged%C3%A4chtnis) abrufen. Erst Tools machen einen Agenten handlungsfähig, statt dass er nur Ratschläge gibt. Manche Tools sind integriert und immer vorhanden. Andere erscheinen erst, wenn dem Agenten eine [Verbindung](#verbindung) oder ein [Skill](#skill) zugewiesen ist. Mehr dazu: [Integrierte Tools](/de/docs/capabilities/built-in-tools/) · [Grundkonzepte](/de/docs/get-started/core-concepts/#tool) ### Tool-Aufruf [Abschnitt betitelt „Tool-Aufruf“](#tool-aufruf) Engl. *Tool call*. Ein einzelner Aufruf eines Tools innerhalb einer Ausführung. Du siehst ihn, während er passiert, zusammen mit dem, was er zurückgegeben hat. ## U [Abschnitt betitelt „U“](#u) ### Unterhaltung [Abschnitt betitelt „Unterhaltung“](#unterhaltung) Engl. *Conversation*. Ein fortlaufender, dauerhafter Austausch mit einem Agenten. Die Unterhaltung enthält den Nachrichtenverlauf, den der Agent als Kontext liest, und bleibt erhalten, wenn du die App schließt. Betreffen mehrere Unterhaltungen dasselbe Vorhaben, lassen sie sich in einem [Projekt](#projekt) zusammenfassen. Mehr dazu: [Unterhaltungen](/de/docs/work/conversations/) ## V [Abschnitt betitelt „V“](#v) ### Verbindung [Abschnitt betitelt „Verbindung“](#verbindung) Engl. *Connection*. Eine autorisierte Verknüpfung zwischen deinem endue-Konto und einem externen Dienst, etwa deinem Gmail-Konto, deinem Slack-Workspace oder deinem Notion. Eine Verbindung ist an genau ein Konto beim Anbieter gebunden und kann jederzeit von beiden Seiten widerrufen werden. Einen Dienst zu verbinden heißt noch nicht, ihn einem Agenten zu überlassen: Eine Verbindung muss einem Agenten [zugewiesen](#zuweisung) werden, bevor dieser Agent sie nutzen kann. Mehr dazu: [Connectors im Überblick](/de/docs/connect/overview/) ## Z [Abschnitt betitelt „Z“](#z) ### Zuweisung [Abschnitt betitelt „Zuweisung“](#zuweisung) Engl. *Binding*. Die Verknüpfung zwischen einem [Agenten](#agent) und einer Fähigkeit, die er nutzen darf. [Verbindungen](#verbindung) und [Skills](#skill) werden bestimmten Agenten zugewiesen. Nur weil eine Verbindung in deinem Konto existiert, steht sie nicht jedem deiner Agenten zur Verfügung. Durch die Zuweisung bleibt vorhersehbar, worauf ein Agent zugreifen kann. Ein Agent mit drei Tools verhält sich beständiger als einer mit zwanzig. Mehr dazu: [Connectors im Überblick](/de/docs/connect/overview/#verbindung-und-zuweisung) *** ## Frühere Begriffe [Abschnitt betitelt „Frühere Begriffe“](#frühere-begriffe) Diese Begriffe findest du in älterem Material. Verwende den aktuellen Namen. | Alter Begriff | Heute | Hinweis | | ------------------------------------------- | --------------------------------- | ---------------------------------------------------------------------------------------- | | Studio | [Agent Builder](#agent-builder) | War nie ein Produktname; nicht wieder einführen | | Abilities, Ability | [Ressourcen](#ressourcen) | Früherer Name desselben Panels und desselben Abschnitts im Agent Builder | | Computer, Workspace (im Sinne des Rechners) | [endue Computer](#endue-computer) | „Workspace“ (deutsch „Arbeitsbereich“) meint jetzt nur noch den Dateibereich des Agenten | | Artifact | [Output](#output) | Bezeichnete einen Output aus einer einzelnen Datei. Auch Apps sind Outputs | | Character build, quest, party | — | Die RPG-Metaphern wurden aus den Produkttexten entfernt | # So funktioniert endue > Was tatsächlich zwischen dem Moment passiert, in dem du eine Nachricht sendest, und dem Moment, in dem dir ein Agent ein Ergebnis übergibt. Wenn du einen Agenten in endue um etwas bittest, antwortet er nicht in einem Zug. Er arbeitet in einer Schleife: entscheiden, handeln, prüfen, was zurückkommt, wieder entscheiden. Wer diese Schleife versteht, macht aus einem frustrierenden Agenten einen nützlichen. Denn fast jede Frage zu seinem Verhalten (warum er das getan hat, warum er angehalten hat, warum er dich etwas gefragt hat) ist eine Frage zur Schleife. ## Die Schleife [Abschnitt betitelt „Die Schleife“](#die-schleife) Eine **Ausführung** durchläuft diesen Zyklus immer wieder, bis der Agent eine Antwort hat oder dich braucht. 1. **Kontext lesen.** Zuerst stellt der Agent zusammen, was er weiß: seinen Systemprompt, die bisherige Unterhaltung, relevante Erinnerungen und das Projekt, in dem er arbeitet. 2. **Entscheiden.** Er wählt die nächste Aktion: ein Tool aufrufen, dir eine Frage stellen oder antworten. 3. **Handeln.** Hat er ein Tool gewählt, wird es ausgeführt. Du siehst den Aufruf und sein Ergebnis in dem Moment, in dem sie passieren. 4. **Ergebnis ansehen.** Die Ausgabe des Tools fließt zurück in den Kontext. Auch ein fehlgeschlagener Aufruf ist eine Information: Der Agent sieht den Fehler und kann etwas anderes versuchen. 5. **Wiederholen.** Zurück zu Schritt 2, mit mehr Informationen als vorher. Der Agent verlässt die Schleife, wenn er hat, was er braucht, wenn er etwas von dir braucht oder wenn er an ein Limit stößt. ## Was der Agent sehen kann [Abschnitt betitelt „Was der Agent sehen kann“](#was-der-agent-sehen-kann) Ein Agent weiß nicht alles über dein Konto, und das ist Absicht. Zu Beginn einer Ausführung enthält sein Kontext Folgendes: | Enthalten | Nicht enthalten | | ---------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------- | | Sein Systemprompt in der aktuellen Revision | Unterhaltungen anderer Agenten | | Der Verlauf dieser Unterhaltung | Unterhaltungen, die du anderswo mit diesem Agenten geführt hast, sofern sie nicht Teil dieses Verlaufs sind | | Gespeicherte Erinnerungen, die gerade relevant sind | Alles, was er sich je gemerkt hat: Das Gedächtnis wird gezielt ausgewählt, nicht komplett geladen | | Der Kontext des Projekts, falls die Unterhaltung zu einem gehört | Daten aus Diensten, die du nicht verbunden hast | | Die Tools, die er nutzen darf | Tools, die anderen Agenten zugewiesen sind | Deshalb ist die Zuweisung so wichtig. Wenn du Gmail mit deinem Konto verbindest, landet dein Posteingang nicht im Kontext jedes Agenten. Du weist die Verbindung den Agenten zu, die sie brauchen, und nur diese Agenten können sie sehen. ## Warum Ausführungen pausieren [Abschnitt betitelt „Warum Ausführungen pausieren“](#warum-ausführungen-pausieren) Eine Ausführung hält unterwegs aus genau drei Gründen an. Jeder davon sieht in der Unterhaltung anders aus. **Es fehlen Informationen, die nur du hast.** Der Agent stellt eine Frage (eine Auswahl zwischen Optionen, ein freier Text oder mehrere Präferenzen) und wartet. Sobald du antwortest, geht die Arbeit weiter. **Der Agent will etwas Unumkehrbares tun.** Eine E-Mail senden, eine Nachricht posten, Daten löschen. Die Ausführung pausiert und zeigt dir genau diese Aktion mit genau diesen Argumenten. Diese Freigabepflicht ist nicht konfigurierbar. **Der Agent will eine Fähigkeit, die er nicht hat.** Wäre ein Skill hilfreich, ist ihm aber nicht zugewiesen, kann der Agent danach fragen, statt zu scheitern. Du gewährst ihn oder lehnst ab, direkt in der Unterhaltung. Pausieren ist kein Scheitern Eine pausierte Ausführung hält ihre Stelle und fängt nicht von vorn an. Sobald du antwortest, macht der Agent mit allem weiter, was er bereits erarbeitet hat. ## Wo die Arbeit passiert [Abschnitt betitelt „Wo die Arbeit passiert“](#wo-die-arbeit-passiert) Ausführungen laufen auf den Servern von endue, nicht in deinem Browser-Tab. Das hat eine Folge, die du kennen solltest: **Wenn du die App schließt, hört die Arbeit nicht auf.** Starte eine lange Aufgabe, schließ den Tab und komm später zurück: Die Ausführung ist weitergelaufen, und das Ergebnis wartet auf dich. Genau das macht auch Routinen möglich, denn bei einer geplanten Ausführung muss niemand zusehen. Soll die Arbeit auf einem eigenen Rechner stattfinden, mit Zugriff auf dessen Dateien, installiere dort [endue Computer](/de/docs/build/own-server/) und stelle ihn dem Agenten zur Verfügung. Gesteuert wird die Ausführung weiterhin von den Servern von endue, Dateien und Programme bleiben auf deinem Rechner. ## Was das in der Praxis bedeutet [Abschnitt betitelt „Was das in der Praxis bedeutet“](#was-das-in-der-praxis-bedeutet) Aus der Funktionsweise der Schleife ergeben sich direkt drei Gewohnheiten: **Gib dem Agenten eine Möglichkeit, sich selbst zu überprüfen.** Die Schleife ist nur so gut wie die Rückmeldung in Schritt 4. Eine Aufgabe, bei der der Agent seine Arbeit selbst prüfen kann (suchen und bestätigen, schreiben und noch einmal lesen), gelingt besser als eine, bei der er blind richtig liegen muss. **Beschreib das Ziel genau, nicht die Schritte.** In Schritt 2 wählt der Agent seine Aktionen selbst. Sagst du ihm, *wie ein gutes Ergebnis aussieht*, hat er etwas, worauf er hinarbeiten kann. Wer jeden Schritt vorschreibt, arbeitet gegen die Schleife. **Korrigiere früh.** Du kannst eine Ausführung nachsteuern, während sie läuft. Eine Korrektur in Schritt 3 kostet einen Schritt; dieselbe Korrektur nach dem Ende der Ausführung kostet die ganze Ausführung. ## Weiterlesen [Abschnitt betitelt „Weiterlesen“](#weiterlesen) [Grundkonzepte](/de/docs/get-started/core-concepts/)Die Begriffe, die diese Seite voraussetzt: Agent, Ausführung, Tool, Skill, Gedächtnis. [Schnellstart](/de/docs/get-started/quickstart/)Sieh der Schleife bei der Arbeit zu, mit einem Agenten, den du selbst erstellst. # Schnellstart > Erstelle einen Agenten in endue, verbinde ihn mit einem Tool, das du schon nutzt, und erhalte ein echtes Ergebnis – in etwa zehn Minuten. Diese Anleitung führt dich durch das Erstellen eines Agenten, der etwas wirklich Nützliches tut, statt nur zu reden. Am Ende hast du einen Agenten mit eigener Identität, eine Tool-Verbindung und ein Ergebnis, das du vorzeigen kannst. ## Bevor du beginnst [Abschnitt betitelt „Bevor du beginnst“](#bevor-du-beginnst) Du brauchst: * Ein endue-Konto, mit dem du im Web angemeldet bist. * Etwa zehn Minuten. * Ein Konto bei einem Dienst, mit dem der Agent arbeiten soll: Gmail, Google Calendar, Slack, Notion oder [einer der anderen](/de/docs/connect/available-connectors/). In Schritt 3 verbindest du einen davon. Nimm ein Konto, mit dessen Daten du unbesorgt experimentieren kannst. Hinweis Diese Anleitung behandelt die Web-App. endue läuft auch [auf dem Desktop, auf Mobilgeräten und in der Kommandozeile](/de/docs/get-started/surfaces/), und der Agent, den du hier erstellst, funktioniert auf all diesen Oberflächen. ## Deinen ersten Agenten erstellen [Abschnitt betitelt „Deinen ersten Agenten erstellen“](#deinen-ersten-agenten-erstellen) 1. **Erstelle den Agenten.** Öffne **Agenten** und wähle **Neuer Agent**. Gib ihm einen Namen. Das Handle, mit dem du ihn später ansprichst, wird automatisch aus dem Namen erzeugt. Beschreibe in einem Satz, wofür dieser Agent da ist. Sei konkret: *„Fasst jeden Morgen meine ungelesenen E-Mails zusammen und markiert alles, was eine Antwort braucht“* ergibt einen weit besseren Agenten als *„E-Mail-Assistent“*. 2. **Gib ihm einen Systemprompt.** Öffne den Agenten und schreib seinen Systemprompt: die festen Anweisungen, die er vor jeder Unterhaltung liest. Sag, was er tun soll, was er niemals tun darf und wie ein gutes Ergebnis aussieht. endue bewahrt jede Version dieses Prompts auf. Ändere ihn nach Belieben; macht eine Änderung den Agenten schlechter, kehre zu der Revision zurück, die funktioniert hat. 3. **Verbinde ein Tool.** Öffne im Agent Builder **Connectors** und verbinde den Dienst, mit dem der Agent arbeiten soll: Gmail, Google Calendar, Slack, Notion oder einen anderen aus dem [vollständigen Katalog](/de/docs/connect/available-connectors/). Du wirst zum jeweiligen Anbieter weitergeleitet, um dich anzumelden und den Zugriff zu erlauben. endue erhält nur die Berechtigungen, die auf diesem Zustimmungsbildschirm angezeigt werden, und du kannst sie jederzeit widerrufen. Weise die Verbindung dann deinem Agenten zu, damit dieser Agent sie nutzen kann und nicht jeder Agent in deinem Konto. Verbinde das Konto, das du wirklich nutzen willst Verbindungen sind an ein bestimmtes Konto beim Anbieter gebunden. Wenn du sowohl ein berufliches als auch ein privates Google-Konto hast, prüfe, mit welchem du dich anmeldest. 4. **Gib ihm eine echte Aufgabe.** Starte eine Unterhaltung mit dem Agenten und gib ihm eine echte Aufgabe statt eines Tests: *„Finde alle E-Mails von dieser Woche, auf die ich noch nicht geantwortet habe, und fasse für jede zusammen, was sie von mir will.“* Der Agent arbeitet in einer **Ausführung**: Er entscheidet, welche Tools er aufruft, ruft sie auf, liest die Ergebnisse und macht weiter, bis er eine Antwort hat. Du kannst jeden Schritt mitverfolgen, während er passiert. 5. **Steuere nach, wenn er in die falsche Richtung läuft.** Du musst nicht warten, bis eine missratene Ausführung zu Ende ist. Schick eine Korrektur, während sie noch läuft, und der Agent berücksichtigt sie im nächsten Schritt. 6. **Gib alles frei, was dein Konto verlässt.** Will der Agent eine E-Mail senden, eine Nachricht posten oder etwas löschen, hält er an und fragt dich zuerst. Gibst du die Aktion frei, führt der Agent genau das aus, was du gesehen hast; lehnst du ab, passt er sich an. Für ausgehende und destruktive Aktionen ist diese Freigabepflicht nicht optional und lässt sich nicht abschalten. 7. **Finde, was er erstellt hat.** Alles Umfangreichere, was der Agent schreibt, etwa ein Bericht, eine Zusammenfassung oder ein Dokument, wird zu einem **Output** mit eigener Seite unter **Outputs**. Outputs sind standardmäßig nur für dich sichtbar. Teile einen Output per Link, wenn ihn jemand ohne Zugang zu deinem Konto lesen soll; Zugriff auf anderes erhält diese Person dadurch nicht. Screenshots folgen Diese Anleitung geht davon aus, dass du im Produkt mitklicken kannst. Kommentierte Screenshots für jeden Schritt werden automatisch aus der App erzeugt und kommen in einer späteren Fassung dieser Seite dazu. ## Regelmäßig ausführen lassen [Abschnitt betitelt „Regelmäßig ausführen lassen“](#regelmäßig-ausführen-lassen) Der Agent, den du gerade erstellt hast, arbeitet, wenn du ihn darum bittest. Den größten Nutzen bringt er, wenn er ohne dich arbeitet. Mach aus derselben Aufgabe eine **Routine** mit Zeitplan: jeden Werktag um 8 Uhr, jeden Montag, am Ersten des Monats. Die Routine läuft, ob endue geöffnet ist oder nicht, und ihre Ergebnisse warten auf dich, wenn du zurückkommst. Braucht sie eine Entscheidung, fragt sie nach, und die Anfrage wartet auf dem Board [Aktivität](/de/docs/work/activity/) auf dich. ## So wird dein Agent besser [Abschnitt betitelt „So wird dein Agent besser“](#so-wird-dein-agent-besser) Ob ein Agent hilft oder nervt, hängt meist davon ab, wie du ihn einrichtest, und nicht davon, welches Modell er nutzt. Wenn du die folgenden Tipps ausprobiert hast, erfährst du unter [Testen und iterieren](/de/docs/build/iterating/), wie du einen Agenten änderst, ohne einen bereits funktionierenden kaputtzumachen. Sag, wie ein gutes Ergebnis aussieht Die Schritte wählt der Agent selbst. Was er nicht erraten kann, ist dein Maßstab dafür, wann etwas „fertig“ ist. Statt *„Fasse meine E-Mails zusammen“* versuch es mit *„Fasse meine ungelesenen E-Mails zusammen, gruppiert nach Absender. Wenn mir jemand eine direkte Frage stellt, zitiere die Frage wörtlich, damit ich antworten kann, ohne die E-Mail zu öffnen.“* Feste Regeln gehören in den Systemprompt, nicht in jede Nachricht Alles, was du in jeder Unterhaltung wiederholen würdest, gehört in den Systemprompt: wer du bist, was dir wichtig ist, was der Agent niemals tun soll und in welchem Format du Ergebnisse haben möchtest. Prompts werden versioniert, du kannst also gefahrlos daran feilen: ändern, prüfen, ob der Agent besser wird, und zur vorherigen Revision zurückkehren, wenn nicht. Gib ihm eine einzige Aufgabe Ein Agent mit klar umrissenem Zweck und drei Tools leistet mehr als einer mit vagem Zweck und zwanzig Tools. Erstelle lieber einen zweiten Agenten, als den ersten immer breiter aufzustellen. Korrigiere ihn, während er arbeitet Wenn du zusiehst, wie eine Ausführung in die falsche Richtung läuft, und abwartest, bis sie fertig ist, ist die ganze Ausführung verschwendet. Schick die Korrektur, sobald du das Problem siehst. Der Agent berücksichtigt sie im nächsten Schritt. Weise nur die Verbindungen zu, die er braucht Verbindungen werden nicht ohne Grund pro Agent zugewiesen. Ein Agent, der deinen Kalender nicht braucht, sollte ihn auch nicht haben. Das begrenzt, was schiefgehen kann, und macht die Entscheidungen des Agenten vorhersehbarer. ## Weiterlesen [Abschnitt betitelt „Weiterlesen“](#weiterlesen) [Grundkonzepte](/de/docs/get-started/core-concepts/)Was ein Agent, eine Ausführung, ein Skill, ein Connector, das Gedächtnis und ein Output eigentlich sind. [So funktioniert endue](/de/docs/get-started/how-it-works/)Die Schleife hinter jeder Ausführung und warum Ausführungen genau dann pausieren. [Agent Builder](/de/docs/build/agent-builder/)Jede Einstellung, die bestimmt, wie sich dein Agent verhält. [Routinen](/de/docs/automate/routines/)Mach aus dem, was du gerade erstellt hast, Arbeit, die ohne dich erledigt wird. ## Hilfe bekommen [Abschnitt betitelt „Hilfe bekommen“](#hilfe-bekommen) * **Dokumentation durchsuchen** – drücke auf jeder Seite `Ctrl`/`⌘` + `K`. * **Frag deinen Agenten** – jede Seite hier gibt es auch als Markdown, und die gesamte Website ist unter [`/llms.txt`](/de/docs/llms.txt) indexiert. Gib einem Agenten diese Adresse und frag ihn. * **Schreib uns** – . # Oberflächen > endue läuft im Browser, auf dem Desktop, auf deinem Smartphone und im Terminal. Jede Oberfläche greift auf dieselben Agenten und denselben Verlauf zu. Eine **Oberfläche** ist einer der Orte, an denen du endue nutzen kannst. Es sind keine getrennten Produkte: Deine Agenten, Unterhaltungen, Verbindungen und Outputs sind überall dieselben. Du kannst also im Browser eine Aufgabe starten und eine Stunde später auf dem Smartphone die Frage des Agenten beantworten. Wähle eine Oberfläche danach aus, was du vorhast, nicht nach Vorliebe. Jede ist für etwas anderes besser geeignet. * Web **Voller Funktionsumfang, nichts zu installieren.** Alles, was endue kann, steht im Browser zur Verfügung: Agenten erstellen und feinabstimmen, mit ihnen chatten, Tools verbinden, Skills schreiben, Routinen planen, Outputs prüfen und die Abrechnung verwalten. Nutze das Web, wenn du etwas *aufbaust*: einen Agenten erstellen, einen Prompt ändern, einen Connector einrichten. Die anderen Oberflächen eignen sich besser zum *Beobachten* und *Reagieren*. * Desktop **endue in einem eigenen Fenster.** endue Desktop ist eine Desktop-App für macOS. Sie öffnet dasselbe endue wie im Web, angemeldet mit demselben Konto, mit denselben Agenten und Unterhaltungen. Jeder Computer, auf dem du dich bei endue Desktop anmeldest, erscheint unter [Geräte](/de/docs/build/devices/). So siehst du, wo dein Konto verwendet wird. Agenten arbeiten nicht darauf. Soll ein Agent mit Dateien auf einem deiner Computer arbeiten, installiere auf diesem Computer [endue Computer](/de/docs/build/own-server/). Einrichtungsanleitung in Arbeit Die Installationsanleitung entsteht gerade und erscheint dann hier. Versionen für Windows und Linux folgen. * Mobil **Zum Reagieren, nicht zum Aufbauen.** Apps für iOS und Android, ausgerichtet auf die Momente, in denen ein Agent dich braucht: Er hat eine Frage gestellt, er möchte eine Freigabe, um etwas zu senden, oder er ist fertig und du möchtest das Ergebnis lesen. Mit den mobilen Apps hältst du lang laufende Arbeit in Gang, auch wenn du nicht am Schreibtisch sitzt. Einrichtungsanleitung in Arbeit Die Installationsanleitung entsteht gerade und erscheint dann hier. * CLI **endue in der Pipe.** Eine einzige `endue`-Binärdatei, die zugleich lokale Laufzeitumgebung und Kommandozeilen-Client ist. Sie ist darauf ausgelegt, sich mit anderen Tools zu kombinieren, statt sie zu ersetzen: | Befehl | Was er tut | | --------------- | ------------------------------------------------------------ | | `endue chat` | Interaktive Sitzung in deinem Terminal | | `endue run` | Einmalige Aufgabe: liest stdin, schreibt stdout | | `endue session` | Frühere Sitzungen auflisten und fortsetzen | | `endue agent` | Agenten ansehen und auswählen | | `endue serve` | Die lokale Laufzeitumgebung starten, in der Agenten arbeiten | | `endue daemon` | Die Laufzeitumgebung als Hintergrunddienst installieren | Nutze die CLI für Skripte und Automatisierung: Logs an einen Agenten übergeben, eine Aufgabe in der CI ausführen, endue in einen bestehenden Shell-Workflow einbinden. Noch nicht allgemein verfügbar Die CLI ist noch nicht für die allgemeine Nutzung veröffentlicht. Sobald sie erscheint, findest du hier die Installationsanleitung. ## Die passende Oberfläche wählen [Abschnitt betitelt „Die passende Oberfläche wählen“](#die-passende-oberfläche-wählen) | Ich möchte … | Nutze | | -------------------------------------------------------------------------------------- | ------------------------------------------------------- | | Einen Agenten erstellen oder sein Verhalten ändern | Web | | Ein Tool verbinden oder Berechtigungen verwalten | Web | | Einen Agenten mit Dateien auf einem eigenen Computer oder Server arbeiten lassen | [endue Computer](/de/docs/build/own-server/) auf diesem Rechner | | Die Frage eines Agenten beantworten, während ich nicht am Schreibtisch bin | Mobil | | Eine Aktion freigeben, die ein Agent ausführen möchte | Jede Oberfläche | | Daten per Pipe an einen Agenten übergeben oder einen Agenten in einem Skript ausführen | CLI | ## Oberflächen und Geräte [Abschnitt betitelt „Oberflächen und Geräte“](#oberflächen-und-geräte) Eine Oberfläche ist der Ort, an dem *du* endue nutzt. Ein [Gerät](/de/docs/build/devices/) ist das, worauf ein *Agent* arbeitet: sein endue Computer, auf dem er Dateien ablegt und Programme ausführt, und sein endue for Chrome, in dem er Webseiten öffnet. Die Geräteliste zeigt auch die Computer, auf denen du endue Desktop nutzt, aber darauf arbeiten keine Agenten. ## Weiterlesen [Abschnitt betitelt „Weiterlesen“](#weiterlesen) [Schnellstart](/de/docs/get-started/quickstart/)Erstelle deinen ersten Agenten in der Web-App. [Grundkonzepte](/de/docs/get-started/core-concepts/)Die Begriffe, die alle Oberflächen gemeinsam haben. # Fehlerbehebung > Der Agent hat das Falsche getan, die Ausführung wird nicht fertig, nichts passiert – die häufigsten Symptome und was jeweils wirklich hilft. Die Symptome, in der Reihenfolge, in der sie typischerweise auftreten. Probleme mit einzelnen Connectors haben eine [eigene Seite](/de/docs/connect/troubleshooting/). ## Der Agent hat das Falsche getan [Abschnitt betitelt „Der Agent hat das Falsche getan“](#der-agent-hat-das-falsche-getan) Sieh dir die [Ausführung](/de/docs/work/runs/) an, bevor du etwas änderst. Die Tool-Aufrufe zeigen, wo es schiefging, und daraus ergibt sich die Lösung. | Was du in der Ausführung siehst | Ursache | Lösung | | ----------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------ | | Er hat keine Tools aufgerufen und aus Allgemeinwissen geantwortet | Er weiß nicht, dass er etwas nachschlagen soll | Schreib das in den [Systemprompt](/de/docs/build/system-prompt/); prüfe, ob der Connector zugewiesen ist | | Er hat das richtige Tool mit falschen Argumenten aufgerufen | Fehlender Kontext | Nimm die Information in den Prompt oder ins [Gedächtnis](/de/docs/capabilities/memory/) auf | | Er hat sich im Kreis gedreht, ohne zu einem Ergebnis zu kommen | Aufgabe zu ungenau beschrieben oder [Denkaufwand](/de/docs/build/models/#denkaufwand) für ihre Länge zu niedrig | Grenze die Aufgabe ein; erhöhe den Denkaufwand | | Die Antwort stimmt, ist aber unbrauchbar | Kein festgelegter Maßstab dafür, wann etwas „fertig“ ist | Beschreibe im Prompt das Ergebnis, das du haben willst | | Er hat dich etwas Offensichtliches gefragt | Die Information steht nirgends, wo er sie sehen kann | Prompt, Gedächtnis oder [Projekt](/de/docs/capabilities/projects/) | Wenn ein einziger Satz zum Nachsteuern die Ausführung zuverlässig rettet, gehört dieser Satz in den Prompt. Siehe [Testen und iterieren](/de/docs/build/iterating/). ## Die Ausführung wird nicht fertig [Abschnitt betitelt „Die Ausführung wird nicht fertig“](#die-ausführung-wird-nicht-fertig) **Sie ist pausiert und wartet auf dich.** Eine [Frage](/de/docs/work/questions/), eine [Freigabe](/de/docs/work/approvals/) oder eine [Skill-Anfrage](/de/docs/capabilities/skills/#wenn-ein-agent-einen-skill-anfordert) hält die Ausführung unbegrenzt an. Scrolle ans Ende der Unterhaltung, dort wartet die Anfrage auf dich. **Sie hat das Schrittlimit erreicht.** Lange Aufgaben enden dann ohne abschließende Antwort. Bitte den Agenten weiterzumachen oder teile die Aufgabe auf. **Sie ist fehlgeschlagen.** Der Fehler steht in der Unterhaltung. Ein Modellfehler bedeutet meist, dass der Modellanbieter den Aufruf abgelehnt hat. Nutzt du [BYOK](/de/docs/account/bring-your-own-key/), prüfe den Schlüssel und das zugehörige Guthaben. Ist die Ursache behoben, starte die Ausführung erneut, entweder auf dem Board [Aktivität](/de/docs/work/activity/#eine-fehlgeschlagene-ausf%C3%BChrung-wiederholen) oder über die Schaltfläche **Erneut versuchen** oben in der Unterhaltung. **Du hast die App geschlossen.** Dadurch wird nichts angehalten. Ausführungen laufen auf den Servern von endue zu Ende, und wenn du zurückkommst, steht das Ergebnis in der Unterhaltung. ## Beim Senden einer Nachricht passiert nichts [Abschnitt betitelt „Beim Senden einer Nachricht passiert nichts“](#beim-senden-einer-nachricht-passiert-nichts) * **Es läuft bereits eine Ausführung.** Eine Nachricht, die du währenddessen sendest, [steuert sie nach](/de/docs/work/steering/), statt einen neuen Durchgang zu starten. * **Dein Kontingent ist aufgebraucht.** Ist das Wochenkontingent erschöpft, werden Ausführungen abgelehnt. Siehe [Tarife und Nutzung](/de/docs/account/plans-and-usage/). * **Du wurdest abgemeldet.** Sitzungen enden nach einer Weile ohne Aktivität. Melde dich wieder an, und die Unterhaltung ist genau dort, wo du aufgehört hast. ## Der Agent kann etwas nicht mehr, das er vorher konnte [Abschnitt betitelt „Der Agent kann etwas nicht mehr, das er vorher konnte“](#der-agent-kann-etwas-nicht-mehr-das-er-vorher-konnte) | Symptom | Was du prüfen solltest | | ----------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- | | Die Tools eines Connectors sind verschwunden | Die Verbindung muss neu autorisiert werden, oder ihre Zuweisung wurde aufgehoben. Siehe [Fehlerbehebung bei Verbindungen](/de/docs/connect/troubleshooting/) | | Er merkt sich nichts mehr | Die [Tool-Gruppe](/de/docs/capabilities/built-in-tools/) Gedächtnis ist möglicherweise ausgeschaltet | | Er speichert keine Outputs mehr | Die Tool-Gruppe Outputs ist möglicherweise ausgeschaltet | | Er verhält sich wie eine ältere Version seiner selbst | Möglicherweise wurde eine [Revision](/de/docs/build/system-prompt/#revisionen-und-zur%C3%BCcksetzen) des Prompts wiederhergestellt | Änderungen gelten ab der *nächsten* Ausführung. Ein Agent, der eine gerade vorgenommene Änderung ignoriert, steckt wahrscheinlich noch mitten in einer Ausführung. ## Eine Routine läuft nicht [Abschnitt betitelt „Eine Routine läuft nicht“](#eine-routine-läuft-nicht) * **Sie wurde nach wiederholten Fehlern pausiert.** endue pausiert eine fehlschlagende Routine und benachrichtigt dich, statt es endlos weiter zu versuchen. * **Sie lief und hat eine Aktion verweigert.** Unbeaufsichtigte Ausführungen können weder senden noch löschen. Siehe [Routinen](/de/docs/automate/routines/#niemand-ist-da-um-freizugeben). * **Sie lief, und du hast es nicht bemerkt.** Sieh auf dem Board [Aktivität](/de/docs/work/activity/) nach; Ergebnisse landen meist als [Output](/de/docs/capabilities/outputs/). In einer neuen Unterhaltung nachstellen Eine lange Unterhaltung bringt einen Verlauf mit, der Antworten verändert, ganz unabhängig von deinen Einstellungen. Lässt sich ein Problem schwer eingrenzen, probier dieselbe Anfrage in einer neuen Unterhaltung, bevor du daraus schließt, dass der Agent kaputt ist. ## Hilfe bekommen [Abschnitt betitelt „Hilfe bekommen“](#hilfe-bekommen) * **Dokumentation durchsuchen** – drücke auf jeder Seite `Ctrl`/`⌘` + `K`. * **Schreib uns** – . Gib an, worum du gebeten hast, was der Agent getan hat und welcher Tool-Aufruf schiefging. Meist reicht das für eine Antwort ohne Rückfragen. ## Siehe auch [Abschnitt betitelt „Siehe auch“](#siehe-auch) [Fehlerbehebung bei Verbindungen](/de/docs/connect/troubleshooting/)Abgelaufene Tokens, widerrufener Zugriff, das falsche Konto. [Testen und iterieren](/de/docs/build/iterating/)Aus einem wiederkehrenden Problem einen besseren Agenten machen. [Ausführungen](/de/docs/work/runs/)Wie du eine Ausführung liest, und alle Gründe, warum eine anhält. # Aktivität > Das Board mit allem, was deine Agenten gerade tun – was auf dich wartet, was läuft, was fehlgeschlagen ist, was fertig ist, und wie du eine Ausführung stoppst oder neu startest, ohne sie zu öffnen. **Aktivität** ist der Startbildschirm: jede Unterhaltung mit jedem deiner Agenten, gruppiert nach ihrem Status. ## Wann du sie nutzt [Abschnitt betitelt „Wann du sie nutzt“](#wann-du-sie-nutzt) Öffne sie, wenn du mehr als einen Agenten hast oder mehr als eine Sache gleichzeitig läuft. Eine Unterhaltung gibt nur über sich selbst Auskunft. Die Aktivität ist der einzige Ort, der die Frage beantwortet: „Was passiert gerade über alle hinweg, und welche braucht mich zuerst?“ Hierher kommst du auch zurück, wenn du eine Weile weg warst. [Ausführungen](/de/docs/work/runs/) laufen weiter, während die App geschlossen ist. Das Board zeigt dir deshalb, was in deiner Abwesenheit passiert ist. ## Die drei Tabs [Abschnitt betitelt „Die drei Tabs“](#die-drei-tabs) Der Startbildschirm hat drei Tabs: | Tab | Zweck | | --------------- | --------------------------------------------------------------------------------------------- | | **Aktivität** | Dieses Board mit den Unterhaltungen nach Status | | **Nutzung** | Die [Nutzungsübersicht](/de/docs/account/usage/) mit Tokens, Modellen und Agenten im Zeitverlauf | | **Neuigkeiten** | Produktankündigungen, die neuesten zuerst. Ein Punkt am Tab bedeutet, dass es ungelesene gibt | ## Das Board lesen [Abschnitt betitelt „Das Board lesen“](#das-board-lesen) 1. **Prüfe die Zahlen in der Kopfzeile.** *Aktiv* ist die Anzahl laufender Unterhaltungen, *Zu prüfen* die Anzahl der Unterhaltungen, die auf dich warten, *Agenten* die Anzahl deiner Agenten, und das Token-Badge zeigt, wie viel deines Tarifkontingents verbraucht ist. Das Badge führt zur [Nutzungsübersicht](/de/docs/account/usage/). 2. **Beschränke die Ansicht auf die Agenten, die dich interessieren.** Die Reihe mit Agenten-Chips unter der Kopfzeile filtert das Board. Ist keiner ausgewählt, siehst du alles. 3. **Lies die Spalten.** * **Wartend** – der Agent hat angehalten und braucht dich, etwa für eine [Frage](/de/docs/work/questions/), eine [Freigabe](/de/docs/work/approvals/) oder einen Skill, den du ihm gewähren sollst. Zeilen hier tragen eine Markierung, und die Spaltenüberschrift zeigt einen Punkt, solange eine davon auf deine Eingabe wartet. * **Aktiv** – eine Ausführung läuft. Die Zeile nennt das Tool, das der Agent in diesem Moment verwendet. * **Fehlgeschlagen** – die Ausführung endete mit einem Fehler. Die Zeile nennt den Grund (Zeitüberschreitung beim Modell, Nutzungslimit erreicht und so weiter). * **Erledigt** – abgeschlossen, nach Datum gruppiert. 4. **Wähle eine Zeile aus, um die Unterhaltung zu öffnen.** Dort antwortest du, gibst frei oder liest das Ergebnis. Das Board leitet dich weiter, es handelt nicht selbst. ## Board und Feed [Abschnitt betitelt „Board und Feed“](#board-und-feed) Der Schalter rechts wechselt zwischen zwei Ansichten derselben Daten: * **Board** – die vier Spalten von oben. Damit sichtest du: Was hängt, was läuft, was ist erledigt? * **Feed** – eine chronologische Liste, das Neueste zuerst. Damit holst du nach, was in welcher Reihenfolge passiert ist. ## Eine Ausführung im Board stoppen [Abschnitt betitelt „Eine Ausführung im Board stoppen“](#eine-ausführung-im-board-stoppen) Eine Zeile in **Aktiv** hat eine Schaltfläche **Stoppen**. Nach einer Rückfrage beendet sie diese Ausführung. Stoppen macht nichts rückgängig Was die Ausführung bereits erledigt hat, bleibt bestehen: gesendete Nachrichten, geschriebene Dateien, ausgeführte Aktionen. Gestoppt wird alles ab diesem Punkt, und eine gestoppte Ausführung lässt sich nicht fortsetzen. Wenn du die Richtung ändern willst, ohne die Ausführung zu verlieren, [steuere sie stattdessen nach](/de/docs/work/steering/). Stoppen gibt es nur in der Spalte **Aktiv**. Eine Unterhaltung unter **Wartend** läuft nicht, sie wartet auf deine Antwort. Es gibt also nichts zu stoppen: Antworte oder lass sie liegen. ## Eine fehlgeschlagene Ausführung wiederholen [Abschnitt betitelt „Eine fehlgeschlagene Ausführung wiederholen“](#eine-fehlgeschlagene-ausführung-wiederholen) Eine Zeile in **Fehlgeschlagen** hat eine Schaltfläche **Erneut versuchen**. Sie führt die letzte Anfrage der Unterhaltung noch einmal aus, ohne eine neue Nachricht hinzuzufügen, und die Zeile wandert nach **Aktiv**. Du musst die Unterhaltung dafür nicht öffnen. Fehlgeschlagene Zeilen in der Feed-Ansicht haben dieselbe Schaltfläche. Du kannst es auch aus der Unterhaltung heraus erneut versuchen. Öffnest du eine Unterhaltung, deren letzte Ausführung fehlgeschlagen ist, erscheinen oben der Grund und eine Schaltfläche **Erneut versuchen**. Das gilt auch, wenn die Nachricht von einem anderen Gerät gesendet wurde oder die Ausführung von einer [Routine](/de/docs/automate/routines/) stammt. Wechsle das Modell im Eingabefeld, bevor du auf **Erneut versuchen** klickst, um die Ausführung mit diesem Modell zu wiederholen. Eine noch blockierte Ausführung startet nicht Ist die Ausführung fehlgeschlagen, weil du ein Nutzungslimit erreicht hast oder das Modell nicht in deinem Tarif enthalten ist, wird ein erneuter Versuch gleich beim Start abgelehnt, solange sich daran nichts geändert hat, und es wird nichts berechnet. Der Grund erscheint als Hinweis. Unterhaltungen aus einem [Kanal](/de/docs/automate/channels/) wie Slack oder Discord haben keine Schaltfläche „Erneut versuchen“: Die neue Antwort ließe sich nicht an diesen Kanal zurücksenden. Stell deine Anfrage dort noch einmal. ## Einschränkungen [Abschnitt betitelt „Einschränkungen“](#einschränkungen) * Das Board zeigt deine neuesten Unterhaltungen, nicht deinen gesamten Verlauf. Ältere Threads findest du in der [Unterhaltungsliste](/de/docs/work/conversations/) des Agenten, zu dem sie gehören. * Es aktualisiert sich nicht zeitgesteuert. Wenn du den Tab erneut öffnest oder zur Seite zurückkehrst, ist es wieder aktuell. * Zahlen und Spalten beziehen sich auf Unterhaltungen, nicht auf einzelne Ausführungen. Eine Unterhaltung, die heute fünfmal gelaufen ist, ist eine Zeile. * Der Agentenfilter ändert, was du siehst, nicht, was in der Kopfzeile gezählt wird. ## Siehe auch [Abschnitt betitelt „Siehe auch“](#siehe-auch) [Ausführungen](/de/docs/work/runs/)Wovon die Spalte „Aktiv“ dir gerade einen Schritt zeigt. [Benachrichtigungen](/de/docs/work/inbox/)Erfahren, dass etwas fertig ist, statt im Board nachzusehen. [Nutzungsübersicht](/de/docs/account/usage/)Der zweite Tab – dorthin führt dich das Token-Badge. [Unterhaltungen](/de/docs/work/conversations/)Einen Thread finden, den das Board nicht mehr anzeigt. # Freigaben > Die Schranke vor allem, was ein Agent nicht zurücknehmen kann – was sie auslöst, was du siehst und was passiert, wenn niemand da ist, der freigeben könnte. Bei einer **Freigabe** hält endue an und fragt nach, bevor ein Agent etwas Unumkehrbares tut. Du siehst die genaue Aktion mit den genauen Argumenten, bevor sie passiert. ## Was sie auslöst [Abschnitt betitelt „Was sie auslöst“](#was-sie-auslöst) Jede Operation, die ein [Connector](/de/docs/connect/overview/) bereitstellt, ist danach eingestuft, was sie in der Welt bewirkt. Zwei Klassen halten immer an und warten auf dich: | Klasse | Beispiele | Freigabepflichtig | | -------------- | ----------------------------------------------------------------------------------------------------------------------------- | ----------------- | | **Lesen** | E-Mails durchsuchen, Dateien auflisten, eine Seite lesen, ein Dashboard abfragen | Nein | | **Schreiben** | Ein Dokument erstellen, eine Zeile hinzufügen, eine E-Mail entwerfen, eine Aufgabe aktualisieren | Nein | | **Senden** | Eine E-Mail senden, in einem Kanal posten, einen Beitrag veröffentlichen, auf einen Kommentar antworten, einen Build auslösen | **Ja** | | **Destruktiv** | Eine Datei löschen, einen Datensatz löschen, einen Alarm stummschalten | **Ja** | Die Grenze verläuft nicht bei „Ändert es etwas?“, sondern bei „Lässt es sich rückgängig machen, und erreicht es jemand anderen?“. Einen Entwurf zu erstellen ist Schreiben. Ihn abzuschicken ist Senden. Die Schranke ist nicht konfigurierbar Sende- und destruktive Operationen fragen immer. Es gibt keine Einstellung, weder pro Agent noch pro Konto, die das abschaltet. Eine Schranke, die ein Agent selbst abschalten könnte, wäre keine. ## Auf Geräten [Abschnitt betitelt „Auf Geräten“](#auf-geräten) Die [Geräte](/de/docs/build/devices/) des Agenten folgen einer eigenen Regel: | Gerät | Fragt vorher | Ohne Nachfrage | | -------------------- | --------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------- | | **endue Computer** | Nichts | Dateien im [Arbeitsbereich](/de/docs/build/workspace/) lesen und schreiben, Programme ausführen | | **endue for Chrome** | Klicken, Tippen, Tasten drücken, Formulare ausfüllen, Dateien hochladen, Tabs schließen | Seiten öffnen und lesen, scrollen, Screenshots aufnehmen | Der Arbeitsbereich ist der eigene Ordner des Agenten auf einem Gerät, das für ihn eingerichtet wurde. Arbeit dort unterbricht dich deshalb nicht bei jedem Aufruf. Bei einer Webseite ist das anders: Ein Klick kann etwas absenden, das jemand anderen erreicht. ## Direktverbindungen [Abschnitt betitelt „Direktverbindungen“](#direktverbindungen) Aufrufe an eine [Direktverbindung](/de/docs/connect/direct-connections/), also an deinen eigenen MCP-Server oder deine eigene HTTP-API, sind nicht eingestuft. Deshalb **fragt jeder Aufruf** standardmäßig nach. In den Einstellungen der Verbindung kannst du **Immer erlauben** für ein Tool (MCP) oder für eine Methode wie GET (HTTP) einschalten. Routinen und Kanäle können nur verwenden, was immer erlaubt ist. ## Was du siehst und was passiert [Abschnitt betitelt „Was du siehst und was passiert“](#was-du-siehst-und-was-passiert) Die Ausführung pausiert und zeigt die Operation und die Argumente, die sie gleich verwenden wird: Empfänger, Betreff, Text, Datei, Datensatz. Klickst du auf **Freigeben**, läuft die Aktion mit genau dem, was du gesehen hast. Eine Freigabe ist keine allgemeine Erlaubnis. Sie gilt für diese eine Aktion mit genau diesen Argumenten. Klickst du auf **Ablehnen**, findet die Aktion nicht statt. Der Agent erfährt das und arbeitet weiter. Meist passt er sich an, statt aufzuhören, und schlägt zum Beispiel einen anderen Entwurf vor. Bearbeiten vor der Freigabe wird nicht unterstützt. Wenn die Argumente falsch sind, lehne ab und sag, was sich ändern soll. Der Agent kommt dann mit einer korrigierten Aktion zurück. ## Unbeaufsichtigte Ausführungen [Abschnitt betitelt „Unbeaufsichtigte Ausführungen“](#unbeaufsichtigte-ausführungen) Eine [Routine](/de/docs/automate/routines/) oder jede andere Ausführung, die niemand beobachtet, kann nicht fragen. Braucht eine Aktion in einer unbeaufsichtigten Ausführung eine Freigabe, wird sie **abgelehnt**, statt zu warten. Das ist Absicht: Eine Aktion, die stundenlang still wartet, bis es jemand bemerkt, ist schlimmer als eine, die klar fehlschlägt. Muss ein geplanter Job etwas senden, rechne damit, dass er einen Entwurf erstellt und dir Bescheid gibt, statt selbst zu senden. ## Ähnliche Schranken [Abschnitt betitelt „Ähnliche Schranken“](#ähnliche-schranken) Zwei weitere Dinge pausieren eine Ausführung für deine Entscheidung, und sie funktionieren genauso: * **Ein [Skill](/de/docs/capabilities/skills/), den der Agent nicht hat.** Er fragt, statt zu scheitern. Du gewährst ihn oder lehnst ihn in der Unterhaltung ab. * **Eine [Frage](/de/docs/work/questions/)**, wenn er Informationen braucht, die nur du hast. ## Einschränkungen [Abschnitt betitelt „Einschränkungen“](#einschränkungen) * Freigaben erteilst du in der Unterhaltung. Das [Aktivitäts-Board](/de/docs/work/activity/) zeigt an, dass eine wartet. * An der Schranke kannst du die Argumente nicht bearbeiten. Lehne stattdessen ab und gib eine neue Richtung vor. * Eine Freigabe gilt für eine Aktion. Der nächste Sendevorgang in derselben Ausführung fragt erneut. * Eine abgelehnte Aktion lässt sich später nicht erneut abspielen. Der Agent muss sie neu vorschlagen. ## Siehe auch [Abschnitt betitelt „Siehe auch“](#siehe-auch) [Verfügbare Connectors](/de/docs/connect/available-connectors/)Alle Connectors und wie viele ihrer Operationen freigabepflichtig sind. [Routinen](/de/docs/automate/routines/)Arbeit planen und was unbeaufsichtigte Ausführungen nicht tun. [Sicherheit und Berechtigungen](/de/docs/account/security/)Worauf ein Agent zugreifen kann und worauf nicht. # Anhänge und Bilder > Bilder und Dateien an eine Nachricht anhängen – was der Agent tatsächlich lesen kann und warum das vom gewählten Modell abhängt. Du kannst Bilder und Dateien an eine Nachricht anhängen. Der Agent liest sie als Teil der [Ausführung](/de/docs/work/runs/), genauso wie deinen Text. ## Anhängen [Abschnitt betitelt „Anhängen“](#anhängen) 1. **Hänge die Datei über das Eingabefeld an** oder **füge sie direkt ein**. Ein Screenshot aus der Zwischenablage und ein kopierter Textblock landen beide als Anhang. 2. **Prüfe die Vorschau.** Bilder erscheinen als Miniaturansicht, textartige Dateien mit den ersten Zeilen. Alles andere erscheint als Chip mit dem Dateinamen. Das reicht, um eine falsche Datei vor dem Senden zu bemerken. 3. **Schreib die Nachricht dazu.** *„Was stimmt hier nicht?“* zusammen mit einem Screenshot ist eine vollständige Anfrage. Die Datei allein ist es nicht. Eingefügter Text kommt als Anhang an, statt ins Eingabefeld gekippt zu werden. So begräbt ein langer eingefügter Text nicht den Satz, den du eigentlich geschrieben hast. ## Was der Agent sieht [Abschnitt betitelt „Was der Agent sieht“](#was-der-agent-sieht) Ein Anhang wird unmittelbar vor dem Absenden der Anfrage für das Modell aufbereitet. Was daraus wird, hängt von der Datei ab: * **Bilder** werden als Bilder an das Modell übergeben, sofern das Modell sie akzeptiert. * **Textartige Dateien** (reiner Text, Markdown, CSV, JSON, YAML, Quellcode) werden als Text gelesen. * **Andere Dateien** werden über Name und Typ erkannt. Kann das Modell das Format nicht öffnen, erfährt es, dass die Datei weggelassen wurde, und warum. Das Modell entscheidet, was ein Anhang wert ist Nicht jedes Modell liest Bilder. Hängst du einen Screenshot an, während ein reines Textmodell ausgewählt ist, klappt der Upload, und der Agent antwortet wie gewohnt. Er antwortet aber, ohne das Bild gesehen zu haben, und sagt das auch. Wenn ein Agent ein Bild zu ignorieren scheint, prüfe zuerst das [Modell](/de/docs/build/models/). ## In der Unterhaltung [Abschnitt betitelt „In der Unterhaltung“](#in-der-unterhaltung) Anhänge bleiben bei der Nachricht, mit der sie gesendet wurden. Wenn du zurückscrollst, siehst du also, was wann gesendet wurde. Außerdem erscheinen sie in der Ressourcenliste des Panels zum [Kontextfenster](/de/docs/work/context-window/). Wählst du dort einen aus, springst du zu seiner Nachricht. ## Einschränkungen [Abschnitt betitelt „Einschränkungen“](#einschränkungen) * Bis zu 50 MB pro Datei. * Was das Modell verwenden kann, hängt vom Modell ab (siehe den Warnhinweis oben). * SVG-Dateien werden gespeichert und weitergegeben, in der Unterhaltung aber nicht als Bild dargestellt. * Ein Anhang gehört zu der Nachricht, mit der er gesendet wurde. Es gibt keine eigene Dateiverwaltung pro Unterhaltung. Der dauerhafte Ort für Ergebnisse ist ein [Output](/de/docs/capabilities/outputs/). * Der Agent liest die Anhänge, die du ihm sendest. Auf Dateien auf deinem Computer kann er nur zugreifen, wenn du dort [endue Computer](/de/docs/build/own-server/) für diesen Agenten installierst. ## Siehe auch [Abschnitt betitelt „Siehe auch“](#siehe-auch) [Das Kontextfenster](/de/docs/work/context-window/)Was Anhänge kosten und wo du das siehst. [Ein Modell wählen](/de/docs/build/models/)Welche Modelle Bilder lesen und wo das angezeigt wird. [Outputs](/de/docs/capabilities/outputs/)Wo die Dateien landen, die der Agent erstellt. # Das Kontextfenster > Jedes Modell hat nur begrenzt Platz. Die Anzeige zeigt, wie viel davon diese Unterhaltung belegt, und das Panel zeigt, was den Platz einnimmt. Ein Modell liest pro Anfrage eine feste Menge Text, sein **Kontextfenster**. Alles, was der Agent braucht, muss hineinpassen: seine Anweisungen, sein Gedächtnis, die Tools, die er aufrufen kann, deine Unterhaltung und deine Anhänge. Das Eingabefeld zeigt, wie voll dieses Fenster ist, und das Kontext-Panel zeigt, womit es gefüllt ist. ## Warum das wichtig ist [Abschnitt betitelt „Warum das wichtig ist“](#warum-das-wichtig-ist) Je voller das Fenster, desto schlechter werden zwei Dinge: * **Ältere Nachrichten werden abgeschnitten.** Der Agent sieht den Anfang eines langen Threads nicht mehr. * **Jeder Schritt kostet mehr.** Bei jedem Schritt einer [Ausführung](/de/docs/work/runs/) wird der gesamte Kontext erneut gesendet. Eine umfangreiche Unterhaltung ist also langsamer und teurer. Wenn ein Agent „vergisst, was wir am Anfang gesagt haben“, ist fast immer das Fenster voll und nicht das Gedächtnis kaputt. ## Was den Platz belegt [Abschnitt betitelt „Was den Platz belegt“](#was-den-platz-belegt) Das Panel teilt das Fenster in Segmente auf: | Segment | Was es ist | | -------------------------------- | ----------------------------------------------------------------------------------- | | **Systemanweisungen** | Der Rahmen, den endue um jede Ausführung legt | | **Identität** | Name, Persönlichkeit und Profil des Agenten | | **Agentenanweisungen** | Sein [Systemprompt](/de/docs/build/system-prompt/) in der aktuellen Revision | | **Anweisungs-Skills** | Skills, deren Inhalt eine dauerhafte Anleitung ist statt eines Befehls | | **Gedächtnis** | Die [Erinnerungen](/de/docs/capabilities/memory/), die für diese Unterhaltung relevant sind | | **Tool-Definitionen** | Das Schema jedes Tools, das der Agent aufrufen kann | | **Nachrichten der Unterhaltung** | Was du und der Agent gesagt habt | | **Angehängte Medien** | [Anhänge](/de/docs/work/attachments/), getrennt von den Nachrichten gezählt | Tools werden noch feiner aufgeschlüsselt: Für jeden Skill, jeden Connector, jede Gruppe integrierter Tools und jedes Gerät siehst du, was das Anbieten der Definitionen kostet, wie viele Aufrufe es in der letzten Ausführung gab und wie viel die Ergebnisse ausmachten. Daran erkennst du den Unterschied zwischen *„dieses Tool ist teuer anzubieten“* und *„dieses Tool hat viel zurückgegeben“*. ## Gemessen oder prognostiziert [Abschnitt betitelt „Gemessen oder prognostiziert“](#gemessen-oder-prognostiziert) Vor der ersten [Ausführung](/de/docs/work/runs/) gibt es nichts zu messen. Der Wert ist dann eine **Prognose** dessen, was die nächste Anfrage enthalten würde. Nach einer Ausführung zeigt er, was diese Anfrage tatsächlich enthielt. Das Panel sagt dir, welchen der beiden Werte du gerade siehst. Dass eine Prognose später von der Messung abweicht, ist normal: Der Agent kann eine Erinnerung oder ein Tool-Ergebnis heranziehen, das nicht vorhersehbar war. ## Ressourcen [Abschnitt betitelt „Ressourcen“](#ressourcen) Das Panel listet außerdem die Anhänge auf, die in dieser Unterhaltung geladen sind. Wählst du einen aus, scrollt die Ansicht zu der Nachricht, mit der er kam. So findest du *„den Screenshot von vorhin“* in einem langen Thread am schnellsten. ## Wenn das Fenster voll ist [Abschnitt betitelt „Wenn das Fenster voll ist“](#wenn-das-fenster-voll-ist) Ungefähr nach Wirkung geordnet: 1. **Starte eine neue [Unterhaltung](/de/docs/work/conversations/).** Das wirkt mit Abstand am stärksten, denn ein neuer Thread schleppt keine der alten Nachrichten mit. 2. **Verschiebe dauerhafte Fakten vorher ins [Gedächtnis](/de/docs/capabilities/memory/) oder ins [Projekt](/de/docs/capabilities/projects/)**, damit du im nächsten Thread nichts neu erklären musst. 3. **Entferne die Zuweisung von Tools, die der Agent nicht nutzt.** Die Definitionen dieser Tools werden bei jedem Schritt erneut gesendet, egal ob sie aufgerufen werden oder nicht. 4. **Wähle ein Modell mit größerem Fenster.** Die Modellauswahl zeigt die Größe jedes Modells. Das verschafft dir Platz, macht einen abschweifenden Thread aber nicht fokussierter. Lange Threads kosten, auch wenn sie hineinpassen Ein Schritt kostet den gesamten Kontext, nicht nur deinen neuen Satz. Zwei fokussierte Unterhaltungen kosten meist weniger und liefern bessere Antworten als eine, die drei Themen abgedeckt hat. ## Einschränkungen [Abschnitt betitelt „Einschränkungen“](#einschränkungen) * Die Fenstergröße gibt das Modell vor. Wechselst du das Modell, ändert sich die Obergrenze. * Beim Kürzen fallen die ältesten Nachrichten zuerst weg, ohne dass sie zusammengefasst werden. * Die Aufschlüsselung spiegelt die letzte Ausführung wider. Änderungen, die du danach vornimmst (etwa ein Tool zuweisen oder den Prompt bearbeiten), erscheinen bei der nächsten. ## Siehe auch [Abschnitt betitelt „Siehe auch“](#siehe-auch) [Unterhaltungen](/de/docs/work/conversations/)Wann du einen neuen Thread beginnst, statt weiterzumachen. [Gedächtnis](/de/docs/capabilities/memory/)Fakten über Unterhaltungen hinweg mitnehmen, statt sie in einer einzelnen festzuhalten. [Ein Modell wählen](/de/docs/build/models/)Fenstergrößen und was jedes Modell pro Token kostet. # Unterhaltungen > Threads mit einem Agenten – was sie festhalten, wann du einen neuen beginnst und wie du sie in Projekten gruppierst. Eine **Unterhaltung** ist ein dauerhafter Thread mit einem Agenten. Sie enthält den Verlauf, den der Agent als Kontext liest, und bleibt erhalten, wenn du die App schließt. ## Wann du sie nutzt [Abschnitt betitelt „Wann du sie nutzt“](#wann-du-sie-nutzt) Unterhaltungen sind der Standardweg, mit einem Agenten zu arbeiten. Beginne eine neue, wenn sich das Thema ändert. Bleib bei einer bestehenden, solange du noch an derselben Sache arbeitest. ## Was der Agent liest [Abschnitt betitelt „Was der Agent liest“](#was-der-agent-liest) Zu Beginn jeder [Ausführung](/de/docs/work/runs/) stellt der Agent seinen Kontext aus der Unterhaltung zusammen, in der er sich befindet. Dazu kommen sein Prompt, seine relevanten [Erinnerungen](/de/docs/capabilities/memory/) und, falls die Unterhaltung zu einem Projekt gehört, der Kontext des [Projekts](/de/docs/capabilities/projects/). Deine anderen Unterhaltungen liest er nicht. Zwei Threads mit demselben Agenten sind unabhängig voneinander. Alles, was der Agent von einem in den anderen mitnehmen soll, gehört ins Gedächtnis oder ins Projekt. ## Neu beginnen oder weitermachen [Abschnitt betitelt „Neu beginnen oder weitermachen“](#neu-beginnen-oder-weitermachen) | Neue Unterhaltung beginnen | Bestehende fortsetzen | | ---------------------------------------------------------------- | ------------------------------------------------ | | Das Thema hat sich geändert | Du verfeinerst dasselbe Ergebnis | | Der Thread ist lang und voller Sackgassen | Erst der bisherige Verlauf macht die Antwort gut | | Du willst beim [Iterieren](/de/docs/build/iterating/) sauber vergleichen | Der Agent steckt mitten in einer Aufgabe | Lange Threads haben ihren Preis: Alles darin konkurriert um die Aufmerksamkeit des Modells und irgendwann um sein Kontextfenster. Ein Thread, der durch drei Themen gewandert ist, liefert schlechtere Antworten als drei fokussierte Threads. ## Verlauf und Rückkehr zur Arbeit [Abschnitt betitelt „Verlauf und Rückkehr zur Arbeit“](#verlauf-und-rückkehr-zur-arbeit) Unterhaltungen sind nach Aktualität sortiert, der zuletzt genutzte Thread steht also oben. Öffnest du ihn, wird der gesamte Verlauf wiederhergestellt, einschließlich der [Tool-Aufrufe](/de/docs/work/runs/) jeder Ausführung. Die Arbeit geht weiter, während du weg bist. Schließt du die App während einer Ausführung, läuft die Ausführung auf dem Server weiter. Wenn du zurückkommst, steht das Ergebnis im Thread. Siehe [Ausführungen](/de/docs/work/runs/#ausf%C3%BChrungen-im-hintergrund). ## Finden und organisieren [Abschnitt betitelt „Finden und organisieren“](#finden-und-organisieren) Mit der Zeit sammeln sich viele Threads an. Vier Funktionen halten die Liste übersichtlich: * **Suchen** berücksichtigt Titel *und* Nachrichtentexte. So findest du eine Unterhaltung über etwas, das darin gesagt wurde, statt über ihren Namen. * **Anheften** hält eine Unterhaltung oben in der Liste, etwa die, zu der du jeden Tag zurückkehrst. * **Umbenennen** ersetzt den Titel, den endue aus deiner ersten Nachricht erzeugt hat. Titel sind eine Zusammenfassung und kein Name, den du gewählt hast. Bei Unterhaltungen, die du behältst, lohnt sich das Umbenennen daher. * **Archivieren** nimmt eine abgeschlossene Unterhaltung aus der Liste, ohne sie zu löschen. Archivierte Threads bleiben durchsuchbar und lassen sich wieder öffnen. Nur die Seitenleiste zeigt sie nicht mehr an. **Link kopieren** legt einen Link zur Unterhaltung in deine Zwischenablage. Er dient dir als Lesezeichen, nicht zum Teilen: Zum Öffnen ist dein Konto nötig. ## In Projekten gruppieren [Abschnitt betitelt „In Projekten gruppieren“](#in-projekten-gruppieren) Wenn sich mehrere Unterhaltungen um dieselbe Arbeit drehen, leg sie in ein [Projekt](/de/docs/capabilities/projects/). Ein Agent, der in einem Projekt arbeitet, liest dessen Kontext. Das ist der günstigste Weg, den Hintergrund nicht in jedem Thread neu erklären zu müssen. Eine Unterhaltung gehört zu einem Agenten Eine Unterhaltung führst du mit genau einem Agenten. Um einen zweiten Agenten an dasselbe Problem zu setzen, beginne eine Unterhaltung mit ihm. Sollen beide Kontext teilen, arbeite mit beiden im selben [Projekt](/de/docs/capabilities/projects/). ## Einschränkungen [Abschnitt betitelt „Einschränkungen“](#einschränkungen) * Eine Unterhaltung lässt sich nicht zu einem anderen Agenten verschieben. * Agenten lesen die Unterhaltungen anderer Agenten nicht, und ein Agent liest auch nicht über seine eigenen Threads hinweg. * Sehr lange Threads überschreiten irgendwann das Kontextfenster des Modells. Die praktische Lösung ist eine neue Unterhaltung, nachdem du alles Dauerhafte ins Gedächtnis oder ins Projekt verschoben hast. ## Siehe auch [Abschnitt betitelt „Siehe auch“](#siehe-auch) [Ausführungen](/de/docs/work/runs/)Was bei jedem Durchgang passiert und wie du ihn liest. [Projekte](/de/docs/capabilities/projects/)Zusammengehörige Unterhaltungen gruppieren und einem Agenten gemeinsamen Kontext geben. [Gedächtnis](/de/docs/capabilities/memory/)Was der Agent von einer Unterhaltung in die nächste mitnimmt. # Benachrichtigungen > Wie ein Agent dich erreicht, wenn du gerade nicht hinsiehst – welche Ereignisse eine Benachrichtigung auslösen, wie du Browser-Benachrichtigungen einschaltest und was zu tun ist, wenn der Browser sie blockiert hat. Mit einer **Benachrichtigung** sagt dir ein Agent, dass etwas passiert ist, während du woanders warst: Eine Antwort ist fertig, eine Routine wurde abgeschlossen, eine Routine ist fehlgeschlagen. ## Wann du sie nutzt [Abschnitt betitelt „Wann du sie nutzt“](#wann-du-sie-nutzt) [Ausführungen](/de/docs/work/runs/) laufen weiter, nachdem du den Tab geschlossen hast, und [Routinen](/de/docs/automate/routines/) laufen, wenn niemand zusieht. Mit Benachrichtigungen musst du nicht daran denken, im [Aktivitäts-Board](/de/docs/work/activity/) nachzusehen. ## Was dich benachrichtigt [Abschnitt betitelt „Was dich benachrichtigt“](#was-dich-benachrichtigt) | Ereignis | Wann es gesendet wird | | -------------------------- | ------------------------------------------------------------------------------------ | | **Antworten von Agenten** | Eine Ausführung endet, während du nicht in der Unterhaltung bist | | **Routine abgeschlossen** | Eine Ausführung einer geplanten [Routine](/de/docs/automate/routines/) endet | | **Routine fehlgeschlagen** | Eine Ausführung einer Routine schlägt fehl | | **Routine übersprungen** | Eine Ausführung einer Routine wird übersprungen, weil ein Nutzungslimit erreicht ist | Schritte innerhalb einer Ausführung lösen keine Benachrichtigung aus. Tool-Aufrufe, Zwischenergebnisse und gestreamter Text erscheinen in der Unterhaltung, und dort liest du sie auch. Eine Ausführung, die für eine [Frage](/de/docs/work/questions/) oder eine [Freigabe](/de/docs/work/approvals/) anhält, erscheint im Aktivitäts-Board unter **Wartend** und in der Zahl **Zu prüfen** in seiner Kopfzeile. Über dieses Board findest du blockierte Arbeit zuverlässig. ## Browser-Benachrichtigungen einschalten [Abschnitt betitelt „Browser-Benachrichtigungen einschalten“](#browser-benachrichtigungen-einschalten) Browser-Benachrichtigungen erreichen dich auch dann, wenn der endue-Tab ganz geschlossen ist. 1. **Öffne Einstellungen → Allgemein → Benachrichtigungen.** 2. **Schalte Browser-Benachrichtigungen ein.** Dein Browser fragt genau in diesem Moment nach der Berechtigung, nicht vorher. 3. **Erlaube sie.** Der Schalter bleibt an, und die vier oben genannten Aktivitätsereignisse kommen ab jetzt als Browser-Benachrichtigungen an. 4. **Wiederhole das in jedem Browser und auf jedem Gerät, das du nutzt.** Ein Abonnement gehört zu einem Browser auf einem Rechner, nicht zu deinem Konto. Wählst du eine Benachrichtigung aus, öffnet sich die Unterhaltung oder das Projekt, aus dem sie stammt. Wenn sich der Schalter nicht einschalten lässt Der Schalter ist deaktiviert, und der Grund steht darunter, wenn der Browser keine Benachrichtigungen zustellen kann: * **Für diese Website blockiert.** Die Berechtigung wird nur ein einziges Mal abgefragt. Öffne das Schloss-Symbol in der Adressleiste → Website-Einstellungen → Benachrichtigungen, erlaube sie und versuche es dann erneut mit dem Schalter. * **iOS und iPadOS.** Web-Push funktioniert erst, wenn du endue zum Home-Bildschirm hinzufügst und es von dort öffnest. * **Keine sichere Verbindung.** Push erfordert HTTPS. * **In dieser Umgebung nicht verfügbar.** Das ist eine serverseitige Einstellung, die du von hier aus nicht beheben kannst. ## Auswählen, worüber du informiert wirst [Abschnitt betitelt „Auswählen, worüber du informiert wirst“](#auswählen-worüber-du-informiert-wirst) Im selben Einstellungsbereich stehen die vier Aktivitätsereignisse, jedes mit eigenem Schalter. Schaltest du eines aus, verstummt es überall, in der App und im Browser. Zwei Dinge solltest du über die Schalter wissen: * **Für Browser-Benachrichtigungen gibt es einen Schalter, nicht vier.** Schaltest du sie ein, gelten sie für alle vier Aktivitätsereignisse. Schaltest du ein einzelnes Ereignis aus, fällt es auch aus den Browser-Benachrichtigungen heraus. * **E-Mail ist noch nicht verfügbar.** Die Zeile ist schon da und als bald verfügbar markiert. ## Damit sie nützlich bleiben [Abschnitt betitelt „Damit sie nützlich bleiben“](#damit-sie-nützlich-bleiben) Benachrichtigungen, die ständig kommen, liest irgendwann niemand mehr. Ob sie ein echtes Signal bleiben, entscheidet sich bei den [Routinen](/de/docs/automate/routines/): Eine tägliche Routine, die einen [Output](/de/docs/capabilities/outputs/) erzeugt, ist eine Benachrichtigung. Eine, die jeden Zwischenschritt meldet, sind mehrere. ## Einschränkungen [Abschnitt betitelt „Einschränkungen“](#einschränkungen) * Benachrichtigungen sagen dir, dass etwas passiert ist. Handeln tust du woanders: Fragen und Freigaben beantwortest du in der Unterhaltung. * Browser-Benachrichtigungen gelten pro Browser. Schaltest du sie am Schreibtisch ein, ändert das nichts an deinem Smartphone. * Entziehst du die Berechtigung für Benachrichtigungen im Browser, wird die Zustellung abgeschaltet, ohne dass sich die Einstellung des Schalters selbst ändert. Der Hinweis unter dem Schalter erklärt den Zustand. * Benachrichtigungen gelten pro Konto und umfassen alle deine Agenten. Eine Einstellung pro Agent gibt es nicht. * E-Mail-Benachrichtigungen sind noch nicht verfügbar. ## Siehe auch [Abschnitt betitelt „Siehe auch“](#siehe-auch) [Aktivität](/de/docs/work/activity/)Wo du blockierte und erledigte Arbeit siehst, ohne benachrichtigt zu werden. [Routinen](/de/docs/automate/routines/)Geplante Arbeit, die Hauptquelle für Benachrichtigungen. [Freigaben](/de/docs/work/approvals/)Worüber du bei einer wartenden Ausführung entscheiden sollst. [Ausführungen](/de/docs/work/runs/)Warum die Arbeit weitergeht, nachdem du die App geschlossen hast. # Fragen eines Agenten > Die drei Arten, wie ein Agent dich während einer Ausführung etwas fragt (Auswahl, Freitext oder eine Reihe von Präferenzen), und was passiert, während er wartet. Fehlt einem Agenten etwas, das er nicht nachschlagen kann, **fragt er dich**, statt zu raten. Die [Ausführung](/de/docs/work/runs/) pausiert, die Frage erscheint in der Unterhaltung, und mit deiner Antwort geht die Arbeit weiter. ## Wann du eine siehst [Abschnitt betitelt „Wann du eine siehst“](#wann-du-eine-siehst) Immer dann, wenn der Agent an einer Weggabelung steht, die nur du auflösen kannst: welches von drei Dokumenten du gemeint hast, welchen Ton ein Entwurf haben soll, ob das letzte Quartal dazugehört. Ein Agent mit gut abgegrenzter Aufgabe fragt selten. Fragt ein Agent ständig, fehlt ihm meist dauerhafter Kontext, der in seinen [Systemprompt](/de/docs/build/system-prompt/) oder in sein [Gedächtnis](/de/docs/capabilities/memory/) gehört. ## Die drei Arten [Abschnitt betitelt „Die drei Arten“](#die-drei-arten) **Auswahl.** Optionen als Schaltflächen. Wähle eine aus oder mehrere, wenn die Frage das erlaubt. Manche Auswahlen kommen in Schritten: Beantwortest du die erste, erscheint die nächste. So grenzt ein Agent etwas ein, ohne dich mit einer Wand aus Fragen zu konfrontieren. **Freitext.** Eine einzelne Frage mit Textfeld, für etwas, das sich nicht auf Optionen reduzieren lässt: eine Betreffzeile, ein Name, ein Satz als Orientierung. **Präferenzen.** Eine Reihe antippbarer Optionen, die in einem Durchgang abgefragt werden. Der Agent nutzt sie, wenn er abstimmen will, wie du eine Arbeit erledigt haben möchtest, statt eine einzelne Sachfrage zu stellen. Alle drei pausieren die Ausführung auf dieselbe Weise und werden in der Unterhaltung beantwortet. ## Während er wartet [Abschnitt betitelt „Während er wartet“](#während-er-wartet) Die Ausführung hält ihre Position und startet nicht neu. Alles, was der Agent bereits erarbeitet hat, etwa ausgeführte Suchen und gelesene Dateien, ist noch da, wenn du antwortest. Du kannst weggehen und zurückkommen: Die Frage steht weiter im Thread, und das [Aktivitäts-Board](/de/docs/work/activity/) führt sie unter „Wartend“. Während du nachdenkst, läuft nichts ab. Du kannst auch mit einer Nachricht antworten Eine Frage schlägt eine Form für die Antwort vor, sie ist kein Käfig. Passt keine der Optionen, schreib das ins Eingabefeld. Der Agent liest es und passt sich an. ## Weniger Fragen, bessere Antworten [Abschnitt betitelt „Weniger Fragen, bessere Antworten“](#weniger-fragen-bessere-antworten) Ein Agent fragt, weil etwas nicht festgelegt ist. Räumst du die Unklarheit aus, kehrt die Frage nicht wieder: | Er fragt immer wieder | Wohin die Antwort gehört | | --------------------------------------------------------------- | ----------------------------------------- | | Welches Konto, welcher Ordner oder welches Dokument gemeint ist | Der [Systemprompt](/de/docs/build/system-prompt/) | | Wie du Ergebnisse formatiert haben möchtest | Der Systemprompt | | Nach einem Fakt über dich oder deine Arbeit | Das [Gedächtnis](/de/docs/capabilities/memory/) | | Nach Hintergrund zu einer bestimmten Arbeit | Das [Projekt](/de/docs/capabilities/projects/) | ## Einschränkungen [Abschnitt betitelt „Einschränkungen“](#einschränkungen) * Eine Frage pausiert die Ausführung, bis sie beantwortet ist. Es gibt kein Zeitlimit und keine Standardantwort. * Bei der Ausführung einer [Routine](/de/docs/automate/routines/) ist niemand da, den der Agent fragen könnte. Geplante Arbeit sollte so genau beschrieben sein, dass keine Entscheidung nötig ist. * Fragen werden in der Unterhaltung beantwortet. Das Aktivitäts-Board zeigt dir, dass eine wartet, beantwortet sie aber nicht für dich. ## Siehe auch [Abschnitt betitelt „Siehe auch“](#siehe-auch) [Freigaben](/de/docs/work/approvals/)Der andere Grund, warum eine Ausführung pausiert, und der strengere. [Ausführungen](/de/docs/work/runs/)Alle Gründe, warum eine Ausführung anhält, in einer Tabelle. [Gedächtnis](/de/docs/capabilities/memory/)Einmal beibringen, statt jede Woche dieselbe Frage zu beantworten. # Ausführungen > Was eine Ausführung ist, wie du die Tool-Aufrufe live verfolgst, warum eine Ausführung anhält und was passiert, wenn du die App mittendrin schließt. Eine **Ausführung** ist ein Durchgang, in dem ein Agent tatsächlich arbeitet: Er liest seinen Kontext, entscheidet, ruft ein Tool auf, liest das Ergebnis und wiederholt das, bis er eine Antwort hat oder dich braucht. ## Wann du sie nutzt [Abschnitt betitelt „Wann du sie nutzt“](#wann-du-sie-nutzt) Eine Ausführung startest du nicht direkt. Sie beginnt, wenn du eine Nachricht sendest. Auf dieser Seite geht es darum, eine Ausführung zu *lesen*: zu verstehen, was der Agent getan hat, warum er angehalten hat und was du dann tust. ## Eine Ausführung lesen [Abschnitt betitelt „Eine Ausführung lesen“](#eine-ausführung-lesen) Jeder Schritt erscheint in der Unterhaltung, sobald er passiert: * **Ein Tool-Aufruf** mit den Argumenten, die der Agent gewählt hat. Nichts auf dem Bildschirm sagt mehr aus. Ein Agent, der nach dem Falschen gesucht hat, verrät dir mehr als eine schlechte Endantwort. * **Das Ergebnis**, das zurückkam, einschließlich Fehlern. Ein fehlgeschlagener Aufruf beendet die Ausführung nicht: Der Agent sieht den Fehler und kann etwas anderes versuchen. * **Der Text des Agenten**, gestreamt, während er entsteht. Ist die Endantwort falsch, scrolle durch die Tool-Aufrufe zurück. Der Fehler ist fast immer in einem davon zu sehen, und [was du ändern solltest](/de/docs/build/iterating/#eine-ausf%C3%BChrung-zur-diagnose-lesen), ergibt sich daraus, in welchem. ## Warum eine Ausführung anhält [Abschnitt betitelt „Warum eine Ausführung anhält“](#warum-eine-ausführung-anhält) | Warum sie angehalten hat | Was du siehst | Was du tust | | ---------------------------------------------------------------- | -------------------------------------------------------------------------------------- | ------------------------------------------------------------- | | Sie ist fertig | Eine Endantwort | Nichts | | Sie braucht Informationen, die nur du hast | Eine [Frage](/de/docs/work/questions/): Optionen, ein Textfeld oder eine Reihe von Präferenzen | Beantworte sie, dann läuft die Ausführung weiter | | Sie will etwas Unumkehrbares tun | Eine Anfrage zur [Freigabe](/de/docs/work/approvals/), die die genaue Aktion zeigt | Freigeben oder ablehnen | | Sie will einen [Skill](/de/docs/capabilities/skills/), den sie nicht hat | Eine Anfrage, den Skill zu gewähren | Gewähren oder ablehnen | | Sie hat ein Schrittlimit erreicht | Die Ausführung endet ohne Endantwort | Bitte den Agenten weiterzumachen oder grenze die Aufgabe ein | | Sie ist fehlgeschlagen | Einen Fehler | Erneut versuchen oder beheben, woran sie hängen geblieben ist | Eine pausierte Ausführung hält ihre Position und fängt nicht von vorn an. Mit deiner Antwort läuft sie weiter, mit allem, was sie bereits erarbeitet hat. ## Ausführungen im Hintergrund [Abschnitt betitelt „Ausführungen im Hintergrund“](#ausführungen-im-hintergrund) Ausführungen laufen auf den Servern von endue, nicht in deinem Browser-Tab. **Wenn du die App schließt, hört die Arbeit nicht auf.** Starte eine lange Aufgabe, schließ den Tab und komm später wieder: Die Ausführung ist weitergelaufen, und das Ergebnis steht im Thread. Die Unterhaltungsliste markiert Threads, die fertig wurden, während du weg warst. Du musst dir also nicht merken, wo du nachsehen solltest. Darauf beruhen auch [Routinen](/de/docs/automate/routines/): Eine geplante Ausführung braucht niemanden, der zusieht. Pro Unterhaltung immer nur eine Ausführung In einer Unterhaltung läuft immer nur ein Durchgang auf einmal. Eine Nachricht, die du während einer laufenden Ausführung sendest, dient zum [Nachsteuern](/de/docs/work/steering/) dieser Ausführung und startet keine zweite. ## Einschränkungen [Abschnitt betitelt „Einschränkungen“](#einschränkungen) * Eine Ausführung hat ein Schrittlimit. Eine Aufgabe, die mehr Schritte braucht, als das Limit zulässt, endet ohne Endantwort. Teile sie auf oder grenze sie ein. * Eine Ausführung behält die Konfiguration, mit der sie gestartet ist: Prompt-Revision, Modell und zugewiesene Tools. Änderungen während der Ausführung gelten ab der nächsten. * Einen Tool-Aufruf, den der Agent schon gemacht hat, kannst du nicht bearbeiten. Du kannst [nachsteuern](/de/docs/work/steering/), was er als Nächstes tut, oder eine Aktion an der [Freigabeschranke](/de/docs/work/approvals/) ablehnen. * Eine Ausführung lässt sich nicht erneut abspielen. Führst du eine Aufgabe noch einmal aus, beginnt eine neue Ausführung, und Agenten sind nicht deterministisch: Dieselbe Anfrage kann einen anderen Weg nehmen. ## Siehe auch [Abschnitt betitelt „Siehe auch“](#siehe-auch) [Eine Ausführung nachsteuern](/de/docs/work/steering/)Eine Ausführung korrigieren, während sie noch läuft. [Freigaben](/de/docs/work/approvals/)Die Schranke vor allem Unumkehrbaren. [So funktioniert endue](/de/docs/get-started/how-it-works/)Die Schleife hinter jeder Ausführung, ausführlicher erklärt. # Slash-Befehle > Tippe / ins Eingabefeld, um eine App-Funktion wie /usage auszuführen oder den Befehl eines Skills direkt aufzurufen, statt zu beschreiben, was du willst, und zu hoffen, dass der Agent ihn wählt. Wenn du **`/`** ins Eingabefeld tippst, öffnet sich eine Liste der Befehle, die dieser Agent ausführen kann. Wählst du einen aus, sagst du dem Agenten genau, mit welchem Tool er beginnen soll, statt ihm die Wahl zu überlassen. ## Wann du sie nutzt [Abschnitt betitelt „Wann du sie nutzt“](#wann-du-sie-nutzt) Nutze einen Slash-Befehl, wenn du schon weißt, welches Verfahren du willst. *„/weekly-report“* ist schneller und zuverlässiger als *„Kannst du den Wochenbericht so machen wie letztes Mal?“*. Das Zweite ist eine Bitte, die der Agent erst interpretieren muss. Beschreibe in eigenen Worten, was du willst, wenn du nicht weißt, welcher Skill passt, oder wenn die Aufgabe mehrere umfasst. Der Agent wählt dann weiterhin frei aus allem, was ihm zugewiesen ist. ## So nutzt du einen [Abschnitt betitelt „So nutzt du einen“](#so-nutzt-du-einen) 1. **Tippe `/` am Anfang des Eingabefelds.** Die Liste erscheint über der Eingabezeile. 2. **Tippe weiter, um zu filtern.** Mit den Pfeiltasten bewegst du dich durch die Liste. Wenn du mit der Maus über eine Zeile fährst oder sie auswählst, siehst du, was der Befehl tut. 3. **Öffne das ⓘ neben einer Zeile**, um den ganzen Skill zu lesen: wofür er gedacht ist und welche Befehle er mitbringt. 4. **Drücke Enter, um ihn einzufügen, und schreib dann den Rest deiner Nachricht.** Ein Befehl braucht meist Kontext. *„/summarize den Thread von Hana zu den Preisen“* ist ein Befehl plus Gegenstand. 5. **Sende die Nachricht.** Der Agent beginnt seine [Ausführung](/de/docs/work/runs/) mit diesem Befehl und macht dann wie gewohnt weiter. ## Was in der Liste steht [Abschnitt betitelt „Was in der Liste steht“](#was-in-der-liste-steht) Die Liste hat zwei Gruppen, die sich unterschiedlich verhalten. ### Integrierte Befehle [Abschnitt betitelt „Integrierte Befehle“](#integrierte-befehle) Integrierte Befehle sind Funktionen der App, keine Dinge, die der Agent tut. Es gibt sie immer, bei jedem Agenten. Wenn du einen ausführst, startet keine [Ausführung](/de/docs/work/runs/), und es wird nichts verbraucht. | Befehl | Funktion | | ------------ | ------------------------------------------------------------------------------------------------------------------------------------- | | **`/usage`** | Zeigt, was diese Unterhaltung verbraucht hat: Tokens, Credits und die beteiligten Modelle. Siehe [Nutzungsübersicht](/de/docs/account/usage/) | Die Namen integrierter Befehle sind reserviert. Trägt ein Skill zufällig denselben Namen, wird der integrierte Befehl ausgeführt. Die Zeile des Skills bleibt in der Liste, damit du weiterhin siehst, dass es ihn gibt. ### Skill-Befehle [Abschnitt betitelt „Skill-Befehle“](#skill-befehle) Die übrigen stammen aus den [Skills](/de/docs/capabilities/skills/), die diesem Agenten zugewiesen sind. Das hat zwei Folgen: * **Ein anderer Agent hat eine andere Liste.** Derselbe Befehl ist nicht überall verfügbar, es sei denn, der Skill ist beiden Agenten zugewiesen. * **Ist die Gruppe leer, ist noch kein Skill zugewiesen.** Weise im [Agent Builder](/de/docs/build/agent-builder/) einen zu. Ab der nächsten Nachricht erscheint er in der Liste. ## Was die Wahl eines Skill-Befehls tatsächlich bewirkt [Abschnitt betitelt „Was die Wahl eines Skill-Befehls tatsächlich bewirkt“](#was-die-wahl-eines-skill-befehls-tatsächlich-bewirkt) Der Befehl benennt ein Tool, und der Agent muss dieses Tool **in seinem ersten Schritt** aufrufen. Danach läuft alles wie gewohnt: Er liest das Ergebnis und entscheidet, was als Nächstes kommt, auch ob er andere Tools aufruft. Genau das macht es nützlich. Du bekommst einen verlässlichen Start (das richtige Verfahren, eröffnet mit deiner Eingabe), ohne den Rest der Ausführung in ein Skript zu zwängen. Manche Befehle fragen, bevor sie handeln Ein Befehl, dessen Skill angibt, dass er eine Bestätigung braucht, hält trotzdem an der [Freigabeschranke](/de/docs/work/approvals/) an, sobald er einen ausgehenden oder destruktiven Schritt erreicht. Ihn aus der Liste zu wählen ist keine Freigabe. ## Ein Name, der kein Befehl ist [Abschnitt betitelt „Ein Name, der kein Befehl ist“](#ein-name-der-kein-befehl-ist) Ein `/something`, das zu nichts passt, wird nicht an den Agenten gesendet. Das Eingabefeld hält die Nachricht auf und meldet, dass der Name kein Befehl ist. So wird aus einem Tippfehler keine Nachricht, die der Agent interpretieren muss. Als Befehl gelesen wird nur eine Nachricht, die aus einem Schrägstrich und einem einzelnen Wort besteht, ohne etwas danach. `/usage in July`, ein Dateipfad und ein Satz, der zufällig mit einem Schrägstrich beginnt, sind gewöhnliche Nachrichten und werden normal gesendet. ## Einschränkungen [Abschnitt betitelt „Einschränkungen“](#einschränkungen) * Skill-Befehle gelten pro Agent. Eine globale Liste davon gibt es nicht. Nur integrierte Befehle sind überall gleich. * Ein Skill-Befehl steuert nur den **ersten** Schritt. Den Rest der Ausführung wählt der Agent selbst. * Sendest du einen Befehl, während eine Ausführung läuft, dient er zum [Nachsteuern](/de/docs/work/steering/) dieser Ausführung, statt den Befehl zu starten. Beim Nachsteuern kommt dein Text an, nicht die Wahl des Tools. * Die Liste zeigt, was der Agent gerade aufrufen kann. Ein Skill, den du mitten in der Unterhaltung zuweist, erscheint ab der nächsten Nachricht. * Was ein integrierter Befehl anzeigt, existiert nur auf diesem Bildschirm. Es ist keine Nachricht, steht also nicht im Verlauf und ist nach dem Neuladen weg. ## Siehe auch [Abschnitt betitelt „Siehe auch“](#siehe-auch) [Skills](/de/docs/capabilities/skills/)Woher Befehle kommen und wie du einen Skill zuweist. [Ausführungen](/de/docs/work/runs/)Was nach dem ersten Schritt passiert. [Freigaben](/de/docs/work/approvals/)Die Schranke, die ein Befehl nicht umgeht. # Eine Ausführung nachsteuern > Eine Korrektur senden, während ein Agent noch arbeitet – was sie ändern kann, wann sie greift und was passiert, wenn deine Nachsteuerungen aufgebraucht sind. **Nachsteuern** heißt, einer [Ausführung](/de/docs/work/runs/), die noch läuft, eine Korrektur zu schicken. Der Agent greift sie im nächsten Schritt auf. Eine Korrektur kostet also einen Schritt statt der ganzen Ausführung. ## Wann du nachsteuerst [Abschnitt betitelt „Wann du nachsteuerst“](#wann-du-nachsteuerst) In dem Moment, in dem du siehst, dass die Ausführung in die falsche Richtung läuft. Lässt du eine schlechte Ausführung zu Ende laufen und erklärst danach, was falsch war, ist alles verschwendet, was sie in der Zwischenzeit getan hat. Außerdem muss der Agent den Kontext neu aufbauen, den er vor deinen Augen schon einmal gesammelt hat. Gute Nachsteuerungen sind kurz und korrigieren gezielt: * *„Nur diese Woche, nicht den ganzen Monat.“* * *„Lass die Newsletter weg.“* * *„Schreib es als Tabelle, nicht als Fließtext.“* * *„Hör auf zu suchen, du hast schon genug. Fass nur noch zusammen.“* ## So funktioniert es [Abschnitt betitelt „So funktioniert es“](#so-funktioniert-es) Tippe ins Eingabefeld, während die Ausführung läuft, und sende. Mehr ist nicht zu tun: Eine Nachricht, die während einer Ausführung gesendet wird, ist eine Nachsteuerung, kein neuer Durchgang. Der Agent schließt den Tool-Aufruf ab, den er gerade macht, und liest deine Korrektur, bevor er über den nächsten Schritt entscheidet. Deshalb scheint eine Nachsteuerung manchmal eine Aktion zu spät anzukommen: Ein bereits laufender Aufruf wird nicht abgebrochen. ## Was Nachsteuern ändern kann und was nicht [Abschnitt betitelt „Was Nachsteuern ändern kann und was nicht“](#was-nachsteuern-ändern-kann-und-was-nicht) | Kann | Kann nicht | | -------------------------------------------- | -------------------------------------------------------------------------- | | Umlenken, was der Agent als Nächstes tut | Einen bereits gelaufenen Tool-Aufruf rückgängig machen | | Die Aufgabe eingrenzen oder erweitern | Modell oder Prompt für diese Ausführung ändern | | Das Ausgabeformat ändern | Daten wiederherstellen, die eine Aktion bereits gelöscht hat | | Die Suche beenden und eine Antwort verlangen | Eine E-Mail zurückholen, die eine freigegebene Aktion bereits gesendet hat | Alles Unumkehrbare sichert die [Freigabeschranke](/de/docs/work/approvals/) ab, nicht das Nachsteuern. Sie ist der Mechanismus für „Tu das nicht“, und sie greift *vor* der Aktion, nicht danach. ## Wenn die Nachsteuerungen aufgebraucht sind [Abschnitt betitelt „Wenn die Nachsteuerungen aufgebraucht sind“](#wenn-die-nachsteuerungen-aufgebraucht-sind) Eine einzelne Ausführung nimmt nur eine begrenzte Zahl an Nachsteuerungen an, standardmäßig fünf. Das verhindert, dass eine Ausführung endlos umgelenkt wird, statt neu gestartet zu werden. Erreichst du das Limit, geht deine Nachricht nicht verloren: Sie wird als normale Folgenachricht zugestellt und nach dem Ende der Ausführung bearbeitet. Die Unterhaltung zeigt dir an, wenn das passiert. Wiederholte Nachsteuerungen sind ein Prompt-Fehler Wenn du demselben Agenten jedes Mal dieselbe Korrektur schickst, gehört sie in den [Systemprompt](/de/docs/build/system-prompt/). Eine Nachsteuerung repariert eine Ausführung, ein Prompt repariert alle. ## Einschränkungen [Abschnitt betitelt „Einschränkungen“](#einschränkungen) * Standardmäßig fünf Nachsteuerungen pro Ausführung. * Eine Nachsteuerung gilt für die Ausführung, in die sie gesendet wurde. Für die nächste Ausführung wird sie nicht gemerkt, es sei denn, du nimmst sie in den Prompt oder ins [Gedächtnis](/de/docs/capabilities/memory/) auf. * Nachsteuern ist in den Chat-Oberflächen verfügbar. Eine Ausführung, die eine [Routine](/de/docs/automate/routines/) oder ein [Kanal](/de/docs/automate/channels/) gestartet hat, liegt nicht vor dir, sodass du sie nicht nachsteuern kannst. * Ein bereits laufender Tool-Aufruf wird abgeschlossen, bevor die Korrektur gelesen wird. ## Siehe auch [Abschnitt betitelt „Siehe auch“](#siehe-auch) [Ausführungen](/de/docs/work/runs/)Was eine Ausführung ist und wie du sie live verfolgst. [Freigaben](/de/docs/work/approvals/)Die Schranke, die unumkehrbare Aktionen stoppt, bevor sie passieren. [Testen und iterieren](/de/docs/build/iterating/)Aus wiederholten Korrekturen einen besseren Agenten machen.