Neue Fähigkeiten für Deep Agents vermitteln: Planung, Subagenten und SKILL.md-Dateien
Wie DeepAgents von LangChain Planung, Subagenten, Dateisystemspeicher und schrittweises Laden von Fähigkeiten mit einem Build-Plan, Testempfehlungen und Bereitstellungsanweisungen kombinieren.
Agentebasierte KI bezieht sich auf Systeme, die aus mehreren zusammenarbeitenden Agenten bestehen, die ein komplexes, verworrenes Problem aufteilen, Informationen austauschen und wie ein kleines Team von Spezialisten arbeiten. Ein einzelner Chatbot beantwortet eine Frage. Ein agentebasiertes System benötigt Planung, Gedächtnis und die Nutzung von Werkzeugen, um eine Aufgabe in mehreren Schritten durchzuführen. Lernalgorithmen durch Verstärkung (Reinforcement Learning, RL) sind der klassische Weg zu Agenten, die durch Versuch und Irrtum lernen: Ein tiefes neuronales Netz beobachtet die Umgebung, wählt Aktionen wie Werkzeugaufrufe oder Codeausführung aus und erhält Belohnungen, die seine Strategie steuern. Tiefes RL hat übermenschliches Spielvermögen im Go und Schach sowie starke Ergebnisse in der Robotik hervorgebracht – alles durch die Maximierung der erwarteten kumulativen Belohnung. Die Anwendung dieser Konzepte auf von großen Sprachmodellen angetriebene Agenten eröffnet eine interessante Möglichkeit, nämlich Agenten, die wiederverwendbare Routinen oder Fähigkeiten erlernen und anschließend mit weniger Aufwand planen und ausführen können.
Was macht einen Agenten „tief“?
Deep Agents erweitern einen LLM-Assistenten um vier Funktionen:
- Ein Planungstool, das komplexe Aufgaben in Schritte aufteilt.
- Subagenten für parallele Arbeit und Kontextisolation.
- Ein persistentes Dateisystem, das gleichzeitig als Speicher dient.
- Ein detaillierter Systemprompt mit Zielen und Einschränkungen.
Zusammen ermöglichen diese Funktionen es einem Agenten, zu planen, den Zustand beizubehalten und komplexe Arbeitsabläufe auszuführen, ohne dass der Prompt-Kontext beeinträchtigt wird. Ein oberflächlicher Chatbot antwortet einmal. Ein Deep Agent wiederholt den Prozess: Er plant, sucht, speichert Ergebnisse, synthetisiert und verfeinert. Wenn nach einem Bericht gefragt wird, kann er beispielsweise eine To-Do-Liste erstellen, Websuchen oder Analysen durchführen, Notizen in Dateien speichern, anschließend Entwürfe erstellen und überarbeiten – alles gesteuert vom Modell, ohne menschliches Eingreifen.
Verstärkungslernen und die Herkunft von Fähigkeiten
Reinforcement Learning ist die Grundlage für Agenten, die durch Handeln lernen. Der Agent beobachtet einen Zustand, führt eine Aktion aus und erhält entweder eine Belohnung oder eine Strafe; indem er die erwartete Summe zukünftiger Belohnungen maximiert, verbessert er seine Strategie. Es unterscheidet sich vom überwachten Lernen, das Labels verwendet, sowie vom unüberwachten Lernen, das nach verborgenen Strukturen sucht, da es sich mit sequenziellen Entscheidungen unter Unsicherheit befasst. Deep Reinforcement Learning setzt neuronale Netze als Funktionsapproximatoren ein, damit Bilder, Texte und rohe Sensordaten verarbeitet werden können. Bekannte Meilensteine sind Deep Q-Networks für Atari sowie Policy-Gradient-Methoden wie PPO und A2C für kontinuierliche Steuerungssysteme und Strategiespiele. Neuere Arbeiten befassen sich mit hierarchischem Fähigkeitslernen, bei dem Agenten Optionen entdecken – also zeitlich erweiterte Aktionen, die Unterziele lösen – was die Erkundung und den Transfer von Wissen fördert.
Für LLM-Agenten spielt das Reinforcement Learning zwei Rollen. Eine besteht darin, das Modell selbst mithilfe von Feedback-Signalen feinzujustieren. RLHF zum Beispiel hat dazu beigetragen, Modelle sicherer und themenrelevanter zu gestalten. DeepSeek-R1 zeigte, dass reines Reinforcement Learning ohne gelabelte Daten in der Lage ist, ein Reasoning-Modell so auszubilden, dass es mit den besten Systemen in Mathematik und Programmierung mithalten kann: Das Modell erzeugt mehrere Antworten, ein automatischer Bewertungsalgorithmus belohnt die richtigen und bestraft die anderen, und über viele Runden verbessert ein Algorithmus wie PPO die Strategie des Modells. Reale Pipelines fügen möglicherweise noch überwachtes Feinjustieren sowie Rejection Sampling hinzu, um Lesbarkeit und Sicherheit zu gewährleisten.
Die andere Rolle befindet sich auf der Ebene des Agentenframeworks, wo methoden, die auf RL beruhen, dabei helfen können, Fähigkeiten zu erwerben. Ein Agent könnte die Abläufe dessen aufzeichnen, was er getan hat (welche Tools verwendet wurden, welche Ergebnisse zurückkamen) und diese an ein offline-basiertes RL oder Lernen durch Nachahmung weiterleiten, um wiederholbare Verfahren zu identifizieren. Indem er auf frühere Erfolge und Misserfolge blickt, kann er häufig wiederholte Tool-Sequenzen in höherstufige Routinen zusammenfassen. Diese Routinen, die als Skriptdateien oder Anweisungen im Markdown-Format festgehalten werden, können dem Agenten bei späteren Aufgaben schrittweise offenbart werden. Das System erlangt so eine Form des kontinuierlichen Lernens: Angesichts neuer Situationen lernt es spontan eine Fähigkeit und speichert sie als Modul.
Wie die DeepAgents-Bibliothek aufgebaut ist
Die DeepAgents-Bibliothek von LangChain verwandelt diese Ideen in eine für die Praxis geeignete Lösung, wobei die Architektur von mehrschrittigen Agenten wie Claude Code und Manus geprägt wird.
- Planung mit
write_todos. Ein integriertes Werkzeug ermöglicht es dem Agenten, vor dem Handeln eine schrittweise Liste zu erstellen. Diese Liste leitet die Arbeit und kann sich ändern, wenn neue Informationen einfließen. - Dateisystem und Speicher. Dateihilfsmittel (
ls,read_file,write_file,edit_file) ermöglichen es dem Agenten, Kontextinhalte in Dateien oder Datenbanken zu speichern. Das Speichern von Zwischenergebnissen und Notizen verhindert einen Überlauf des Kontextfensters und ermöglicht es dem Agenten, frühere Schritte erneut zu durchgehen. Ein anschließbares Backend – egal ob im Arbeitsspeicher, auf lokaler Festplatte, in der Cloud oder in einer isolierten Sandbox – kümmert sich um die Persistenz und die sichere Ausführung von Code.
task-Tool erzeugt spezialisierte Helfer, wie beispielsweise einen Forschungsunteragenten oder einen Kritikunteragenten. Jeder arbeitet in seinem eigenen Kontext, wodurch der Hauptagent nicht überladen wird, und kann eigene Systemanweisungen sowie Tools haben. Der Hauptagent kann Websuchen oder Codeanalysen an sie weiterleiten und anschließend Zusammenfassungen erhalten. Ein Allzweckunteragent spiegelt einfach die Einstellungen des Hauptagenten wider, wenn nur Isolation gewünscht ist.SKILL.md sowie optional Skripte oder Dokumente enthält. Fähigkeiten unterscheiden sich von Tools dadurch, dass sie nicht vollständig in die Anweisung eingebunden werden. Nur das YAML-Frontmatter (Name, Beschreibung, Tags) gelangt in den Kontext, während die vollständigen Anweisungen schrittweise sichtbar werden, sobald der Agent sie für relevant hält. Dadurch wird der Tokenverbrauch erheblich reduziert. Eine PDF-Fähigkeit kann beispielsweise ein langes Tutorial enthalten, das der Agent nur dann liest, wenn die Aufgabe des Benutzers PDFs betrifft. Fähigkeiten verteilen Fachwissen und Verfahren auf verschiedene Agenten, und diese können sogar neue Fähigkeitsdefinitionen erstellen, wenn sie auf neue Aufgaben stoßen.Wegen dieses Designs schneiden tiefe Agenten bei langen, mehrschrittigen Problemen weitaus besser ab als flache Agenten. Sie planen im Voraus, nutzen Erinnerung, lernen aus Erfahrungen und können große Kontexte verarbeiten. Branchenberichte weisen darauf hin, dass die Aufgaben für Agenten immer komplexer werden, wobei ihre Länge alle paar Monate etwa verdoppelt wird – genau hier spielen diese Eigenschaften eine entscheidende Rolle. Es kommt zu einem Wandel von der Beantwortung isolierter Anfragen hin zur autonomen Problemlösung.
Schrittweise Implementierung
Der untenstehende Plan kombiniert die Agentenarchitektur mit RL-Methoden, wo dies sinnvoll ist. Er verwendet Python sowie das DeepAgents SDK. Beginnen Sie damit, die Bibliotheken zu installieren und die Umgebung einzurichten:
# Install deepagents and necessary tools
!pip install --upgrade deepagents langchain tavily-python
# Import libraries and set API keys (e.g., for LLM and search tool)
import os
from getpass import getpass
os.environ["OPENAI_API_KEY"] = getpass("OpenAI API Key: ")
os.environ["TAVILY_API_KEY"] = getpass("Tavily API Key: ")
from deepagents import create_deep_agent
from deepagents.backends import FilesystemBackend
from deepagents.middleware.filesystem import FileData
from langchain.chat_models import init_chat_model
from tavily import TavilyClient
Definierung des Agenten und seiner Fähigkeiten
Danach folgt der vollwertige Agent mit seinen Werkzeugen sowie allen vordefinierten Fähigkeiten. Für die Produktion ist ein langlebiger Backend, wie zum Beispiel der lokale Speicher oder LangGraph, eine bessere Wahl als vorübergehender Speicher. Diese Version verwendet einen FilesystemBackend, der im aktuellen Verzeichnis angesiedelt ist, und lädt die Fähigkeitsordner hoch:
from deepagents import create_deep_agent
# Assume we have local skill directories under "./skills"
skill_dirs = ["./skills/pdf_processing", "./skills/data_analysis"]
agent = create_deep_agent(
model=model,
system_prompt="""
You are a highly capable AI assistant. Your objectives:
1. Break tasks into steps using write_todos().
2. Use internet_search and file tools to gather and store information.
3. When given a task, plan and execute it step-by-step, writing to files as needed.
4. Load skills from the filesystem to handle specialized tasks when relevant.
5. Summarize results and refine final output before returning.
""",
tools=[internet_search], # Web search tool
backend=FilesystemBackend(root_dir="./workspace"), # Persistent file storage
skills=skill_dirs, # Load skills from local directories
)
Die Systemanweisung betont Planung und Nutzung von Fähigkeiten. Der Parameter skills verweist auf Verzeichnisse, deren Unterordner jeweils ein SKILL.md sowie unterstützende Dateien enthalten. ./skills/pdf_processing/SKILL.md könnte beispielsweise dem Agenten beibringen, wie man PDFs analysiert. Wenn die Fähigkeiten auf diese Weise geladen werden, sieht der Agent zunächst nur Namen und Beschreibungen. Wenn eine Aufgabe des Benutzers PDFs beinhaltet, liest er das entsprechende SKILL.md sowie alle referenzierten Dateien, um den Ablauf zu erlernen.
Ein Beispiel für die Struktur:
skills/
├── pdf_processing/
│ └── SKILL.md
└── data_analysis/
├── SKILL.md
└── analysis_script.py
Und ein möglicher pdf_processing/SKILL.md:
---
name: pdf-processing
description: Skill to extract and analyze content from PDF documents.
---
# PDF Processing Skill
To use this skill, follow these steps:
1. Use `pdf-tools` to read PDF content.
2. Summarize key findings from the PDF text.
...
Die vollständigen Anweisungen werden nur gelesen, wenn der Agent entscheidet, dass die aktuelle Anfrage PDFs betrifft. Das ist progressive Offenlegung im Einsatz: große Skill-Dateien vergrößern nicht jede Anfrage.
Wie ein Ablauf aussieht
Geben Sie nun dem Agenten eine komplexe Aufgabe. Die anfängliche Anfrage regt ihn dazu an, zunächst einen Plan zu erstellen.
from langchain.schema import HumanMessage
query = "Organize the latest quarterly sales data and write a summary report."
response = agent.invoke({
"messages": [HumanMessage(content=query)]
})
print(response["messages"][-1]["content"])
Konzeptionell wird der Agent voraussichtlich Folgendes tun:
- Er ruft
write_todos()auf, um eine Checkliste zu erstellen – beispielsweise indem er die Verkaufsdaten laden, Diagramme erstellen, Gesamtbeträge berechnen und den Bericht schreibt. - Er führt Tool-Aufrufe durch, wobei er
internet_searchoder eingebaute Dateielesefunktionen verwendet, um vorhandene Daten zu sammeln. - Falls die Aufgabe eine spezialisierte Vorgehensweise erfordert, überträgt er möglicherweise die Reinigung oder Analyse auf einen Unteragenten.
- Er nutzt vorhandene Fähigkeiten. Falls eine Datenanalyse-Fähigkeit vorhanden ist, kann er
SKILL.mdaus./skills/data_analysislesen und diese befolgen. - Er speichert Zwischenergebnisse wie gereinigte Datensätze oder Diagramme im Dateisystem.
- Er schreibt den endgültigen Zusammenfassungstext und überarbeitet diesen.
Ein vollständiger Ablauf ruft entfernte LLMs auf, weshalb die Überprüfung hier hauptsächlich darauf abzielt, die Struktur richtig zu gestalten. Der Code wählt einen zuverlässigen Backend aus, umfasst risikoreiche Schritte in try/except-Blöcken (eine vollständige Version sollte API- und Dateifehler erfassen) und kann durch Logging-Middleware erweitert werden. Unit-Tests für jedes Tool, bei denen die LLM-Antworten emuliert werden, würden dies überprüfen.
Testen und Bewertung
Agenten-Workflows werden hauptsächlich durch Beurteilung bewertet. Es wird geprüft, ob der Agent Aufgaben korrekt abschließt und sich an seinen Plan hält. Ein Ansatz verwendet synthetische Aufgaben mit bekannten Antworten: Man gibt ihm ein kleines Mathematikprojekt und vergleicht den Endbericht mit der Lösung. Automatisierte Metriken helfen ebenfalls, wie beispielsweise die Erfolgsrate der Aufgaben (ob jeder Schritt abgeschlossen wurde) oder die Ähnlichkeit zu einer Referenzantwort, die von einem LLM-Bewerter bewertet wird. Freitexte benötigen möglicherweise weiterhin eine menschliche Überprüfung oder eine modellbasierte Kritik für die endgültige Beurteilung.
Falls RL zur Fähigkeitsentwicklung verwendet wird, kann der Fortschritt anhand von Belohnungskurven gemessen werden. Erstellen Sie eine Umgebung, in der das Abschließen von Unteraufgaben eine Belohnung einbringt, und zeichnen Sie die Gesamtbelohnung pro Episode auf – beispielsweise mit OpenAI Gym oder einer eigenen Konfiguration. Entscheidend sind die Metriken wie die Stichprobeneffizienz (wie schnell das Lernen konvergiert), die Endleistung sowie die Stabilität bei unterschiedlichen Zufallsinitialisierungen. In der Praxis sollten Sie außerdem eine Reihe von Aufgaben aus den Bereichen Forschung, Programmierung und Analyse durchführen und dabei die Erfolgsrate sowie den Tokenverbrauch für jede Aufgabe tracken.
Observierbarkeit ist in der Produktion unerlässlich. Ausstatten Sie den Agenten mit Funktionen zur Überwachung und Protokollierung, da LangSmith jede Tool-Aufruf- und LLM-Antwortverarbeitung erfassen kann. In einem eingesetzten System können die Protokolle mit Anzahl der Schritte, Latenz pro Aufruf sowie Fehlern an CloudWatch oder Prometheus übertragen werden. Für RL-Komponenten sollten Belohnungshistorien, Verlustkurven sowie Hyperparameter protokolliert werden. Stresstests mit großen Datensätzen, langen Sitzungen sowie ungewöhnlichen Eingaben helfen dabei, die Stabilität zu überprüfen.
Als Service bereitstellen
In einer tatsächlichen Implementierung läuft der Agent als Microservice. Eine skalierbare Architektur sieht wie folgt aus:
+------------------+ +--------------+
| Client/User | <--> | API Gateway | <---> [HTTP requests]
+------------------+ +------+-------+
|
v
+-------------+
| AgentCore | <-- AWS Bedrock AgentCore (managed runtime)
+-------------+
|
+-------------+-------------+
| |
+-------------------+ +-------------------+
| Deep Agent Service | | Storage (S3/DB) | <-- File/memory backend, logs
+-------------------+ +-------------------+
| |
+-------------+-------------+
|
+---------------+
| LLM Models | <-- e.g., OpenAI, Anthropic, local LLMs
+---------------+
Ein Agentendienst auf AWS AgentCore oder einem ähnlichen System erhält Anfragen, koordiniert Subagenten und führt Toolaufrufe durch, wobei jede Interaktion in einem persistenten Speicher zur Überwachung und zur Aufrechterhaltung des Gedächtnisses aufgezeichnet wird. Einige Designaspekte sind besonders hervorzuheben.
- Skalierbarkeit und Zuverlässigkeit. Der Agent wird in einem serverlosen oder konteinerbasierten Laufzeitumfeld wie AWS Bedrock AgentCore, Azure AI Agent Service oder Kubernetes ausgeführt. Er skaliert mit der Last und startet für jede Anfrage neue Instanzen, wobei jede Sitzung in ihrer eigenen Micro-VM stattfinden kann. Ein persistenter Backend-Speicher (S3, eine Datenbank oder der LangGraph-Speicher) bewahrt den Zustand und das Gedächtnis über Neustarts hinweg.
- Überwachbarkeit. Verfolgen Sie jede Aufrufung. In AWS verbindet das Bedrock AgentCore Starter Kit CloudWatch und X-Ray zur Überwachung von Latenzzeiten und Fehlern. Das Protokollieren von Hash-Werten von Anfragen und Antworten anstelle von rohen, sensiblen Daten ermöglicht es weiterhin, die Leistung sowie die Token-Nutzung, die Anzahl der API-Aufrufe und die Erfolgsraten zu tracken.
- Sicherheit. Beschränken Sie, was der Agent erreichen kann. Dateisystem-Tools sollten nur innerhalb bestimmter Verzeichnisse funktionieren, und die Ausführung von Code im
sandbox-Backend sollte in gesicherten Umgebungen wie Modal oder Daytona stattfinden. Weisen Sie allen Cloud-Ressourcen, die vom Agenten aufgerufen werden, IAM-Rollen mit minimalem Berechtigungsgrad zu und fügen Sie Eingabenvalidierung sowie Inhaltsfilterung durch Sicherheitsprüfungen gegen bösartige Anfragen hinzu. - Kosten. Abwägen zwischen Modelltyp und Backend-Optionen. Ein günstigeres Anthropic-Modell kann routinemäßige Aufgaben übernehmen, während ein Premium-Modell wie GPT-4o für die entscheidenden Planungsschritte verwendet wird. Das Übertragen des Kontexts in den Speicher sowie die Wiederverwendung von Tool-Ergebnissen reduzieren wiederholte Prompt-Token.
Ein vollständiges Beispiel
Dieses Python-Beispiel implementiert den Plan inklusive Fehlerbehandlung und Kommentaren. Es ist konzeptionell und benötigt echte API-Schlüssel sowie eine Umgebung zum Ausführen.
from deepagents import create_deep_agent
from deepagents.backends import FilesystemBackend
from deepagents.middleware.filesystem import FileData
from langchain.chat_models import init_chat_model
from tavily import TavilyClient
import os
def setup_agent():
"""Initialize the Deep Agent with tools, skills, and system prompt."""
# Model and tools initialization
model = init_chat_model(model="openai:gpt-4o")
tavily_client = TavilyClient(api_key=os.environ["TAVILY_API_KEY"])
def web_search(query: str, max_results: int = 3) -> str:
results = tavily_client.search(query, max_results=max_results)
return "\n".join(f"{r.title}: {r.summary}" for r in results)
# Create the deep agent with planning, files, and skills
try:
agent = create_deep_agent(
model=model,
tools=[web_search],
system_prompt="""You are an expert agent. Your workflow:
1. Create a plan with write_todos().
2. Use tools (e.g. web_search) and file system to research and work.
3. If specialized tasks arise, load relevant skills from the 'skills' directory.
4. Save results and refine the output at each step.
""",
backend=FilesystemBackend(root_dir="./workspace"),
skills=["./skills/pdf_processing", "./skills/data_analysis"]
)
return agent
except Exception as e:
print(f"Error initializing agent: {e}")
raise
def invoke_agent(agent, user_query):
"""Invoke the agent on a user query and return the final answer."""
try:
messages = [{"role": "user", "content": user_query}]
result = agent.invoke({"messages": messages})
return result["messages"][-1]["content"]
except Exception as e:
print(f"Agent invocation failed: {e}")
return None
# Example usage
if __name__ == "__main__":
agent = setup_agent()
task = "Analyze the recent research on climate change and summarize key findings."
answer = invoke_agent(agent, task)
print("Agent response:", answer)
Die Erstellung und Aufrufung von Agenten erfolgen in Funktionen mit Docstrings sowie try/except-Blöcken. Das web_search-Tool nutzt Tavily für externe Daten, und der Systemprompt weist den Agenten an, zu planen, Fähigkeiten anzuwenden und seine Ausgabe zu verfeinern. Eine Produktionsversion würde Randfälle wie leere Suchergebnisse oder API-Zeitüberschreitungen überprüfen und stattdessen Ausnahmendetails protokollieren anstatt sie auszugeben. Geheime Informationen sollten in einer sicheren Umgebung aufbewahrt werden, nicht im Quellcode. Die Struktur lässt sich natürlich erweitern, indem weitere Tools oder Subagenten hinzugefügt werden.
Um es ordnungsgemäß zu validieren, sollten Unit-Tests geschrieben werden. Mocken Sie den LLM, damit er feste Planerausgaben zurückgibt, und überprüfen Sie, ob der Agent die erwarteten Dateien erstellt oder die Tools in der richtigen Reihenfolge aufruft. Messen Sie außerdem die Inferenzverzögerung sowie die Tokenkosten bei Benchmark-Aufgaben.
Abwägungen, die berücksichtigt werden müssen
Deep Agents kombinieren Planung, Speicherfunktionen, Delegation an Unteragenten sowie ladebare Fähigkeiten, um mehrstufige Aufgaben zu bewältigen, die einfache Chatbots nicht schaffen können. Ein klarer Systemprompt, ein auf Planung ausgerichteter Arbeitsablauf sowie ein umfangreiches Werkzeugset bilden eine solide Grundlage für autonome Assistenten. Die Fähigkeiten enthalten modulares Wissen – beispielsweise pdf-processing oder deploy-to-prod – das nach Bedarf geladen wird, damit der Kontext übersichtlich bleibt und der Agent weiter lernen kann.
- Richtigkeit im Verhältnis zu Kosten. Starke Modelle wie GPT-4o oder Claude Sonnet sowie umfangreiche Suchfunktionen verbessern die Genauigkeit, erhöhen jedoch die Kosten für Tokens und APIs. Die Kombination unterschiedlicher Modellgrößen sowie Caching hilft, Qualität und Ausgaben in Einklang zu bringen.
- Skalierbarkeit im Verhältnis zur Komplexität. Ein serverloser Agent-Runtime wie AWS AgentCore bietet Automatisches Skalieren und Überwachungsmöglichkeiten, erfordert jedoch Integrationsarbeiten: Die Agent-Code muss in Container verpackt und die Netzwerkkonfiguration angepasst werden.
Zukünftig könnte der Erwerb von Fähigkeiten selbst automatisiert werden: Reinlernverfahren oder unüberwachtes Lernen anhand früherer Abläufe könnten neue Definitionen von Fähigkeiten erzeugen. Mehr-Agenten-Frameworks wie Microsoft AutoGen oder Salesforce AgentForce könnten mehrere spezialisierte Agenten koordinieren, die über LangGraph-Protokolle miteinander kommunizieren.
Um einen Agenten zu entwickeln, der Fähigkeiten erlernt, sind zwei Dinge erforderlich: die richtige Software-Stack-Struktur sowie, falls gewünscht, Reinlernverfahren, die ihn im Laufe der Zeit verbessern. Mit DeepAgents und diszipliniertem Engineering können Assistenten bereitgestellt werden, die komplexe Probleme eigenständig lösen, neue Verfahren erlernen und in großem Umfang zuverlässig arbeiten.