Die 15 besten Python-Frameworks für komplette agentische KI-Anwendungen

Agentische KI-Anwendungen zu bauen ist heute deutlich einfacher als noch vor ein paar Jahren. Statt Agent-Loops, Tool-Integrationen, Speicher, Retrieval und Orchestrierung von Grund auf zu entwickeln, können Entwickler auf Python-Frameworks zurückgreifen, die den Großteil dieser Bausteine bereits mitbringen.

Viele der Frameworks in diesem Artikel habe ich selbst genutzt, um RAG-Anwendungen, autonome Agenten, Multi-Agent-Systeme und bereitstellbare KI-Tools zu entwickeln.

Für flexible Agent-Workflows greife ich oft zu LangChain, für datenverbundene Anwendungen zu LlamaIndex und Haystack, und das OpenAI Agents SDK oder Google ADK nutze ich, wenn ich Provider-Modelle besonders schnell integrieren möchte.

Einige dieser Frameworks sind so gereift, dass eine Eigenentwicklung oft überflüssig ist. Mit einem API-Schlüssel, etwas Model-Credits und dem passenden Framework kannst du einen Agenten erstellen, ihn mit Tools oder privaten Daten verbinden, testen und per API oder Benutzeroberfläche ausliefern.

Dieser Artikel vergleicht 15 Python-Frameworks in fünf Kategorien: Allzweck-Agent-Frameworks, offizielle Agent-SDKs, Multi-Agent-Orchestrierungs-Frameworks, Data- und RAG-Frameworks sowie schlanke Open-Model-Frameworks.

Jeder Abschnitt enthält außerdem ein kurzes Python-Beispiel, das du kopieren, einfügen und testen kannst, um die Funktionsweise des Frameworks schnell zu verstehen.

Allzweck-Agent-Frameworks

Diese Frameworks liefern breite Bausteine, um Agenten zu entwickeln, Tools anzubinden, Zustände zu verwalten und mehrstufige Workflows zu steuern.

1. LangChain

Für viele Entwickler begann modernes LLM-App-Development mit LangChain, einem Open-Source-Python-Framework, das Sprachmodelle mit externen Daten, Tools, APIs und Anwendungslogik verbindet. Es war eines der ersten weit verbreiteten Frameworks, um die OpenAI API mit Websites, Dokumenten, Vektordatenbanken und anderen Datenquellen zu nutzen und so kontextbewusstere Anwendungen zu bauen.

Heute ist LangChain zu einem vollständigen Ökosystem für End-to-End agentische KI-Anwendungen gereift, inklusive RAG-Systemen, toolnutzenden Agenten, Workflows, Integrationen, Monitoring und Evaluation. Ich empfehle dir den AI Engineering with LangChain Lernpfad, um mehr zu erfahren.

Das folgende Beispiel erstellt einen einfachen LangChain-Agenten, der ein Dokumentations-Suchtool nutzen kann, um vor der Antwort relevante Informationen zu finden.

# pip install -U langchain "langchain[openai]"

from langchain.agents import create_agent

def search_docs(query: str) -> str:
    """Search the company documentation."""
    return f"Documentation found for: {query}"

agent = create_agent(
    model="openai:gpt-5.5",
    tools=[search_docs],
    system_prompt="Use the documentation tool when needed.",
)

result = agent.invoke({
    "messages": [{
        "role": "user",
        "content": "What is our remote-work policy?"
    }]
})

print(result["messages"][-1].content)

2. LangGraph

Während LangChain das Erstellen von Agenten und Tools vereinfacht, bietet LangGraph mehr Kontrolle über deren Ablauf. Anwendungen lassen sich als Graph aus verbundenen Schritten strukturieren, wodurch sich Loops, Toolaufrufe, gemeinsamer Zustand, menschliche Freigaben und Multi-Agent-Workflows gezielt steuern lassen.

