Multi-Agent-KI-Systeme mit Agno erstellen

In der heutigen KI-Ära reicht ein einzelner Agent für viele Anwendungsfälle nicht mehr aus. Anwendungen werden täglich komplexer, und in vielen Szenarien wird ein Multi-Agent-Framework benötigt, das mehrere Aufgaben gleichzeitig verwalten kann, ohne dass dauerhaft menschliches Eingreifen erforderlich ist. Dieser Ansatz der Multi-Agent-Entwicklung kann die Effizienz deutlich steigern und wird in modernen digitalen Workflows immer wichtiger.

Solche Systeme bestehen aus mehreren KI-Agenten, die zusammenarbeiten, miteinander kommunizieren und ihre Aktionen koordinieren. Dadurch können sie Aufgaben erledigen, die für ein einzelnes Modell zu langsam, zu unzuverlässig oder zu ineffizient wären. Ein Single-Agent-Ansatz benötigt häufig mehr Zeit und kann den gesamten Ablauf verlangsamen, während ein Multi-Agent-System es ermöglicht, mehrere Bereiche parallel zu bearbeiten und verschiedene Tätigkeiten gleichzeitig auszuführen.

Multi-Agent-Architekturen arbeiten in der Regel, indem sie große Aufgaben in kleinere, besser steuerbare Teilaufgaben zerlegen. Dadurch können sie deutlich flexibler auf dynamische Umgebungen reagieren.

Wichtige Erkenntnisse

• Agno vereinfacht die Multi-Agent-Entwicklung durch ein leichtgewichtiges und gut verständliches Framework, mit dem intelligente Agenten ohne aufwendige Einrichtung erstellt, bereitgestellt und orchestriert werden können.
• Agno unterstützt multimodale Funktionen, sodass Agenten Text, Bilder, Audio, Video und Dateien verarbeiten können. Dadurch eignet sich das Framework für anspruchsvolle reale Anwendungsfälle.
• Ein optimiertes Wissensmanagement mit RAG-Unterstützung hilft Agenten dabei, genau die Informationen abzurufen, die sie benötigen. Das verbessert Genauigkeit, Effizienz und Kontextverarbeitung.
• Einsteigerfreundliche Dokumentation und klare APIs ermöglichen Entwicklern, Content-Teams und weiteren Anwendern einen schnellen Einstieg.
• Agno eignet sich besonders gut für Workflow-Automatisierung, da spezialisierte Agenten für Recherche, Zusammenfassung, Texterstellung und Bearbeitung zu einer skalierbaren Pipeline kombiniert werden können.

Beispiel: Eine Pipeline für Content-Erstellung

Stellen Sie sich einen Workflow zur Content-Erstellung vor: Ein Agent identifiziert aktuelle Themen, ein zweiter recherchiert das ausgewählte Thema, ein dritter fasst die Ergebnisse zusammen, ein vierter erstellt einen SEO-optimierten Entwurf und ein fünfter überprüft die Qualität vor der Veröffentlichung. Jeder Agent hat eine klar definierte Aufgabe. Gemeinsam können sie hochwertige Inhalte deutlich schneller und präziser erstellen als ein einzelnes System. Am Ende muss das Ergebnis nur noch geprüft werden. Genau darin liegt die Stärke gut geplanter und koordinierter Multi-Agent-Systeme.

Mit der wachsenden Nachfrage steigt auch der Bedarf an schnellerer und zuverlässigerer Agentenkoordination. Entwickler erwarten, dass Agenten Kontext intelligent teilen, doppelte Arbeit vermeiden, Fehler abfangen und insbesondere in Produktionsumgebungen in Echtzeit funktionieren. Eine schwache Koordination kann zu uneinheitlichen Ergebnissen, höherer Latenz und anfälligen Automatisierungsworkflows führen. Da KI-gestützte Produkte immer weiter zunehmen, wird eine robuste agentische Grundlage zunehmend zur Voraussetzung statt zu einer optionalen Optimierung.

Was ist Agno?

Agno ist eine sehr schnelle Plattform zum Erstellen und Ausführen von KI-Agenten. Viele Menschen gehen heute davon aus, dass KI-Integration lediglich bedeutet, eine Chatbot-API anzubinden. Reale KI-Produkte benötigen jedoch meist deutlich mehr. Häufig arbeiten mehrere Agenten zusammen, speichern Informationen, nutzen Tools, rufen Daten ab, kommunizieren mit APIs und müssen in Produktionsumgebungen zuverlässig laufen. Agno wurde entwickelt, um genau diese Aufgaben zu vereinfachen. Das Framework ist einsteigerfreundlich, leichtgewichtig und wird durch hilfreiche Dokumentation unterstützt. Wenn ein Problem auftritt, lassen sich schnell verständliche Erklärungen, Beispiele und Anleitungen finden. Agno soll den gesamten Prozess vom Lernen über die Entwicklung bis zur Bereitstellung so einfach gestalten, dass Anfänger gut starten können, während gleichzeitig leistungsfähige KI-Systeme möglich bleiben.

Agno stellt Entwicklern die Bausteine bereit, die sie für intelligente Agenten und Multi-Agent-Workflows benötigen, darunter:

• Speicher
• Wissen
• Tools
• Zustandsverwaltung
• Guardrails
• Human-in-the-loop
• Kontextkomprimierung
• mehr als 100 integrierte Toolkits und weitere Funktionen

