# Einführung

Jeder ist Baumakler. Weitaus weniger Menschen können genau erklären, warum ihr Agent ewig in der Schleife bleibt, ein ihm gegebenes Werkzeug ignoriert oder selbstbewusst über den Erfolg einer Aufgabe berichtet, die er nie erledigt hat. In der Lücke zwischen der Bereitstellung eines Agenten und dem Verstehen eines Agenten befinden sich diese fünf Ressourcen, und jede davon ist völlig kostenlos.

Ich habe hier bewusst die Register gemischt: einen praktischen Kurs, den Sie an einem Wochenende absolvieren können, einen anspruchsvollen akademischen Textual content für den Fall, dass der Hype nachlässt und Sie die Grundlagen brauchen, und ein paar Dinge dazwischen. Wenn Sie nur drei davon durchgehen, werden Sie Agenten so gestalten, dass sie wissen, was unter der Orchestrierung geschieht, und nicht wie jemand, der Eingabeaufforderungen einfügt und darauf hofft.

# KI-Agenten für Anfänger (Microsoft)

Beginnen Sie hier, wenn Sie Struktur wünschen. KI-Agenten für Anfänger ist ein vollständiger Kurs auf GitHub unter einer MIT-Lizenz, der mehr als fünfzehn Lektionen mit Video-Komplettlösungen und ausführbarem Python für jede einzelne umfasst. Es geht von den eigentlichen Grundlagen – was ein Agent ist und wann Sie einen tatsächlich brauchen – über die Entwurfsmuster, die Sie ständig wiederverwenden: Werkzeugnutzung, Planung, Retrieval-Augmented Technology (RAG), Multi-Agent-Setups und die Speicher- und Kontexttechnik, die eine Demo von etwas Brauchbarem unterscheiden.

Was es zum besten kostenlosen Ausgangspunkt macht, ist, dass es beibehalten und nicht aufgegeben wird und die neueren Interoperabilitätsstandards wie Mannequin Context Protocol (MCP) abdeckt, die das meiste Materials aus der Ära 2023 vollständig älter sind. Es kommt einem strukturierten Lehrbuch am nächsten, das auch kompiliert.

# Hugging Face AI Brokers-Kurs

Der Hugging Face Brokers-Kurs ist dasjenige, das mit dem von Microsoft kombiniert werden kann, da es unermüdlich praxisorientiert und mit Frameworks vergleichbar ist. Sie erstellen Agenten über Smolagents, LlamaIndex und LangGraph hinweg, anstatt eine einzige Bibliothek zu vereinen. Das ist genau die Perspektive, die Sie sich wünschen, bevor Sie einen Produktions-Stack in ein Ökosystem übernehmen.

Es ist wirklich kostenlos, ohne Paywall-Stufe und endet mit einem Benchmark-Projekt und einem Zertifikat, sodass es eher eine Ziellinie als eine endlose Playlist gibt. Wenn Ihnen der Kurs von Microsoft die Konzepte beibringt, vermittelt Ihnen dieser Kurs die Schwielen.

# Effektive Agenten aufbauen (anthropisch)

Anthropics technischer Leitfaden Effektive Agenten aufbauen ist kurz, das ist der Punkt. Es wird die nützlichste Unterscheidung auf diesem Gebiet getroffen – zwischen Workflows (große Sprachmodelle, die vordefinierten Pfaden folgen) und Agenten (große Sprachmodelle, die ihren eigenen Prozess steuern) – und dann die wenigen Muster katalogisiert, die es zu kennen gilt: Eingabeaufforderungsverkettung, Routing, Parallelisierung, Orchestrator-Employee- und Evaluator-Optimierer-Schleifen.

Sein bester Beitrag ist eine Warnung, die in den meisten Tutorials übersprungen wird: Agenten bringen höhere Kosten mit sich und bergen die Möglichkeit, Fehler zu verschlimmern. Daher sollten Sie nach der einfachsten Lösung greifen, die funktioniert, und die Autonomie nur dann hinzufügen, wenn das Drawback dies erfordert. Lesen Sie es, nachdem sich Ihr erster Agent daneben benimmt, und Sie werden das Gefühl haben, als würde Ihnen jemand Ihren eigenen Fehler erklären.

# Multiagentensysteme (Shoham & Leyton-Brown)

Wenn der Hype nachlässt und Sie wissen möchten, warum sich Multiagentensysteme so verhalten, wie sie es tun, Multiagentensysteme von Yoav Shoham und Kevin Leyton-Brown ist die strenge Grundlage. Die Autoren stellen mit Zustimmung ihres Herausgebers eine kostenlose elektronische Kopie zur Verfügung; Laden Sie es von dieser Seite herunter, anstatt woanders nach dem PDF zu suchen, da die Leser ausdrücklich aufgefordert werden, einen Hyperlink zur Quelle anzugeben.

Dies sind die Spieltheorie, die verteilte Entscheidungsfindung und die logischen Grundlagen, die den heutigen Agentengesprächen zugrunde liegen. Es stammt aus der Zeit vor der Ära der großen Sprachmodelle und ist genau deshalb wertvoll: Koordinations-, Verhandlungs- und Anreizprobleme zwischen Agenten sind alt und intestine erforscht, und die meisten Leute, die sie jetzt wiederentdecken, würden Wochen sparen, wenn sie die eigentliche Theorie einmal lesen würden.

# Whitepaper-Serie zu Google und Kaggle Brokers

Googles Fünfteiler Agenten-Whitepaper-Reihe zu Kaggle ist kostenlos, aktuell und insgesamt buchlang. Die Bände behandeln Agentenarchitekturen, Instruments und Interoperabilität mit MCP, Kontext-Engineering für Sitzungen und Speicher, Agentenqualität und -bewertung sowie den Sprung vom Prototyp zur Produktion.

Dieses vierte Thema – die Bewertung – ist der Grund, warum diese Serie ihren Platz verdient: Die Messung, ob ein Agent tatsächlich intestine ist, ist die am wenigsten gelehrte und am meisten benötigte Fähigkeit in der gesamten Disziplin, und das meiste kostenlose Materials hört bei „Bei meinem Beispiel funktioniert es“ auf. Wenn ich diese fünf nach dem ordnen müsste, was Ihre Agenten in diesem Quartal am meisten verbessern wird, würde ich das Bewertungsvolumen an die erste Stelle setzen. Etwas zum Laufen zu bringen, ist die Demo. Zu wissen, ob es funktioniert, ist die Aufgabe.

# Wohin als nächstes gehen?

Fünf Ressourcen, ein bewusster Weg: Lernen Sie Microsoft und Hugging Face kennen, schärfen Sie Ihr Urteilsvermögen mit Anthropic, verankern Sie es in der Theorie mit Shoham und Leyton-Brown und lernen Sie, mit der Google-Reihe zu messen. Nichts davon kostet etwas außer den Stunden, und die Stunden sind der einzige Teil, der jemals von Bedeutung sein würde.

Nahla Davies ist Softwareentwickler und technischer Autor. Bevor sie sich hauptberuflich dem technischen Schreiben widmete, schaffte sie es – neben anderen faszinierenden Dingen –, als leitende Programmiererin bei einer Inc. 5.000-Organisation für experimentelles Branding zu arbeiten, zu deren Kunden Samsung, Time Warner, Netflix und Sony gehören.

Bild vom Autor

# Einführung

Für den lokalen Betrieb eines leistungsstarken KI-Modells ist keine Excessive-Finish-Workstation oder teure Cloud-Einrichtung mehr erforderlich. Mit leichtgewichtigen Instruments und kleineren Open-Supply-Modellen können Sie jetzt sogar einen älteren Laptop computer in eine praktische lokale KI-Umgebung für Codierung, Experimente und Workflows im Agentenstil verwandeln.

In diesem Tutorial lernen Sie, wie man läuft Qwen3.5 lokal verwenden Ollama und verbinde es mit OpenCode um ein einfaches lokales Agenten-Setup zu erstellen. Das Ziel besteht darin, alles unkompliziert, zugänglich und anfängerfreundlich zu halten, sodass Sie einen funktionierenden lokalen KI-Assistenten erhalten, ohne sich mit einem komplizierten Stack herumschlagen zu müssen.

# Ollama installieren

Der erste Schritt besteht darin, Ollama zu installieren, wodurch es einfach ist, große Sprachmodelle lokal auf Ihrem Laptop auszuführen.

Wenn Sie verwenden Home windowskönnen Sie Ollama entweder direkt vom offiziellen herunterladen Laden Sie Ollama für Home windows herunter Seite und installieren Sie sie wie jede andere Anwendung, oder führen Sie den folgenden Befehl aus PowerShell:

irm https://ollama.com/set up.ps1 | iex

Die Ollama-Downloadseite enthält auch Installationsanweisungen für Linux Und macOSdamit Sie die dortigen Schritte befolgen können, wenn Sie ein anderes Betriebssystem verwenden.

Sobald die Set up abgeschlossen ist, können Sie Ollama starten und Ihr erstes lokales Modell abrufen.

# Ollama starten

In den meisten Fällen startet Ollama automatisch nach der Set up, insbesondere wenn Sie es zum ersten Mal starten. Das bedeutet, dass Sie möglicherweise nichts weiter tun müssen, bevor Sie ein Modell lokal ausführen.

Wenn der Ollama-Server noch nicht läuft, können Sie ihn mit dem folgenden Befehl manuell starten:

# Qwen3.5 lokal ausführen

Sobald Ollama ausgeführt wird, besteht der nächste Schritt darin, Qwen3.5 herunterzuladen und auf Ihrem Laptop zu starten.

Wenn Sie die Qwen3.5-Modellseite in Ollama besuchen, sehen Sie mehrere Modellgrößen, von größeren Varianten bis hin zu kleineren, leichteren Optionen.

Für dieses Tutorial verwenden wir die 4B-Model, da sie ein gutes Gleichgewicht zwischen Leistung und Hardwareanforderungen bietet. Es ist eine praktische Wahl für ältere Laptops und erfordert normalerweise etwa 3,5 GB Arbeitsspeicher (RAM).

Um das Modell von Ihrem Terminal herunterzuladen und auszuführen, verwenden Sie den folgenden Befehl:

Wenn Sie diesen Befehl zum ersten Mal ausführen, lädt Ollama die Modelldateien auf Ihren Laptop herunter. Abhängig von Ihrer Internetgeschwindigkeit kann dies einige Minuten dauern.

Nach Abschluss des Downloads kann es einen Second dauern, bis Ollama das Modell lädt und alles vorbereitet, was für die lokale Ausführung erforderlich ist. Sobald Sie fertig sind, wird eine interaktive Terminal-Chat-Oberfläche angezeigt, über die Sie das Modell direkt auffordern können.

Zu diesem Zeitpunkt können Sie Qwen3.5 bereits im Terminal für einfache lokale Gespräche, schnelle Exams und einfache Codierungshilfe verwenden, bevor Sie es für einen effizienteren Workflow mit OpenCode verbinden.

# OpenCode installieren

Nach der Einrichtung von Ollama und Qwen3.5 besteht der nächste Schritt in der Set up von OpenCode, einem lokalen Codierungsagenten, der mit Modellen arbeiten kann, die auf Ihrem eigenen Laptop ausgeführt werden.

Sie können die OpenCode-Web site besuchen, um die verfügbaren Installationsoptionen zu erkunden und mehr über die Funktionsweise zu erfahren. Für dieses Tutorial verwenden wir die Schnellinstallationsmethode, da dies der einfachste Einstieg ist.

Führen Sie den folgenden Befehl in Ihrem Terminal aus:

curl -fsSL https://opencode.ai/set up | bash

Dieses Installationsprogramm übernimmt den Einrichtungsprozess für Sie und installiert die erforderlichen Abhängigkeiten, einschließlich Node.js bei Bedarf, sodass Sie nicht alles manuell konfigurieren müssen.

# Starten von OpenCode mit Qwen3.5

Nachdem sowohl Ollama als auch OpenCode installiert sind, können Sie OpenCode mit Ihrem lokalen Qwen3.5-Modell verbinden und es als einfachen Codierungsagenten verwenden.

Wenn Sie sich die Qwen3.5-Seite in Ollama ansehen, werden Sie feststellen, dass Ollama jetzt einfache Integrationen mit externen KI-Instruments und Codierungsagenten unterstützt. Dies macht es viel einfacher, lokale Modelle in einem praktischeren Arbeitsablauf zu nutzen, anstatt nur im Terminal mit ihnen zu chatten.

Führen Sie den folgenden Befehl aus, um OpenCode mit dem Qwen3.5 4B-Modell zu starten:

ollama launch opencode --model qwen3.5:4b

Dieser Befehl weist Ollama an, OpenCode mit Ihrem lokal verfügbaren Qwen3.5-Modell zu starten. Nach der Ausführung werden Sie zur OpenCode-Schnittstelle weitergeleitet, wobei Qwen3.5 4B bereits verbunden und einsatzbereit ist.

# Erstellen eines einfachen Python-Projekts mit Qwen3.5

Sobald OpenCode mit Qwen3.5 läuft, können Sie damit beginnen, ihm einfache Eingabeaufforderungen zu geben, um Software program direkt von Ihrem Terminal aus zu erstellen.

Für dieses Tutorial haben wir es gebeten, ein kleines zu erstellen Python Erstellen Sie ein Spielprojekt von Grund auf mit der folgenden Eingabeaufforderung:

Erstellen Sie ein neues Python-Projekt und erstellen Sie ein modernes Guess the Phrase-Spiel mit sauberem Code, einfachem Gameplay, Punkteverfolgung und einer benutzerfreundlichen Terminalschnittstelle.

Nach ein paar Minuten generierte OpenCode die Projektstruktur, schrieb den Code und kümmerte sich um die Einrichtung, die erforderlich warfare, um das Spiel zum Laufen zu bringen.

Wir haben es auch gebeten, alle erforderlichen Abhängigkeiten zu installieren und das Projekt zu testen, wodurch sich der Workflow viel näher an die Arbeit mit einem einfachen lokalen Codierungsagenten als an einem einfachen Chatbot anfühlen ließ.

Das Endergebnis warfare ein voll funktionsfähiges Python-Spiel, das im Terminal reibungslos lief. Das Gameplay warfare einfach, die Codestruktur warfare sauber und die Punkteverfolgung funktionierte wie erwartet.

Wenn Sie beispielsweise ein korrektes Zeichen eingeben, zeigt das Spiel sofort den passenden Buchstaben im versteckten Wort an und zeigt so, dass die Logik sofort funktioniert.

# Letzte Gedanken

Ich warfare wirklich beeindruckt, wie einfach es ist, mit Ollama, Qwen3.5 und OpenCode ein lokales Agenten-Setup auf einem älteren Laptop computer zum Laufen zu bringen. Für ein leichtes, kostengünstiges Setup funktioniert es überraschend intestine und sorgt dafür, dass sich die lokale KI viel praktischer anfühlt, als viele Leute erwarten.

Allerdings läuft nicht alles reibungslos.