Ich finde es besonders hilfreich für autonome Agenten, die wiederholt entscheiden müssen, was sie als Nächstes tun, das richtige Tool wählen, das Ergebnis prüfen und weitermachen, bis die Aufgabe erledigt ist. LangGraph unterstützt zudem Persistenz, Streaming, Checkpoints und Recovery für langlaufende Anwendungen. Unser LangGraph-Tutorial liefert weitere Details.

Das folgende Beispiel erstellt einen Agenten, der wiederholt Rechner-Tools aufruft, bis er genug Informationen für eine Antwort hat:

# pip install -U langgraph langchain langchain-openai

from langchain.chat_models import init_chat_model
from langchain.tools import tool
from langgraph.graph import MessagesState, StateGraph, START
from langgraph.prebuilt import ToolNode, tools_condition

model = init_chat_model("openai:gpt-5.5", temperature=0)

@tool
def add(a: int, b: int) -> int:
    """Add two numbers."""
    return a + b

@tool
def multiply(a: int, b: int) -> int:
    """Multiply two numbers."""
    return a * b

tools = [add, multiply]
model_with_tools = model.bind_tools(tools)

def call_model(state: MessagesState):
    response = model_with_tools.invoke(state["messages"])
    return {"messages": [response]}

builder = StateGraph(MessagesState)
builder.add_node("agent", call_model)
builder.add_node("tools", ToolNode(tools))

builder.add_edge(START, "agent")
builder.add_conditional_edges("agent", tools_condition)
builder.add_edge("tools", "agent")

agent = builder.compile()

result = agent.invoke({
    "messages": [{
        "role": "user",
        "content": "Add 12 and 8, then multiply the result by 3."
    }]
})

print(result["messages"][-1].content)

Der Graph sendet die Anfrage an das Modell, führt erforderliche Tools aus und springt zurück zum Modell, bis eine finale Antwort entsteht.

3. Agno

Agno ist ein Python-Framework zum Aufbau von Agenten, Multi-Agent-Teams und strukturierten Workflows. Es beinhaltet außerdem AgentOS, das hilft, Agenten per APIs bereitzustellen, Sessions und Traces zu speichern und sie als Produktionsanwendungen zu betreiben. Da es auf eigener Infrastruktur laufen kann, behalten Organisationen die Kontrolle über Daten und Sicherheit.

Das folgende Beispiel erstellt einen Research-Agenten, der das Web durchsucht und anschließend eine prägnante Antwort liefert.

# pip install -U agno ddgs openai

from agno.agent import Agent
from agno.models.openai import OpenAIResponses
from agno.tools.duckduckgo import DuckDuckGoTools

agent = Agent(
    name="AI Research Assistant",
    model=OpenAIResponses(id="gpt-5.5"),
    tools=[DuckDuckGoTools()],
    instructions="Search when needed and keep the answer concise.",
)

agent.print_response(
    "Find one recent development in open-source AI and summarize it.",
    stream=True,
)

Der Agent nutzt das Such-Tool, um aktuelle Informationen zu finden, und streamt eine kurze Zusammenfassung an die Nutzer.

4. Pydantic AI

Pydantic AI ist ein Python-natives Framework des Pydantic-Teams zum Bau von Agenten und generativen KI-Anwendungen. Es fühlt sich ähnlich an wie Arbeiten mit Pydantic-Modellen oder FastAPI, da Agenten, Tools, Abhängigkeiten und Ausgaben über Standard-Python-Funktionen, Type Hints, Dekoratoren und BaseModel-Klassen definiert werden. Pydantic-Validierung sorgt anschließend für strukturierte, zuverlässige Tool-Argumente und Model-Ausgaben.

Ich empfehle dir das Pydantic AI Tutorial, um tiefer einzusteigen.

Das folgende Beispiel erstellt einen Agenten, der einen validierten Artikelplan als Pydantic-Modell zurückgibt.

# pip install -U pydantic-ai

from pydantic import BaseModel, Field
from pydantic_ai import Agent


class ArticlePlan(BaseModel):
    title: str
    key_points: list[str]
    reading_time_minutes: int = Field(ge=1)