Agno bietet Entwicklern einen vollständigen Stack für Agenten, die logisch schlussfolgern, Tools verwenden, Wissen speichern, Erinnerungen behalten und mehrstufige Aufgaben zuverlässig ausführen können. Im Kern ermöglicht Agno einem Sprachmodell, den Ablauf der Ausführung zu steuern. Das Modell entscheidet, wann es nachdenken, handeln oder antworten soll, während Anweisungen sein Verhalten definieren und Tools die Verbindung zu externen Systemen herstellen.

Agno erweitert Agenten durch leistungsstarke Funktionen wie Memory zum Abrufen früherer Interaktionen, Storage zum Erhalten des Gesprächszustands, Wissen über vektorbasierte Abfrageverfahren, auch als Agentic RAG bezeichnet, sowie Reasoning zur Analyse von Zwischenergebnissen vor der finalen Antwort.

Neben einzelnen Agenten bietet Agno außerdem übergeordnete Abstraktionen für komplexe Systeme. Dazu gehören Teams, in denen mehrere spezialisierte Agenten zusammenarbeiten, und Workflows, die Agenten und Funktionen über strukturierte und wiederholbare Schritte koordinieren. Ob Sie Ihren ersten Agenten erstellen oder vollständige Multi-Agent-Automatisierungspipelines entwickeln: Agno liefert die Werkzeuge, um diese effizient zu bauen, auszuführen und zu debuggen.

Was ist ein Agent und was ist ein Multi-Agent-System?

Ein Agent ist eine autonome Softwareeinheit, die Informationen aus ihrer Umgebung aufnimmt, Entscheidungen trifft und Aktionen ausführt, um ein bestimmtes Ziel zu erreichen. Man kann einen Agenten mit einem einzelnen Mitarbeitenden in einem Unternehmen vergleichen: Er kennt seine Aufgabe, arbeitet eigenständig und handelt ohne ständige Überwachung. In praktischen KI-Workflows kann ein Agent zum Beispiel ein Chatbot sein, der Fragen beantwortet, ein Skript zur Datenbereinigung, das fehlerhafte Zeilen korrigiert, oder ein Schreibagent, der aus Stichpunkten einen Text erstellt. Jeder Agent funktioniert besonders gut, wenn er eine klar abgegrenzte Verantwortung hat. Dadurch bleibt sein Verhalten einfacher, vorhersehbarer und leichter zu verbessern.

Ein Multi-Agent-System, auch MAS genannt, erweitert dieses Prinzip, indem mehrere Agenten kombiniert werden, die zusammenarbeiten, sich abstimmen oder miteinander kommunizieren, um komplexe Aufgaben effizienter zu lösen als ein einzelner Agent. Es ähnelt einem Team, in dem jedes Mitglied eine bestimmte Aufgabe übernimmt und gemeinsam mit den anderen auf ein größeres Ziel hinarbeitet.

In einem Workflow zur Content-Erstellung kann beispielsweise ein Agent recherchieren, ein anderer zusammenfassen, ein dritter schreiben und ein vierter redigieren. Zusammen entsteht daraus eine strukturierte und skalierbare Pipeline. Multi-Agent-Systeme sind besonders hilfreich, wenn sich Aufgaben sinnvoll in Teilaufgaben zerlegen lassen, Zusammenarbeit erforderlich ist oder Abläufe zuverlässig im größeren Maßstab ausgeführt werden müssen.

Ein einfacher Agent mit Agno

Um leistungsfähige Agenten zu erstellen, sollte man mit einem einfachen Aufbau beginnen. Starten Sie mit einem Modell, einigen wenigen wichtigen Tools und klar formulierten Anweisungen. Sobald der Basis-Agent zuverlässig funktioniert, können Sie nach und nach Memory, Wissensabruf, Workflows und Multi-Agent-Koordination ergänzen. Ziel ist es, zunächst das Kernverhalten zu überprüfen, bevor zusätzliche Komplexität hinzukommt.

Geben Sie Ihrem Agenten zu Beginn klar definierte und wertvolle Aufgaben wie Berichtserstellung, Datenextraktion, Zusammenfassung, Klassifizierung, Wissenssuche oder Dokumentenverarbeitung. Diese grundlegenden Bausteine helfen zu verstehen, wie sich der Agent im praktischen Einsatz verhält und was Nutzer tatsächlich benötigen. Darauf aufbauend lässt sich das System gezielt zu einer fortgeschritteneren Lösung weiterentwickeln.

# Import the core components from Agno
from agno.agent import Agent
from agno.models.anthropic import Claude

# 1. Create the Agent
agent = Agent(
    model=Claude(id="claude-sonnet-4-5"),   # Language model controlling execution
    instructions="You are a helpful assistant. Respond clearly and concisely."
)

# 2. Run the Agent and print response
agent.print_response("Explain what an AI agent is in simple words.")

Agentenausführung in Entwicklung und Produktion

Bei der Entwicklung eines Agenten können Sie die Methode Agent.print_response() verwenden. Diese Methode gibt die Antwort des Agenten direkt im Terminal in einem gut lesbaren Format aus.

Hinweis: Diese Methode ist nur für die Entwicklungsphase vorgesehen. In Produktionsumgebungen sollten stattdessen Agent.run() oder Agent.arun() verwendet werden.

Das Ausführen eines Agenten in Agno ist unkompliziert. Sie rufen Agent.run() oder für asynchrone Ausführung Agent.arun() auf, und das Framework übernimmt die Verarbeitung im Hintergrund. Jeder Durchlauf beginnt damit, dass Agno den vollständigen Kontext zusammenstellt. Dazu gehören Systemnachrichten, Nutzereingaben, Chatverlauf, Memory und Sitzungszustand, bevor alles an das Modell gesendet wird.