Da dieser Aufbau auf einem kleineren und quantisierten Modell basiert, sind die Ergebnisse für komplexere Codierungsaufgaben nicht immer aussagekräftig genug. Meiner Erfahrung nach kann es einfache Projekte, grundlegende Skripterstellung, Recherchehilfe und allgemeine Aufgaben recht intestine bewältigen, aber es fängt an, Probleme zu bekommen, wenn die Software program-Engineering-Arbeit anspruchsvoller oder mehrstufiger wird.

Ein Drawback, auf das ich immer wieder stieß, warfare, dass das Modell manchmal mitten in einer Aufgabe anhielt. Als das passierte, musste ich manuell tippen weitermachen damit es weitergeht und die Arbeit zu Ende geht. Das ist zum Experimentieren zwar machbar, aber es macht den Workflow weniger zuverlässig, wenn Sie eine konsistente Ausgabe für größere Codierungsaufgaben wünschen.

Abid Ali Awan (@1abidaliawan) ist ein zertifizierter Datenwissenschaftler, der gerne Modelle für maschinelles Lernen erstellt. Derzeit konzentriert er sich auf die Erstellung von Inhalten und das Schreiben technischer Blogs zu maschinellem Lernen und Datenwissenschaftstechnologien. Abid verfügt über einen Grasp-Abschluss in Technologiemanagement und einen Bachelor-Abschluss in Telekommunikationstechnik. Seine Imaginative and prescient ist es, ein KI-Produkt mithilfe eines graphischen neuronalen Netzwerks für Schüler mit psychischen Erkrankungen zu entwickeln.

In diesem Tutorial erstellen wir ein vollständiges Framework für kognitive Blaupausen und Laufzeitagenten. Wir definieren strukturierte Blaupausen für Identität, Ziele, Planung, Gedächtnis, Validierung und Werkzeugzugriff und verwenden sie, um Agenten zu erstellen, die nicht nur reagieren, sondern ihre Ergebnisse auch planen, ausführen, validieren und systematisch verbessern. Im Rahmen des Tutorials zeigen wir, wie dieselbe Laufzeit-Engine durch Blueprint-Portabilität mehrere Agentenpersönlichkeiten und -verhalten unterstützen kann, wodurch das Gesamtdesign modular, erweiterbar und praktisch für fortgeschrittene Agenten-KI-Experimente wird.

import json, yaml, time, math, textwrap, datetime, getpass, os
from typing import Any, Callable, Dict, Record, Elective
from dataclasses import dataclass, area
from enum import Enum


from openai import OpenAI
from pydantic import BaseModel
from wealthy.console import Console
from wealthy.panel import Panel
from wealthy.desk import Desk
from wealthy.tree import Tree


attempt:
   from google.colab import userdata
   OPENAI_API_KEY = userdata.get('OPENAI_API_KEY')
besides Exception:
   OPENAI_API_KEY = getpass.getpass(" Enter your OpenAI API key: ")


os.environ("OPENAI_API_KEY") = OPENAI_API_KEY
consumer = OpenAI(api_key=OPENAI_API_KEY)
console = Console()


class PlanningStrategy(str, Enum):
   SEQUENTIAL   = "sequential"
   HIERARCHICAL = "hierarchical"
   REACTIVE     = "reactive"


class MemoryType(str, Enum):
   SHORT_TERM = "short_term"
   EPISODIC   = "episodic"
   PERSISTENT = "persistent"


class BlueprintIdentity(BaseModel):
   identify: str
   model: str = "1.0.0"
   description: str
   writer: str = "unknown"


class BlueprintMemory(BaseModel):
   sort: MemoryType = MemoryType.SHORT_TERM
   window_size: int = 10
   summarize_after: int = 20


class BlueprintPlanning(BaseModel):
   technique: PlanningStrategy = PlanningStrategy.SEQUENTIAL
   max_steps: int = 8
   max_retries: int = 2
   think_before_acting: bool = True


class BlueprintValidation(BaseModel):
   require_reasoning: bool = True
   min_response_length: int = 10
   forbidden_phrases: Record(str) = ()


class CognitiveBlueprint(BaseModel):
   identification: BlueprintIdentity
   objectives: Record(str)
   constraints: Record(str) = ()
   instruments: Record(str) = ()
   reminiscence: BlueprintMemory = BlueprintMemory()
   planning: BlueprintPlanning = BlueprintPlanning()
   validation: BlueprintValidation = BlueprintValidation()
   system_prompt_extra: str = ""


def load_blueprint_from_yaml(yaml_str: str) -> CognitiveBlueprint:
   return CognitiveBlueprint(**yaml.safe_load(yaml_str))


RESEARCH_AGENT_YAML = """
identification:
 identify: ResearchBot
 model: 1.2.0
 description: Solutions analysis questions utilizing calculation and reasoning
 writer: Auton Framework Demo
objectives:
 - Reply consumer questions precisely utilizing accessible instruments
 - Present step-by-step reasoning for all solutions
 - Cite the tactic used for every calculation
constraints:
 - By no means fabricate numbers or statistics
 - All the time validate mathematical outcomes earlier than reporting
 - Don't reply questions outdoors your software capabilities
instruments:
 - calculator
 - unit_converter
 - date_calculator
 - search_wikipedia_stub
reminiscence:
 sort: episodic
 window_size: 12
 summarize_after: 30
planning:
 technique: sequential
 max_steps: 6
 max_retries: 2
 think_before_acting: true
validation:
 require_reasoning: true
 min_response_length: 20
 forbidden_phrases:
   - "I do not know"
   - "I can not decide"
"""


DATA_ANALYST_YAML = """
identification:
 identify: DataAnalystBot
 model: 2.0.0
 description: Performs statistical evaluation and information summarization
 writer: Auton Framework Demo
objectives:
 - Compute descriptive statistics for given information
 - Determine developments and anomalies
 - Current findings clearly with numbers
constraints:
 - Solely work with numerical information
 - All the time report uncertainty when pattern measurement is small (< 5 objects)
instruments:
 - calculator
 - statistics_engine
 - list_sorter
reminiscence:
 sort: short_term
 window_size: 6
planning:
 technique: hierarchical
 max_steps: 10
 max_retries: 3
 think_before_acting: true
validation:
 require_reasoning: true
 min_response_length: 30
 forbidden_phrases: ()
"""

Wir richten die Kernumgebung ein und definieren den kognitiven Bauplan, der das Denken und Verhalten eines Agenten strukturiert. Wir erstellen stark typisierte Modelle für Identität, Speicherkonfiguration, Planungsstrategie und Validierungsregeln mithilfe von Pydantic und Enumerationen. Wir definieren außerdem zwei YAML-basierte Blaupausen, die es uns ermöglichen, verschiedene Agentenpersönlichkeiten und -funktionen zu konfigurieren, ohne das zugrunde liegende Laufzeitsystem zu ändern.

@dataclass
class ToolSpec:
   identify: str
   description: str
   parameters: Dict(str, str)
   perform: Callable
   returns: str


class ToolRegistry:
   def __init__(self):
       self._tools: Dict(str, ToolSpec) = {}


   def register(self, identify: str, description: str,
                parameters: Dict(str, str), returns: str):
       def decorator(fn: Callable) -> Callable:
           self._tools(identify) = ToolSpec(identify, description, parameters, fn, returns)
           return fn
       return decorator


   def get(self, identify: str) -> Elective(ToolSpec):
       return self._tools.get(identify)


   def name(self, identify: str, **kwargs) -> Any:
       spec = self._tools.get(identify)
       if not spec:
           increase ValueError(f"Instrument '{identify}' not present in registry")
       return spec.perform(**kwargs)


   def get_tool_descriptions(self, allowed: Record(str)) -> str:
       strains = ()
       for identify in allowed:
           spec = self._tools.get(identify)
           if spec:
               params = ", ".be a part of(f"{ok}: {v}" for ok, v in spec.parameters.objects())
               strains.append(
                   f"• {spec.identify}({params})n"
                   f"  → {spec.description}n"
                   f"  Returns: {spec.returns}"
               )
       return "n".be a part of(strains)


   def list_tools(self) -> Record(str):
       return checklist(self._tools.keys())


registry = ToolRegistry()


@registry.register(
   identify="calculator",
   description="Evaluates a secure mathematical expression",
   parameters={"expression": "A math expression string, e.g. '2 ** 10 + 5 * 3'"},
   returns="Numeric end result as float"
)
def calculator(expression: str) -> str:
   attempt:
       allowed = {ok: v for ok, v in math.__dict__.objects() if not ok.startswith("_")}
       allowed.replace({"abs": abs, "spherical": spherical, "pow": pow})
       return str(eval(expression, {"__builtins__": {}}, allowed))
   besides Exception as e:
       return f"Error: {e}"


@registry.register(
   identify="unit_converter",
   description="Converts between frequent models of measurement",
   parameters={
       "worth": "Numeric worth to transform",
       "from_unit": "Supply unit (km, miles, kg, lbs, celsius, fahrenheit, liters, gallons, meters, ft)",
       "to_unit": "Goal unit"
   },
   returns="Transformed worth as string with models"
)
def unit_converter(worth: float, from_unit: str, to_unit: str) -> str:
   conversions = {
       ("km", "miles"): lambda x: x * 0.621371,
       ("miles", "km"): lambda x: x * 1.60934,
       ("kg", "lbs"):   lambda x: x * 2.20462,
       ("lbs", "kg"):   lambda x: x / 2.20462,
       ("celsius", "fahrenheit"): lambda x: x * 9/5 + 32,
       ("fahrenheit", "celsius"): lambda x: (x - 32) * 5/9,
       ("liters", "gallons"): lambda x: x * 0.264172,
       ("gallons", "liters"): lambda x: x * 3.78541,
       ("meters", "ft"): lambda x: x * 3.28084,
       ("ft", "meters"): lambda x: x / 3.28084,
   }
   key = (from_unit.decrease(), to_unit.decrease())
   if key in conversions:
       return f"{conversions(key)(float(worth)):.4f} {to_unit}"
   return f"Conversion from {from_unit} to {to_unit} not supported"


@registry.register(
   identify="date_calculator",
   description="Calculates days between two dates, or provides/subtracts days from a date",
   parameters={
       "operation": "'days_between' or 'add_days'",
       "date1": "Date string in YYYY-MM-DD format",
       "date2": "Second date for days_between (YYYY-MM-DD), or variety of days for add_days"
   },
   returns="Outcome as string"
)
def date_calculator(operation: str, date1: str, date2: str) -> str:
   attempt:
       d1 = datetime.datetime.strptime(date1, "%Y-%m-%d")
       if operation == "days_between":
           d2 = datetime.datetime.strptime(date2, "%Y-%m-%d")
           return f"{abs((d2 - d1).days)} days between {date1} and {date2}"
       elif operation == "add_days":
           end result = d1 + datetime.timedelta(days=int(date2))
           return f"{end result.strftime('%Y-%m-%d')} (added {date2} days to {date1})"
       return f"Unknown operation: {operation}"
   besides Exception as e:
       return f"Error: {e}"


@registry.register(
   identify="search_wikipedia_stub",
   description="Returns a stub abstract for well-known subjects (demo — no dwell web)",
   parameters={"subject": "Subject to lookup"},
   returns="Brief textual content abstract"
)
def search_wikipedia_stub(subject: str) -> str:
   stubs = {
       "openai": "OpenAI is an AI analysis firm based in 2015. It created GPT-4 and the ChatGPT product.",
   }
   for key, val in stubs.objects():
       if key in subject.decrease():
           return val
   return f"No stub discovered for '{subject}'. In manufacturing, this may question Wikipedia's API."

Wir implementieren die Instrument-Registrierung, die es Agenten ermöglicht, externe Funktionen dynamisch zu erkennen und zu nutzen. Wir entwerfen ein strukturiertes System, in dem Werkzeuge mit Metadaten registriert werden, einschließlich Parametern, Beschreibungen und Rückgabewerten. Wir implementieren außerdem mehrere praktische Instruments, wie einen Taschenrechner, einen Einheitenumrechner, einen Datumsrechner und einen Wikipedia-Such-Stub, den die Agenten während der Ausführung aufrufen können.

@registry.register(
   identify="statistics_engine",
   description="Computes descriptive statistics on an inventory of numbers",
   parameters={"numbers": "Comma-separated checklist of numbers, e.g. '4,8,15,16,23,42'"},
   returns="JSON with imply, median, std_dev, min, max, rely"
)
def statistics_engine(numbers: str) -> str:
   attempt:
       nums = (float(x.strip()) for x in numbers.cut up(","))
       n = len(nums)
       imply = sum(nums) / n
       sorted_nums = sorted(nums)
       mid = n // 2
       median = sorted_nums(mid) if n % 2 else (sorted_nums(mid-1) + sorted_nums(mid)) / 2
       std_dev = math.sqrt(sum((x - imply) ** 2 for x in nums) / n)
       return json.dumps({
           "rely": n, "imply": spherical(imply, 4), "median": spherical(median, 4),
           "std_dev": spherical(std_dev, 4), "min": min(nums),
           "max": max(nums), "vary": max(nums) - min(nums)
       }, indent=2)
   besides Exception as e:
       return f"Error: {e}"


@registry.register(
   identify="list_sorter",
   description="Types a comma-separated checklist of numbers",
   parameters={"numbers": "Comma-separated numbers", "order": "'asc' or 'desc'"},
   returns="Sorted comma-separated checklist"
)
def list_sorter(numbers: str, order: str = "asc") -> str:
   nums = (float(x.strip()) for x in numbers.cut up(","))
   nums.type(reverse=(order == "desc"))
   return ", ".be a part of(str(n) for n in nums)


@dataclass
class MemoryEntry:
   function: str
   content material: str
   timestamp: float = area(default_factory=time.time)
   metadata: Dict = area(default_factory=dict)


class MemoryManager:
   def __init__(self, config: BlueprintMemory, llm_client: OpenAI):
       self.config = config
       self.consumer = llm_client
       self._history: Record(MemoryEntry) = ()
       self._summary: str = ""


   def add(self, function: str, content material: str, metadata: Dict = None):
       self._history.append(MemoryEntry(function=function, content material=content material, metadata=metadata or {}))
       if (self.config.sort == MemoryType.EPISODIC and
               len(self._history) > self.config.summarize_after):
           self._compress_memory()


   def _compress_memory(self):
       to_compress = self._history(:-self.config.window_size)
       self._history = self._history(-self.config.window_size:)
       textual content = "n".be a part of(f"{e.function}: {e.content material(:200)}" for e in to_compress)
       attempt:
           resp = self.consumer.chat.completions.create(
               mannequin="gpt-4o-mini",
               messages=({"function": "consumer", "content material":
                   f"Summarize this dialog historical past in 3 sentences:n{textual content}"}),
               max_tokens=150
           )
           self._summary += " " + resp.decisions(0).message.content material.strip()
       besides Exception:
           self._summary += f" (compressed {len(to_compress)} messages)"


   def get_messages(self, system_prompt: str) -> Record(Dict):
       messages = ({"function": "system", "content material": system_prompt})
       if self._summary:
           messages.append({"function": "system",
               "content material": f"(Reminiscence Abstract): {self._summary.strip()}"})
       for entry in self._history(-self.config.window_size:):
           messages.append({
               "function": entry.function if entry.function != "software" else "assistant",
               "content material": entry.content material
           })
       return messages


   def clear(self):
       self._history = ()
       self._summary = ""


   @property
   def message_count(self) -> int:
       return len(self._history)

