Open-Source-Framework

Baue autonome KI-Agenten
die wirklich liefern

Name: Pydantic DeepAgents
Author: Vstorm

Produktionsreifes Python-Framework mit Deep-Agent-Pattern — Agenten die planen, coden, ausführen und delegieren wie Claude Code.

Quick Start testen Auf GitHub ansehen 467

Terminal

Warum es nutzen?

Ohne DeepAgents

✗ Fragile Chains die bei unerwarteten Inputs brechen
✗ Keine Typsicherheit — dict-basiert, fehleranfällig
✗ Schwer zu debuggende Agent-Entscheidungspfade
✗ Manuelles Kontextfenster-Management
✗ Kein Subagent-Delegationsmuster

Mit DeepAgents

✓ Modulare Agenten mit strukturierter Planung
✓ Vollständig typsicher mit Pydantic-Modellen
✓ Vollständige Observability über Logfire
✓ Automatische Kontextzusammenfassung
✓ Eingebaute Subagent-Delegation und Kommunikation

In 4 Schritten starten

Von pip install zu autonomen Agenten in Minuten

Installieren

pip install pydantic-deepagents — ein Paket, null Konfiguration, alles inklusive.

Agent definieren

Beschreibe was dein Agent tut — typisierte Tools, System-Prompts und optionale Sub-Agenten.

Ausführen

Dein Agent plant, führt aus und delegiert — mit Echtzeit-Streaming über WebSocket.

Mit Sub-Agenten skalieren

Teile komplexe Aufgaben in spezialisierte Sub-Agenten auf, die autonom zusammenarbeiten.

Alles was ein Agent braucht

Von Planung bis Deployment — das komplette Deep-Agent-Toolkit.

Deep-Agent-Pattern

Implementiert die Claude-Code-Architektur — Agenten die autonom denken, planen und mehrstufige Aufgaben ausführen.

Unbegrenzter Kontext

Eingebaute Konversationskompaktierung ermöglicht Aufgaben die jedes Kontextfenster überschreiten.

Subagent-Delegation

Spezialisierte Subagenten für parallele Recherche, Code-Generierung oder Analyse — Ergebnisse zusammenführen.

Persistenter Speicher

Agenten erinnern sich zwischen Sitzungen. Projekt- und globaler Speicher mit automatischer Relevanzfilterung.

Umfangreiches Toolsystem

Dateizugriff, Shell-Ausführung, Web-Suche und Custom-Tools — alles mit typsicheren Pydantic-Modellen.

Produktionsreif

Streaming, Checkpoints, Multi-Provider-Support, Logfire-Integration — bewährt in 30+ Produktionsumgebungen.

Wie schneidet es ab?

Vergleich mit den Alternativen.

Funktion	DeepAgents	LangChain	CrewAI	AutoGen
Typsicherheit	✓	✗	✗	✗
Subagent-Delegation	✓	✗	✓	✓
Tool-System	✓	✓	✓	✓
Multi-Provider	✓	✓	Partial	✓
Observability	✓	Partial	✗	✗
Produktionsgetestet	✓	✓	✗	✗

So funktioniert's

Eine Schichtarchitektur von der Anwendung bis zum LLM.

Your Application

DeepAgent Orchestrator

Planning
Engine

Memory
Manager

Context
Compactor

Middleware Stack

GuardrailsCost TrackingLoggingPermissions

Tool Registry

FilesystemShellWeb SearchSub-agentsCustom

LLM Provider

ClaudeOpenAIGemini

Drei Zeilen zum ersten Agenten

Vom Basis-Setup über Custom-Tools bis zur Subagent-Delegation.

from pydantic_deep import create_deep_agent, DeepAgentDeps, StateBackend

agent = create_deep_agent(
    model="anthropic:claude-sonnet-4-20250514",
    instructions="You are a senior Python developer.",
)

deps = DeepAgentDeps(backend=StateBackend())

result = await agent.run(
    "Refactor the auth module to use JWT tokens",
    deps=deps,
)

from pydantic_ai import RunContext
from pydantic_deep import create_deep_agent, DeepAgentDeps, StateBackend

async def analyze_logs(ctx: RunContext[DeepAgentDeps], path: str) -> str:
    """Analyze log files for errors and patterns."""
    return ctx.deps.backend.read(path)

agent = create_deep_agent(
    model="openai:gpt-4.1",
    instructions="You are a DevOps assistant.",
    tools=[analyze_logs],
)