Das Modell kann entweder eine direkte Antwort oder einen Tool-Aufruf zurückgeben. Wird ein Tool aufgerufen, führt Agno dieses aus und setzt den Ablauf fort, bis das Modell eine finale Antwort erzeugt. Das Ergebnis wird als RunOutput-Objekt zurückgegeben und enthält Inhalte, Metadaten, Nachrichten, Reasoning-Traces und Metriken.

Eingaben können in verschiedenen Formaten übergeben werden, darunter Strings, Listen, Dictionaries und Pydantic-Modelle. Agno unterstützt sowohl synchrone als auch Streaming-Ausführung. Mit stream=True lassen sich Antwortbestandteile bereits während der Generierung empfangen. Mit stream_events=True werden interne Reasoning-Schritte, Tool-Aufrufe und Memory-Aktualisierungen sichtbar, was eine umfassende Beobachtbarkeit ermöglicht.

Dadurch wird es einfacher, Agenten zu debuggen, zu überwachen oder interaktive Benutzeroberflächen um sie herum zu entwickeln. Ob ein einfacher Bericht erzeugt oder eine komplexe toolbasierte Operation koordiniert wird: Die Run-Schleife von Agno bietet ein flexibles und gut vorhersehbares Ausführungsmodell.

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

# You can set the debug mode on the agent for all runs to have more verbose output

agent = Agent(
    model=OpenAIChat(id="gpt-5-mini"),
    tools=[DuckDuckGoTools()],
    instructions="Search the web and give a short, factual answer.",
    markdown=True,
    debug_mode=True,
)

agent.print_response("Latest breakthroughs in quantum computing?")

In diesem Beispiel erhält der Agent Zugriff auf das DuckDuckGoTools-Toolkit. Dadurch kann er im Web suchen und aktuelle Informationen abrufen.

Je nach Anforderung kann ein Agent mit Debug-Modus, spezifischen Anweisungen oder Tools erstellt werden. Für weitere Details ist es hilfreich, die Agno-Dokumentation zu lesen, die im Ressourcenbereich erwähnt wird.

Zu den wichtigen Funktionen gehört unter anderem das Erstellen von Agno-Agenten mit:

• Storage
• Memory
• Knowledge

Das folgende Beispiel zeigt einen Health-&-Fitness-Agenten mit persistentem Speicher.

Health-&-Fitness-Assistent

Mit Agno können leistungsfähige Agenten erstellt werden, die mehrere Komponenten kombinieren:

• Eine vektorbasierte Wissensdatenbank, zum Beispiel PDFs, Leitfäden und kuratierte Inhalte
• SQLite-Speicher für langfristige Erinnerung
• Websuch-Tools für aktuelle Informationen
• OpenAI-Modelle für natürlichsprachliche Intelligenz

In diesem Beispiel unterstützt ein Health-&-Fitness-Agent Nutzer dabei, Ernährung, Trainingsplanung und gesunde Gewohnheiten besser zu verstehen. Durch persistenten Speicher kann sich der Agent an frühere Fitnessziele erinnern, vorherige Fragen nachverfolgen und im Laufe der Zeit individuellere Hinweise geben. Mögliche Beispiel-Prompts sind:

• „Give me a 20-minute full-body workout routine.”
• „What is the difference between HIIT and steady-state cardio?”
• „Explain macros in simple terms.”
• „What did I ask you last time about sleep?”
• „Summarize my earlier questions about nutrition.”
• „How much protein do vegans need?”

from textwrap import dedent
from typing import Optional, List

import typer
from rich import print
from agno.agent import Agent
from agno.db.sqlite import SqliteDb
from agno.db.base import SessionType
from agno.session import AgentSession
from agno.knowledge.knowledge import Knowledge
from agno.knowledge.embedder.openai import OpenAIEmbedder
from agno.vectordb.lancedb import LanceDb, SearchType
from agno.models.openai import OpenAIChat
from agno.tools.duckduckgo import DuckDuckGoTools

# --------- Setup Health & Fitness Knowledge Base ---------
fitness_knowledge = Knowledge(
    vector_db=LanceDb(
        uri="tmp/fitness_lancedb",
        table_name="fitness_knowledge",
        search_type=SearchType.hybrid,
        embedder=OpenAIEmbedder(id="text-embedding-3-small")
    )
)

# Add a well-structured PDF containing fitness fundamentals
fitness_knowledge.add_content(
    url="https://health/FitnessBasics.pdf"
)

# --------- Setup Database for persistent sessions ---------
db = SqliteDb(db_file="tmp/fitness_agent.db")


def fitness_agent(user: str = "user"):
    session_id: Optional[str] = None

    # Ask the user whether they want a new or existing session
    start_new = typer.confirm("Start a new fitness session?")

    if not start_new:
        previous_sessions: List[AgentSession] = db.get_sessions(
            user_id=user,
            session_type=SessionType.AGENT
        )
        if len(previous_sessions) > 0:
            session_id = previous_sessions[0].session_id

    # --------- Create Fitness Agent ---------
    agent = Agent(
        user_id=user,
        session_id=session_id,
        model=OpenAIChat(id="gpt-5-mini"),
        instructions=dedent("""\
            You are a friendly Health & Fitness Assistant dedicated to helping users
            understand nutrition, exercise, and healthy living.

            How you respond:
            1. Always check the fitness knowledge base first.
            2. If information is missing or needs updates, perform a web search.
            3. Provide clear, actionable guidance with structured steps.
            4. Avoid overly technical terms—use simple explanations.
            5. Keep your tone motivating, encouraging, and non-judgmental.

            You can:
            - Explain workouts (strength, cardio, flexibility, mobility)
            - Provide short actionable routines
            - Clarify nutrition basics (macros, calories, protein needs)
            - Offer general wellness advice (sleep habits, hydration)
            - Summarize/chat history when asked
            - Retrieve past discussions using stored session memory

            Safety rules:
            - Do NOT give medical diagnoses.
            - Avoid personalized medical or therapeutic advice.
            - Offer general wellness guidance only.
        """),
        db=db,
        knowledge=fitness_knowledge,
        tools=[DuckDuckGoTools()],
        read_chat_history=True,
        markdown=True,
    )

    # --------- Run Agent in CLI ---------
    print("[bold cyan]Your Health & Fitness Assistant is ready![/bold cyan]")
    if session_id is None:
        print("Started a new session.\n")
    else:
        print(f"Continuing previous session: {session_id}\n")

    agent.cli_app(markdown=True)