Wir erweitern das Instrument-Ökosystem und führen die Speicherverwaltungsschicht ein, die den Gesprächsverlauf speichert und bei Bedarf komprimiert. Wir implementieren statistische Instruments und Sortierprogramme, die es dem Datenanalyseagenten ermöglichen, strukturierte numerische Operationen durchzuführen. Gleichzeitig entwerfen wir ein Speichersystem, das Interaktionen verfolgt, lange Historien zusammenfasst und dem Sprachmodell kontextbezogene Nachrichten liefert.

@dataclass
class PlanStep:
   step_id: int
   description: str
   software: Elective(str)
   tool_args: Dict(str, Any)
   reasoning: str


@dataclass
class Plan:
   job: str
   steps: Record(PlanStep)
   technique: PlanningStrategy


class Planner:
   def __init__(self, blueprint: CognitiveBlueprint,
                registry: ToolRegistry, llm_client: OpenAI):
       self.blueprint = blueprint
       self.registry  = registry
       self.consumer    = llm_client


   def _build_planner_prompt(self) -> str:
       bp = self.blueprint
       return textwrap.dedent(f"""
           You might be {bp.identification.identify}, model {bp.identification.model}.
           {bp.identification.description}


           ## Your Objectives:
           {chr(10).be a part of(f'  - {g}' for g in bp.objectives)}


           ## Your Constraints:
           {chr(10).be a part of(f'  - {c}' for c in bp.constraints)}


           ## Accessible Instruments:
           {self.registry.get_tool_descriptions(bp.instruments)}


           ## Planning Technique: {bp.planning.technique}
           ## Max Steps: {bp.planning.max_steps}


           Given a consumer job, produce a JSON execution plan with this precise construction:
           {{
             "steps": (
               {{
                 "step_id": 1,
                 "description": "What this step does",
                 "software": "tool_name or null if no software wanted",
                 "tool_args": {{"arg1": "value1"}},
                 "reasoning": "Why this step is required"
               }}
             )
           }}


           Guidelines:
           - Solely use instruments listed above
           - Set software to null for pure reasoning steps
           - Maintain steps <= {bp.planning.max_steps}
           - Return ONLY legitimate JSON, no markdown fences
           {bp.system_prompt_extra}
       """).strip()


   def plan(self, job: str, reminiscence: MemoryManager) -> Plan:
       system_prompt = self._build_planner_prompt()
       messages = reminiscence.get_messages(system_prompt)
       messages.append({"function": "consumer", "content material":
           f"Create a plan to finish this job: {job}"})
       resp = self.consumer.chat.completions.create(
           mannequin="gpt-4o-mini", messages=messages,
           max_tokens=1200, temperature=0.2
       )
       uncooked = resp.decisions(0).message.content material.strip()
       uncooked = uncooked.change("```json", "").change("```", "").strip()
       information = json.hundreds(uncooked)
       steps = (
           PlanStep(
               step_id=s("step_id"), description=s("description"),
               software=s.get("software"), tool_args=s.get("tool_args", {}),
               reasoning=s.get("reasoning", "")
           )
           for s in information("steps")
       )
       return Plan(job=job, steps=steps, technique=self.blueprint.planning.technique)


@dataclass
class StepResult:
   step_id: int
   success: bool
   output: str
   tool_used: Elective(str)
   error: Elective(str) = None


@dataclass
class ExecutionTrace:
   plan: Plan
   outcomes: Record(StepResult)
   final_answer: str


class Executor:
   def __init__(self, blueprint: CognitiveBlueprint,
                registry: ToolRegistry, llm_client: OpenAI):
       self.blueprint = blueprint
       self.registry  = registry
       self.consumer    = llm_client

Wir implementieren das Planungssystem, das eine Benutzeraufgabe in einen strukturierten Ausführungsplan umwandelt, der aus mehreren Schritten besteht. Wir entwerfen einen Planer, der das Sprachmodell anweist, einen JSON-Plan zu erstellen, der Begründung, Werkzeugauswahl und Argumente für jeden Schritt enthält. Diese Planungsebene ermöglicht es dem Agenten, komplexe Probleme vor der Ausführung in kleinere ausführbare Aktionen zu unterteilen.

  def execute_plan(self, plan: Plan, reminiscence: MemoryManager,
                    verbose: bool = True) -> ExecutionTrace:
       outcomes: Record(StepResult) = ()
       if verbose:
           console.print(f"n(daring yellow) Executing:(/) {plan.job}")
           console.print(f"   Technique: {plan.technique} | Steps: {len(plan.steps)}")


       for step in plan.steps:
           if verbose:
               console.print(f"n  (cyan)Step {step.step_id}:(/) {step.description}")
           attempt:
               if step.software and step.software != "null":
                   if verbose:
                       console.print(f"    Instrument: (inexperienced){step.software}(/) | Args: {step.tool_args}")
                   output = self.registry.name(step.software, **step.tool_args)
                   end result = StepResult(step.step_id, True, str(output), step.software)
                   if verbose:
                       console.print(f"    Outcome: {output}")
               else:
                   context_text = "n".be a part of(
                       f"Step {r.step_id} end result: {r.output}" for r in outcomes)
                   immediate = (
                       f"Earlier outcomes:n{context_text}nn"
                       f"Now full this step: {step.description}n"
                       f"Reasoning trace: {step.reasoning}"
                   ) if context_text else (
                       f"Full this step: {step.description}n"
                       f"Reasoning trace: {step.reasoning}"
                   )
                   sys_prompt = (
                       f"You might be {self.blueprint.identification.identify}. "
                       f"{self.blueprint.identification.description}. "
                       f"Constraints: {'; '.be a part of(self.blueprint.constraints)}"
                   )
                   resp = self.consumer.chat.completions.create(
                       mannequin="gpt-4o-mini",
                       messages=(
                           {"function": "system", "content material": sys_prompt},
                           {"function": "consumer",   "content material": immediate}
                       ),
                       max_tokens=500, temperature=0.3
                   )
                   output = resp.decisions(0).message.content material.strip()
                   end result = StepResult(step.step_id, True, output, None)
                   if verbose:
                       preview = output(:120) + "..." if len(output) > 120 else output
                       console.print(f"    Reasoning: {preview}")
           besides Exception as e:
               end result = StepResult(step.step_id, False, "", step.software, str(e))
               if verbose:
                   console.print(f"    Error: {e}")
           outcomes.append(end result)


       final_answer = self._synthesize(plan, outcomes, reminiscence)
       return ExecutionTrace(plan=plan, outcomes=outcomes, final_answer=final_answer)


   def _synthesize(self, plan: Plan, outcomes: Record(StepResult),
                   reminiscence: MemoryManager) -> str:
       steps_summary = "n".be a part of(
           f"Step {r.step_id} ({'' if r.success else ''}): {r.output(:300)}"
           for r in outcomes
       )
       synthesis_prompt = (
           f"Authentic job: {plan.job}nn"
           f"Step outcomes:n{steps_summary}nn"
           f"Present a transparent, full last reply. Combine all step outcomes."
       )
       sys_prompt = (
           f"You might be {self.blueprint.identification.identify}. "
           + ("All the time present your reasoning. " if self.blueprint.validation.require_reasoning else "")
           + f"Objectives: {'; '.be a part of(self.blueprint.objectives)}"
       )
       messages = reminiscence.get_messages(sys_prompt)
       messages.append({"function": "consumer", "content material": synthesis_prompt})
       resp = self.consumer.chat.completions.create(
           mannequin="gpt-4o-mini", messages=messages,
           max_tokens=600, temperature=0.3
       )
       return resp.decisions(0).message.content material.strip()


@dataclass
class ValidationResult:
   handed: bool
   points: Record(str)
   rating: float


class Validator:
   def __init__(self, blueprint: CognitiveBlueprint, llm_client: OpenAI):
       self.blueprint = blueprint
       self.consumer    = llm_client


   def validate(self, reply: str, job: str,
                use_llm_check: bool = False) -> ValidationResult:
       points = ()
       v = self.blueprint.validation


       if len(reply) < v.min_response_length:
           points.append(f"Response too brief: {len(reply)} chars (min: {v.min_response_length})")


       answer_lower = reply.decrease()
       for phrase in v.forbidden_phrases:
           if phrase.decrease() in answer_lower:
               points.append(f"Forbidden phrase detected: '{phrase}'")


       if v.require_reasoning:
           indicators = ("as a result of", "subsequently", "since", "step", "first",
                         "end result", "calculated", "computed", "discovered that")
           if not any(ind in answer_lower for ind in indicators):
               points.append("Response lacks seen reasoning or rationalization")


       if use_llm_check:
           points.prolong(self._llm_quality_check(reply, job))


       return ValidationResult(handed=len(points) == 0,
                               points=points,
                               rating=max(0.0, 1.0 - len(points) * 0.25))


   def _llm_quality_check(self, reply: str, job: str) -> Record(str):
       immediate = (
           f"Job: {job}nnAnswer: {reply(:500)}nn"
           f'Does this reply deal with the duty? Reply JSON: {{"on_topic": true/false, "difficulty": "..."}}'
       )
       attempt:
           resp = self.consumer.chat.completions.create(
               mannequin="gpt-4o-mini",
               messages=({"function": "consumer", "content material": immediate}),
               max_tokens=100
           )
           uncooked = resp.decisions(0).message.content material.strip().change("```json","").change("```","")
           information = json.hundreds(uncooked)
           if not information.get("on_topic", True):
               return (f"LLM high quality test: {information.get('difficulty', 'off-topic')}")
       besides Exception:
           move
       return ()

Wir erstellen den Executor und die Validierungslogik, die die vom Planer generierten Schritte tatsächlich ausführt. Wir implementieren ein System, das je nach Schrittdefinition entweder registrierte Instruments aufrufen oder Argumentationen über das Sprachmodell durchführen kann. Wir fügen außerdem einen Validator hinzu, der die endgültige Antwort anhand von Blueprint-Einschränkungen wie Mindestlänge, Begründungsanforderungen und verbotenen Phrasen prüft.

@dataclass
class AgentResponse:
   agent_name: str
   job: str
   final_answer: str
   hint: ExecutionTrace
   validation: ValidationResult
   retries: int
   total_steps: int


class RuntimeEngine:
   def __init__(self, blueprint: CognitiveBlueprint,
                registry: ToolRegistry, llm_client: OpenAI):
       self.blueprint = blueprint
       self.reminiscence    = MemoryManager(blueprint.reminiscence, llm_client)
       self.planner   = Planner(blueprint, registry, llm_client)
       self.executor  = Executor(blueprint, registry, llm_client)
       self.validator = Validator(blueprint, llm_client)


   def run(self, job: str, verbose: bool = True) -> AgentResponse:
       bp = self.blueprint
       if verbose:
           console.print(Panel(
               f"(daring)Agent:(/) {bp.identification.identify} v{bp.identification.model}n"
               f"(daring)Job:(/) {job}n"
               f"(daring)Technique:(/) {bp.planning.technique} | "
               f"Max Steps: {bp.planning.max_steps} | "
               f"Max Retries: {bp.planning.max_retries}",
               title=" Runtime Engine Beginning", border_style="blue"
           ))


       self.reminiscence.add("consumer", job)
       retries, hint, validation = 0, None, None


       for try in vary(bp.planning.max_retries + 1):
           if try > 0 and verbose:
               console.print(f"n(yellow)⟳ Retry {try}/{bp.planning.max_retries}(/)")
               console.print(f"  Points: {', '.be a part of(validation.points)}")


           if verbose:
               console.print("n(daring magenta) Part 1: Planning...(/)")
           attempt:
               plan = self.planner.plan(job, self.reminiscence)
               if verbose:
                   tree = Tree(f"(daring)Plan ({len(plan.steps)} steps)(/)")
                   for s in plan.steps:
                       icon = "" if s.software else ""
                       department = tree.add(f"{icon} Step {s.step_id}: {s.description}")
                       if s.software:
                           department.add(f"(inexperienced)Instrument:(/) {s.software}")
                           department.add(f"(yellow)Args:(/) {s.tool_args}")
                   console.print(tree)
           besides Exception as e:
               if verbose: console.print(f"(pink)Planning failed:(/) {e}")
               break


           if verbose:
               console.print("n(daring magenta) Part 2: Executing...(/)")
           hint = self.executor.execute_plan(plan, self.reminiscence, verbose=verbose)


           if verbose:
               console.print("n(daring magenta) Part 3: Validating...(/)")
           validation = self.validator.validate(hint.final_answer, job)


           if verbose:
               standing = "(inexperienced)PASSED(/)" if validation.handed else "(pink)FAILED(/)"
               console.print(f"  Validation: {standing} | Rating: {validation.rating:.2f}")
               for difficulty in validation.points:
                   console.print(f"    {difficulty}")


           if validation.handed:
               break


           retries += 1
           self.reminiscence.add("assistant", hint.final_answer)
           self.reminiscence.add("consumer",
               f"Your earlier reply had points: {'; '.be a part of(validation.points)}. "
               f"Please enhance."
           )


       if hint:
           self.reminiscence.add("assistant", hint.final_answer)


       if verbose:
           console.print(Panel(
               hint.final_answer if hint else "No reply generated",
               title=f" Remaining Reply — {bp.identification.identify}",
               border_style="inexperienced"
           ))


       return AgentResponse(
           agent_name=bp.identification.identify, job=job,
           final_answer=hint.final_answer if hint else "",
           hint=hint, validation=validation,
           retries=retries,
           total_steps=len(hint.outcomes) if hint else 0
       )


   def reset_memory(self):
       self.reminiscence.clear()


def build_engine(blueprint_yaml: str, registry: ToolRegistry,
                llm_client: OpenAI) -> RuntimeEngine:
   return RuntimeEngine(load_blueprint_from_yaml(blueprint_yaml), registry, llm_client)


