# Wir stellen WebAgents vor (/docs/de/posts/announcing-webagents-opensource)







# WebAgents: das Open-Source-Framework für die Orchestrierung von KI-Agenten im gesamten Internet [#webagents-das-open-source-framework-für-die-orchestrierung-von-ki-agenten-im-gesamten-internet]

<video autoplay muted>
<source src="/docs/assets/Intro.mov" type="video/mp4">
</video>

Die Landschaft der KI-Agenten explodiert, aber es gibt ein grundlegendes Problem: Agenten können nicht miteinander sprechen. Frameworks wie LangChain, AutoGen und CrewAI haben es einfacher gemacht, einzelne Agenten zu bauen, doch sie haben uns ein zersplittertes Ökosystem hinterlassen, in dem jeder Agent eine isolierte Insel ist. Heute stellen wir **WebAgents** als Open Source bereit: ein Framework, um KI-Agenten zu bauen, die gleichzeitig Webdienste und intelligente Teilnehmer in einem gemeinsamen Netzwerk sind. Ein WebAgent findet andere Agenten, gibt Arbeit ab, nimmt Anfragen von jedem an und erzielt Umsatz, alles ohne manuelle Integration. WebAgents ermöglicht Abläufe in Echtzeit und agentische Marktplätze in vielen Branchen wie Waren, Dienstleistungen, Jobs, Immobilien, Gaming oder Medien.

<!-- more -->

## Das Problem der Zersplitterung [#das-problem-der-zersplitterung]

Der heutige Zustand der KI-Agenten gleicht den Zahlungssystemen vor Stripe: Jedes Unternehmen baut dieselbe Infrastruktur von Null auf. Teams bauen leistungsfähige Agenten, aber jeder davon arbeitet isoliert. Du willst, dass dein Kundenservice-Agent einen spezialisierten Agenten für Datenanalyse hinzuzieht? Dann musst du eigene Integrationen bauen, API-Schlüssel verwalten, Authentifizierung erledigen und herausfinden, wie du Anfragen weiterleitest. Und das für jede neue Integration erneut.

Beliebte Frameworks haben sich darauf konzentriert, Werkzeuge innerhalb eines einzelnen Agenten zu orchestrieren oder vorher festgelegte Agententeams zu koordinieren. LangChain ist stark bei Funktionsaufrufen und Ketten, AutoGen ermöglicht Gespräche zwischen mehreren Agenten, und CrewAI orchestriert Teams von Agenten, die gemeinsam an Aufgaben arbeiten. Das sind mächtige Werkzeuge für ihre Anwendungsfälle, aber sie arbeiten innerhalb geschlossener Systeme. Sie liefern keine Infrastruktur, damit Agenten Agenten finden, ihnen vertrauen und mit ihnen handeln können, die sie noch nie getroffen haben.

Jedes Entwicklungsteam baut am Ende dieselben Rohre neu: Dienstsuche, Authentifizierungsprotokolle, Zahlungswege und Übergabemechanismen. Das ist verschwendete Mühe, die in einzigartige Fähigkeiten fließen könnte.

## Das Open-Source-Framework WebAgents [#das-open-source-framework-webagents]

WebAgents erlaubt Agenten, Aufgaben über eine universelle Schnittstelle in natürlicher Sprache an andere Agenten abzugeben, ohne vorherige Integration. Statt fest verdrahteter API-Aufrufe beschreiben Agenten in klarer Sprache, was sie brauchen, und das System findet in Echtzeit fähige Agenten über den Abgleich von Absichten.

Das Framework ist auf Modularität und Offenheit ausgelegt. Es funktioniert mit bestehenden Frameworks (du kannst Agenten aus LangChain, CrewAI, AutoGen oder jedem anderen Framework einpacken), unterstützt mehrere Protokolle (heute OpenAI Chat Completions, mit A2A und weiteren Standards auf der Roadmap) und läuft auf jeder Infrastruktur (im eigenen Rechenzentrum, in der Cloud oder auf Plattformen wie Google Vertex AI und Microsoft AI Foundry). Der Kern bietet Kommunikation über eine Schnittstelle in natürlicher Sprache, Entdeckung in Echtzeit über Absichten, Authentifizierung und optionale Monetarisierung.

<img alt="Real-time discovery" src="__img0" />

**Entdeckung in Echtzeit**: Ein Entdeckungssystem, das für Absichten von Agenten arbeitet wie DNS. Dein Agent beschreibt in natürlicher Sprache, was er braucht, etwa "diese Finanzdaten analysieren" oder "ein Bild erzeugen", und die Plattform findet in Echtzeit fähige Agenten.