if __name__ == "__main__":
    typer.run(fitness_agent)

Agno Teams

Agno Teams ermöglicht den Aufbau autonomer Multi-Agent-Systeme, in denen mehrere Agenten oder sogar verschachtelte Unterteams gemeinsam komplexe Aufgaben bearbeiten. Ein Team funktioniert wie eine Baumstruktur: Die Teamleitung verteilt Aufgaben an Unterteams oder einzelne Agenten.

Eine Teamleitung delegiert Aufgaben auf Grundlage der jeweiligen Rollen der Mitglieder und der Anforderungen der Aufgabe. Teams übernehmen dieselben zentralen Funktionen wie Agenten, darunter Modellkonfiguration, Anweisungen, datenbankgestützte Sitzungshistorie, Reasoning, Wissenszugriff, Memory und Tool-Nutzung.

Teams sollten eingesetzt werden, wenn Aufgaben komplex sind, mehrere Tools erfordern oder aus vielen Schritten bestehen. Sie sind besonders nützlich, wenn das Kontextfenster eines einzelnen Agenten überlastet wäre. Die Aufteilung von Arbeitspaketen auf fokussierte Einzelagenten sorgt dafür, dass der Kontext jedes Agenten kleiner und effizienter bleibt.

from agno.team import Team
from agno.agent import Agent
team = Team(
    members=[
        Agent(
            name="Research Agent",
            role="You gather factual information and provide structured research summaries."
        ),
        Agent(
            name="Editing Agent",
            role="You refine writing, fix grammar, and improve clarity and tone."
        ),
        Team(
            name="Creative Team",
            role="You coordinate creative tasks such as brainstorming and drafting content.",
            members=[
                Agent(
                    name="Idea Agent",
                    role="You generate ideas, outlines, and creative directions."
                ),
                Agent(
                    name="Drafting Agent",
                    role="You write initial drafts based on ideas and research."
                ),
            ]
        ),
    ]
)

Agno Workflows

Agno Workflows helfen dabei, vorhersehbare Schritt-für-Schritt-Automatisierungen für Multi-Agent-Systeme zu entwickeln.

Statt Agenten völlig frei interagieren zu lassen, ordnen Workflows Agenten, Teams und Funktionen in einer festen Reihenfolge an. Jeder Schritt erledigt einen Teil der Aufgabe, übergibt sein Ergebnis an den nächsten Schritt und erzeugt gemeinsam mit den anderen Schritten eine zuverlässige und wiederholbare Pipeline, vergleichbar mit einer Fertigungslinie für komplexe Arbeit.

from agno.agent import Agent
from agno.workflow import Workflow

# Define agents with specific roles
designer = Agent(
    name="System Designer",
    instructions="Plan the structure of a simple Python program and describe its components clearly."
)

coder = Agent(
    name="Coder",
    instructions="Write clean, well-documented Python code based on the system design."
)

tester = Agent(
    name="Tester",
    instructions="Review the code, identify bugs or edge cases, and suggest improvements."
)

# Build the workflow
dev_workflow = Workflow(
    name="Software Development Workflow",
    steps=[designer, coder, tester]
)

# Run the workflow
dev_workflow.print_response(
    "Create a small Python script that fetches weather data from an API and prints it neatly.",
    stream=True
)

Dieses Beispiel zeigt, wie Agno Workflows eine mehrstufige Programmieraufgabe automatisieren können. In diesem Workflow übernimmt jeder Agent einen bestimmten Teil des Softwareentwicklungsprozesses: die Planung der Lösung, das Schreiben des Codes und das Testen. Der Workflow koordiniert diese Schritte in der richtigen Reihenfolge und unterstützt so ein sauberes und zuverlässiges Ergebnis.

Agno Workflows ermöglichen es, Agenten und Teams durch eine kontrollierte Abfolge von Schritten zu orchestrieren. Die Workflow-Klasse verwaltet den gesamten Ausführungsablauf, während jeder Step eine einzelne Arbeitseinheit darstellt, die von einem Agenten, einem Team oder einer Funktion ausgeführt wird. Workflows können mit Konstrukten wie Loop für Wiederholungen, Parallel für gleichzeitige Ausführung, Condition für bedingte Logik und Router für Verzweigungen erweitert werden. Dadurch lassen sich flexible, wartbare und produktionsreife Automatisierungspipelines gestalten.

Context Engineering

Context Engineering beschreibt die Praxis, Informationen für Sprachmodelle bewusst zu entwerfen, zu strukturieren und zu steuern, damit sie sich wie gewünscht verhalten. Im Kern geht es um eine einfache Frage:

„Welche Informationen führen am effektivsten zu dem Ergebnis, das ich benötige?“ In Agno betrifft dies vor allem die Erstellung der Systemnachricht. Diese bildet den grundlegenden Kontext, der Rolle, Persönlichkeit, Einschränkungen und Fähigkeiten eines Agenten oder Teams definiert. Durch sorgfältiges Gestalten dieses Kontexts können Sie:

• Agenten und Teams auf bestimmte Verhaltensweisen oder Fachbereiche ausrichten.
• einschränken oder erweitern, was ein Agent tun darf.
• konsistente, zuverlässige und anwendungsbezogene Ausgaben erzeugen.
• komplexe Workflows ermöglichen, etwa mehrstufiges Reasoning, Tool-Nutzung und strukturierte Antworten.

Context Engineering ist ein iterativer Prozess. Dabei werden Anweisungen verfeinert, Agentenbeschreibungen getestet, Schemata angepasst und Delegation oder Tools genutzt, bis das Verhalten dem gewünschten Ziel entspricht.

Woraus besteht der Kontext eines Agenten?

Agno-Agenten erstellen ihren vollständigen Kontext aus mehreren Bestandteilen:

• Systemnachricht: Der zentrale Prompt mit Anweisungen, Agentenbeschreibungen, Rollen und zusätzlichem Kontext.
• Nutzernachricht: Die neueste Frage oder Aufgabe des Nutzers.
• Chatverlauf: Die laufende Unterhaltung, die Kontinuität und Erinnerung unterstützt.
• Zusätzliche Eingaben: Few-Shot-Beispiele, Referenzdaten oder ergänzende Anweisungen.

Zusammen liefern diese Elemente dem Modell die notwendigen Informationen, um präzise und zielgerichtete Antworten zu erzeugen.

Context Caching

Viele Modellanbieter bieten Prompt-Caching an. Dabei können statische Teile von System- oder Nutzernachrichten gespeichert und wiederverwendet werden. Das senkt Kosten und verbessert die Antwortgeschwindigkeit, insbesondere wenn dieselben Anweisungen oder Rollenbeschreibungen wiederholt genutzt werden.

Agno ermöglicht es, Kontext so zu strukturieren, dass wiederverwendbare oder statische Inhalte möglichst früh in der Systemnachricht stehen. Dadurch können Anbieter diese Inhalte leichter zwischenspeichern. Wenn mehr Kontrolle erforderlich ist, kann die Systemnachricht manuell definiert werden, um das Caching weiter zu optimieren.

Beispiele für Einsatzmöglichkeiten von Prompt-Caching sind:

• Zwischenspeichern einer ausführlichen Agentenpersona oder von Anweisungen für wiederkehrende Aufgaben.
• Speichern wiederverwendbarer Few-Shot-Beispiele für strukturierte Ausgaben.
• Wiederverwenden gemeinsamer Workflow-Anweisungen über mehrere Schritte oder Agenten hinweg.

Im Kern setzt sich der Kontext eines Agenten aus folgenden Elementen zusammen:

• System Message: Rolle, Anweisungen, Metadaten, Zusatzinformationen, Beispiele und optional Memory oder Zustand.
• User Message: Der Inhalt, den der Nutzer an run() oder print_response() übergibt, optional erweitert um Wissensdatenbank-Referenzen oder Dependency Injections.
• Optionale Kontext-Erweiterungen: Chatverlauf, Few-Shot-Beispiele, Tool-Anweisungen, Erinnerungen oder eigene Systemnachrichten.

Agno erlaubt es, jede dieser Ebenen über einfache Parameter anzupassen. Dadurch werden Agenten vorhersehbarer, besser steuerbar und enger auf ihre Aufgaben ausgerichtet.

Systemnachrichten automatisch erstellen

Agno kann eine Systemnachricht automatisch aus den angegebenen Parametern zusammensetzen. Dazu gehören zum Beispiel Rolle, Anweisungen, additional_context, Metadaten wie Zeit oder Standort sowie Memory oder Zustand.

Beispiel: Ein Planungsagent mit automatischen Kontext-Erweiterungen

from agno.agent import Agent

planner = Agent(
    name="Trip Planner",
    role="Planning Assistant",
    description="You help users plan efficient and budget-friendly travel itineraries.",
    instructions=[
        "Always ask 2 clarifying questions before suggesting an itinerary.",
        "Keep responses concise unless the user asks for detail."
    ],
    expected_output="Provide output in a sectioned format with headers.",
    additional_context="""
    Example format:
    - Destination
    - Budget
    - Suggested Itinerary
    """,
    add_datetime_to_context=True,
    add_location_to_context=True,
    add_name_to_context=True,
)

planner.print_response("Plan me a 3-day trip to Singapore.")

Context Engineering in Agno gibt Kontrolle über:

• das, was das Modell sieht
• die Art, wie es sich verhält
• die Konsistenz seiner Ergebnisse
• den effizienten Einsatz von Tokens

Durch die Kombination von Systemnachrichten, Erinnerungen, Tool-Anweisungen, Few-Shot-Beispielen und nutzererweiterten Nachrichten können Agenten entstehen, die zuverlässig, kontextbezogen und auf bestimmte Fachbereiche spezialisiert sind.

Knowledge

Das Knowledge-System von Agno basiert auf Retrieval-Augmented Generation, kurz RAG. Statt Prompts mit zu vielen Informationen zu überladen, werden Inhalte in einer durchsuchbaren Wissensdatenbank gespeichert. Agenten rufen automatisch nur die Informationen ab, die sie wirklich benötigen. Dadurch werden Antworten genauer, skalierbarer und effizienter.

Die Knowledge-Pipeline in 3 Schritten