agent = Agent(
    "openai:gpt-5.6-sol",
    output_type=ArticlePlan,
    instructions="Create concise article plans for technical readers.",
)

result = agent.run_sync(
    "Create a short article plan about building AI agents in Python."
)

print(result.output)

Der Agent erzeugt ein ArticlePlan-Objekt und prüft vor der Rückgabe, ob alle Felder den geforderten Python-Typen und Regeln entsprechen.

Offizielle Agent-SDKs

Offizielle Agent-SDKs werden von KI-Anbietern gepflegt und bieten meist die einfachste Integration mit ihren Modellen, APIs, Tools, Deployment-Systemen und Observability-Plattformen.

5. OpenAI Agents SDK

Das OpenAI Agents SDK ist ein leichtgewichtiges, Python-first-Framework für Single- und Multi-Agent-Anwendungen. Es bietet einen eingebauten Agent-Loop, Function-Tools, Handoffs, Guardrails, Sessions, menschliche Freigaben und Tracing, ohne zu viele Abstraktionen hinzuzufügen.

Ich arbeite sehr gern mit dem OpenAI Agents SDK, weil es simpel, schnell zu integrieren und gut nachvollziehbar ist. Ich habe damit viele Anwendungen ohne größere Probleme gebaut. Zudem entstehen automatisch Traces, die im OpenAI-Dashboard einsehbar sind—ideal, um Modellantworten, Toolaufrufe, Handoffs und den kompletten Ausführungsfluss zu inspizieren.

Das folgende Beispiel erstellt einen History-Agenten, der eine Python-Funktion aufrufen kann, um eine überraschende historische Tatsache abzurufen.

# pip install openai-agents

import asyncio
from agents import Agent, Runner, function_tool


@function_tool
def history_fun_fact() -> str:
    """Return a surprising historical fact."""
    return "The first computer programmer, Ada Lovelace, lived in the 1800s."


agent = Agent(
    name="History Assistant",
    instructions=(
        "Answer history questions clearly and briefly. "
        "Use history_fun_fact when it is helpful."
    ),
    tools=[history_fun_fact],
)


async def main():
    result = await Runner.run(
        agent,
        "Tell me something surprising about the history of computing.",
    )
    print(result.final_output)


if __name__ == "__main__":
    asyncio.run(main())

Das SDK führt den Agenten aus, ruft bei Bedarf das History-Tool auf, gibt dessen Ergebnis ans Modell zurück und erzeugt die finale Antwort. Der komplette Lauf kann zudem im Trace-Viewer inspiziert werden.

7. Google Agent Development Kit

Googles Agent Development Kit, kurz ADK, ist ein Open-Source-Framework zum Aufbau, Testen und Deployment einzelner Agenten, toolnutzender Assistenten, Graph-Workflows und Multi-Agent-Systeme. Es harmoniert besonders gut mit Gemini-Modellen, unterstützt aber auch andere Anbieter.

ADK ist zu einem meiner Favoriten geworden, weil es einfach ist und sich natürlich mit Gemini verwenden lässt.

Ich habe damit mehrere Anwendungen ohne größere Probleme erstellt. Auch wenn ich das OpenAI Agents SDK weiterhin am einfachsten zu integrieren finde und es mir bei Steuerung und Features mehr Flexibilität bietet, ist ADK eine starke Alternative—vor allem für Gemini-basierte Anwendungen.

Das folgende Beispiel erstellt einen Event-Assistenten, der eine Python-Funktion aufrufen kann, um die Startzeit einer Veranstaltung abzurufen.

# pip install google-adk

from google.adk.agents.llm_agent import Agent


def get_event_time(city: str) -> dict:
    """Return the event starting time for a city."""
    return {
        "status": "success",
        "city": city,
        "time": "6:00 PM",
    }


root_agent = Agent(
    model="gemini-flash-latest",
    name="event_assistant",
    description="Provides information about events in different cities.",
    instruction=(
        "Answer event questions clearly. "
        "Use the get_event_time tool when the starting time is requested."
    ),
    tools=[get_event_time],
)