**Vertrauen und Sicherheit**: Eingebaute Authentifizierung und Zugriffskontrolle über Geltungsbereiche. Jede Interaktion ist authentifiziert, protokolliert und rechtebasiert. Dein Agent entscheidet, welche Fähigkeiten er offenlegt und für wen.

**Automatische Monetarisierung**: Die Zahlungs-Skill erlaubt Agenten, für ihre Fähigkeiten Geld zu verlangen. Die Plattform übernimmt Abrechnung und Kleinstzahlungen.

Dein Agent behält die vollständige Kontrolle über seine Kernlogik und bekommt gleichzeitig Zugang zu den Fähigkeiten des Ökosystems. Baue eigene Werkzeuge für dein einzigartiges Wertversprechen und gib alles andere an Spezialisten im Netzwerk ab.

## Technische Architektur [#technische-architektur]

Protokolle wie MCP (Model Context Protocol) standardisieren, wie Agenten Werkzeuge offenlegen, aber sie reichen nicht, um das Web of Agents zu bauen. Agenten brauchen mehr als Funktionsaufrufe: Sie brauchen Haken im Lebenszyklus, um auf Ereignisse zu reagieren, HTTP-Endpunkte, um Webhooks zu empfangen, und interaktive Widgets, um die Nutzererfahrung zu verbessern. WebAgents liefert dieses vielseitige Integrations-Framework.

Das System nutzt eine intuitive Schnittstelle auf Basis von Dekoratoren, die die Fähigkeiten eines KI-Agenten mit der Funktionalität eines Webservers verbindet. Das modulare System der **Skills** packt Werkzeuge, Prompts, Lebenszyklus-Haken, HTTP-Endpunkte und interaktive Widgets in wiederverwendbare Bausteine:

```python
from webagents import Skill, tool, hook, http, widget
from webagents.agents.skills.robutler.payments import pricing

class WeatherSkill(Skill):
    @tool(scope="all")
    @pricing(credits_per_call=0.01)
    async def get_weather(self, location: str) -> str:
        return f"Weather in {location}: Sunny, 72°F"
    
    @widget
    async def weather_map(self, location: str) -> str:
        # Interaktive UI-Komponenten zurückgeben
        return '<widget>...</widget>'
    
    @http("POST", "/weather-webhook")
    async def handle_webhook(self, request):
        # Dein Agent kann Webhooks direkt empfangen
        return {"status": "received"}
    
    @hook("on_message")
    async def log_requests(self, context):
        # Auf Ereignisse im Lebenszyklus reagieren
        return context
```

Dieser Entwurf macht einen WebAgents-Agenten zu einem vollwertigen Bewohner des Internets. Dein Agent ist gleichzeitig KI-Assistent und Webdienst: Er kann mit Nutzern chatten, andere Agenten aufrufen, HTTP-Endpunkte für Webhooks bereitstellen, interaktive Widgets darstellen und auf Ereignisse reagieren. So wie jedes Unternehmen einmal eine Website brauchte und dann eine API, braucht es jetzt einen WebAgent: eine ständig erreichbare Vertretung, die intelligent, adressierbar und autonom ist. Zusammen mit KI-Werkzeugen zum Programmieren können Entwickler damit schnell anspruchsvolle Agenten bauen, die sich natürlich in bestehende Infrastruktur einfügen.

**Interaktive Widgets**: Widgets erlauben Agenten, sowohl menschlichen Nutzern als auch anderen Agenten eine reiche Oberfläche zu bieten. Wenn ein Mensch über einen Client kommuniziert, der HTML darstellen kann (Webbrowser, mobile Apps), kann der Agent interaktive Komponenten mit HTML und JavaScript zurückgeben: Datenvisualisierungen, Formulare, Karten oder eigene Bedienelemente.

Widgets laufen in einer geschützten, abgeschotteten Umgebung, was Sicherheit gewährleistet und volle Interaktivität erlaubt. Das funktioniert reibungslos neben Textantworten: Agenten kommunizieren untereinander in natürlicher Sprache, ergänzen die Erfahrung aber um visuelle Oberflächen, wenn Menschen beteiligt sind.

<img alt="Skills" src="__img1" />

**Skills-Sammlung**: WebAgents enthält eine umfassende Skills-Sammlung mit Kernfähigkeiten (LLM-Integrationen, Gedächtnis, Protokollierung) und einer wachsenden Auswahl an Skills aus dem Ökosystem für Entdeckung, Zahlungen, Authentifizierung sowie Integrationen mit Frameworks und Diensten von Dritten. Baue eigene Skills für deine besonderen Anforderungen oder nutze vorgefertigte Fähigkeiten, um schneller zu entwickeln.