• Store: Inhalte verarbeiten und indexieren. Agno liest Dateien, zerlegt sie in Chunks, zum Beispiel feste, semantische oder rekursive Abschnitte, wandelt sie in Embeddings um und speichert sie in einer Vektordatenbank.
• Search: Relevante Informationen abrufen. Wenn ein Nutzer eine Frage stellt, durchsucht der Agent die Wissensdatenbank per semantischer Suche, um die passendsten Chunks zu finden.
• Generate: Präzise Antworten erzeugen. Der abgerufene Kontext und die Nutzerfrage werden kombiniert, um fundierte und quellenbezogene Antworten zu erstellen.

Warum semantische Suche funktioniert

Agno kann Text in numerische Repräsentationen umwandeln, bei denen ähnliche Bedeutungen nah beieinander liegen. So können beispielsweise „refund policy“ und „return guidelines“ als verwandt erkannt werden, auch wenn sie nicht dieselben Schlüsselwörter enthalten.

Knowledge einrichten

from agno.knowledge.knowledge import Knowledge
from agno.vectordb.pgvector import PgVector
from agno.knowledge.reader.pdf_reader import PDFReader
from agno.knowledge.chunking.semantic import SemanticChunking
from agno.agent import Agent

# 1. Vector DB + embeddings
vector_db = PgVector(
    table_name="company_knowledge",
    db_url="postgresql://user:pass@localhost:5432/db"
)

# 2. Create a knowledge base
knowledge = Knowledge(
    name="Company Docs",
    vector_db=vector_db,
    max_results=5,
)

# 3. Add content with semantic chunking
knowledge.add_content(
    path="employee_handbook.pdf",
    reader=PDFReader(
        chunking_strategy=SemanticChunking(chunk_size=1000)
    ),
    metadata={"type": "policy", "department": "hr"}
)

# 4. Agent with automatic knowledge search
agent = Agent(
    knowledge=knowledge,
    search_knowledge=True  # agent decides when to search
)

print(agent.run("How many vacation days do I get?"))

Guardrails

Guardrails sind integrierte Sicherheitsprüfungen, die ausgeführt werden, bevor ein Agent Nutzereingaben verarbeitet. Man kann sie als Kontrollpunkte verstehen, die unsichere, schädliche oder unerwünschte Inhalte filtern oder blockieren, bevor sie das LLM erreichen.

Sie funktionieren, indem sie:

• die Eingabe prüfen,
• unsichere oder unerwünschte Muster erkennen,
• die Eingabe entweder bereinigen oder die Anfrage mit einem Fehler stoppen.

Guardrails helfen dabei, typische Risiken in LLM-gestützten Anwendungen zu reduzieren:

• PII-Erkennung: Blockiert personenbezogene Daten wie Telefonnummern, E-Mail-Adressen, Kreditkartendaten und ähnliche Informationen.
• Schutz vor Prompt Injection: Verhindert, dass Nutzer Systemanweisungen umgehen.
• Jailbreak-Prävention: Blockiert Versuche, das LLM zu unsicherem Verhalten zu verleiten.
• Schutz vor Datenabfluss: Hilft dabei, die versehentliche Offenlegung sensibler interner Inhalte zu vermeiden.
• Filterung von NSFW- oder schädlichen Inhalten

Integrierte Guardrails von Agno verwenden

Agno enthält mehrere Guardrails, die direkt eingesetzt werden können:

• PIIDetection Guardrail
• PromptInjection Guardrail
• OpenAIModeration Guardrail

Die Verwendung eines Guardrails ist einfach. Er wird beim Erstellen eines Agenten über pre_hooks übergeben.

Beispiel: PII Detection Guardrail

from agno.guardrails import PIIDetectionGuardrail
from agno.agent import Agent
from agno.models.openai import OpenAIChat

agent = Agent(
    name="Privacy-Protected Agent",
    model=OpenAIChat(id="gpt-5-mini"),
    pre_hooks=[PIIDetectionGuardrail()],  # Add guardrail here
)

# If input contains PII, an error will be raised
result = agent.run("My number is 9876543210")

Eigene Guardrails erstellen

Wenn die integrierten Guardrails nicht ausreichen, können eigene Guardrails erstellt werden. Dafür wird BaseGuardrail erweitert und Folgendes implementiert:

• check() – synchrone Logik
• async_check() – asynchrone Logik

Wenn die Prüfung fehlschlägt, muss ein InputCheckError ausgelöst werden.

Beispiel für einen eigenen Guardrail: Beleidigende Wörter blockieren

Dieser Guardrail überprüft Nutzereingaben auf beleidigende oder unangemessene Wörter und blockiert die Nachricht, bevor sie das LLM erreicht.

Das ist nützlich für:

• das Verhindern toxischer Interaktionen
• die Moderation von Chatbots
• saubere und regelkonforme Unternehmensanwendungen

Eigener Guardrail: BadWordsGuardrail

from agno.guardrails import BaseGuardrail
from agno.exceptions import InputCheckError, CheckTrigger
from agno.run.agent import RunInput

class BadWordsGuardrail(BaseGuardrail):
    """Guardrail to block offensive or forbidden words."""

    # A simple list of offensive or banned words
    forbidden_words = {"stupid", "idiot", "dumb", "nonsense"}

    def check(self, run_input: RunInput) -> None:
        """Sync check for forbidden words."""
        if isinstance(run_input.input_content, str):
            words = run_input.input_content.lower().split()
            if any(word in self.forbidden_words for word in words):
                raise InputCheckError(
                    "Your message contains forbidden or offensive language.",
                    check_trigger=CheckTrigger.INPUT_NOT_ALLOWED,
                )

    async def async_check(self, run_input: RunInput) -> None:
        """Async version of the same check."""
        if isinstance(run_input.input_content, str):
            words = run_input.input_content.lower().split()
            if any(word in self.forbidden_words for word in words):
                raise InputCheckError(
                    "Your message contains forbidden or offensive language.",
                    check_trigger=CheckTrigger.INPUT_NOT_ALLOWED,
                )