Der Agent nutzt die Funktion als Tool, sobald er die Startzeit für eine bestimmte Stadt abrufen muss.

8. Claude Agent SDK

Das Claude Agent SDK ist Anthropics Python- und TypeScript-Framework für autonome Agenten, basierend auf demselben Agent-Loop, den Tools und dem Kontextmanagement, die auch Claude Code antreiben. Besonders nützlich ist es für Agenten, die Dateien lesen, Code bearbeiten, Befehle ausführen, sich mit MCP-Tools verbinden und längere Aufgaben erledigen müssen.

Anthropic, OpenAI und Google verzahnen ihre Modelle eng mit den eigenen Agent-Frameworks, wodurch Tools, Sessions, Tracing und andere erweiterte Features schnell eingerichtet sind.

Das Claude Agent SDK ist jedoch speziell für Claude ausgelegt und nicht für beliebige Open-Source- oder lokal gehostete Modelle. Mehr dazu findest du in unserem Claude Agent SDK Tutorial.

Das folgende Beispiel erstellt einen Coding-Agenten, der eine Python-Datei überprüft, Fehler identifiziert und automatisch behebt.

# pip install claude-agent-sdk

import asyncio
from claude_agent_sdk import (
    AssistantMessage,
    ClaudeAgentOptions,
    ResultMessage,
    query,
)


async def main():
    async for message in query(
        prompt="Review app.py for errors that could cause crashes and fix them.",
        options=ClaudeAgentOptions(
            allowed_tools=["Read", "Edit", "Glob"],
            permission_mode="acceptEdits",
        ),
    ):
        if isinstance(message, AssistantMessage):
            for block in message.content:
                if hasattr(block, "text"):
                    print(block.text)
                elif hasattr(block, "name"):
                    print(f"Tool used: {block.name}")

        elif isinstance(message, ResultMessage):
            print(f"Completed: {message.subtype}")


if __name__ == "__main__":
    asyncio.run(main())

Das SDK führt den Agent-Loop aus, während Claude die Datei liest, die nötigen Tools auswählt, den Code editiert und den Fortschritt streamt, bis die Aufgabe abgeschlossen ist.

Multi-Agent-Orchestrierungs-Frameworks

Multi-Agent-Frameworks koordinieren mehrere spezialisierte Agenten—jeder mit einer bestimmten Rolle, einem Ziel, einem Toolset oder einer Phase in einem größeren Workflow. 

9. CrewAI

CrewAI ist ein populäres Python-Framework zum Aufbau von Multi-Agent-Teams. Entwickler können Agenten mit unterschiedlichen Rollen, Zielen und Aufgaben erstellen und sie als Crew autonom zusammenarbeiten lassen. Aufgaben können sequentiell ablaufen oder hierarchisch, wobei ein Manager koordiniert und Arbeit an die am besten geeigneten Agenten delegiert.

Das folgende Python-Beispiel erstellt einen Researcher und eine Schreibassistenz, die gemeinsam einen kurzen Bericht erstellen.

# pip install crewai
# Set OPENAI_API_KEY before running

from crewai import Agent, Crew, Process, Task

researcher = Agent(
    role="AI Researcher",
    goal="Find the key facts about {topic}",
    backstory="You research technical topics carefully.",
)

writer = Agent(
    role="Technical Writer",
    goal="Turn research into a clear summary",
    backstory="You explain complex topics simply.",
)

research_task = Task(
    description="Research {topic} and identify three key findings.",
    expected_output="Three concise findings.",
    agent=researcher,
)

writing_task = Task(
    description="Write a short summary using the research findings.",
    expected_output="A clear one-paragraph report.",
    agent=writer,
    context=[research_task],
)

crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, writing_task],
    process=Process.sequential,
)

result = crew.kickoff(inputs={"topic": "agentic AI"})
print(result.raw)

Der Researcher erledigt die erste Aufgabe, und die Schreibassistenz nutzt dessen Ergebnisse als Kontext für den finalen Bericht.