if __name__ == "__main__":


   print("n" + "="*60)
   print("DEMO 1: ResearchBot")
   print("="*60)
   research_engine = build_engine(RESEARCH_AGENT_YAML, registry, consumer)
   research_engine.run(
       job=(
           "what number of steps of 20cm top would that be? Additionally, if I burn 0.15 "
           "energy per step, what is the complete calorie burn? Present all calculations."
       )
   )


   print("n" + "="*60)
   print("DEMO 2: DataAnalystBot")
   print("="*60)
   analyst_engine = build_engine(DATA_ANALYST_YAML, registry, consumer)
   analyst_engine.run(
       job=(
           "Analyze this dataset of month-to-month gross sales figures (in 1000's): "
           "142, 198, 173, 155, 221, 189, 203, 167, 244, 198, 212, 231. "
           "Compute key statistics, determine the very best and worst months, "
           "and calculate development from first to final month."
       )
   )


   print("n" + "="*60)
   print("PORTABILITY DEMO: Identical job → 2 totally different blueprints")
   print("="*60)
   SHARED_TASK = "Calculate 15% of two,500 and inform me the end result."


   responses = {}
   for identify, yaml_str in (
       ("ResearchBot",    RESEARCH_AGENT_YAML),
       ("DataAnalystBot", DATA_ANALYST_YAML),
   ):
       eng = build_engine(yaml_str, registry, consumer)
       responses(identify) = eng.run(SHARED_TASK, verbose=False)


   desk = Desk(title=" Blueprint Portability", show_header=True, show_lines=True)
   desk.add_column("Agent",   fashion="cyan",   width=18)
   desk.add_column("Steps",   fashion="yellow", width=6)
   desk.add_column("Legitimate?",  width=7)
   desk.add_column("Rating",   width=6)
   desk.add_column("Reply Preview", width=55)


   for identify, r in responses.objects():
       desk.add_row(
           identify, str(r.total_steps),
           "" if r.validation.handed else "",
           f"{r.validation.rating:.2f}",
           r.final_answer(:140) + "..."
       )
   console.print(desk)

Wir stellen die Laufzeit-Engine zusammen, die Planung, Ausführung, Speicheraktualisierungen und Validierung zu einem vollständig autonomen Workflow orchestriert. Wir führen mehrere Demonstrationen durch, die zeigen, wie unterschiedliche Blaupausen bei Verwendung derselben Kernarchitektur unterschiedliche Verhaltensweisen hervorrufen. Abschließend veranschaulichen wir die Blueprint-Portabilität, indem wir dieselbe Aufgabe auf zwei Agenten ausführen und deren Ergebnisse vergleichen.

Zusammenfassend haben wir ein voll funktionsfähiges Laufzeitsystem im Auton-Stil erstellt, das kognitive Blaupausen, Werkzeugregister, Speicherverwaltung, Planung, Ausführung und Validierung in ein zusammenhängendes Framework integriert. Wir haben gezeigt, wie verschiedene Agenten die gleiche zugrunde liegende Architektur nutzen und sich dabei unterschiedlich verhalten können, indem wir benutzerdefinierte Blaupausen erstellt haben, was die Flexibilität und Leistungsfähigkeit des Designs hervorgehoben hat. Durch diese Implementierung haben wir nicht nur untersucht, wie moderne Laufzeitagenten funktionieren, sondern auch eine solide Grundlage geschaffen, die wir mit umfangreicheren Instruments, stärkeren Speichersystemen und fortschrittlicheren autonomen Verhaltensweisen weiter ausbauen können.

Schauen Sie sich das an Vollständige Codes hier Und Verwandtes Papier. Sie können uns auch gerne weiter folgen Twitter und vergessen Sie nicht, bei uns mitzumachen 120.000+ ML SubReddit und Abonnieren Unser E-newsletter. Warten! Bist du im Telegram? Jetzt können Sie uns auch per Telegram kontaktieren.

Aktie

Publish


Aktie

5 wesentliche Sicherheitsmuster für robuste Agenten-KI
Bild vom Herausgeber

Einführung

Agentische KIdas sich um autonome Softwareeinheiten, sogenannte Agenten, dreht, hat die KI-Landschaft verändert und viele ihrer sichtbarsten Entwicklungen und Tendencies in den letzten Jahren beeinflusst, darunter Anwendungen, die auf generativen und Sprachmodellen basieren.

Mit jeder großen Technologiewelle wie der Agenten-KI entsteht die Notwendigkeit, diese Systeme zu sichern. Dies erfordert eine Umstellung vom statischen Datenschutz hin zum Schutz dynamischer, mehrstufiger Verhaltensweisen. Dieser Artikel listet 5 wichtige Sicherheitsmuster für robuste KI-Agenten auf und zeigt, warum sie wichtig sind.

1. Simply-in-Time-Software-Berechtigungen

Dies wird oft als JIT abgekürzt und ist ein Sicherheitsmodell, das Benutzern oder Anwendungen nur bei Bedarf und nur für einen begrenzten Zeitraum spezielle oder erhöhte Zugriffsrechte gewährt. Dies steht im Gegensatz zu klassischen, dauerhaften Privilegien, die bestehen bleiben, sofern sie nicht manuell geändert oder widerrufen werden. Im Bereich der Agenten-KI wäre ein Beispiel die Ausgabe kurzfristiger Zugriffstoken, um den „Explosionsradius“ zu begrenzen, wenn der Agent kompromittiert wird.

Beispiel: Bevor ein Agent einen Abrechnungsabgleichsjob ausführt, fordert er ein eng begrenztes, schreibgeschütztes 5-Minuten-Token für eine einzelne Datenbanktabelle an und löscht das Token automatisch, sobald die Abfrage abgeschlossen ist.

2. Begrenzte Autonomie

Dieses Sicherheitsprinzip ermöglicht es KI-Agenten, innerhalb einer begrenzten Umgebung, d. h. innerhalb klar definierter sicherer Parameter, unabhängig zu agieren und so ein Gleichgewicht zwischen Kontrolle und Effizienz herzustellen. Dies ist besonders wichtig in Hochrisikoszenarien, in denen katastrophale Fehler bei vollständiger Autonomie vermieden werden können, indem für wise Aktionen die Zustimmung eines Menschen erforderlich ist. In der Praxis wird dadurch eine Kontrollebene geschaffen, um Risiken zu reduzieren und Compliance-Anforderungen zu unterstützen.

Beispiel: Ein Agent kann ausgehende E-Mails selbst entwerfen und planen, aber jede Nachricht an mehr als 100 Empfänger (oder mit Anhängen) wird vor dem Senden zur Genehmigung an einen Menschen weitergeleitet.

3. Die KI-Firewall

Damit ist eine dedizierte Sicherheitsschicht gemeint, die Eingaben (Benutzeraufforderungen) und nachfolgende Reaktionen filtert, prüft und steuert, um KI-Systeme zu schützen. Es trägt zum Schutz vor Bedrohungen wie Immediate-Injection, Datenexfiltration und toxischen oder richtlinienverletzenden Inhalten bei.

Beispiel: Eingehende Eingabeaufforderungen werden auf Eingabeaufforderungsmuster überprüft (z. B. Aufforderungen, frühere Anweisungen zu ignorieren oder Geheimnisse preiszugeben), und markierte Eingabeaufforderungen werden entweder blockiert oder in eine sicherere Kind umgeschrieben, bevor der Agent sie sieht.

4. Ausführungs-Sandboxing

Nehmen Sie eine streng isolierte, non-public Umgebung oder einen Netzwerkperimeter und führen Sie darin jeglichen vom Agenten generierten Code aus: Dies wird als Ausführungs-Sandboxing bezeichnet. Es trägt dazu bei, unbefugten Zugriff, Ressourcenerschöpfung und potenzielle Datenschutzverletzungen zu verhindern, indem es die Auswirkungen einer nicht vertrauenswürdigen oder unvorhersehbaren Ausführung eindämmt.

Beispiel: Ein Agent, der ein Python-Skript zur Transformation von CSV-Dateien schreibt, führt es in einem gesperrten Container ohne ausgehenden Netzwerkzugriff, strengen CPU-/Speicherkontingenten und einer schreibgeschützten Bereitstellung der Eingabedaten aus.

5. Unveränderliche Argumentationsspuren

Diese Vorgehensweise unterstützt die Prüfung autonomer Agentenentscheidungen und die Erkennung von Verhaltensproblemen wie Drift. Dazu gehört die Erstellung zeitgestempelter, manipulationssicherer und dauerhafter Protokolle, die die Eingaben des Agenten, wichtige Zwischenartefakte, die für die Entscheidungsfindung verwendet werden, und Richtlinienprüfungen erfassen. Dies ist ein entscheidender Schritt in Richtung Transparenz und Rechenschaftspflicht für autonome Systeme, insbesondere in wichtigen Anwendungsbereichen wie Beschaffung und Finanzen.

Beispiel: Für jede Bestellung, die der Agent genehmigt, zeichnet er den Anfragekontext, die abgerufenen Richtlinienausschnitte, die angewendeten Leitplankenprüfungen und die endgültige Entscheidung in einem einmal beschreibbaren Protokoll auf, das bei Audits unabhängig überprüft werden kann.

Wichtige Erkenntnisse

Diese Muster funktionieren am besten als mehrschichtiges System und nicht als eigenständige Steuerelemente. Simply-in-Time-Software-Berechtigungen minimieren den Zugriff, auf den ein Agent jederzeit zugreifen kann, während die begrenzte Autonomie die Aktionen einschränkt, die er ohne Aufsicht durchführen kann. Die KI-Firewall reduziert das Risiko an der Interaktionsgrenze, indem sie Eingaben und Ausgaben filtert und formt, und das Ausführungs-Sandboxing dämmt die Auswirkungen jeglichen Codes ein, den der Agent generiert oder ausführt. Schließlich liefern unveränderliche Argumentationsspuren den Prüfpfad, mit dem Sie Abweichungen erkennen, Vorfälle untersuchen und Richtlinien im Laufe der Zeit kontinuierlich verschärfen können.

Zusammengenommen verringern diese Einschränkungen die Wahrscheinlichkeit, dass ein einzelner Fehler zu einem systemischen Verstoß wird, ohne die betrieblichen Vorteile zunichte zu machen, die die Agenten-KI attraktiv machen.

Aktie

Publish


Aktie

Agentische KI geht über das Experimentieren hinaus und findet Eingang in echte Unternehmensabläufe. Im Gegensatz zu herkömmlichen KI-Modellen, die lediglich Vorhersagen generieren, können Agenten-KI-Systeme schlussfolgern, Werkzeuge koordinieren, Arbeitsabläufe auslösen und autonom innerhalb definierter Leitplanken agieren. Doch für mittelständische Unternehmen, die die Einführung evaluieren, bleibt eine große Frage: Was kostet die Implementierung eigentlich?

Die kurze Antwort lautet: Es hängt vom Umfang, der Integrationstiefe und der betrieblichen Komplexität ab. Wir können jedoch realistische grobe Spannen angeben, um die Erwartungen zu orientieren.

Was treibt die Kosten der Agenten-KI an?

Für ein mittelständisches Unternehmen (typischerweise 200–1.500 Mitarbeiter) werden die Kosten für die Implementierung einer Agenten-KI von fünf Hauptfaktoren beeinflusst:

1. Komplexität des Anwendungsfalls

Ein einfacher interner Workflow-Automatisierungsagent (z. B. Rechnungsvalidierung oder IT-Ticketweiterleitung) kostet deutlich weniger als ein Orchestrierungssystem mit mehreren Agenten, das CRM-, ERP-, Finanz- und Compliance-Systeme umfasst.

2. Systemintegrationen

Agentische KI arbeitet selten isoliert. Integration mit:

CRM-Plattformen

ERP-Systeme

Knowledge Warehouses

APIs und Legacy-Datenbanken

erhöht die Entwicklungs- und Testzeit.

3. Datenbereitschaft

Wenn Ihre Daten strukturiert, zugänglich und sauber sind, erfolgt die Implementierung schneller. Wenn Daten fragmentiert oder isoliert sind, steigen die Datenentwicklungskosten.

4. Sicherheits- und Compliance-Anforderungen

Für regulierte Branchen (Finanzen, Gesundheitswesen, Fertigung) erhöhen Governance-Ebenen wie Prüfpfade, Erklärbarkeitsmodule und rollenbasierte Zugriffskontrollen den Implementierungsaufwand.

5. Bereitstellungsmodell

Cloud-native Bereitstellungen sind im Allgemeinen kosteneffizienter als stark angepasste On-Premise-Umgebungen.

Grobe Kostenspannen für mittelständische Unternehmen

Während die genauen Zahlen variieren, finden Sie hier einen praktischen Schätzrahmen:

Part 1: AI PoC oder MVP

Grober Bereich: 40.000 – 120.000 US-Greenback

Dazu gehört:

Use-Case-Design

Einrichtung der Agentenarchitektur

Begrenzte Integrationen

Kontrollierter Piloteinsatz

Grundlegende Leistungsüberwachung

In dieser Part werden Machbarkeit und ROI vor der Skalierung validiert.

Part 2: Produktionsbereitstellung (einzelne Abteilung)

Grober Bereich: 120.000 – 350.000 US-Greenback

Dazu gehören typischerweise:

Multisystemintegrationen

Sicherheits- und Governance-Ebenen

Workflows zur Agenten-Orchestrierung

Überwachungs-Dashboards

Leistungsoptimierung

In dieser Part arbeiten die KI-Agenten in Reside-Workflows mit messbarer Wirkung.

Part 3: Agentisches Ökosystem im Unternehmensmaßstab

Grober Bereich: 350.000 $ – 900.000 $+

Für Unternehmen, die Folgendes bereitstellen:

Abteilungsübergreifende Koordination mehrerer Agenten

Autonome Entscheidungsweiterleitung

Umgebungsübergreifende Bereitstellung (Entwicklung, Staging, Produktion)

Kontinuierliche Lernpipelines

Erweiterte Compliance- und Audit-Frameworks

Die Kosten steigen mit zunehmender Autonomie, Zuverlässigkeit und Größe.

Zu berücksichtigende laufende Kosten

Über die anfängliche Implementierung hinaus sollten mittelständische Unternehmen Folgendes einplanen:

Cloud-Infrastruktur und API-Nutzung (LLM-Kosten können je nach Nutzungsvolumen variieren)

Überwachung und AgentOps-Administration

Kontinuierliche Modellumschulung

Sicherheitsüberprüfungen und Governance-Updates

Die Betriebskosten liegen typischerweise zwischen 15–25 % der ursprünglichen Baukosten professional Jahrabhängig von Systemkomplexität und Nutzungsvolumen.

Welcher ROI kann die Investition ausgleichen?

Agentische KI rechtfertigt ihre Kosten oft durch:

20–40 % Reduzierung der manuellen Bearbeitungszeit

Schnellere Entscheidungszyklen

Geringere Fehlerquoten

Reduzierte Compliance-Gefährdung

Verbesserte Skalierbarkeit ohne proportionales Personalwachstum

Bei mittelständischen Unternehmen ist der ROI in der Regel innerhalb von 6–12 Monaten sichtbar, wenn Anwendungsfälle klar definiert und mit betrieblichen Kennzahlen verknüpft sind.

Letzte Perspektive

Die Implementierung einer Agenten-KI ist eher eine strategische Investition als ein einfacher Softwarekauf. Für mittelständische Unternehmen bietet ein stufenweiser Rollout – beginnend mit einem fokussierten MVP und Skalierung nach messbarem Erfolg – ​​die beste Stability zwischen Kostenkontrolle und langfristiger Wirkung.