Diesen eigenen Guardrail in einem Agno-Agenten verwenden

from agno.agent import Agent
from agno.models.openai import OpenAIChat
agent = Agent(
    name="Polite Chatbot",
    model=OpenAIChat(id="gpt-5-mini"),
    pre_hooks=[BadWordsGuardrail()],  # Add the custom guardrail
)

# This will raise an InputCheckError
agent.run("You are so stupid!")

# This will be allowed
response = agent.run("Can you help me with Python?")
print(response)

Multimodale Agenten

Multimodale Agenten sind KI-Agenten, die verschiedene Medientypen verstehen und erzeugen können, nicht nur Text. Sie können unter anderem Folgendes unterstützen:

• Text
• Bilder
• Audio
• Video
• Dateien / Dokumente

Das bedeutet, dass ein Agent Folgendes leisten kann:

• Bilder beschreiben oder analysieren
• Audio transkribieren und verstehen
• Videosequenzen interpretieren
• PDF-, CSV- oder JSON-Dateien lesen
• Bild- oder Audioantworten erzeugen

Multimodale Agenten ermöglichen leistungsstarke Anwendungsfälle, darunter:

• visuelle Frage-Antwort-Szenarien
• Speech-to-Text- und Text-to-Speech-Anwendungen
• Videoanalyse
• Generierung von Produktbeschreibungen aus Bildern
• Dokumentenzusammenfassung

Agno vereinfacht multimodale Workflows, indem Medienobjekte wie Image, Audio, Video und File direkt an die Methoden .run() oder .print_response() eines Agenten übergeben werden können.

Agno-Agenten unterstützen multimodale Eingaben und Ausgaben nur dann, wenn das zugrunde liegende Modell diese Funktionen ebenfalls unterstützt.

Für vollständige Details ist ein Blick in die Dokumentation sinnvoll.

Der grundlegende Ablauf ist:

• Ein Modell mit multimodaler Unterstützung auswählen
• Medieneingaben über Agno-Medienklassen bereitstellen
• Text-, Bild- oder Audioausgaben empfangen

Anwendungsfall: Fragen zu einem Bild stellen.

from agno.agent import Agent
from agno.media import Image
from agno.models.openai import OpenAIChat

agent = Agent(
    model=OpenAIChat(id="gpt-5-mini"),
    markdown=True,
)

image = Image(
    url="https://upload.wikimedia.org/wikipedia/commons/5/5f/Great_Pyramid_of_Giza.jpg"
)

agent.print_response(
    "Describe this landmark and tell me its historical importance.",
    images=[image]
)

Best Practices für die Nutzung von Agno

Agno unterstützt Entwickler beim Erstellen intelligenter Agenten und gewinnt in der Entwickler-Community zunehmend an Bedeutung. Dieser Artikel stellt nur eine Auswahl der Funktionen vor, denn es gibt noch viele weitere Möglichkeiten. Die folgenden Vorgehensweisen helfen dabei, bessere Agenten mit diesem Framework zu entwickeln.

Das passende Modell für den jeweiligen Anwendungsfall wählen

Unterschiedliche Modelle unterstützen unterschiedliche Fähigkeiten, und je nach Anwendungsfall können einige Modelle besser funktionieren als andere. Deshalb ist es wichtig, verschiedene Modelle für verschiedene Szenarien zu testen. Die passende Modellauswahl kann außerdem Latenz reduzieren und Genauigkeit verbessern.

Verschiedene Modelle unterstützen unterschiedliche Funktionen:

• multimodale Eingaben wie Bilder, Audio oder Video
• Tool Calling
• strukturierte Ausgaben
• schnelle Inferenz im Vergleich zu tieferem Reasoning

Best Practices für die Modellauswahl:

• GPT-5 Mini oder Llama 3.2 für leichtgewichtiges Reasoning verwenden.
• GPT-5, Gemini 2.0 oder Claude 3.7 für anspruchsvollere Reasoning-Aufgaben einsetzen.
• Audio- oder videofähige Modelle nutzen, wenn multimodale Agenten entwickelt werden.

Rollen, Anweisungen und Beschreibungen von Agenten klar halten

Unklare oder schlecht formulierte Anweisungen können zu unvorhersehbarem Verhalten führen. Strukturierte Anweisungen verbessern dagegen Konsistenz und Zuverlässigkeit.

Best Practices für Agentenanweisungen:

• Eine eindeutige Rolle definieren, zum Beispiel „You are a financial analysis assistant“.
• Anweisungen ergänzen, die das Ausgabeformat festlegen.
• Anweisungen ergänzen, die den Ton definieren.
• Anweisungen ergänzen, die Einschränkungen beschreiben.
• Anweisungen ergänzen, die Regeln für die Tool-Nutzung festlegen.
• Zu lange oder übermäßig komplexe System-Prompts vermeiden.

Tools gezielt verwenden und ihren Zweck klar definieren

Tools erweitern die Fähigkeiten eines Agenten, etwa durch Browsing, Bildgenerierung, Codeausführung oder Suche. Zu viele Tools können jedoch dazu führen, dass der Agent das falsche Tool auswählt oder unnötige Aktionen ausführt.