10. MetaGPT

MetaGPT ist ein Multi-Agent-Framework, das ein Softwareunternehmen mit spezialisierten Rollen wie Product Manager, Architect, Project Manager und Engineer abbildet. Diese Agenten folgen strukturierten Vorgehensweisen und verwandeln kurze Anforderungen in Pläne, technische Designs, Dokumentation und lauffähigen Code. 

Das folgende Beispiel erstellt ein Softwareteam und bittet es, einen einfachen Task-Manager für die Kommandozeile zu bauen.

# pip install metagpt
# Configure a supported LLM API before running

import asyncio

from metagpt.roles import (
    Architect,
    Engineer,
    ProductManager,
    ProjectManager,
)
from metagpt.team import Team


async def startup(idea: str):
    company = Team()

    company.hire([
        ProductManager(),
        Architect(),
        ProjectManager(),
        Engineer(),
    ])

    company.invest(investment=3.0)
    company.run_project(idea=idea)

    await company.run(n_round=5)


if __name__ == "__main__":
    asyncio.run(
        startup("Build a simple command-line task manager")
    )

Die Agenten teilen die Anforderungen gemäß ihrer Rollen auf und arbeiten zusammen, um das Softwareprojekt zu planen und zu entwickeln. 

11. AgentScope

AgentScope ist ein Python-Framework für steuerbare und beobachtbare Agenten sowie Multi-Agent-Anwendungen. Es bietet fertige Agenten, Tools, Speicher, Nachrichtenrouting, Streaming, parallele Toolaufrufe, Workflows, Tracing und menschliche Eingriffe. Mit AgentScope Studio lassen sich Agent-Ausführungen zudem inspizieren und visualisieren.

Das folgende Beispiel erstellt einen ReAct-Agenten, der Python-Code schreiben und ausführen kann, um eine Berechnung zu erledigen.

# pip install agentscope
# Set DASHSCOPE_API_KEY before running

import asyncio
import os

from agentscope.agent import ReActAgent
from agentscope.formatter import DashScopeChatFormatter
from agentscope.memory import InMemoryMemory
from agentscope.message import Msg
from agentscope.model import DashScopeChatModel
from agentscope.tool import Toolkit, execute_python_code


async def main():
    toolkit = Toolkit()
    toolkit.register_tool_function(execute_python_code)

    agent = ReActAgent(
        name="Nova",
        sys_prompt="You are a helpful Python assistant named Nova.",
        model=DashScopeChatModel(
            model_name="qwen-max",
            api_key=os.environ["DASHSCOPE_API_KEY"],
            stream=True,
        ),
        formatter=DashScopeChatFormatter(),
        toolkit=toolkit,
        memory=InMemoryMemory(),
    )

    await agent(
        Msg(
            name="user",
            content="Use Python to calculate the sum of numbers from 1 to 100.",
            role="user",
        )
    )


if __name__ == "__main__":
    asyncio.run(main())

Der Agent entscheidet sich für das Python-Ausführungs-Tool, führt den generierten Code aus und nutzt das Ergebnis für die Antwort.

12. CAMEL-AI

CAMEL-AI ist ein Open-Source-Python-Framework zum Aufbau von Agenten, Multi-Agent-Gesellschaften und Rollenspiel-Simulationen. Es ist stark forschungsorientiert und bietet Komponenten für Agenten-Kollaboration, Tools, Speicher, Retrieval, Datengenerierung und Weltsimulation. Cloud-Modelle und lokal gehostete Modelle werden über Plattformen wie Ollama, vLLM und SGLang unterstützt.

Das folgende Beispiel erstellt einen Agenten, der das Web durchsuchen kann, bevor er eine Frage beantwortet.

# pip install "camel-ai[web_tools]"
# Set OPENAI_API_KEY before running

from camel.agents import ChatAgent
from camel.models import ModelFactory
from camel.toolkits import SearchToolkit
from camel.types import ModelPlatformType, ModelType