Organisationen, die die Umsetzung mit einer strukturierten Roadmap, einer starken Governance und messbaren Zielen angehen, sind diejenigen, die echten Unternehmenswert erschließen. Unternehmen mögen Intellectyxbekannt für KI-Beratung auf Unternehmensniveau und Bereitstellung von Agentensystemen, hilft Unternehmen beim Übergang vom Experimentieren zur skalierbaren intelligenten Automatisierung mit kontrolliertem Risiko und vorhersehbaren Investitionen.

Die eigentliche Frage ist nicht nur, wie viel die Agenten-KI kostet, sondern auch, wie viel betriebliche Effizienz und Wettbewerbsvorteile Ihr Unternehmen durch die strategische Implementierung erzielen kann.

Bild vom Autor

# Einführung

Agentische KI-Systeme kann komplexe Aufgaben aufschlüsseln, Instruments verwenden und Entscheidungen über mehrere Schritte hinweg treffen, um Ziele zu erreichen. Im Gegensatz zu einfachen Chatbots, die auf einzelne Anfragen reagieren, planen, führen Agenten ihre Vorgehensweise aus und passen sie auf der Grundlage der Ergebnisse an. Diese Fähigkeit eröffnet Möglichkeiten zur Automatisierung und Problemlösung, die mit früheren KI-Systemen nicht möglich waren.

Der Aufbau effektiver Agenten erfordert ein Verständnis dafür, wie man KI-Systemen Entscheidungsfreiheit verleiht und gleichzeitig Kontrolle und Zuverlässigkeit behält. Hier sind sieben Schritte, um die Entwicklung der Agenten-KI zu meistern.

# Schritt 1: Die Kernagentenschleife verstehen

Jeder Agent folgt einem Grundzyklus: Beobachten Sie den aktuellen Zustand, überlegen Sie, was als nächstes zu tun ist, ergreifen Sie Maßnahmen und beobachten Sie die Ergebnisse. Diese Schleife wird fortgesetzt, bis der Agent seine Aufgabe abschließt oder feststellt, dass er nicht fortfahren kann.

• In der Beobachtungsphase geht es darum, zu verstehen, welche Informationen verfügbar sind und was das Ziel ist.
• In der Argumentationsphase entscheidet das große Sprachmodell (LLM) auf der Grundlage seiner Anweisungen und des aktuellen Standing, welche Maßnahmen ergriffen werden sollen.
• In der Aktionsphase wird diese Entscheidung ausgeführt, unabhängig davon, ob eine API aufgerufen, Code ausgeführt oder nach Informationen gesucht wird.
• Abschließend beobachtet der Agent die Ergebnisse und bezieht sie in seinen nächsten Argumentationsschritt ein.

Das Verständnis dieser Schleife ist von grundlegender Bedeutung. Jede Komponente kann ausfallen oder zu unerwarteten Ergebnissen führen. Ihr Agentendesign muss diese Möglichkeiten elegant bewältigen. Bauen Sie Ihr mentales Modell um diesen Zyklus herum auf, bevor Sie Code schreiben.

Sie können es durchlesen 7 unverzichtbare Designmuster für Agenten-KI um einen Überblick über Agentenentwurfsmuster zu erhalten.

# Schritt 2: Klare Aufgabengrenzen und Ziele definieren

Agenten benötigen klar definierte Ziele. Vage Ziele führen zu verwirrtem Verhalten, bei dem der Agent irrelevante Maßnahmen ergreift oder nie erkennt, wann er fertig ist. Ihre Aufgabendefinition sollte angeben, wie Erfolg aussieht und welche Einschränkungen gelten.

Für einen Kundendienstmitarbeiter besteht der Erfolg möglicherweise darin, das Downside des Kunden zu lösen oder es korrekt an einen Menschen weiterzuleiten. Zu den Einschränkungen kann gehören, dass Sie niemals Zusagen über Rückerstattungen über einem bestimmten Betrag machen. Diese Grenzen verhindern, dass der Agent bei der Verfolgung seines Ziels unangemessene Maßnahmen ergreift.

Schreiben Sie explizite Zielkriterien, die der Agent überprüfen kann. Anstelle von „Dem Benutzer helfen“ geben Sie an: „Beantworten Sie die Frage des Benutzers mithilfe der Wissensdatenbank oder informieren Sie ihn, dass seine Frage menschliche Hilfe erfordert.“ Konkrete Ziele ermöglichen eine konkrete Bewertung.

# Schritt 3: Auswahl der richtigen Instruments für Ihren Agenten

Instruments sind Funktionen, die Ihr Agent aufrufen kann, um mit der Umgebung zu interagieren. Dazu können das Durchsuchen von Datenbanken, das Aufrufen von APIs, das Ausführen von Code, das Lesen von Dateien oder das Senden von Nachrichten gehören. Die von Ihnen bereitgestellten Instruments definieren die Fähigkeiten Ihres Agenten.

Beginnen Sie mit einem minimalen Toolset. Jedes Software erhöht die Komplexität und potenzielle Fehlermöglichkeiten. Wenn Ihr Agent Informationen abrufen muss, stellen Sie ihm eine Suchfunktion zur Verfügung. Wenn Berechnungen durchgeführt werden müssen, stellen Sie einen Taschenrechner oder ein Codeausführungstool bereit. Wenn Aktionen ausgeführt werden müssen, stellen Sie spezifische Funktionen für diese Aktionen bereit.

Dokumentieren Sie jedes Werkzeug klar in der Aufforderung des Agenten. Geben Sie den Zweck des Instruments, die erforderlichen Parameter und die zu erwartenden Ergebnisse an. Gute Werkzeugbeschreibungen helfen dem Agenten, für jede Scenario das richtige Werkzeug auszuwählen. Schlechte Beschreibungen führen zu Werkzeugmissbrauch und Fehlern.

Implementieren Sie eine ordnungsgemäße Fehlerbehandlung in Ihren Instruments. Wenn ein Software ausfällt, geben Sie informative Fehlermeldungen zurück, die dem Agenten helfen, zu verstehen, was schief gelaufen ist, und möglicherweise einen anderen Ansatz auszuprobieren.

Lesen Was sind Agenten-Workflows? Muster, Anwendungsfälle, Beispiele und mehr um zu verstehen, wie man LLMs mit Instruments, Speicher und Abruffunktionen erweitert, um Agenten und Arbeitsabläufe zu erstellen. Wenn Sie durch Bauen lernen möchten, gehen Sie durch Agentische KI zum Anfassen in Python: Ein Video-Tutorial.

# Schritt 4: Effektive Aufforderungen und Anweisungen entwerfen

Dein Systemaufforderung des Agenten ist die Bedienungsanleitung. In dieser Eingabeaufforderung werden der Zweck des Agenten, die verfügbaren Instruments, die Lösung von Problemen und die Formatierung seiner Antworten erläutert. Pünktliche Qualität wirkt sich direkt auf die Zuverlässigkeit der Agenten aus.

Strukturieren Sie Ihre Eingabeaufforderung mit klaren Abschnitten: Rolle und Ziele des Agenten, verfügbare Instruments und deren Verwendung, Argumentationsstrategien, Anforderungen an das Ausgabeformat sowie Einschränkungen oder Regeln. Zeigen Sie dem Agenten anhand von Beispielen, wie er mit häufigen Szenarien umgeht.

Fügen Sie explizite Argumentationsanweisungen hinzu. Weisen Sie den Agenten an, Schritt für Schritt zu denken, Informationen vor dem Handeln zu überprüfen, Unsicherheiten anzuerkennen und bei Bedarf um Klarstellung zu bitten. Diese metakognitiven Anweisungen verbessern die Entscheidungsqualität.

Bringen Sie dem Agenten bei komplexen Aufgaben bei, vor der Ausführung Pläne zu erstellen. Ein Planungsschritt, bei dem der Agent seinen Ansatz darlegt, führt häufig zu einer kohärenteren Ausführung, als wenn er direkt zur Tat übergeht.

# Schritt 5: Robustes Zustands- und Speichermanagement implementieren

Agenten arbeiten über mehrere Runden hinweg und bauen während ihrer Arbeit Kontext auf. Verwalten von Standing und Speicher effektiv ist notwendig. Der Agent benötigt Zugriff auf den Gesprächsverlauf, die Ergebnisse früherer Aktionen und alle von ihm gesammelten Zwischendaten.

Gestalten Sie Ihre Landesvertretung sorgfältig. Welche Informationen muss der Agent nachverfolgen? Für einen Recherchemitarbeiter könnten dies bereits durchgeführte Abfragen, gefundene Quellen und extrahierte Informationen sein. Für einen Planungsagenten können dies verfügbare Zeitfenster, Teilnehmerpräferenzen und Einschränkungen sein.

Berücksichtigen Sie Token-Limits. Lange Gespräche können über Kontextfenster hinausgehen und Sie dazu zwingen, Speicherverwaltungsstrategien zu implementieren.

• Durch die Zusammenfassung werden ältere Interaktionen in prägnante Zusammenfassungen komprimiert, während wichtige Fakten erhalten bleiben.
• Durch verschiebbare Fenster bleiben aktuelle Austausche im Element erhalten, während älterer Kontext komprimiert oder weggelassen wird.
• Die selektive Aufbewahrung identifiziert und bewahrt wichtige Informationen – wie Benutzerpräferenzen, Aufgabenziele oder wichtige Entscheidungen – und entfernt gleichzeitig weniger relevante Particulars.

Implementieren Sie bei komplexen Agenten sowohl das Kurzzeit- als auch das Langzeitgedächtnis. Das Kurzzeitgedächtnis speichert den unmittelbaren Kontext, der für die aktuelle Aufgabe benötigt wird. Das Langzeitgedächtnis speichert Informationen, die über Sitzungen hinweg bestehen bleiben sollten, wie etwa Benutzerpräferenzen, erlernte Muster oder Referenzdaten. Speichern Sie den Langzeitspeicher in einer Datenbank oder einem Vektorspeicher, den der Agent bei Bedarf abfragen kann.

Machen Sie Zustandsänderungen für den Agenten sichtbar. Wenn eine Aktion den Zustand ändert, zeigen Sie dem Agenten deutlich, was sich geändert hat. Dies hilft ihm, die Auswirkungen seiner Maßnahmen zu verstehen und die nächsten Schritte entsprechend zu planen. Statusaktualisierungen konsistent formatieren, damit der Agent sie zuverlässig analysieren und beurteilen kann.

Sie können es durchlesen KI-Agentenspeicher: Was, warum und wie es funktioniert vom mem0-Staff für einen detaillierten Überblick über den Speicher in KI-Agenten.

# Schritt 6: Einbau von Leitplanken und Sicherheitsmaßnahmen

Agentensysteme benötigen Einschränkungen, um schädliches oder unbeabsichtigtes Verhalten zu verhindern. Diese Leitplanken funktionieren auf mehreren Ebenen: Auf welche Instruments der Agent zugreifen kann, welche Aktionen diese Instruments ausführen können und welche Entscheidungen der Agent autonom treffen darf.

Implementieren Sie eine Aktionsbestätigung für Vorgänge mit hohem Risiko. Bevor der Agent eine E-Mail sendet, einen Kauf tätigt oder Daten löscht, ist eine menschliche Genehmigung zwingend erforderlich. Das Human-in-the-Loop-Ansatz verhindert kostspielige Fehler und sorgt gleichzeitig für die Automatisierung von Routineaufgaben.

Setzen Sie dem Agentenverhalten klare Grenzen. Die maximale Anzahl an Schleifeniterationen verhindert Endlosschleifen. Maximale Kostenbudgets verhindern eine Überlastung externer Systeme. Ratenbegrenzungen verhindern eine Überlastung externer Systeme.

Überwachen Sie auf Fehlermodi. Wenn der Agent wiederholt dieselbe fehlgeschlagene Aktion versucht, greifen Sie ein. Wenn es anfängt, Toolaufrufe zu halluzinieren, die nicht existieren, stoppen Sie es. Wenn es außerhalb der Aufgabe liegt, leiten Sie es um. Implementieren Sie Schutzschalter, die die Ausführung stoppen, wenn etwas schief geht.

Protokollieren Sie alle Agentenaktionen und -entscheidungen. Dieser Audit-Path ist für das Debugging und das Verständnis des Verhaltens Ihres Agenten in der Produktion von unschätzbarem Wert. Wenn etwas schief geht, zeigen Ihnen die Protokolle genau, was der Agent gedacht und getan hat.

Sie können das überprüfen Erweiterte Leitplanken für KI-Agenten Tutorial von James Briggs, um mehr zu erfahren.

# Schritt 7: Kontinuierliches Testen, Bewerten und Verbessern

Das Agentenverhalten ist schwerer vorherzusagen als Single-Flip-Abschlüsse. Da Sie nicht jedes Szenario vorhersehen können, sind strenge Assessments unerlässlich. Erstellen Sie Testfälle, die gängige Szenarien, Randfälle und Fehlermodi abdecken.

Bewerten Sie sowohl die Aufgabenerfüllung als auch die Verhaltensqualität. Hat der Agent das Ziel erreicht? Hat es das so effizient gemacht? Wurden Anweisungen und Einschränkungen befolgt? Wurden Fehler angemessen behandelt? Alle diese Dimensionen sind wichtig.

Take a look at mit gegnerischen Eingaben:

• Was passiert, wenn Instruments unerwartete Daten zurückgeben?
• Was passiert, wenn der Benutzer widersprüchliche Anweisungen gibt?
• Was passiert, wenn externe APIs ausfallen?

Robuste Agenten gehen damit elegant um, anstatt sie kaputt zu machen. Messen Sie die Leistung nach Möglichkeit auch quantitativ. Verfolgen Sie Erfolgsraten, Anzahl der Schritte bis zum Abschluss, Werkzeugnutzungsmuster und Kosten professional Aufgabe. Mithilfe dieser Kennzahlen können Sie Verbesserungen erkennen und Rückschritte erkennen.

Benutzerfeedback ist wichtig. Der reale Einsatz offenbart Probleme, die beim Testen übersehen werden. Wenn Benutzer Probleme melden, können Sie den Entscheidungsprozess des Agenten nachvollziehen, um zu verstehen, was schief gelaufen ist. Struggle es ein sofortiges Downside? Ein Werkzeugproblem? Ein Denkfehler? Nutzen Sie diese Erkenntnisse, um Ihren Agenten zu verbessern.

Wenn Sie daran interessiert sind, mehr zu erfahren, können Sie die durchgehen Bewertung von KI-Agenten Kurs von DeepLearning.AI.

# Abschluss

Agentische KI ist ein spannender Bereich, der großes Interesse und Akzeptanz gefunden hat. Daher wird es immer neue Frameworks und verbesserte Designmuster geben.

Es ist wichtig, über die Entwicklungen auf dem Laufenden zu bleiben. Aber die Grundlagen wie das Setzen klarer Ziele, geeignete Instruments, gute Eingabeaufforderungen, robuste Zustands- und Speicherverwaltung, geeignete Leitplanken und kontinuierliche Bewertung ändern sich nicht. Konzentrieren Sie sich additionally auf sie.

