AutoGPT - Entwicklerhandbuch

Worum geht's?

AutoGPT ist eine Open-Source-Plattform, um kontinuierliche KI-Agenten zu bauen, bereitzustellen und auszuführen, die mehrstufige Workflows automatisieren. Du stellst einen Agenten visuell zusammen, indem du Blocks miteinander verdrahtest — jeder Block ist eine einzelne, abgegrenzte Aktion — und sie zu einem Graph verbindest. Anschließend führst du ihn bei Bedarf, nach Zeitplan oder als Reaktion auf externe Trigger aus. Dieses Handbuch ist der Einstiegspunkt für Entwickelnde: Es erklärt, was AutoGPT heute ist, wie die Plattform aufgebaut ist, welches Vokabular du brauchst und wo im Repository alles liegt.

Gegen Primärquellen geprüft

Dieses Handbuch basiert auf der offiziellen AutoGPT-Dokumentation (agpt.co/docs) und dem Significant-Gravitas/AutoGPT-GitHub-Repository (dev-Branch), geprüft am 25. Juni 2026. Codesignaturen und Dateipfade sind aus dem Repository-Quellcode zitiert; die Plattform entwickelt sich schnell, prüfe daher immer gegen den aktuellen dev-Branch, bevor du dich auf ein bestimmtes Detail verlässt.

1. Was AutoGPT ist (und was nicht)

Der Name „AutoGPT“ umfasst zwei verschiedene Projekte, die im selben Repository liegen. Zu wissen, welches davon du gerade vor dir hast, erspart viel Verwirrung.

	AutoGPT Platform	AutoGPT Classic
Was es ist	Eine moderne Plattform, um KI-Agenten als visuelle Workflows zu bauen, bereitzustellen und auszuführen	Der ursprüngliche autonome Standalone-Agent aus dem Jahr 2023
Wie du es nutzt	Web-UI (Low-Code-Agent Builder) + ein Server-Backend	Python-Toolkit, CLI und ein Referenz-Agent
Status	Aktiv weiterentwickelt, der Fokus des Projekts	Legacy / Maintenance, als Referenz erhalten
Liegt in	`autogpt_platform/`	`classic/` (Forge, Benchmark, Frontend)
Lizenz	Polyform Shield	MIT

Der Rest dieses Handbuchs dreht sich um die Platform. Classic wird in §6 zusammengefasst.

Mentales Modell

Stell dir die Platform als eine visuelle Programmierumgebung für KI-Agenten vor. Statt ein Skript zu schreiben, das ein LLM und einige APIs aufruft, ziehst du Blocks auf eine Arbeitsfläche und verbindest sie. Die Runtime führt diesen Graph für dich aus, kümmert sich um Credentials, Wiederholungen, Zeitplanung und die Abrechnung von Credits und lässt dich das Ergebnis veröffentlichen, damit andere es ausführen können.

2. Die zwei Hälften der Platform

Die Platform ist aufgeteilt in ein Frontend (wo Menschen Agenten bauen und betreiben) und einen Server (wo Agenten tatsächlich laufen).

Frontend

Eine Next.js-/TypeScript-Webanwendung. Hier kannst du:

Funktion	Was sie tut
Agent Builder	Eine Low-Code-Arbeitsfläche, um Agenten durch das Verbinden von Blocks zu entwerfen und zu konfigurieren
Workflow-Verwaltung	Den Graph bauen, ändern und optimieren; jeder Block führt eine einzelne Aktion aus
Deployment-Steuerung	Den Lebenszyklus eines Agenten vom Test bis zur Produktion verwalten
Library / einsatzbereite Agenten	Einen vorkonfigurierten Agenten auswählen und ausführen, ohne etwas bauen zu müssen
Agenten-Interaktion	Deine Agenten ausführen und ihre Eingaben über die UI bereitstellen
Monitoring & Analytics	Läufe, Ausgaben und Performance über die Zeit verfolgen

Server

Das Backend ist das „Kraftwerk“, in dem Agenten laufen. Einmal bereitgestellt, kann ein Agent durch externe Quellen (Webhooks, Zeitpläne, manuelle Läufe) ausgelöst werden und kontinuierlich arbeiten. Der Server ist eine Reihe von Python-Services und enthält:

Core-Logik — die Graph-Engine und die Block-Bibliothek, die die Ausführung antreiben.
Infrastruktur — die unterstützenden Services (Datenbank, Queue, Cache, Auth, Datei-Scanning, …).
Marketplace — ein Katalog, in dem du vorgefertigte Agenten finden und bereitstellen kannst.