model = ModelFactory.create(
    model_platform=ModelPlatformType.OPENAI,
    model_type=ModelType.GPT_5_5,
    model_config_dict={"temperature": 0.0},
)

agent = ChatAgent(
    system_message="You are a helpful AI research assistant.",
    model=model,
    tools=[SearchToolkit().search_duckduckgo],
)

response = agent.step(
    "What are the main uses of multi-agent AI systems?"
)

print(response.msgs[0].content)

Der Agent nutzt die DuckDuckGo-Suche, wenn aktuelle Informationen benötigt werden, und gibt anschließend die finale Antwort zurück.

Daten- und RAG-Agent-Frameworks

Diese Frameworks verbinden LLMs und Agenten mit Dokumenten, Datenbanken, APIs und anderen privaten Datenquellen, damit sie vor der Antwort relevanten Kontext abrufen können.

13. LlamaIndex

LlamaIndex ist ein Python-Framework zum Aufbau kontextbewusster Anwendungen über privaten oder domänenspezifischen Daten. Es bietet Connectoren, Indizes, Retriever, Query Engines, Agenten und Workflows für RAG, Enterprise Search und Dokumentenassistenten.

LlamaIndex gehörte zu meinen Favoriten, als ich mit RAG-Anwendungen begann. Daten laden, indexieren und abfragen ist extrem einfach, und oft ist der Code kürzer und übersichtlicher als bei einer vergleichbaren Umsetzung mit LangChain. Du kannst den LlamaIndex-Kurs besuchen, um mehr zu lernen.

Das folgende Beispiel lädt Dokumente aus einem Ordner, erstellt einen durchsuchbaren Index und beantwortet eine Frage anhand des gefundenen Kontexts.

# pip install llama-index
# Set OPENAI_API_KEY before running

from llama_index.core import SimpleDirectoryReader, VectorStoreIndex

documents = SimpleDirectoryReader("data").load_data()
index = VectorStoreIndex.from_documents(documents)

query_engine = index.as_query_engine()
response = query_engine.query(
    "What are the main findings in these documents?"
)

print(response)

LlamaIndex indiziert die Dateien im data-Ordner und ruft relevante Informationen ab, bevor die Antwort generiert wird.

14. Haystack

Haystack ist ein Open-Source-Python-Framework für produktionsreife RAG-Pipelines, semantische Suchsysteme, Agenten und datenorientierte KI-Anwendungen. Die modulare Pipeline-Struktur ermöglicht eine transparente Steuerung, wie Informationen abgerufen, in Prompts eingebettet und an ein Modell gesendet werden.

Ich habe Haystack für RAG- und Multi-Agent-Anwendungen genutzt—ohne größere Probleme. Obwohl es ein Allzweck-Framework ist, spielt es seine Stärken besonders aus, wenn LLMs mit Dokumenten, Text, Suchsystemen und anderen Datenquellen verbunden werden.

Das folgende Beispiel speichert einige Dokumente, ruft das relevanteste ab und nutzt es zur Beantwortung einer Frage.

# pip install -U haystack-ai
# Set OPENAI_API_KEY before running

from haystack import Document, Pipeline
from haystack.components.builders import ChatPromptBuilder
from haystack.components.generators.chat import (
    OpenAIResponsesChatGenerator,
)
from haystack.components.retrievers import InMemoryBM25Retriever
from haystack.dataclasses import ChatMessage
from haystack.document_stores.in_memory import InMemoryDocumentStore

document_store = InMemoryDocumentStore()
document_store.write_documents([
    Document(content="The London AI event starts at 6:00 PM."),
    Document(content="The Berlin AI event starts at 7:00 PM."),
])

template = [
    ChatMessage.from_system(
        "Answer using the following documents:\n"
        "{% for doc in documents %}{{ doc.content }}{% endfor %}"
    ),
    ChatMessage.from_user("{{ question }}"),
]