Sobald Sie diese Grundlagen beherrschen, können Sie Agenten entwickeln, die echte Probleme zuverlässig lösen. Der Unterschied zwischen einer beeindruckenden Demo und einem produktionsbereiten Agenten liegt im durchdachten Design, sorgfältigem Einschränkungsmanagement und strengen Assessments und Bewertungen. Bauen Sie weiter! Wenn Sie sich auch selbst Agenten-KI beibringen möchten, schauen Sie sich das an Agentische KI: Eine Roadmap zum Selbststudium für einen strukturierten Lernweg.

# Nützliche Lernressourcen

Bala Priya C ist ein Entwickler und technischer Redakteur aus Indien. Sie arbeitet gerne an der Schnittstelle von Mathematik, Programmierung, Datenwissenschaft und Inhaltserstellung. Zu ihren Interessen- und Fachgebieten gehören DevOps, Datenwissenschaft und Verarbeitung natürlicher Sprache. Sie liebt es zu lesen, zu schreiben, zu programmieren und Kaffee zu trinken! Derzeit arbeitet sie daran, zu lernen und ihr Wissen mit der Entwickler-Neighborhood zu teilen, indem sie Tutorials, Anleitungen, Meinungsbeiträge und mehr verfasst. Bala erstellt außerdem ansprechende Ressourcenübersichten und Programmier-Tutorials.

In diesem Artikel erfahren Sie einen klaren, praktischen Fahrplan für die Beherrschung der Agenten-KI: Was sie ist, warum sie wichtig ist und wie Sie im Jahr 2026 echte Systeme erstellen, bereitstellen und präsentieren können.

Zu den Themen, die wir behandeln werden, gehören:

• Grundlegende Grundlagen in Mathematik, Programmierung und maschinellem Lernen.
• Konzepte und Architekturen hinter autonomen, werkzeugnutzenden KI-Agenten.
• Bereitstellung, Spezialisierungspfade und Portfoliostrategie.

Kommen wir gleich zur Sache.

Die Roadmap zur Beherrschung der Agenten-KI im Jahr 2026
Bild vom Herausgeber

Einführung

Agentische KI verändert die Artwork und Weise, wie wir mit Maschinen interagieren. Im Gegensatz zur herkömmlichen KI, die nur auf Befehle reagiert, kann die agentische KI selbstständig planen, handeln und Entscheidungen treffen, um komplexe Ziele zu erreichen. Sie sehen es in selbstfahrenden Robotern, digitalen Assistenten und KI-Agenten, die Geschäftsabläufe oder Forschungsaufgaben erledigen. Diese Artwork von KI steigert die Produktivität. Der globale KI-Markt wächst schnell und es wird erwartet, dass die Agenten-KI bis 2026 zum Mainstream wird. Dieser Leitfaden bietet einen klaren, schrittweisen Fahrplan zur Beherrschung der Agenten-KI im Jahr 2026.

Was ist Agentische KI?

Agentische KI bezieht sich auf Systeme, die dies können Initiative ergreifen Und selbstständig agieren Ziele zu erreichen und gleichzeitig von ihrer Umgebung zu lernen. Sie befolgen nicht nur Anweisungen; Vielmehr planen, denken und passen sie sich neuen Situationen an. Im Finanzwesen können sie beispielsweise Investitionen automatisch anpassen oder in der Forschung selbstständig Experimente erforschen und vorschlagen.

Schritt-für-Schritt-Roadmap zur Beherrschung der Agenten-KI im Jahr 2026

Schritt 1: Voraussetzungen

Zunächst müssen Sie die Kernkonzepte der Mathematik und Programmierung erlernen, bevor Sie mit dem maschinellen Lernen fortfahren.

Lerne Mathematik

Bauen Sie ein solides Verständnis für die folgenden Themen auf:
Lineare Algebra: Lernen Sie Vektoren, Matrizen, Matrixoperationen, Eigenwerte und Singulärwertzerlegung. In diesen YouTube-Kursen können Sie lernen:

Infinitesimalrechnung: Lernen Sie Ableitungen, Gradienten und Optimierungstechniken. In diesen YouTube-Kursen können Sie lernen:

Wahrscheinlichkeit und Statistik: Konzentrieren Sie sich auf Schlüsselkonzepte wie das Bayes-Theorem, Wahrscheinlichkeitsverteilungen und Hypothesentests. Zu den hilfreichen Ressourcen gehören:

Sie können auch auf dieses Lehrbuch zurückgreifen, um die Grundlagen der Mathematik zu erlernen, die für maschinelles Lernen erforderlich sind: LEHRBUCH: Mathematik für maschinelles Lernen

Lernen Sie Programmieren

Erlernen Sie nun die Grundlagen des Programmierens in einer der folgenden Sprachen:

Python (empfohlen)
Python ist die beliebteste Programmiersprache für maschinelles Lernen. Diese Ressourcen können Ihnen beim Erlernen von Python helfen:

Nachdem Sie die Grundlagen der Programmierung geklärt haben, konzentrieren Sie sich auf Bibliotheken wie Pandas, MatplotlibUnd NumPydie zur Datenmanipulation und -visualisierung verwendet werden. Einige Ressourcen, die Sie sich vielleicht ansehen möchten, sind:

R (Various)
R ist nützlich für statistische Modellierung und Datenwissenschaft. Lernen Sie hier die R-Grundlagen:

Schritt 2: Schlüsselkonzepte des maschinellen Lernens verstehen

Zu diesem Zeitpunkt verfügen Sie bereits über ausreichende Kenntnisse in Mathematik und Programmierung; Jetzt können Sie mit dem Erlernen der Grundlagen des maschinellen Lernens beginnen. Zu diesem Zweck sollten Sie wissen, dass es drei Arten des maschinellen Lernens gibt:

• Betreutes Lernen: Eine Kind des maschinellen Lernens, bei der mit gekennzeichneten Datensätzen Algorithmen trainiert werden, um Muster zu erkennen und Entscheidungen zu treffen. Wichtige Algorithmen zum Erlernen: Lineare Regression, logistische Regression, Help Vector Machines (SVM), k-Nearest Neighbors (k-NN) und Entscheidungsbäume.
• Unüberwachtes Lernen: Eine Artwork maschinelles Lernen, bei dem das Modell anhand unbeschrifteter Daten trainiert wird, um Muster, Gruppierungen oder Strukturen ohne vordefinierte Ausgaben zu finden. Wichtige Algorithmen zum Erlernen: Hauptkomponentenanalyse (PCA), k-Means-Clustering, hierarchisches Clustering und DBSCAN.
• Verstärkungslernen: Eine Kategorie des maschinellen Lernens, bei der ein Agent lernt, Entscheidungen zu treffen, indem er mit einer Umgebung interagiert und Belohnungen oder Strafen erhält. Sie können es an dieser Stelle überspringen, tiefer darauf einzugehen.

Der beste Kurs, den ich gefunden habe, um die Grundlagen des maschinellen Lernens zu erlernen, ist:
Spezialisierung auf maschinelles Lernen von Andrew Ng | Coursera

Es handelt sich um einen kostenpflichtigen Kurs, den Sie kaufen können, falls Sie eine Zertifizierung benötigen, Sie können die Movies aber auch auf YouTube finden:
Maschinelles Lernen von Professor Andrew Ng

Einige andere Ressourcen, die Sie konsultieren können, sind:

Versuchen Sie, das zu üben und umzusetzen scikit-lernen Bibliothek von Python. Folgen diese YouTube-Playlist für reibungsloses Lernen.

Schritt 3: Autonome Agenten verstehen

Das Herzstück der Agenten-KI sind autonome Agenten, die:

1. Wahrnehmen: Interpretieren Sie Eingaben aus der Umgebung.
2. Planen: Generieren Sie Strategien, um Ziele zu erreichen.
3. Akt: Führen Sie Aktionen aus und interagieren Sie mit der Welt.
4. Lernen: Verbessern Sie Entscheidungen basierend auf Suggestions.

Sie müssen sich auf Themen wie Multiagentensysteme, zielorientierte Planungs- und Suchalgorithmen (A*, D* Lite), hierarchisches Verstärkungslernen, Planung und Simulationsumgebungen (OpenAI Fitness center, Unity ML-Brokers) konzentrieren. Die besten Ressourcen, die ich gefunden habe, um mehr über autonome Agenten zu erfahren, sind:

Schritt 4: Tauchen Sie tief in die Architekturen der Agenten-KI ein

Sie müssen lernen, Agentensysteme mit einfachen, modernen Instruments zu erstellen. Sie können mit neuronal-symbolischen Agenten beginnen, die die Lernfähigkeit neuronaler Netze mit grundlegendem logischen Denken verbinden. Anschließend können Sie die transformatorbasierte Entscheidungsfindung erkunden, bei der große Sprachmodelle bei der Planung und Problemlösung helfen. Unterwegs sollten Sie auch die Argumentationsmaschine für die Entscheidungsfindung verstehen; Gedächtnissysteme für den Umgang mit unmittelbarem Kontext, Langzeitwissen und erfahrungsbasiertem Lernen; und die Software-Schnittstelle und Zielverwaltungssysteme, um Agenten mit externen APIs zu verbinden, Aufgaben zu verwalten und den Fortschritt zu verfolgen. Probieren Sie anschließend Instruments wie AutoGPT, LangChain und Reinforcement Studying with Human Suggestions (RLHF) aus, um Agenten zu erstellen, die Anweisungen befolgen und Aufgaben selbstständig erledigen können. Die Ressourcen, die ich hilfreich fand, sind:

Schritt 5: Wählen Sie eine Spezialisierung

Agentische KI erstreckt sich über mehrere Domänen. Sie müssen eines auswählen, auf das Sie sich konzentrieren möchten:

1. Robotik und autonome Systeme: Mit Instruments wie ROS, Gazebo und PyBullet können Sie in die Navigation, Pfadplanung und Manipulation von Robotern eintauchen. Einige gute Ressourcen, die Sie konsultieren können, sind:
2. KI-Agenten für Geschäfts- und Workflow-Automatisierung: Sie können an intelligenten Assistenten arbeiten, die Recherche, Reporting, Kundenanfragen oder Marketingaufgaben übernehmen. Diese Agenten verbinden verschiedene Instruments, automatisieren sich wiederholende Arbeiten und helfen Groups, mithilfe von Frameworks wie LangChain und GPT-APIs schnellere und intelligentere Entscheidungen zu treffen.
3. Generative und Entscheidungsfindungs-KI: Sie können große Sprachmodelle erkunden, die selbstständig Argumentation, Planung und mehrstufige Problemlösung durchführen. Diese Spezialisierung umfasst die Verwendung von Transformatoren, RLHF und Agent-Frameworks zum Aufbau von Systemen, die Aufgaben durchdenken und zuverlässige Ausgaben generieren können. Einige kostenlose Ressourcen, die Sie konsultieren können, sind:

Eine weitere Ressource, die Sie konsultieren können, ist: Multiagentensystem in der künstlichen Intelligenz | So erstellen Sie ein Multi-Agent-KI-System | Einfach lernen

Schritt 6: Lernen Sie, Agenten-KI-Systeme bereitzustellen

Sobald Sie Ihr Agenten-KI-System erstellt haben, müssen Sie lernen, wie Sie es einsetzen, damit andere es nutzen können. Bei der Bereitstellung handelt es sich um den Prozess der Umwandlung Ihres Agenten in einen Dienst oder eine Anwendung, die stabil ausgeführt werden kann, Anforderungen verarbeitet und in der realen Welt funktioniert. Dafür können Sie wählen FastAPI oder Flasche um Ihren Agenten über eine REST-API verfügbar zu machen; Docker zum Verpacken von allem in einen lauffähigen Behälter; und Cloud-Anbieter wie AWS, Azurblauoder GCPwo Sie Ihr System im großen Maßstab ausführen können. Diese Instruments helfen Ihrem Agenten, reibungslos auf verschiedenen Computern zu arbeiten, den Datenverkehr zu verwalten und auch bei vielen Benutzern stabil zu bleiben. Die folgenden Ressourcen könnten nützlich sein:

Schritt 7: Erstellen Sie ein Portfolio und lernen Sie weiter

Sobald Sie Erfahrung im Aufbau agentischer KI-Systeme gesammelt haben, besteht der nächste Schritt darin, Ihre Fähigkeiten unter Beweis zu stellen und weiter zu lernen. Ein starkes Portfolio beweist nicht nur Ihr Fachwissen, sondern zeichnet Sie auch in den Augen eines Arbeitgebers oder von Mitarbeitern aus. Und vergessen Sie nicht, Ihre Fähigkeiten stets aufzufrischen, indem Sie an neuen Projekten arbeiten, sich mit neuen Instruments vertraut machen und sich über die neuesten Forschungsergebnisse informieren. Zu diesem Zweck:

Abschluss

Dieser Leitfaden bietet einen umfassenden Fahrplan zum Erlernen und Beherrschen der Agenten-KI im Jahr 2026. Beginnen Sie noch heute mit dem Lernen, denn die Möglichkeiten sind endlos und je früher Sie beginnen, desto mehr können Sie erreichen. Wenn Sie Fragen haben oder weitere Hilfe benötigen, kommentieren Sie bitte.

In diesem Tutorial untersuchen wir, wie man Agentensysteme aufbaut, die über eine einzelne Interaktion hinausdenken, indem Speicher als Kernfunktion genutzt wird. Wir gehen durch, wie wir das episodische Gedächtnis zum Speichern von Erfahrungen und das semantische Gedächtnis zum Erfassen langfristiger Muster entwerfen, sodass der Agent sein Verhalten über mehrere Sitzungen hinweg weiterentwickeln kann. Während wir planen, handeln, überarbeiten und reflektieren, beobachten wir, wie sich der Agent allmählich an die Präferenzen des Benutzers anpasst und autonomer wird. Am Ende verstehen wir, wie gedächtnisgesteuertes Denken uns hilft, Agenten zu schaffen, die sich bei jeder Interaktion kontextbezogener, konsistenter und intelligenter anfühlen. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

import numpy as np
from collections import defaultdict
import json
from datetime import datetime
import pickle


class EpisodicMemory:
   def __init__(self, capability=100):
       self.capability = capability
       self.episodes = ()
      
   def retailer(self, state, motion, consequence, timestamp=None):
       if timestamp is None:
           timestamp = datetime.now().isoformat()
       episode = {
           'state': state,
           'motion': motion,
           'consequence': consequence,
           'timestamp': timestamp,
           'embedding': self._embed(state, motion, consequence)
       }
       self.episodes.append(episode)
       if len(self.episodes) > self.capability:
           self.episodes.pop(0)
  
   def _embed(self, state, motion, consequence):
       textual content = f"{state} {motion} {consequence}".decrease()
       return hash(textual content) % 10000
  
   def retrieve_similar(self, query_state, ok=3):
       if not self.episodes:
           return ()
       query_emb = self._embed(query_state, "", "")
       scores = ((abs(ep('embedding') - query_emb), ep) for ep in self.episodes)
       scores.kind(key=lambda x: x(0))
       return (ep for _, ep in scores(:ok))
  
   def get_recent(self, n=5):
       return self.episodes(-n:)