Unter Docker Compose ist das Backend kein einzelner Prozess, sondern mehrere zusammenwirkende Services — ein REST-API-Server, ein Executor, ein Websocket-Server, ein Datenbank-Manager, ein Scheduler und ein Notification-Server — plus ihre Abhängigkeiten (Postgres über Supabase, Redis/FalkorDB, RabbitMQ, ClamAV). Du musst nicht über jeden einzelnen davon nachdenken, um Agenten zu bauen, aber es ist nützlich zu wissen, dass das Backend beim Self-Hosting eine verteilte Menge von Services ist (siehe Self-Hosting).

3. Kernkonzepte

Diese fünf Begriffe tauchen überall in der UI, der Dokumentation und dem Code auf. Verinnerliche sie, bevor du weitergehst.

Konzept	Definition
Block	Die kleinste Funktionseinheit — ein Block tut eine Sache (ein LLM aufrufen, eine E-Mail senden, rechnen, eine Webseite lesen). Blocks haben ein typisiertes Eingabe-Schema und ein typisiertes Ausgabe-Schema.
Node	Eine konkrete Instanz eines Blocks, die auf der Arbeitsfläche platziert und deren Eingaben konfiguriert sind. Derselbe Block kann als beliebig viele Nodes erscheinen.
Link	Eine Verbindung von einem Ausgabe-Pin einer Node zu einem Eingabe-Pin einer anderen. Über Links fließen Daten durch den Agenten.
Graph	Der gesamte Agent: eine Menge von Nodes, die durch Links verbunden sind. „Agent“ und „Graph“ sind faktisch Synonyme — der Graph ist der Workflow des Agenten.
Agent	Ein Graph, den du ausführen, planen, veröffentlichen und teilen kannst. Ein Agent hat Versionen.

Zwei weitere Begriffe für die Verteilung:

Marketplace — der öffentliche Katalog von Agenten, die andere veröffentlicht haben; durchsuche, teste und stelle sie bereit.
Library — deine eigene Sammlung von Agenten (selbst gebaut oder aus dem Marketplace hinzugefügt), bereit zur Ausführung.

            ┌─────────┐      link       ┌──────────────┐     link      ┌──────────────┐
 input ───▶ │  Node A │ ───────────────▶│    Node B    │──────────────▶│    Node C     │ ───▶ output
            │ (Block) │  output → input │   (Block)    │               │   (Block)     │
            └─────────┘                 └──────────────┘               └──────────────┘
                                  one Graph = one Agent

Wie sich Daten tatsächlich bewegen

Die run()-Methode eines Blocks ist ein async Generator: Sie yieldet ein oder mehrere (output_name, value)-Paare. Jeder ausgegebene Wert wandert entlang jedes Links, der an diesen Ausgabe-Pin angehängt ist, und landet auf dem verbundenen Eingabe-Pin der nachgelagerten Node. Dieses Streaming-Modell ist der Grund, warum ein einzelner Block mehrere Ergebnisse über die Zeit ausgeben kann, nicht nur einen einzigen Rückgabewert. Die Mechanik wird in Building Blocks behandelt.

4. Tech-Stack

Bereich	Technologie
Backend-Sprache	Python (~69 % des Repos)
Frontend-Sprache	TypeScript (~29 %)
Containerisierung	Docker Engine ≥ 20.10, Docker Compose ≥ 2.0
Datenbank	PostgreSQL über Supabase, angesprochen über Prisma
Queue / Cache	RabbitMQ, Redis / FalkorDB
Schema/Validierung	Pydantic-Modelle für das Eingabe- & Ausgabe-Schema jedes Blocks
Standard (Classic)	Agent Protocol der AI Engineer Foundation

Der Einsatz von Pydantic ist für Entwickelnde wichtig: Das Eingabe- und Ausgabe-Schema eines Blocks sind Pydantic-Modelle, die in JSON Schema umgewandelt und in der Datenbank gespeichert werden. Dieses JSON Schema ist das, was der Agent Builder als Formular rendert und wogegen der Executor zur Laufzeit validiert.

5. Monorepo-Aufbau

Das Repository ist ein Monorepo. Die zwei Lizenzzonen bilden sich auf zwei Top-Level-Bereiche ab:

AutoGPT/
├── autogpt_platform/          # ← the Platform (Polyform Shield License)
│   ├── backend/
│   │   └── backend/
│   │       ├── blocks/        # the block library — _base.py defines the Block class
│   │       ├── data/          # block.py, model.py (SchemaField, Credentials, …), graph, execution
│   │       ├── sdk/           # the Block SDK (auto-registration, provider/credentials helpers)
│   │       └── integrations/  # provider definitions, OAuth, webhooks
│   ├── frontend/              # Next.js web app (Agent Builder, Library, Marketplace)
│   ├── docker-compose.yml     # the full self-host stack
│   └── .env.default           # template you copy to .env
│
├── classic/                   # ← AutoGPT Classic (MIT License)
│   ├── forge/                 # agent-building toolkit
│   ├── benchmark/             # agbenchmark
│   └── frontend/              # classic GUI
│
├── docs/                      # documentation source
└── run                        # root CLI (./run setup | agent | benchmark) — Classic

Die für die Block-Entwicklung relevantesten Dateien — backend/data/block.py, backend/blocks/_base.py und backend/data/model.py — werden in Building Blocks seziert.

6. AutoGPT Classic (Legacy)

Alles außerhalb von autogpt_platform/ ist das ursprüngliche AutoGPT, unter der MIT-Lizenz. Du wirst es für neue Arbeiten selten brauchen, aber zur Einordnung:

Forge — ein einsatzbereites Toolkit, das den Boilerplate beim Bau deines eigenen Standalone-Agenten übernimmt. Seine Komponenten lassen sich auch einzeln wiederverwenden.
agbenchmark — ein Benchmarking-Harness für jeden Agenten, der das Agent Protocol spricht; auf PyPI als agbenchmark veröffentlicht.
Classic GUI — ein einfaches Frontend, das sich über das Agent Protocol mit Agenten verbindet.
Root-CLI — ./run setup, ./run agent, ./run benchmark verbinden diese miteinander. Führe ./run setup einmal aus, um Abhängigkeiten zu installieren.

Wenn dein Ziel der Bau moderner Agenten ist, ignoriere Classic und arbeite in autogpt_platform/.

7. Lizenzierung — lies das, bevor du kommerziell baust

AutoGPT verwendet zwei Lizenzen, aufgeteilt nach Ordner. Das ist wichtig, wenn du planst, es zu hosten oder zu kommerzialisieren:

Geltungsbereich	Lizenz	Praktische Bedeutung
Alles in `autogpt_platform/`	Polyform Shield	Source-available. Du darfst es nutzen, selbst hosten und modifizieren, aber die Shield-Lizenz schränkt das Anbieten als konkurrierendes kommerzielles Produkt/Service ein.
Alles außerhalb von `autogpt_platform/` (Classic, Forge, agbenchmark, Classic GUI)	MIT	Permissiv — frei nutzbar, auch kommerziell.

Keine Rechtsberatung

Polyform Shield ist keine OSI-„Open-Source“-Lizenz im strengen Sinne — sie ist source-available mit einer Wettbewerbsbeschränkung. Bevor du ein kommerzielles Angebot auf Basis der Platform baust, lies den tatsächlichen Lizenztext im Repository und hole dir deine eigene rechtliche Prüfung ein. Die Zusammenfassung oben dient der Orientierung, sie ist keine rechtliche Stellungnahme.

8. Wie es weitergeht

Du willst …	Lies
Die Platform auf deinem eigenen Rechner ausführen	Self-Hosting — Anforderungen, Docker-Setup, Ports, Fehlerbehebung
Deinen eigenen Block schreiben	Building Blocks — die `Block`-Klasse, Schemas, `run()`, Credentials und Testing
AutoGPT mit anderen Agenten-Frameworks vergleichen	Überblick zum Agenten-Vergleich

9. Quellen

Significant-Gravitas/AutoGPT — README.md, autogpt_platform/backend/backend/data/block.py, autogpt_platform/backend/backend/blocks/_base.py, autogpt_platform/backend/backend/data/model.py (dev branch, reviewed 2026-06-25)
AutoGPT documentation — agpt.co/docs
Repository — github.com/Significant-Gravitas/AutoGPT

1. Was AutoGPT ist (und was nicht)​

2. Die zwei Hälften der Platform​

Frontend​

Server​

3. Kernkonzepte​

4. Tech-Stack​

5. Monorepo-Aufbau​

6. AutoGPT Classic (Legacy)​

7. Lizenzierung — lies das, bevor du kommerziell baust​

8. Wie es weitergeht​

9. Quellen​