pipeline = Pipeline()
pipeline.add_component(
    "retriever",
    InMemoryBM25Retriever(document_store),
)
pipeline.add_component(
    "prompt_builder",
    ChatPromptBuilder(template=template),
)
pipeline.add_component(
    "llm",
    OpenAIResponsesChatGenerator(model="gpt-5.5"),
)

pipeline.connect("retriever", "prompt_builder.documents")
pipeline.connect("prompt_builder", "llm")

question = "When does the London AI event start?"

result = pipeline.run({
    "retriever": {"query": question},
    "prompt_builder": {"question": question},
})

print(result["llm"]["replies"][0].text)

Haystack ruft das passende Dokument ab, fügt es dem Prompt hinzu und nutzt GPT-5.5 für eine fundierte Antwort.

Schlanke Frameworks und Open-Model-Optionen

Diese Frameworks bieten einfache Abstraktionen, um Agenten mit gehosteten oder lokal laufenden Open-Source-Modellen zu bauen.

15. Hugging Face smolagents

Hugging Face smolagents ist ein schlankes Python-Framework, mit dem sich Agenten mit wenig Code erstellen lassen. Der CodeAgent agiert durch das Schreiben von Python, während der ToolCallingAgent strukturierte Toolaufrufe nutzt. Besonders gut funktioniert es mit Hugging Face Modellen, Inference Providers und lokal gehosteten Open-Source-Modellen.

Das folgende Beispiel erstellt einen Web-Suchagenten und übergibt ihn an einen Manager-Agenten, der entscheidet, wann er Recherche delegiert.

# pip install -U "smolagents[toolkit]"
# Set HF_TOKEN before running

from smolagents import (
    CodeAgent,
    InferenceClientModel,
    ToolCallingAgent,
    WebSearchTool,
)

model = InferenceClientModel(
    model_id="Qwen/Qwen3-Next-80B-A3B-Thinking"
)

web_agent = ToolCallingAgent(
    tools=[WebSearchTool()],
    model=model,
    name="web_search_agent",
    description="Searches the web and returns useful information.",
)

manager_agent = CodeAgent(
    tools=[],
    model=model,
    managed_agents=[web_agent],
)

result = manager_agent.run(
    "Who created Hugging Face, and when was it founded?"
)

print(result)

Der Manager entscheidet, wann aktuelle Informationen nötig sind, delegiert die Suche an den spezialisierten Web-Agenten und liefert anschließend die finale Antwort.

Schneller Framework-Vergleich

Die Tabelle unten vergleicht die Hauptstärken der Frameworks und den Anwendungstyp, für den sie sich am besten eignen.

Fazit

Wenn du neu in agentischer KI bist, starte mit einem offiziellen SDK wie dem OpenAI Agents SDK, Google ADK oder dem Claude Agent SDK. Sie sind eng mit den jeweiligen Modellen und APIs verzahnt, daher ist das Setup meist schnell erledigt. API-Schlüssel hinzufügen, Credits laden und loslegen.

Ich mag diese SDKs, weil sie es leicht machen, Agenten zu erstellen, Tools zu verbinden und im Nachhinein zu prüfen, was während eines Laufs passiert ist. Mit wenigen Zeilen Python kannst du einen nützlichen Agenten oder sogar ein kleines Multi-Agent-System bauen.

Brauche ich mehr Flexibilität, schaue ich in der Regel auf LangChain oder LangGraph. LangChain hilft, wenn ich viele Integrationen brauche, während LangGraph mir mehr Kontrolle über Zustand, Loops und längere Workflows gibt.

Für Agenten-Teams mit unterschiedlichen Rollen ist CrewAI eine gute Option. Für RAG, private Dokumente und datenverbundene Anwendungen würde ich LlamaIndex oder Haystack wählen.

Und smolagents ist eine gute Wahl, wenn ich etwas Schlankes, Einfaches und gut mit offenen oder lokalen Modellen Nutzbares möchte.

Mein Rat: Starte mit dem einfachsten Framework, das zu deinem Projekt passt. Baue eine kleine Version, teste sie gründlich und füge nur dann mehr Komplexität hinzu, wenn du sie wirklich brauchst.