deps = DeepAgentDeps(backend=StateBackend())
result = await agent.run("Find and fix recent errors", deps=deps)

from pydantic_deep import create_deep_agent, DeepAgentDeps, StateBackend
from pydantic_deep.types import SubAgentConfig

agent = create_deep_agent(
    model="anthropic:claude-sonnet-4-20250514",
    instructions="You are a tech lead. Delegate tasks to subagents.",
    subagents=[
        SubAgentConfig(
            name="code-reviewer",
            description="Reviews code for bugs and best practices",
            instructions="You are an expert code reviewer.",
        ),
    ],
)

deps = DeepAgentDeps(backend=StateBackend())
result = await agent.run("Review the PR changes", deps=deps)

Gebaut für echte Arbeit

Von Code-Generierung bis Forschungspipelines.

Code-Generierung & Refactoring

Autonome Agenten die Codebasen lesen, Änderungen planen und über mehrere Dateien implementieren.

— Multi-Datei-Refactoring
— Automatisiertes Code-Review
— Test-Generierung
— Dependency-Updates

Forschungsagenten

Agenten die das Web durchsuchen, Ergebnisse analysieren und strukturierte Berichte erstellen.

— Web-Suche & Scraping
— Quellen-Kreuzreferenz
— Strukturierte Ausgabe
— Zitatverfolgung

Data-Pipeline-Automatisierung

Pipelines bauen, überwachen und reparieren mit Agenten die deine Infrastruktur verstehen.

— Pipeline-Scaffolding
— Fehlerdiagnose
— Schema-Migrationen
— Performance-Tuning

CLI & DeepResearch

Interaktives Terminal, Editor-Integration und autonome Recherche — alles inklusive.

Interaktives CLI

Vollständiges Terminal-Interface mit Textual. Gespräche fortsetzen, Modelle wechseln, Token-Verbrauch verfolgen — oder in Zed per ACP einbinden.

Sitzungswiederaufnahme & persistenter Speicher
Multi-Provider-Modellwechsel
Custom Skills & Web-Suche
Zed-Editor-Integration via ACP

DeepResearch

Autonomer Forschungsagent der Abfragen plant, an Subagenten delegiert, Quellen kreuzreferenziert und strukturierte Berichte mit Zitaten schreibt.

Mehrstufige Forschungsplanung
Parallele Subagent-Delegation
Web-Suche mit vollständigem Seitenabruf
Strukturierte Berichte mit Zitaten

Häufig gestellte Fragen

Alles was Sie über unsere Tools und Projekte wissen müssen.

Was ist pydantic-deep?

Ein Python-Framework zum Erstellen autonomer KI-Agenten, inspiriert von der Claude-Code-Architektur. Es implementiert das Deep-Agent-Pattern — Agenten, die planen, Dateien lesen/schreiben, an Subagenten delegieren und persistenten Speicher über Sitzungen hinweg behalten.

Wie unterscheidet es sich von LangChain oder CrewAI?

DeepAgents ist standardmäßig typsicher (Pydantic-Modelle, keine Dicts), modular (Tools komponieren, keine Chains) und beobachtbar (Logfire-Integration). Es konzentriert sich auf das Deep-Agent-Pattern — langlebige Agenten, die autonom planen und ausführen.

Welche LLM-Anbieter werden unterstützt?

Jeder von Pydantic AI unterstützte Anbieter — OpenAI, Anthropic, Google Gemini, Groq, Mistral und jede OpenAI-kompatible API (wie Ollama für lokale Modelle). Anbieterwechsel mit einer Konfigurationszeile.

Kann ich eigene Tools verwenden?

Ja. Definieren Sie Tools mit dem @tool-Dekorator von Pydantic AI. Tools sind typgeprüft, unterstützen asynchrone Ausführung und integrieren sich in das Berechtigungssystem. Sie können auch vorgefertigte Toolsets (Dateisystem, Datenbank, Konsole) aus Begleitbibliotheken verwenden.

Ist es produktionsreif?

Ja. DeepAgents betreibt über 30 Produktions-Deployments bei Vstorm. Es umfasst strukturiertes Logging über Logfire, Fehlerwiederherstellung, Token-Usage-Tracking und wurde in echten KI-Agenten-Anwendungen kampferprobt.

Alle Fragen anzeigen

Bereit für Agenten, die wirklich denken?

Installiere pydantic-deep, definiere deinen Agenten und lass ihn planen, coden und delegieren — wie Claude Code, aber deiner.

Quick Start testen

Baue autonome KI-Agenten die wirklich liefern