class SemanticMemory:
   def __init__(self):
       self.preferences = defaultdict(float)
       self.patterns = defaultdict(checklist)
       self.success_rates = defaultdict(lambda: {'success': 0, 'whole': 0})
      
   def update_preference(self, key, worth, weight=1.0):
       self.preferences(key) = 0.9 * self.preferences(key) + 0.1 * weight * worth
  
   def record_pattern(self, context, motion, success):
       pattern_key = f"{context}_{motion}"
       self.patterns(context).append((motion, success))
       self.success_rates(pattern_key)('whole') += 1
       if success:
           self.success_rates(pattern_key)('success') += 1
  
   def get_best_action(self, context):
       if context not in self.patterns:
           return None
       action_scores = defaultdict(lambda: {'success': 0, 'whole': 0})
       for motion, success in self.patterns(context):
           action_scores(motion)('whole') += 1
           if success:
               action_scores(motion)('success') += 1
       best_action = max(action_scores.gadgets(), key=lambda x: x(1)('success') / max(x(1)('whole'), 1))
       return best_action(0) if best_action(1)('whole') > 0 else None
  
   def get_preference(self, key):
       return self.preferences.get(key, 0.0)

Wir definieren die Kernspeicherstrukturen, auf die sich unser Agent verlässt. Wir bauen ein episodisches Gedächtnis auf, um spezifische Erfahrungen zu erfassen, und ein semantisches Gedächtnis, um Muster im Laufe der Zeit zu verallgemeinern. Indem wir diese Grundlagen schaffen, bereiten wir den Agenten darauf vor, aus Interaktionen zu lernen, so wie es Menschen tun. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

class MemoryAgent:
   def __init__(self):
       self.episodic_memory = EpisodicMemory(capability=50)
       self.semantic_memory = SemanticMemory()
       self.current_plan = ()
       self.session_count = 0
      
   def understand(self, user_input):
       user_input = user_input.decrease()
       if any(phrase in user_input for phrase in ('suggest', 'recommend', 'what ought to')):
           intent="advice"
       elif any(phrase in user_input for phrase in ('bear in mind', 'favor', 'like', 'favourite')):
           intent="preference_update"
       elif any(phrase in user_input for phrase in ('do', 'full', 'end', 'activity')):
           intent="task_execution"
       else:
           intent="dialog"
       return {'intent': intent, 'uncooked': user_input}
  
   def plan(self, state):
       intent = state('intent')
       user_input = state('uncooked')
       similar_episodes = self.episodic_memory.retrieve_similar(user_input, ok=3)
       plan = ()
       if intent == 'advice':
           genre_prefs = {ok: v for ok, v in self.semantic_memory.preferences.gadgets() if 'genre_' in ok}
           if genre_prefs:
               best_genre = max(genre_prefs.gadgets(), key=lambda x: x(1))(0)
               plan.append(('suggest', best_genre.exchange('genre_', '')))
           else:
               plan.append(('suggest', 'normal'))
       elif intent == 'preference_update':
           genres = ('sci-fi', 'fantasy', 'thriller', 'romance', 'thriller')
           detected_genre = subsequent((g for g in genres if g in user_input), None)
           if detected_genre:
               plan.append(('update_preference', detected_genre))
       elif intent == 'task_execution':
           best_action = self.semantic_memory.get_best_action('activity')
           if best_action:
               plan.append(('execute', best_action))
           else:
               plan.append(('execute', 'default'))
       self.current_plan = plan
       return plan

Wir konstruieren die Wahrnehmungs- und Planungssysteme des Agenten. Wir verarbeiten die Eingaben des Benutzers, erkennen Absichten und erstellen Pläne, indem wir die zuvor gebildeten Erinnerungen nutzen. Wir beginnen zu gestalten, wie der Agent seine nächsten Aktionen begründet und entscheidet. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

 def act(self, motion):
       action_type, param = motion
       if action_type == 'suggest':
           if param == 'normal':
               return f"Let me be taught your preferences first! What genres do you get pleasure from?"
           return f"Based mostly in your preferences, I like to recommend exploring {param}!"
       elif action_type == 'update_preference':
           self.semantic_memory.update_preference(f'genre_{param}', 1.0, weight=1.0)
           return f"Received it! I am going to bear in mind you get pleasure from {param}."
       elif action_type == 'execute':
           return f"Executing activity with technique: {param}"
       return "Motion accomplished"
  
   def revise_plan(self, suggestions):
       if 'no' in suggestions.decrease() or 'incorrect' in suggestions.decrease():
           if self.current_plan:
               action_type, param = self.current_plan(0)
               if action_type == 'suggest':
                   genre_prefs = sorted(
                       ((ok, v) for ok, v in self.semantic_memory.preferences.gadgets() if 'genre_' in ok),
                       key=lambda x: x(1),
                       reverse=True
                   )
                   if len(genre_prefs) > 1:
                       new_genre = genre_prefs(1)(0).exchange('genre_', '')
                       self.current_plan = (('suggest', new_genre))
                       return True
       return False
  
   def replicate(self, state, motion, consequence, success):
       self.episodic_memory.retailer(state('uncooked'), str(motion), consequence)
       self.semantic_memory.record_pattern(state('intent'), str(motion), success)

Wir definieren, wie der Agent Aktionen ausführt, seine Entscheidungen revidiert, wenn das Suggestions den Erwartungen widerspricht, und wie er durch die Speicherung von Erfahrungen reflektiert. Wir verbessern kontinuierlich das Verhalten des Agenten, indem wir ihn aus jeder Runde lernen lassen. Durch diese Schleife machen wir das System anpassungsfähig und selbstkorrigierend. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

 def run_session(self, user_inputs):
       self.session_count += 1
       print(f"n{'='*60}")
       print(f"SESSION {self.session_count}")
       print(f"{'='*60}n")
       outcomes = ()
       for i, user_input in enumerate(user_inputs, 1):
           print(f"Flip {i}")
           print(f"Person: {user_input}")
           state = self.understand(user_input)
           plan = self.plan(state)
           if not plan:
               print("Agent: I am unsure what to do with that.n")
               proceed
           response = self.act(plan(0))
           print(f"Agent: {response}n")
           success="suggest" in plan(0)(0) or 'replace' in plan(0)(0)
           self.replicate(state, plan(0), response, success)
           outcomes.append({
               'flip': i,
               'enter': user_input,
               'intent': state('intent'),
               'motion': plan(0),
               'response': response
           })
       return outcomes

Wir simulieren reale Interaktionen, bei denen der Agent mehrere Benutzereingaben innerhalb einer einzigen Sitzung verarbeitet. Wir beobachten, wie sich der Zyklus Wahrnehmen → Planen → Handeln → Reflektieren immer wieder entfaltet. Während wir Sitzungen durchführen, sehen wir, wie der Agent nach und nach personalisierter und intelligenter wird. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

def evaluate_memory_usage(agent):
   print("n" + "="*60)
   print("MEMORY ANALYSIS")
   print("="*60 + "n")
   print(f"Episodic Reminiscence:")
   print(f"  Complete episodes saved: {len(agent.episodic_memory.episodes)}")
   if agent.episodic_memory.episodes:
       print(f"  Oldest episode: {agent.episodic_memory.episodes(0)('timestamp')}")
       print(f"  Newest episode: {agent.episodic_memory.episodes(-1)('timestamp')}")
   print(f"nSemantic Reminiscence:")
   print(f"  Discovered preferences: {len(agent.semantic_memory.preferences)}")
   for pref, worth in sorted(agent.semantic_memory.preferences.gadgets(), key=lambda x: x(1), reverse=True)(:5):
       print(f"    {pref}: {worth:.3f}")
   print(f"n  Motion patterns discovered: {len(agent.semantic_memory.patterns)}")
   print(f"n  Success charges by context-action:")
   for key, stats in checklist(agent.semantic_memory.success_rates.gadgets())(:5):
       if stats('whole') > 0:
           charge = stats('success') / stats('whole')
           print(f"    {key}: {charge:.2%} ({stats('success')}/{stats('whole')})")


def compare_sessions(results_history):
   print("n" + "="*60)
   print("CROSS-SESSION ANALYSIS")
   print("="*60 + "n")
   for i, ends in enumerate(results_history, 1):
       recommendation_quality = sum(1 for r in outcomes if 'preferences' in r('response').decrease())
       print(f"Session {i}:")
       print(f"  Turns: {len(outcomes)}")
       print(f"  Customized responses: {recommendation_quality}")

Wir analysieren, wie effektiv der Agent seine Erinnerungen nutzt. Wir überprüfen gespeicherte Episoden, erlernte Präferenzen und Erfolgsmuster, um zu bewerten, wie sich der Agent entwickelt. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

def run_demo():
   agent = MemoryAgent()
   print("n SCENARIO: Agent learns consumer preferences over a number of periods")
   session1_inputs = (
       "Hello, I am searching for one thing to learn",
       "I actually like sci-fi books",
       "Are you able to suggest one thing?",
   )
   results1 = agent.run_session(session1_inputs)
   session2_inputs = (
       "I am bored, what ought to I learn?",
       "Really, I additionally get pleasure from fantasy novels",
       "Give me a advice",
   )
   results2 = agent.run_session(session2_inputs)
   session3_inputs = (
       "What do you recommend for tonight?",
       "I am within the temper for thriller too",
       "Advocate one thing primarily based on what you recognize about me",
   )
   results3 = agent.run_session(session3_inputs)
   evaluate_memory_usage(agent)
   compare_sessions((results1, results2, results3))
   print("n" + "="*60)
   print("EPISODIC MEMORY RETRIEVAL TEST")
   print("="*60 + "n")
   question = "suggest sci-fi"
   comparable = agent.episodic_memory.retrieve_similar(question, ok=3)
   print(f"Question: '{question}'")
   print(f"Retrieved {len(comparable)} comparable episodes:n")
   for ep in comparable:
       print(f"  State: {ep('state')}")
       print(f"  Motion: {ep('motion')}")
       print(f"  Final result: {ep('consequence')(:50)}...")
       print()


if __name__ == "__main__":
   print("="*60)
   print("MEMORY & LONG-TERM AUTONOMY IN AGENTIC SYSTEMS")
   print("="*60)
   run_demo()
   print("n Tutorial full! Key takeaways:")
   print("  • Episodic reminiscence shops particular experiences")
   print("  • Semantic reminiscence generalizes patterns")
   print("  • Brokers enhance suggestions over periods")
   print("  • Reminiscence retrieval guides future choices")

Wir bringen alles zusammen, indem wir mehrere Sitzungen durchführen und den Speicherabruf testen. Wir beobachten, wie sich der Agent über Interaktionen hinweg verbessert und verfeinern Empfehlungen auf der Grundlage des gesammelten Wissens. Diese umfassende Demo veranschaulicht, wie sich aus den von uns entwickelten Speichersystemen auf natürliche Weise langfristige Autonomie ergibt.

Zusammenfassend erkennen wir, wie die Kombination aus episodischem und semantischem Gedächtnis es uns ermöglicht, Agenten zu entwickeln, die kontinuierlich lernen und im Laufe der Zeit immer bessere Entscheidungen treffen. Wir beobachten, wie der Agent Empfehlungen verfeinert, Pläne anpasst und vergangene Erfahrungen abruft, um seine Reaktionen Sitzung für Sitzung zu verbessern. Durch diese Mechanismen sehen wir, wie aus einfachen, aber effektiven Gedächtnisstrukturen langfristige Autonomie entsteht.

Schauen Sie sich das an VOLLSTÄNDIGE CODES hier. Schauen Sie sich gerne bei uns um GitHub-Seite für Tutorials, Codes und Notebooks. Sie können uns auch gerne weiter folgen Twitter und vergessen Sie nicht, bei uns mitzumachen 100.000+ ML SubReddit und Abonnieren Unser Publication. Warten! Bist du im Telegram? Jetzt können Sie uns auch per Telegram kontaktieren.

Asif Razzaq ist CEO von Marktechpost Media Inc.. Als visionärer Unternehmer und Ingenieur setzt sich Asif dafür ein, das Potenzial der künstlichen Intelligenz für das soziale Wohl zu nutzen. Sein jüngstes Unterfangen ist die Einführung einer Medienplattform für künstliche Intelligenz, Marktechpost, die sich durch eine ausführliche Berichterstattung über maschinelles Lernen und Deep-Studying-Nachrichten auszeichnet, die sowohl technisch fundiert als auch für ein breites Publikum leicht verständlich ist. Die Plattform verfügt über mehr als 2 Millionen monatliche Aufrufe, was ihre Beliebtheit beim Publikum verdeutlicht.

Folgen Sie MARKTECHPOST: Fügen Sie uns als bevorzugte Quelle bei Google hinzu.

Unternehmen bewegen sich von einfachen Chatbots zu komplexen, geschäftskritischen KI-Systemen. Verschiedene Groups experimentieren gleichzeitig, was spannend klingt, aber schnell chaotisch wird. Wenn es keine gemeinsame Kontrollschicht gibt, steigen die Kosten, die Systeme fragmentieren und die Zuverlässigkeit sinkt. Die OpenAI Ausfall im August 2025 machte dies schmerzlich deutlich: Copiloten froren ein, Chatbots versagten und die Produktivität sank branchenübergreifend.

Die Frage ist nun nicht, ob Unternehmen KI nutzen können, sondern ob sie darauf vertrauen können, dass sie ihr Geschäft betreibt. Um KI sicher zu skalieren, müssen Sie eine Möglichkeit haben, sie über Modelle, Anbieter und interne Instruments hinweg zu verwalten, zu steuern und zu überwachen. Die herkömmliche Infrastruktur wurde dafür nicht entwickelt, daher sind zwei neue Schichten entstanden, um diese Lücke zu schließen: das AI Gateway und das MCP. Gemeinsam verwandeln sie verstreute KI-Experimente in etwas Zuverlässiges, Konformitätsfähiges und bereit für den echten Unternehmenseinsatz.

Das KI-Rückgrat des Unternehmens: Kontrolle mit dem KI-Gateway schaffen

Ein AI Gateway ist mehr als ein einfacher Proxy. Es fungiert als leistungsstarke Middleware-Schicht – die Eingangs-, Richtlinien- und Telemetrieschicht für den gesamten generativen KI-Verkehr. Es ist zwischen Anwendungen und dem Ökosystem der LLM-Anbieter (einschließlich APIs von Drittanbietern und selbst gehosteten Modellen) positioniert und fungiert als einheitliche Steuerungsebene, um die dringendsten Herausforderungen bei der Einführung von KI zu bewältigen.

Einheitlicher Zugriff und Herstellerunabhängigkeit