Best Practices für Tools:

• Nur wirklich benötigte Tools anbinden, um Tool-Verwirrung zu vermeiden.
• Beschreiben, wann und warum jedes Tool verwendet werden soll.

Agenten als modulare Einheiten entwerfen

Statt einen einzigen großen Agenten zu erstellen:

• Das System in spezialisierte Agenten aufteilen
• Diese mit Teams kombinieren
• Getrennte Rollen wie Klassifizierer, Rechercheur, Autor, Prüfer, Ausführer und weitere zuweisen

Ein modularer Aufbau verbessert die Wartbarkeit und unterstützt qualitativ hochwertigere Ergebnisse.

Die Wissensdatenbank sauber halten und indexieren

Das integrierte Knowledge-System von Agno verbessert den Kontextabruf. Dieser Prozess trägt dazu bei, die Abrufgenauigkeit und Relevanz der Antworten zu erhöhen.

Best Practices für die Wissensdatenbank:

• Die RAG-Pipeline mit Speichern, Chunking und Indexierung korrekt nutzen.
• Große Dokumente vermeiden, die nicht in Chunks aufgeteilt sind.
• Indizes aktualisieren, wenn sich Daten ändern.
• Zusammengehörige Dokumente unter passenden Namespaces gruppieren.

Guardrails für Sicherheit und Eingabevalidierung verwenden

Guardrails verhindern, dass unsichere oder unerwünschte Eingaben den Agenten erreichen. Sie schützen außerdem vor Prompt Injection, dem Abfluss sensibler Daten und schädlichen Inhalten.

Empfohlene Maßnahmen:

Integrierte Guardrails sollten immer ergänzt werden, zum Beispiel:

• PIIDetectionGuardrail
• PromptInjectionGuardrail
• OpenAIModerationGuardrail

Für domänenspezifische Prüfungen können eigene Guardrails erstellt werden, etwa für URL-Blockierung, Profanity-Filtering oder Metadatenvalidierung.

Guardrails werden über den Parameter pre_hooks eingebunden.

In Produktion immer Fehlerbehandlung implementieren

Agenten arbeiten probabilistisch, deshalb können Fehler auftreten.

Best Practices für Fehlerbehandlung:

• try/except um .run()-Aufrufe verwenden.
• InputCheckError abfangen, wenn Guardrails genutzt werden.
• Tool-Ausgaben validieren, bevor sie weiterverarbeitet werden.
• Fehler für das Debugging protokollieren.

Das Verhalten von Agenten gründlich testen

Vor der Bereitstellung:

• Jeden Tool-Pfad testen.
• Guardrail-Auslöser überprüfen.
• Auf Halluzinationen prüfen.
• JSON- oder strukturierte Ausgabeformate validieren.
• Die Performance mit realen Workloads messen.

Zusammen helfen diese Prüfungen dabei, bessere multimodale und Multi-Agent-KI-Systeme zu entwickeln, die produktionsreif und einfacher zu warten sind.

FAQs

Was ist Agno?

Agno ist ein schnelles und leichtgewichtiges Multi-Agent-Framework, das Entwicklern hilft, intelligente agentische Systeme einfacher zu erstellen, auszuführen und zu verwalten. Es bietet Funktionen für Koordination, Workflows, Memory, Wissensabruf und multimodale Fähigkeiten.

Ist Agno für Anfänger geeignet?

Ja. Agno wurde einsteigerfreundlich konzipiert und bietet klare Abstraktionen, einfache APIs und eine gute Dokumentation. Dadurch können Einsteiger schnell agentische Anwendungen erstellen und testen.

Was unterscheidet Agno von anderen Agenten-Frameworks?

Agno bietet einen All-in-One-Stack, der Framework, Runtime und Control Plane mit hoher Performance und multimodaler Unterstützung verbindet. Dadurch werden Entwicklung und produktiver Einsatz vereinfacht, ohne auf Flexibilität zu verzichten.

Kann Agno mit externen Tools und APIs integriert werden?

Ja. Agno ist darauf ausgelegt, sich mit externen APIs, Datenbanken, Vektorspeichern und Modellanbietern zu verbinden. Damit eignet es sich für reale Produktionsworkflows und Automatisierungsaufgaben.

Unterstützt Agno multimodale Eingaben wie Bilder, Audio oder Dateien?

Ja. Agno bietet multimodale Funktionen, mit denen Agenten Text, Bilder, Audio, Videos und Dokumente verarbeiten können. Dadurch werden anspruchsvolle Anwendungsfälle wie KI-Assistenten, Analysewerkzeuge und Medienworkflows möglich.

Fazit

Agno vereinfacht die Entwicklung leistungsfähiger, zuverlässiger und produktionsreifer KI-Agenten. Dank seiner modularen Architektur, integrierter Guardrails, multimodaler Fähigkeiten sowie der umfassenden Unterstützung für Tools und Agententeams können Entwickler weit über einfache Chat-Anwendungen hinausgehen und vollständige intelligente Systeme erstellen.

Auf den ersten Blick mag Agno komplex wirken, doch die Dokumentation bietet einen guten Einstieg und enthält zahlreiche hilfreiche Informationen zum Erstellen, Entwickeln und Skalieren agentischer Anwendungen. Agno ist leichtgewichtig, einsteigerfreundlich und eignet sich als zukunftssichere Grundlage für die nächste Generation von KI-Anwendungen.

Dieser Artikel hat lediglich die wichtigsten Funktionen von Agno vorgestellt. Es gibt jedoch noch viele weitere Möglichkeiten zu entdecken.