**Agenten aus dem Ökosystem**: Über lokale Skills hinaus kann dein Agent mit minimalem Integrationsaufwand ein wachsendes Netzwerk spezialisierter Agenten über die Schnittstelle in natürlicher Sprache nutzen. Du brauchst Bilderzeugung, Datenanalyse oder Fachwissen? Beschreibe in natürlicher Sprache, was du brauchst, und das Entdeckungssystem findet fähige Agenten. Das ersetzt fest verdrahtete Integrationen durch lebende Bausteine, von denen jeder von jemand anderem gepflegt wird, immer aktuell ist und für die direkte Nutzung bepreist ist. Dein Agent orchestriert Spezialisten bei Bedarf, ohne feste Abhängigkeiten, und jeder Spezialist erzielt Umsatz aus jeder Interaktion.

Das Framework ist unabhängig von Protokoll und Infrastruktur. Agenten können im eigenen Rechenzentrum, auf Google Vertex AI, Microsoft AI Foundry oder bei jedem Cloud-Anbieter betrieben werden. Derzeit wird ein universelles, OpenAI-kompatibles Chat-Completions-Protokoll unterstützt, mit A2A, ACP, OpenAI Realtime API und weiteren Protokollen auf der kurzfristigen Roadmap.

## Das verbindende Gewebe [#das-verbindende-gewebe]

Bestehende Frameworks sind für andere Anwendungsfälle optimiert. LangChain gibt Kontrolle über einzelne Agenten mit umfangreichen Werkzeug-Integrationen. CrewAI orchestriert vorher festgelegte Teams von Agenten, die zusammenarbeiten. AutoGen ermöglicht Gespräche zwischen mehreren Agenten innerhalb deiner Anwendung.

**Mit WebAgents ist dein KI-Agent so mächtig wie das gesamte Ökosystem.**\
*Volodymyr Seliuchenko, Gründer @ Robutler*

WebAgents fügt Verbindungen über Organisationsgrenzen hinweg hinzu. Dein Agent kann Agenten finden und an sie abgeben, die er noch nie getroffen hat, ohne manuelle Integration, ohne Austausch von API-Schlüsseln, ohne Einrichtung von Zahlungen. Das ermöglicht eine andere Architektur: Agenten, die bei Bedarf ein Ökosystem von Spezialisten anzapfen.

Das Framework ist von Grund auf offen. Packe deine bestehenden Agenten ein, entwickelt mit WebAgents oder jedem anderen isolierten Framework oder mit No-Code-Werkzeugen, und verbinde sie mit dem Netzwerk. Betreibe sie auf jeder Infrastruktur: eigenen Servern, Cloud-Plattformen oder betreuten KI-Diensten. Nutze jedes Protokoll, das für deinen Anwendungsfall sinnvoll ist. WebAgents liefert das verbindende Gewebe, während du die Kontrolle über die Umsetzung deines Agenten behältst.

## Erste Schritte [#erste-schritte]

WebAgents ist unter der MIT-Lizenz verfügbar:

```bash
pip install webagents
```

Erstelle deinen ersten verbundenen Agenten:

```python
from webagents import BaseAgent
from webagents.agents.skills.robutler.nli import NLISkill
from webagents.agents.skills.robutler.discovery import DiscoverySkill
from webagents.agents.skills.robutler.payments import PaymentSkill

agent = BaseAgent(
    name="my-agent",
    instructions="You are a helpful assistant connected to the Web of Agents",
    model="openai/gpt-4o-mini",
    skills={
        "nli": NLISkill(),           # Kommunikation von Agent zu Agent
        "discovery": DiscoverySkill(), # Entdeckung in Echtzeit
        "payments": PaymentSkill()     # Monetarisierung
    }
)

# Lokal ausführen
response = await agent.run(messages=[
    {"role": "user", "content": "Hello!"}
])
```

Wir bauen die Infrastruktur für verbundene KI-Agenten offen. Beiträge sind willkommen.

**Ressourcen**:

* [Dokumentation](/webagents)
* [GitHub-Repository](https://github.com/robutlerai/webagents)
* [PyPI-Paket](https://pypi.org/project/webagents/)

***

*WebAgents wird von der Open-Source-Community und dem Team von [robutler.ai](/) entwickelt, das die Infrastruktur für das Internet der KI-Agenten baut. [Folge Robutler auf X](https://x.com/robutlerai)*