In einer Welt mit mehreren Modellen ist die Bewältigung der Komplexität eine große Herausforderung. Ein AI Gateway bietet einen einzigen, einheitlichen API-Endpunkt für den Zugriff auf viele LLMs, selbst gehostete Open-Supply-Modelle (z. B. Lama, Falke) und kommerzielle Anbieter (z. B. OpenAI, Claude, Zwillinge, Groq, Mistral). Über eine Schnittstelle kann das Gateway verschiedene Modelltypen unterstützen: Chat, Vervollständigung, Einbettung und Neubewertung.

Eine praktische Designwahl ist die Kompatibilität mit APIs im OpenAI-Stil. Dies reduziert den Integrationsaufwand und ermöglicht Groups die Wiederverwendung vorhandener Shopper-Bibliotheken. Durch die Übersetzung allgemeiner Anfragen in anbieterspezifische Formate fungiert das Gateway als Protokolladapter. Die Wahl eines LLM wird zu einer Laufzeitkonfiguration und nicht zu einer fest codierten Entscheidung. Groups können ein neues, günstigeres oder leistungsstärkeres Modell testen, indem sie eine Einstellung im Gateway ändern, ohne den Anwendungscode zu ändern. Dies beschleunigt das Experimentieren und Optimieren und verringert gleichzeitig das Lock-in-Risiko.

Governance und Compliance

Da KI Teil von Geschäftsprozessen wird, sind Governance und Compliance von entscheidender Bedeutung. Ein AI Gateway zentralisiert die API-Schlüsselverwaltung und bietet entwicklerspezifische Token für die Entwicklung und eng begrenzte, widerrufliche Token für die Produktion. Es erzwingt die rollenbasierte Zugriffskontrolle (RBAC) und lässt sich in Enterprise Single Signal-On (SSO) integrieren, um den Zugriff für bestimmte Benutzer, Groups oder Dienste auf bestimmte Modelle zu definieren.

Richtlinien können einmal auf Gateway-Ebene definiert und bei jeder Anfrage durchgesetzt werden, z. B. das Filtern persönlich identifizierbarer Informationen (PII) oder das Blockieren unsicherer Inhalte. Das Gateway sollte manipulationssichere Aufzeichnungen von Anfragen und Antworten erfassen, um die Prüfbarkeit für Requirements wie SOC 2, HIPAA und DSGVO zu unterstützen. Für Organisationen mit Anforderungen an die Datenresidenz kann das Gateway in einer Digital Non-public Cloud (VPC), vor Ort oder in Air-Hole-Umgebungen bereitgestellt werden, sodass smart Daten unter der Kontrolle des Unternehmens bleiben.

Kostenmanagement und -optimierung

Ohne angemessene Aufsicht können die KI-bezogenen Ausgaben schnell steigen. Ein AI Gateway bietet Instruments für ein proaktives Finanzmanagement, einschließlich der Echtzeitverfolgung der Token-Nutzung und -Ausgaben nach Benutzer, Staff, Modell, Anbieter oder Area. Die Preise können den Preislisten der Anbieter entnommen werden, um eine manuelle Nachverfolgung zu vermeiden.

Diese Transparenz ermöglicht interne Chargeback- oder Showback-Modelle und macht KI zu einer messbaren Ressource. Administratoren können Budgetgrenzen und Kontingente basierend auf Kosten oder Token-Anzahl festlegen, um Überschreitungen zu verhindern. Routingfunktionen können die Kosten senken, indem sie Abfragen für bestimmte Aufgaben an kostengünstige Modelle weiterleiten und, sofern möglich, Techniken wie dynamische Modellauswahl, Caching und Anforderungsstapelung anwenden.

Zuverlässigkeit und Leistung: Wie ein leistungsstarkes KI-Gateway aussieht

Damit KI unverzichtbar ist, muss sie zuverlässig und reaktionsfähig sein. Viele KI-Anwendungen – Echtzeit-Chat-Assistenten und Retrieval-Augmented Era (RAG)-Systeme – reagieren empfindlich auf Latenz. Ein intestine konzipiertes KI-Gateway sollte einen Overhead im einstelligen Millisekundenbereich im Scorching Path anstreben.

Zu den Architekturbüros, die dies ermöglichen, gehören:

• In-Reminiscence-Authentifizierung und Ratenbegrenzung im Anforderungspfad, um externe Netzwerkaufrufe zu vermeiden.
• Asynchrone Protokollierung und Metriken über eine dauerhafte Warteschlange, um den Scorching Path minimal zu halten.
• Horizontale Skalierung mit CPU-gebundener Verarbeitung, um bei steigender Nachfrage eine gleichbleibende Leistung aufrechtzuerhalten.
• Verkehrskontrollen wie latenzbasiertes Routing zum schnellsten verfügbaren Modell, gewichteter Lastausgleich und automatisches Failover, wenn ein Anbieter ausfällt.

Diese Designoptionen ermöglichen es Unternehmen, das Gateway direkt im Produktionsinferenzpfad zu platzieren, ohne übermäßige Leistungseinbußen hinnehmen zu müssen.

Referenzarchitektur für ein KI-Gateway

Agenten mit der Mannequin Management Aircraft (MCP) freisetzen

Fortschritte in der KI hängen davon ab, was LLMs mithilfe von Instruments erreichen können. Übergang von der Textgenerierung zu Agentische KI. Die Systeme, die mit externen Instruments schlussfolgern, planen und interagieren können, benötigen eine Standardmethode, um Modelle mit den Systemen zu verbinden, die sie verwenden müssen.

Der Aufstieg der Agenten-KI und die Notwendigkeit eines Standardprotokolls

Agentische KI-Systeme bestehen aus zusammenarbeitenden Elementen: einem zentralen Argumentationsmodell, einem Speichermodul, einem Orchestrator und Instruments. Um innerhalb eines Unternehmens nützlich zu sein, müssen diese Agenten zuverlässig mit internen und externen Systemen wie Slack kommunizieren. GitHubJira, Confluence, Datadog und proprietäre Datenbanken und APIs.

In der Vergangenheit conflict für die Verbindung eines LLM mit einem Device benutzerdefinierter Code für jede API erforderlich, der fragil und schwer zu skalieren conflict. Der Mannequin Context Protocol (MCP)eingeführt von Anthropic, standardisiert, wie KI-Agenten Instruments entdecken und mit ihnen interagieren. MCP fungiert als Abstraktionsschicht und trennt das „Gehirn“ der KI (das LLM) von ihren „Händen“ (den Werkzeugen). Ein Agent, der „MCP spricht“, kann jedes über einen MCP-Server bereitgestellte Device erkennen und verwenden, wodurch die Entwicklung beschleunigt und eine modulare, wartbare Architektur für Agentensysteme mit mehreren Instruments gefördert wird.

Die Risiken einer unregierten MCP

Der Einsatz von MCP-Servern ohne Governance in einer Unternehmensumgebung wirft drei Bedenken auf:

• Sicherheit: MCP-Server arbeiten mit den ihnen erteilten Berechtigungen. Der Umgang mit Anmeldeinformationen und die Verwaltung von Zugriffskontrollen über mehrere Instruments hinweg können unsicher und schwer zu prüfen sein.
• Sichtweite: Direkte Verbindungen bieten begrenzte Einblicke in die Agentenaktivität. Ohne zentralisierte Protokolle der Device-Nutzung und -Ergebnisse leidet die Überprüfbarkeit.
• Operationen: Die Verwaltung, Aktualisierung und Überwachung vieler MCP-Server in verschiedenen Umgebungen (Entwicklung, Staging, Produktion) ist komplex.

Die Risiken eines unkontrollierten MCP entsprechen denen eines unregulierten LLM-API-Zugriffs, können jedoch größer sein. Ein ungeprüfter Agent mit Device-Zugriff könnte beispielsweise eine Produktionsdatenbank löschen, vertrauliche Informationen in einem öffentlichen Kanal veröffentlichen oder Finanztransaktionen falsch ausführen. Eine Governance-Schicht für MCP ist daher für Unternehmensbereitstellungen unerlässlich.

Der moderne Gen-AI-Stack

Das Gateway als Kontrollpunkt für die Agenten-KI

Ein KI-Gateway mit MCP-Bewusstsein ermöglicht es Unternehmen, interne MCP-Server über eine zentrale Schnittstelle zu registrieren, bereitzustellen und zu verwalten. Das Gateway kann als sicherer Proxy für MCP-Device-Aufrufe fungieren, sodass Entwickler über ein einziges SDK und einen Endpunkt eine Verbindung zu registrierten Servern herstellen können, ohne direkt Device-spezifische Anmeldeinformationen verwalten zu müssen.

Durch die Integration der MCP-Unterstützung in das Gateway erhalten Unternehmen eine einheitliche Steuerungsebene für Modell- und Toolaufrufe. Agenten-Workflows beinhalten eine Schleife: Der Agent begründet, indem er ein LLM aufruft, handelt dann, indem er ein Device aufruft, und begründet dann noch einmal. Mit einem integrierten Ansatz kann der gesamte Prozess: die erste Eingabeaufforderung, der LLM-Aufruf, die Entscheidung des Modells, ein Device zu verwenden, der Device-Aufruf über dasselbe Gateway, die Antwort des Instruments und die endgültige Ausgabe in einem einzigen Hint erfasst werden. Diese einheitliche Ansicht vereinfacht die Durchsetzung, Fehlerbehebung und Compliance von Richtlinien.

Abschluss

AI Gateways und MCP bieten zusammen einen praktischen Weg zum sicheren Betrieb agentenbasierter KI im großen Maßstab. Sie helfen Groups dabei, fortschrittliche Modelle und Instruments als verwaltete Komponenten des breiteren Software program-Stacks zu behandeln – vorbehaltlich konsistenter Richtlinien-, Beobachtbarkeits- und Leistungsanforderungen. Mit einer zentralen Kontrollebene für Modelle und Instruments können Unternehmen KI auf zuverlässige, sichere und kostenbewusste Weise einführen.

Sie können mehr über das Thema erfahren Hier.

Häufig gestellte Fragen

Zhipu AI hat GLM-4,6 veröffentlicht, ein großes Replace für ihre GLM-Serie, die sich auf agierische Workflows, langkontextbezogene Argumentation und praktische Codierungsaufgaben konzentriert. Das Modell erhöht das Eingangsfenster auf 200k Token mit a 128K Max -Ausgangzielt auf einen niedrigeren Tokenverbrauch bei angewandten Aufgaben ab und schiffen mit Offene Gewichte Für lokale Bereitstellung.

Additionally, was genau ist neu?

• Kontext + Ausgangsbegrenzungen: 200k Eingabekontext und 128K Maximale Ausgangs -Token.
• Codierungsergebnisse der realen Welt: Auf dem erweiterten CC-Financial institution (Multi-Flip-Aufgaben, die von menschlichen Evaluatoren in isolierten Docker-Umgebungen ausgeführt werden, wird berichtet Nahe Parität mit Claude Sonnet 4 (48,6% Gewinnrate) und verwendet ~ 15% weniger Token gegen GLM-4,5 Aufgaben beenden. Aufgabenaufforderungen und Agentenbahnen werden zur Inspektion veröffentlicht.
• Benchmark -Positionierung: Zhipu fasst „klare Gewinne“ über GLM-4,5 in acht öffentlichen Benchmarks und Staaten Parität mit Claude Sonnet 4/40 auf mehreren zusammen; Es stellt auch fest GLM-4.6 bleibt immer noch Sonett 4.5 beim Codieren zurück– Eine nützliche Einschränkung für die Modellauswahl.
• Verfügbarkeit von Ökosystemen: GLM-4.6 ist über verfügbar Z.ai API Und OpenRouter; Es wird in beliebte Codierungsagenten (Claude Code, Cline, Roo -Code, Kilo -Code) und vorhandene Codierungsplan -Benutzer integriert, indem sie den Modellnamen auf umschalten glm-4.6.
• Offene Gewichte + Lizenz: Umarmende Gesichtsmodellkartenlisten Lizenz: MIT Und Modellgröße: 355b Params (MOE) mit BF16/F32 -Tensoren. (MOE „Gesamtparameter“ entsprechen den aktiven Parametern professional Token nicht. Für 4,6 auf der Karte wird keine aktive Params angegeben.)
• Lokale Inferenz: vllm Und Sglang werden für die lokale Portion unterstützt; Gewichte sind eingeschaltet Umarmtes Gesicht Und ModelsCope.

Zusammenfassung

GLM-4,6 ist ein inkrementeller, aber materieller Schritt: ein 200k-Kontextfenster, ~ 15% Token-Reduktion auf CC-Bench gegen GLM-4,5, Nahparkitätsaufgabe Win-Fee mit Claude-Sonett 4 und sofortige Verfügbarkeit über Z.AI, OpenRouter und offene Artifakte für lokale Servierungen.

FAQs

1) Was sind die Kontext- und Ausgangs -Token -Grenzen?
GLM-4.6 unterstützt a 200k Eingabekontext und 128K Maximale Ausgangs -Token.

2) Sind offene Gewichte verfügbar und unter welcher Lizenz?
Ja. Die Umarmungsgesichts -Modellkartenlisten Offene Gewichte mit Lizenz: MIT und a 357B-Parameter Moe Konfiguration (BF16/F32 -Tensoren).

3) Wie ist GLM-4,6 mit GLM-4,5 und Claude Sonnet 4 bei angewendeten Aufgaben verglichen?
Auf dem erweiterten CC-Financial institutionGLM-4.6 Berichte ~ 15% weniger Token gegen GLM-4,5 Und Nahe Eltern mit Claude Sonnet 4 (48,6% Win-Fee).

4) Kann ich GLM-4,6 lokal ausführen?
Ja. Zhipu liefert Gewichte auf Umarmung von Gesicht/Fashions und dokumentiert die lokale Schlussfolgerung mit vllm Und Sglang; Neighborhood-Quantisierungen werden für {Hardware} für Workstation-Klasse erscheinen.

Schauen Sie sich das an Github -SeiteAnwesend Umarmung der Gesichtsmodellkarte Und Technische Particulars. Fühlen Sie sich frei, unsere zu überprüfen Github -Seite für Tutorials, Codes und Notizbücher. Fühlen Sie sich auch frei, uns zu folgen Twitter Und vergessen Sie nicht, sich unserer anzuschließen 100k+ ml Subreddit und abonnieren Unser Publication.

Asif Razzaq ist der CEO von Marktechpost Media Inc. Sein jüngstes Bestreben ist die Einführung einer Medienplattform für künstliche Intelligenz, Marktechpost, die sich durch die ausführliche Berichterstattung über maschinelles Lernen und Deep-Studying-Nachrichten auszeichnet, die von einem breiten Publikum technisch intestine und leicht verständlich sind. Die Plattform verfügt über über 2 Millionen monatliche Ansichten und veranschaulicht ihre Beliebtheit des Publikums.

(empfohlene Lesen) Nvidia AI Open-Sources Vipe (Video Pose Engine): Ein leistungsstarkes und vielseitiges 3D-Videoannotationsinstrument für die räumliche KI