Cybersecurity AI (CAI)

Professional Edition mit unbegrenzten alias1-Token | 📊 Benchmarks ansehen | 🚀 Mehr erfahren

🔓 Community Edition Forschung & Lernen · Perfekt für Forscher & Studierende pip install cai-framework

✅ Kostenlos für die Forschung 🤖 300+ KI-Modelle 🌍 Von der Community getrieben 📚 Open Source 🔧 Erweiterbares Framework

🚀 Professional Edition Enterprise & Produktion · €350/Monat · Unbegrenzte alias1-Token

→ Upgrade auf PRO

⚡ alias1-Modell - ∞ unbegrenzte Token 🚫 Null Ablehnungen - Uneingeschränkte KI 🏆 Schlägt GPT-5 in CTF-Benchmarks 🛡️ Professioneller Support inbegriffen 🇪🇺 Europäische Datensouveränität

CAI PRO mit alias1-Modell übertrifft GPT-5 in KI-gegen-KI-Cybersicherheits-Benchmarks | Vollständige Benchmarks ansehen →

-->

Cybersecurity AI (CAI) ist ein leichtgewichtiges Open-Source-Framework, das Sicherheitsexperten befähigt, KI-gestützte offensive und defensive Automatisierung zu erstellen und bereitzustellen. CAI ist das De-facto-Framework für KI-Sicherheit, das bereits von Tausenden von Einzelanwendern und Hunderten von Organisationen genutzt wird. Ob Sie ein Sicherheitsforscher, ethischer Hacker, IT-Experte oder eine Organisation sind, die Ihre Sicherheitslage verbessern möchte, CAI bietet die Bausteine, um spezialisierte KI-Agenten zu erstellen, die bei der Schadensbegrenzung, Schwachstellenfindung, Ausnutzung und Sicherheitsbewertung helfen können.

🔓 CAI ohne einen Alias-API-Schlüssel ausführen (CAI_LICENSE_OFF)

CAI kann ohne einen ALIAS_API_KEY (d.h. ohne eine Lizenz von Alias Robotics) ausgeführt werden, indem die Umgebungsvariable CAI_LICENSE_OFF=1 gesetzt wird.

Wenn CAI_LICENSE_OFF auf 1, true oder yes gesetzt ist:

• Die Start-Lizenzprüfung wird umgangen — es ist kein ALIAS_API_KEY erforderlich.
• CAI läuft im Open-Source-Modus und Update-Vorgänge zielen auf das öffentliche PyPI-Paket cai-framework anstelle des privaten Alias-Paketindex.
• Sie können jeden anderen unterstützten Modellanbieter (OpenAI, Anthropic, DeepSeek, Ollama, usw.) verwenden, indem Sie CAI_MODEL und den entsprechenden Anbieter-API-Schlüssel konfigurieren.

Schnellstart ohne Lizenz:```bash export CAI_LICENSE_OFF=1 cai

Oder inline:```bash
CAI_LICENSE_OFF=1 cai

Hinweis: Das Modell alias1 benötigt weiterhin einen gültigen ALIAS_API_KEY. CAI_LICENSE_OFF umgeht lediglich die Lizenzschranke des Frameworks – es gewährt keinen Zugriff auf von Alias gehostete Modelle.

Hauptfunktionen:

• 🤖 300+ KI-Modelle: Unterstützung für OpenAI, Anthropic, DeepSeek, Ollama und mehr
• 🔧 Integrierte Sicherheitswerkzeuge: Einsatzbereite Werkzeuge für Aufklärung, Exploitation und Privilegienerweiterung
• 🏆 Kampferprobt: Bewährt in HackTheBox-CTFs, Bug-Bounty-Programmen und realen Sicherheits-Fallstudien
• 🎯 Agentenbasierte Architektur: Modulares Framework-Design zum Bau spezialisierter Agenten für verschiedene Sicherheitsaufgaben
• 🛡️ Guardrails-Schutz: Integrierte Abwehrmechanismen gegen Prompt Injection und gefährliche Befehlsausführung
• 📚 Forschungsorientiert: Forschungsgrundlage zur Demokratisierung der Cybersicherheits-KI für die Gemeinschaft

[!NOTE] Read the technical report: CAI: An Open, Bug Bounty-Ready Cybersecurity AI Eine HTML-Leseausgabe mit Abbildungen und Referenzen wird vom Robot Cybersecurity Lab betreut.

Für weitere Informationen siehe unsere Abschnitte Impact und CAI-Zitierung.

[!WARNING] ⚠️ CAI befindet sich in aktiver Entwicklung, daher sollte man keine einwandfreie Funktionsweise erwarten. Stattdessen können Sie beitragen, indem Sie ein Issue erstellen oder einen PR senden.

Der Zugriff auf diese Bibliothek und die Nutzung von Informationen, Materialien (oder Teilen davon), ist nicht vorgesehen und untersagt, wenn dieser Zugriff oder diese Nutzung gegen geltende Gesetze oder Vorschriften verstößt. Die Autoren ermutigen oder fördern in keiner Weise die unbefugte Manipulation von laufenden Systemen. Dies kann ernsthafte Personenschäden und materielle Schäden verursachen.

Die Autoren von CAI ermutigen oder fördern in keiner Weise die unbefugte Manipulation von Computersystemen. Bitte nutzen Sie den Quellcode hier nicht für Cyberkriminalität. Stattdessen testen Sie zum Guten. Durch Herunterladen, Verwenden oder Modifizieren dieses Quellcodes stimmen Sie den Bedingungen der LICENSE und den in der Datei DISCLAIMER dargelegten Einschränkungen zu.

🔖 Inhaltsverzeichnis

• Cybersicherheits-KI (CAI)
• 🔖 Inhaltsverzeichnis
• 🎯 Auswirkung
• 🏆 Wettbewerbe und Herausforderungen
• 📊 Forschungsauswirkungen
• 📚 Forschungsprodukte: Cybersecurity AI
• PoCs
• Motivation
• 👤 Warum CAI?
• Ethische Prinzipien hinter CAI
• Closed-Source-Alternativen
• Lernen - CAI-Fluency
• 🔩 Installation
• OS X
• Ubuntu 24.04
• Ubuntu 20.04
• Windows WSL
• Android
• 🔩 Einrichtung der .env-Datei
• 🔹 Unterstützung für benutzerdefinierte OpenAI-Basis-URL
• 📐 Architektur:
• 🔹 Agent
• 🔹 Tools
• 🔹 Handoffs
• 🔹 Patterns
• 🔹 Turns und Interaktionen
• 🔹 Tracing
• 🔹 Guardrails
• 🔹 Human-In-The-Loop (HITL)
• 🚀 Schnellstart

🎯 Auswirkung

🏆 Wettbewerbe und Herausforderungen

📊 Forschungsauswirkungen

• Pionierarbeit bei LLM-gestützter KI-Sicherheit mit PentestGPT, die die Grundlage für das Forschungsgebiet Cybersecurity AI legte

• Etablierung der Forschungslinie Cybersecurity AI mit 8 Papieren und technischen Berichten und aktiven Forschungskooperationen

📚 Forschungsprodukte: Cybersecurity AI

Erweiterte HTML-Leseausgaben: CAI · CAIBench · Humanoid robots as attack vectors · The cybersecurity of a humanoid robot · Hacking consumer robots in the AI era

PoCs

CAI mit alias0 bei ROS-Nachrichteninjektionsangriffen im MiR-100-Roboter	CAI mit alias0 bei API-Schwachstellenerkennung bei Mercado Libre

CAI im JWT@PortSwigger CTF — Cybersecurity AI	CAI im HackableII Boot2Root CTF — Cybersecurity AI

Weitere Fallstudien und PoCs finden Sie unter https://aliasrobotics.com/case-studies-robot-cybersecurity.php.

Motivation

👤 Warum CAI?

Die Cybersicherheitslandschaft befindet sich in einem dramatischen Wandel, da KI zunehmend in Sicherheitsabläufe integriert wird. Wir sagen voraus, dass bis 2028 KI-gestützte Sicherheitstestwerkzeuge menschliche Pentester zahlenmäßig übertreffen werden. Dieser Wandel stellt eine grundlegende Veränderung in der Art und Weise dar, wie wir Cybersicherheitsherausforderungen angehen. KI ist nicht nur ein weiteres Werkzeug – sie wird unerlässlich, um komplexe Sicherheitslücken zu beheben und ausgeklügelten Bedrohungen einen Schritt voraus zu sein. Da Unternehmen mit immer fortschrittlicheren Cyberangriffen konfrontiert sind, wird KI-verbessertes Sicherheitstesten entscheidend für die Aufrechterhaltung robuster Verteidigungsmaßnahmen sein.

Diese Arbeit baut auf früheren Bemühungen auf[^4] und ebenso glauben wir, dass der demokratisierte Zugang zu fortschrittlichen Cybersicherheits-KI-Werkzeugen für die gesamte Sicherheitsgemeinschaft von entscheidender Bedeutung ist. Aus diesem Grund veröffentlichen wir Cybersecurity AI (CAI) als Open-Source-Framework. Unser Ziel ist es, Sicherheitsforscher, ethische Hacker und Organisationen zu befähigen, leistungsstarke KI-gesteuerte Sicherheitswerkzeuge zu bauen und einzusetzen. Indem wir diese Fähigkeiten offen zur Verfügung stellen, möchten wir die Spielregeln angleichen und sicherstellen, dass hochmoderne Sicherheits-KI-Technologie nicht auf gut finanzierte Privatunternehmen oder staatliche Akteure beschränkt bleibt.

Bug-Bounty-Programme sind zu einem Eckpfeiler der modernen Cybersicherheit geworden und bieten einen entscheidenden Mechanismus für Unternehmen, Schwachstellen in ihren Systemen zu identifizieren und zu beheben, bevor sie ausgenutzt werden können. Diese Programme haben sich als äußerst effektiv bei der Sicherung sowohl öffentlicher als auch privater Infrastruktur erwiesen, da Forscher kritische Schwachstellen entdecken, die sonst unbemerkt geblieben wären. CAI wurde speziell entwickelt, um diese Bemühungen zu verstärken, indem ein leichtes, ergonomisches Framework zum Bau spezialisierter KI-Agenten bereitgestellt wird, die bei verschiedenen Aspekten der Bug-Bounty-Jagd unterstützen können – von der ersten Aufklärung bis zur Schwachstellenvalidierung und Berichterstattung. Unser Framework zielt darauf ab, menschliche Expertise mit KI-Fähigkeiten zu erweitern und Forschern zu helfen, effizienter und gründlicher bei der Sicherung digitaler Systeme zu arbeiten.

Ethische Prinzipien hinter CAI

Sie fragen sich vielleicht, ob die Veröffentlichung von CAI in-the-wild angesichts seiner Fähigkeiten und Sicherheitsauswirkungen ethisch vertretbar ist. Unsere Entscheidung, dieses Framework als Open Source zu veröffentlichen, wird von zwei ethischen Kernprinzipien geleitet:

1. Demokratisierung der Cybersicherheits-KI: Wir glauben, dass fortschrittliche Cybersicherheits-KI-Werkzeuge der gesamten Sicherheitsgemeinschaft zugänglich sein sollten, nicht nur gut finanzierten Privatunternehmen oder staatlichen Akteuren. Durch die Veröffentlichung von CAI als Open-Source-Framework möchten wir Sicherheitsforscher, ethische Hacker und Organisationen befähigen, leistungsstarke KI-gesteuerte Sicherheitswerkzeuge zu bauen und einzusetzen, um die Wettbewerbsbedingungen in der Cybersicherheit anzugleichen.
2. Transparenz bei KI-Sicherheitsfähigkeiten: Basierend auf unseren Forschungsergebnissen, dem Verständnis der Technologie und der Analyse wichtiger technischer Berichte argumentieren wir, dass aktuelle LLM-Anbieter ihre Cybersicherheitsfähigkeiten untergraben. Dies ist äußerst gefährlich und irreführend. Indem wir CAI offen entwickeln, bieten wir einen transparenten Maßstab dafür, was KI-Systeme in Cybersicherheitskontexten tatsächlich leisten können, und ermöglichen fundiertere Entscheidungen über Sicherheitsstrategien.CAI basiert auf den folgenden Kernprinzipien:

• Cybersicherheitsorientiertes KI-Framework: CAI wurde speziell für Cybersicherheitsanwendungsfälle entwickelt und zielt auf die teil- und vollautomatische Ausführung von offensiven und defensiven Sicherheitsaufgaben ab.
• Open Source, kostenlos für die Forschung: CAI ist Open Source und für Forschungszwecke kostenlos. Wir zielen darauf ab, den Zugang zu KI und Cybersicherheit zu demokratisieren. Für die professionelle oder kommerzielle Nutzung, einschließlich On-Premise-Bereitstellungen, dedizierten technischen Support und kundenspezifische Erweiterungen, kontaktieren Sie uns, um eine Lizenz zu erhalten.
• Leichtgewichtig: CAI ist darauf ausgelegt, schnell und einfach zu bedienen zu sein.
• Modulares und agentenzentriertes Design: CAI arbeitet auf der Grundlage von Agenten und agentischen Mustern, was Flexibilität und Skalierbarkeit ermöglicht. Sie können problemlos die am besten geeigneten Agenten und Muster für Ihren Cybersicherheits-Anwendungsfall hinzufügen.
• Werkzeugintegration: CAI integriert bereits eingebaute Werkzeuge und ermöglicht es dem Benutzer, eigene Werkzeuge mit eigener Logik einfach zu integrieren.
• Protokollierung und Nachverfolgung integriert: unter Verwendung von phoenix, dem Open-Source-Tool für Nachverfolgung und Protokollierung von LLMs. Dies bietet dem Benutzer eine detaillierte Rückverfolgbarkeit der Agenten und ihrer Ausführung.
• Multi-Modell-Unterstützung: mehr als 300 unterstützte Modelle, ermöglicht durch LiteLLM. Die beliebtesten Anbieter:
• Anthropic: Claude 3.7, Claude 3.5, Claude 3, Claude 3 Opus
• OpenAI: , , , ,

Closed-Source-Alternativen

Cybersicherheits-KI ist ein kritisches Feld, dennoch verfolgen viele Gruppen es fälschlicherweise mit Closed-Source-Methoden für reinen wirtschaftlichen Gewinn, indem sie ähnliche Techniken nutzen und auf bestehenden Closed-Source-Modellen (oft von Drittanbietern) aufbauen. Dieser Ansatz verschwendet nicht nur wertvolle Ingenieursressourcen, sondern stellt auch eine wirtschaftliche Verschwendung dar und führt zu redundanten Bemühungen, da sie oft das Rad neu erfinden. Hier sind einige der Closed-Source-Initiativen, die wir verfolgen und die versuchen, genAI und agentische Frameworks in der Cybersicherheits-KI zu nutzen:

• Autonomous Cyber
• CrackenAGI
• ETHIACK
• Horizon3
• Irregular
• Kindo
• Lakera
• Mindfort
• Mindgard
• NDAY Security
• Penligent
• Runsybil
• Selfhack
• Sola Security
• SQUR
• Staris
• Sxipher (seems discontinued)
• Terra Security
• Vibeproxy
• Xint
• XBOW
• ZeroPath
• Zynap
• 7ai

Learn - CAI Fluency

[!NOTE]

Der technische Bericht CAI Fluency (arXiv:2508.13588) etabliert formale Bildungsrahmen für Cybersicherheits-KI-Kompetenz.

🔩 Installation

[!NOTE] CAI Professional Edition Benutzer: Wenn Sie ein aktives CAI Pro Abonnement haben, stellen wir dedizierte Installationsanleitungen für die Versionen 0.5 und 0.6 bereit. Offizieller Support ist für Ubuntu 24.04 (x86_64) verfügbar. Installationsanweisungen für andere Betriebssysteme werden ohne offiziellen Support bereitgestellt:

• CAI Pro v0.6 Installationsanleitung
• CAI Pro v0.5 Installationsanleitung

Installation der Community-Edition```bash

pip install cai-framework

Immer eine neue virtuelle Umgebung erstellen, um eine ordnungsgemäße Abhängigkeitsinstallation beim Aktualisieren von CAI sicherzustellen.

Die folgenden Unterabschnitte bieten eine detailliertere Anleitung für ausgewählte gängige Betriebssysteme. Beachten Sie den Abschnitt [Entwicklung](#development) für entwicklerbezogene Installationsanweisungen.
Für die API-Key-Umgebungssyntax überprüfen Sie die litellm-Dokumentation. [LiteLLM Dokumentation](https://docs.litellm.ai/docs/tutorials/installation)

### OS X```bash
brew update && \
    brew install git [email protected]

# Create virtual environment
python3.12 -m venv cai_env

# Install the package from the local directory
source cai_env/bin/activate && pip install cai-framework

# Generate a .env file and set up with defaults
echo -e 'OPENAI_API_KEY="sk-1234"\nANTHROPIC_API_KEY=""\nOLLAMA=""\nPROMPT_TOOLKIT_NO_CPR=1\nCAI_STREAM=false' > .env

# Launch CAI
cai  # first launch it can take up to 30 seconds

Ubuntu 24.04```bash

sudo apt-get update &&
sudo apt-get install -y git python3-pip python3.12-venv

Create the virtual environment

python3.12 -m venv cai_env

Install the package from the local directory

source cai_env/bin/activate && pip install cai-framework

Generate a .env file and set up with defaults

echo -e 'OPENAI_API_KEY="sk-1234"\nANTHROPIC_API_KEY=""\nOLLAMA=""\nPROMPT_TOOLKIT_NO_CPR=1\nCAI_STREAM=false' > .env

Launch CAI

cai # first launch it can take up to 30 seconds

### Ubuntu 20.04```bash
sudo apt-get update && \
    sudo apt-get install -y software-properties-common

# Fetch Python 3.12
sudo add-apt-repository ppa:deadsnakes/ppa && sudo apt update
sudo apt install python3.12 python3.12-venv python3.12-dev -y

# Create the virtual environment
python3.12 -m venv cai_env

# Install the package from the local directory
source cai_env/bin/activate && pip install cai-framework

# Generate a .env file and set up with defaults
echo -e 'OPENAI_API_KEY="sk-1234"\nANTHROPIC_API_KEY=""\nOLLAMA=""\nPROMPT_TOOLKIT_NO_CPR=1\nCAI_STREAM=false' > .env

# Launch CAI
cai  # first launch it can take up to 30 seconds

Windows WSL

Gehen Sie zur Microsoft-Seite: https://learn.microsoft.com/en-us/windows/wsl/install. Hier finden Sie alle Anleitungen zur Installation von WSL.

Von Powershell aus schreiben Sie: wsl --install```bash

sudo apt-get update &&
sudo apt-get install -y git python3-pip python3-venv

Create the virtual environment

python3 -m venv cai_env

Install the package from the local directory

source cai_env/bin/activate && pip install cai-framework

Generate a .env file and set up with defaults. If Ollama runs on your windows host, wsl needs to use your host IP for it to become reachable

echo -e 'OPENAI_API_KEY="sk-1234"\nANTHROPIC_API_KEY=""\nOLLAMA=""\nOLLAMA_API_BASE="http://Your.Host.Ip.Here:11434"\nPROMPT_TOOLKIT_NO_CPR=1\nCAI_STREAM=false' > .env

Launch CAI

cai # first launch it can take up to 30 seconds

Möglicherweise treten Probleme beim Ausführen von cai unter Ubuntu auf, da einige Agenten davon ausgehen, dass sie auf einer Kali-Instanz laufen und die benötigten Tools nicht finden können.  
Als Alternative können Sie stattdessen die Docker-Compose-Datei im Ordner „dockerized“ verwenden. Dies funktioniert auch innerhalb von WSL, wenn Docker installiert ist.  
Holen Sie in diesem Fall den Ordner „dockerized“ (das gesamte Repository wird nicht benötigt) und führen Sie die Befehle darin aus.  
Überprüfen Sie die API-Schlüssel-Umgebungsvariablen-Syntax in der LiteLLM-Dokumentation. [LiteLLM Documentation](https://docs.litellm.ai/docs/tutorials/installation)```bash
#build and run docker compose Build takes around 20 min.
docker compose build && docker compose up -d

#access cai
docker compose exec cai cai

Android

Wir empfehlen mindestens 8 GB RAM:

1. Installieren Sie zunächst Userland https://play.google.com/store/apps/details?id=tech.ula&hl=es

2. Installieren Sie Kali minimal in den grundlegenden Optionen (kostenlos). [Oder eine beliebige andere Kali-Option, falls bevorzugt]

3. Aktualisieren Sie die apt-Schlüssel wie in diesem Beispiel: https://superuser.com/questions/1644520/apt-get-update-issue-in-kali, führen Sie im Kali-Terminal von UserLand aus```bash

Get new apt keys

wget http://http.kali.org/kali/pool/main/k/kali-archive-keyring/kali-archive-keyring_2024.1_all.deb

Install new apt keys

sudo dpkg -i kali-archive-keyring_2024.1_all.deb && rm kali-archive-keyring_2024.1_all.deb

Update APT repository

sudo apt-get update

CAI requieres python 3.12, lets install it (CAI for kali in Android)

sudo apt-get update && sudo apt-get install -y git python3-pip build-essential zlib1g-dev libncurses5-dev libgdbm-dev libnss3-dev libssl-dev libreadline-dev libffi-dev libsqlite3-dev wget libbz2-dev pkg-config wget https://www.python.org/ftp/python/3.12.4/Python-3.12.4.tar.xz tar xf Python-3.12.4.tar.xz cd ./configure --enable-optimizations sudo make altinstall # This command takes long to execute

Clone CAI's source code

git clone https://github.com/aliasrobotics/cai && cd cai

Create virtual environment

python3.12 -m venv cai_env

Install the package from the local directory

source cai_env/bin/activate && pip3 install -e .

Generate a .env file and set up

cp .env.example .env # edit here your keys/models

Launch CAI

cai

### :nut_and_bolt: Setup `.env` file

CAI nutzt die `.env`-Datei, um die Konfiguration beim Start zu laden. Um die Einrichtung zu erleichtern, enthält das Repository eine beispielhafte [`.env.example`](https://github.com/aliasrobotics/cai/blob/HEAD/.env.example)-Datei, die eine Vorlage zum Konfigurieren der CAI-Einrichtung und Ihrer LLM-API-Schlüssel bietet, um mit den gewünschten LLM-Modellen zu arbeiten.

:warning: Wichtig:

CAI stellt standardmäßig KEINE API-Schlüssel für Modelle bereit. Bitten Sie uns nicht, Schlüssel bereitzustellen; verwenden Sie Ihre eigenen oder hosten Sie Ihre eigenen Modelle.

:warning: Hinweis:

Der OPENAI_API_KEY darf nicht leer gelassen werden. Er sollte entweder "sk-123" (als Platzhalter) oder Ihren tatsächlichen API-Schlüssel enthalten. Siehe https://github.com/aliasrobotics/cai/issues/27.

:warning: Hinweis:

Wenn Sie das alias1-Modell verwenden, stellen Sie sicher, dass die CAI-Version >0.4.0 ist, und hier haben Sie ein .env-Beispiel, um es nutzen zu können.```bash
OPENAI_API_KEY="sk-1234"
OLLAMA=""
ALIAS_API_KEY="<sk-your-key>"  # note, add yours
CAI_STREAM=False
CAI_MODEL="alias1"

🔹 Unterstützung benutzerdefinierter OpenAI-Basis-URLs

CAI unterstützt die Konfiguration einer benutzerdefinierten OpenAI-API-Basis-URL über die Umgebungsvariable OPENAI_BASE_URL. Dies ermöglicht es Benutzern, API-Aufrufe an einen benutzerdefinierten Endpunkt umzuleiten, z. B. an einen Proxy oder einen selbst gehosteten OpenAI-kompatiblen Dienst.

Beispielkonfiguration für einen .env-Eintrag:``` OLLAMA_API_BASE="https://custom-openai-proxy.com/v1"

Oder direkt von der Befehlszeile:```bash
OLLAMA_API_BASE="https://custom-openai-proxy.com/v1" cai

📐 Architektur:

CAI konzentriert sich darauf, die Koordination und Ausführung von Cybersicherheitsagenten leichtgewichtig, hoch kontrollierbar und für Menschen nützlich zu machen. Dazu baut es auf 8 Säulen auf: Agents, Tools, Handoffs, Patterns, Turns, Tracing, Guardrails und HITL.``` ┌───────────────┐ ┌───────────┐ │ HITL │◀─────-───▶│ Turns │ └───────┬───────┘ └───────────┘ │ ▼ ┌───────────┐ ┌───────────┐ ┌───────────┐ ┌───────────┐ │ Patterns │◀──-──▶│ Handoffs │◀──-─▶ │ Agents │◀──-─▶│ LLMs │ └───────────┘ └─────┬─────┘ └─────┬─────┘ └───────────┘ │ │ │ ▼ ┌────────────┐ ┌────┴──────┐ ┌───────────┐ ┌────────────┐ │ Extensions │◀────▶ │ Tracing │ │ Tools │◀──▶ │ Guardrails │ └────────────┘ └───────────┘ └───────────┘ └────────────┘ │ ┌─────────────┬─────┴────┬─────────────┐ ▼ ▼ ▼ ▼ ┌───────────┐┌───────────┐┌────────────┐┌───────────┐ │ LinuxCmd ││ WebSearch ││ Code ││ SSHTunnel │ └───────────┘└───────────┘└────────────┘└───────────┘

Wenn Sie tiefer in den Code eintauchen möchten, sehen Sie sich die folgenden Dateien als Ausgangspunkt für die Verwendung von CAI an:

* [__init__.py](https://github.com/aliasrobotics/cai/blob/main/src/cai/__init__.py)
* [cli.py](https://github.com/aliasrobotics/cai/blob/main/src/cai/cli.py) - Einstiegspunkt für die Befehlszeilenschnittstelle
* [util.py](https://github.com/aliasrobotics/cai/blob/main/src/cai/util.py) - Hilfsfunktionen
* [agents](https://github.com/aliasrobotics/cai/blob/main/src/cai/agents) - Agent-Implementierungen
* [internal](https://github.com/aliasrobotics/cai/blob/main/src/cai/internal) - CAI-interne Funktionen (Endpunkte, Metriken, Protokollierung usw.)
* [prompts](https://github.com/aliasrobotics/cai/blob/main/src/cai/prompts) - Agent-Prompt-Datenbank
* [repl](https://github.com/aliasrobotics/cai/blob/main/src/cai/repl) - CLI-Ästhetik und Befehle
* [sdk](https://github.com/aliasrobotics/cai/blob/main/src/cai/sdk) - CAI-Befehl-SDK
* [tools](https://github.com/aliasrobotics/cai/tree/main/src/cai/tools) - Agent-Werkzeuge

### 🔹 Agent

Im Kern abstrahiert CAI sein Cybersicherheitsverhalten über `Agents` und agentische `Patterns`. Ein Agent ist *ein intelligentes System, das mit einer Umgebung interagiert*. Technischer ausgedrückt: Innerhalb von CAI verwenden wir eine robotik-zentrierte Definition, bei der ein Agent alles ist, was als ein System betrachtet werden kann, das seine Umgebung durch Sensoren wahrnimmt, über seine Ziele nachdenkt und entsprechend durch Aktoren auf diese Umgebung einwirkt (angepasst von Russel & Norvig, AI: A Modern Approach). In der Cybersicherheit interagiert ein `Agent` mit Systemen und Netzwerken, nutzt Peripheriegeräte und Netzwerkschnittstellen als Sensoren, denkt entsprechend nach und führt dann Netzwerkaktionen aus, als wären sie Aktoren. Dementsprechend implementieren in CAI `Agent`s das `ReACT` (Reasoning and Action) Agentenmodell[^3]. Weitere Informationen finden Sie im [Beispiel hier](https://github.com/aliasrobotics/cai/blob/main/examples/basic/hello_world.py) für den vollständigen Ausführungscode und in diesem [Jupyter Notebook](https://github.com/aliasrobotics/cai/blob/main/fluency/my-first-hack/my_first_hack.ipynb) für ein Tutorial zur Verwendung.```python
from cai.sdk.agents import Agent, Runner, OpenAIChatCompletionsModel

import os
from openai import AsyncOpenAI
from dotenv import load_dotenv
load_dotenv()

agent = Agent(
      name="Custom Agent",
      instructions="""You are a Cybersecurity expert Leader""",
      model=OpenAIChatCompletionsModel(
          model=os.getenv('CAI_MODEL', "openai/gpt-4o"),
          openai_client=AsyncOpenAI(),
          )
      )

message = "Tell me about recursion in programming."
result = await Runner.run(agent, message)

🔹 Werkzeuge

Werkzeuge ermöglichen Cybersicherheitsagenten, Aktionen durchzuführen, indem sie Schnittstellen zur Ausführung von Systembefehlen, Sicherheitsscans, Schwachstellenanalysen und zur Interaktion mit Zielsystemen und APIs bereitstellen – sie sind die Kernfähigkeiten, die es CAI-Agenten ermöglichen, Sicherheitsaufgaben effektiv zu erledigen; in CAI umfassen Werkzeuge integrierte Cybersicherheitsdienstprogramme (wie LinuxCmd zur Befehlsausführung, WebSearch zur OSINT-Sammlung, Code zur dynamischen Skriptausführung und SSHTunnel für sicheren Fernzugriff), Funktionsaufrufmechanismen, die die Integration jeder Python-Funktion als Sicherheitswerkzeug ermöglichen, sowie Agent-als-Werkzeug-Funktionalität, die es spezialisierten Sicherheitsagenten (wie Aufklärungs- oder Exploit-Agenten) ermöglicht, von anderen Agenten genutzt zu werden, wodurch leistungsstarke kollaborative Sicherheitsworkflows ohne formale Übergaben zwischen Agenten entstehen. Weitere Informationen finden Sie im Beispiel hier für die vollständige Konfiguration benutzerdefinierter Funktionen.```python from cai.sdk.agents import Agent, Runner, OpenAIChatCompletionsModel from cai.tools.reconnaissance.exec_code import execute_code from cai.tools.reconnaissance.generic_linux_command import generic_linux_command

import os from openai import AsyncOpenAI from dotenv import load_dotenv load_dotenv()

agent = Agent( name="Custom Agent", instructions="""You are a Cybersecurity expert Leader""", tools= [ generic_linux_command, execute_code ], model=OpenAIChatCompletionsModel( model=os.getenv('CAI_MODEL', "openai/gpt-4o"), openai_client=AsyncOpenAI(), ) )

message = "Tell me about recursion in programming." result = await Runner.run(agent, message)

Sie finden verschiedene [Tools](https://github.com/aliasrobotics/cai/blob/HEAD/tools). Diese sind in 6 Hauptkategorien unterteilt, die von der Sicherheits-Kill-Chain [^2] inspiriert sind:

1. Aufklärung und Bewaffnung - *reconnaissance* (crypto, listing, etc)
2. Ausnutzung - *exploitation*
3. Privilege Escalation - *escalation*
4. Laterale Bewegung - *lateral*
5. Datenerfassung - *exfiltration*
6. Kommando und Kontrolle - *control*

### 🔹 Handoffs

`Handoffs` ermöglichen es einem `Agent`, Aufgaben an einen anderen Agent zu delegieren, was in Cybersecurity-Operationen entscheidend ist, wenn spezialisiertes Fachwissen für verschiedene Phasen eines Einsatzes benötigt wird. In unserem Framework werden `Handoffs` als Werkzeuge für das LLM implementiert, wobei eine **Handoff/Transfer-Funktion** wie `transfer_to_flag_discriminator` dem `ctf_agent` erlaubt, die Kontrolle an den `flag_discriminator_agent` zu übergeben, sobald er glaubt, die Flagge gefunden zu haben. Dadurch entsteht eine Sicherheitsvalidierungskette, bei der der erste Agent für Ausnutzung und Flaggenfindung zuständig ist, während der zweite Agent auf die Flaggenüberprüfung spezialisiert ist. Dies gewährleistet eine ordnungsgemäße Aufgabentrennung und nutzt die spezialisierten Fähigkeiten verschiedener Modelle für unterschiedliche Sicherheitsaufgaben. Weitere Informationen finden Sie im [Beispiel hier](https://github.com/aliasrobotics/cai/blob/main/examples/cai/agent_patterns/handoffs.py) für den vollständigen Ausführungscode.```python
from cai.sdk.agents import function_tool
from cai.tools.common import run_command
from cai.sdk.agents import Agent, OpenAIChatCompletionsModel, HandoffInputData, Runner, function_tool, handoff, trace
from cai.sdk.agents.extensions import handoff_filters

import os
from openai import AsyncOpenAI
from dotenv import load_dotenv
load_dotenv()

@function_tool
def execute_cli_command(command: str) -> str:
    return run_command(command)

flag_discriminator = Agent(
    name="Flag discriminator",
    description="Agent focused on extracting the flag from the output",
    instructions="You are an agent tailored to extract the flag from a given output.",
    model=OpenAIChatCompletionsModel(
        model=os.getenv('CAI_MODEL', "qwen2.5:14b"),
        openai_client=AsyncOpenAI(),
    ) 
)

ctf_agent = Agent(
    name="CTF agent",
    description="Agent focused on conquering security challenges",
    instructions="You are a Cybersecurity expert Leader facing a CTF",
    tools=[
        execute_cli_command,
    ],
    model=OpenAIChatCompletionsModel(
        model= os.getenv('CAI_MODEL', "qwen2.5:14b"),
        openai_client=AsyncOpenAI(),
    ), 
    handoffs = [flag_discriminator]
)

🔹 Patterns

Ein agentisches Pattern ist ein strukturiertes Entwurfsparadigma in Systemen der künstlichen Intelligenz, in denen autonome oder semi-autonome Agenten innerhalb eines definierten Interaktionsrahmens (des Patterns) arbeiten, um ein Ziel zu erreichen. Diese Patterns legen die Organisation, Koordination und Kommunikationsmethoden zwischen Agenten fest, die Entscheidungsfindung, Aufgabenausführung und Delegation leiten.

Ein agentisches Pattern (AP) kann formal als Tupel definiert werden:

\[ AP = (A, H, D, C, E) \]

wobei:

• \(A\) (Agenten): Eine Menge autonomer Entitäten, \( A = \{a_1, a_2, ..., a_n\} \), jede mit definierten Rollen, Fähigkeiten und internen Zuständen.
• \(H\) (Handoffs): Eine Funktion \( H: A \times T \to A \), die regelt, wie Aufgaben \( T \) zwischen Agenten basierend auf vordefinierter Logik (z.B. Regeln, Verhandlung, Bieten) übertragen werden.
• \(D\) (Entscheidungsmechanismus): Eine Entscheidungsfunktion \( D: S \to A \), wobei \( S \) Systemzustände repräsentiert und \( D \) bestimmt, welcher Agent zu einem bestimmten Zeitpunkt handelt.
• \(C\) (Kommunikationsprotokoll): Eine Nachrichtenfunktion \( C: A \times A \to M \), wobei \( M \) ein Nachrichtenraum ist, der definiert, wie Agenten Informationen teilen.
• \(E\) (Ausführungsmodell): Eine Funktion \( E: A \times I \to O \), wobei \( I \) der Eingaberaum und \( O \) der Ausgaberaum ist, der definiert, wie Agenten Aufgaben ausführen.

Beim Erstellen von Patterns klassifizieren wir sie im Allgemeinen in eine der folgenden Kategorien, obwohl andere existieren:

Für weitere Informationen und Beispiele gängiger Agentic-Patterns siehe den Beispiele-Ordner.

🔹 Turns und Interaktionen

Während des agentischen Flusses (Gesprächs) unterscheiden wir zwischen Interaktionen und Turns.

• Interaktionen sind sequenzielle Austausche zwischen einem oder mehreren Agenten. Jeder Agent, der seine Logik ausführt, entspricht einer Interaktion. Da ein Agent in CAI im Allgemeinen das ReACT-Agentenmodell implementiert[^3], besteht jede Interaktion aus 1) einem Reasoning-Schritt mittels einer LLM-Inferenz und 2) einem Handlungsschritt durch Aufruf von null bis n Tools. Dies ist in process_interaction() in core.py definiert.
• Turns: Ein Turn repräsentiert einen Zyklus von einer oder mehreren Interaktionen, der endet, wenn der ausführende Agent (oder Pattern) None zurückgibt, da er beurteilt, dass keine weiteren Aktionen erforderlich sind. Dies ist in run() definiert, siehe core.py.

[!NOTE] CAI-Agenten sind nicht mit Assistenten in der Assistants API verwandt. Sie sind aus Bequemlichkeit ähnlich benannt, aber ansonsten völlig unabhängig. CAI wird vollständig von der Chat Completions API betrieben und ist daher zustandslos zwischen Aufrufen.

🔹 Tracing

CAI implementiert KI-Beobachtbarkeit durch die Übernahme des OpenTelemetry-Standards und nutzt dazu Phoenix, das umfassende Tracing-Funktionen durch OpenTelemetry-basierte Instrumentierung bietet, sodass Sie Ihre Sicherheitsoperationen in Echtzeit überwachen und analysieren können. Diese Integration ermöglicht detaillierte Einblicke in Agenteninteraktionen, Werkzeugnutzung und Angriffsvektoren während Penetrationstest-Workflows, erleichtert das Debuggen komplexer Exploitation-Ketten, verfolgt Schwachstellenentdeckungsprozesse und optimiert die Agentenleistung für effektivere Sicherheitsbewertungen.

🔹 Guardrails

Guardrails bieten eine kritische Sicherheitsschicht für CAI-Agenten und schützen vor Prompt-Injection-Angriffen und verhindern die Ausführung gefährlicher Befehle. Diese Guardrails laufen parallel zu den Agenten und validieren sowohl Eingabe als auch Ausgabe, um einen sicheren Betrieb zu gewährleisten. Das Framework umfasst:

• Eingabe-Guardrails: Erkennen und blockieren Prompt-Injection-Versuche, bevor sie die Agenten erreichen, unter Verwendung von Pattern-Matching, Unicode-Homographen-Erkennung und KI-gestützter Analyse
• Ausgabe-Guardrails: Validieren Agentenausgaben vor der Ausführung, verhindern gefährliche Befehle wie Reverse Shells, Fork-Bomben oder Datenerfassung
• Mehrschichtige Verteidigung: Schutz auf Eingabe-, Verarbeitungs- und Ausführungsstufen mit werkzeugbezogener Validierung
• Base64/Base32-bewusst: Dekodiert und analysiert automatisch codierte Payloads, um versteckte bösartige Befehle zu erkennen
• Konfigurierbar: Kann über die Umgebungsvariable CAI_GUARDRAILS aktiviert/deaktiviert werden

Für eine detaillierte Implementierung siehe docs/guardrails.md und docs/cai_prompt_injection.md.

🔹 Human-In-The-Loop (HITL)```

                  ┌─────────────────────────────────┐
                  │                                 │
                  │      Cybersecurity AI (CAI)     │
                  │                                 │
                  │       ┌─────────────────┐       │
                  │       │  Autonomous AI  │       │
                  │       └────────┬────────┘       │
                  │                │                │
                  │                │                │
                  │       ┌────────▼─────────┐      │
                  │       │ HITL Interaction │      │
                  │       └────────┬─────────┘      │
                  │                │                │
                  └────────────────┼────────────────┘
                                   │
                                   │ Ctrl+C (cli.py)
                                   │
                       ┌───────────▼───────────┐
                       │   Human Operator(s)   │
                       │  Expertise | Judgment │
                       │    Teleoperation      │
                       └───────────────────────┘

CAI bietet ein Framework zur Entwicklung von Cybersecurity-KIs mit einem starken Fokus auf *semi-autonomen* Betrieb, da die Realität zeigt, dass **vollautonome** Cybersicherheitssysteme noch verfrüht sind und bei der Bewältigung komplexer Aufgaben vor erheblichen Herausforderungen stehen. Während CAI autonome Fähigkeiten erforscht, erkennen wir an, dass effektive Sicherheitsoperationen weiterhin menschliche Teleoperation erfordern, die Fachwissen, Urteilsvermögen und Aufsicht in den Sicherheitsprozess einbringt.

Dementsprechend ist das Human-In-The-Loop (`HITL`)-Modul ein Kernentwurfsprinzip von CAI, das anerkennt, dass menschliche Intervention und Teleoperation wesentliche Bestandteile verantwortungsvoller Sicherheitstests sind. Über die `cli.py`-Schnittstelle können Benutzer nahtlos zu jedem Zeitpunkt während der Ausführung mit Agenten interagieren, indem sie einfach `Ctrl+C` drücken. Dies ist in [core.py](https://github.com/aliasrobotics/cai/blob/HEAD/cai/core.py) und auch in den REPL-Abstraktionen [REPL](https://github.com/aliasrobotics/cai/blob/HEAD/cai/repl) implementiert.

## :rocket: Schnellstart

Um CAI nach der Installation zu starten, geben Sie einfach `cai` in der CLI ein:```bash
└─# cai

          CCCCCCCCCCCCC      ++++++++   ++++++++      IIIIIIIIII
       CCC::::::::::::C  ++++++++++       ++++++++++  I::::::::I
     CC:::::::::::::::C ++++++++++         ++++++++++ I::::::::I
    C:::::CCCCCCCC::::C +++++++++    ++     +++++++++ II::::::II
   C:::::C       CCCCCC +++++++     +++++     +++++++   I::::I
  C:::::C                +++++     +++++++     +++++    I::::I
  C:::::C                ++++                   ++++    I::::I
  C:::::C                 ++                     ++     I::::I
  C:::::C                  +   +++++++++++++++   +      I::::I
  C:::::C                    +++++++++++++++++++        I::::I
  C:::::C                     +++++++++++++++++         I::::I
   C:::::C       CCCCCC        +++++++++++++++          I::::I
    C:::::CCCCCCCC::::C         +++++++++++++         II::::::II
     CC:::::::::::::::C           +++++++++           I::::::::I
       CCC::::::::::::C             +++++             I::::::::I
          CCCCCCCCCCCCC               ++              IIIIIIIIII

                      Cybersecurity AI (CAI), vX.Y.Z
                          Bug bounty-ready AI

CAI>

Das sollte CAI initialisieren und eine Eingabeaufforderung bereitstellen, um jede gewünschte Sicherheitsaufgabe auszuführen. Die Navigationsleiste unten zeigt wichtige Systeminformationen an. Diese Informationen helfen Ihnen, Ihre Umgebung während der Arbeit mit CAI zu verstehen.

Hier ist ein kurzes Demovideo, das Ihnen den Einstieg in CAI erleichtert. Wir gehen die grundlegenden Schritte durch – vom Starten des Tools bis zur Ausführung Ihrer ersten KI-gestützten Aufgabe im Terminal. Egal, ob Sie Anfänger sind oder einfach neugierig, dieser Leitfaden zeigt Ihnen, wie einfach es ist, CAI zu nutzen.

Geben Sie ab hier CAI ein und beginnen Sie Ihre Sicherheitsübung. Der beste Weg zu lernen ist durch Beispiele:

Umgebungsvariablen

Für die Verwendung privater Modelle erhalten Sie eine .env.example-Datei. Kopieren Sie sie und benennen Sie sie in .env um. Füllen Sie Ihre entsprechenden API-Schlüssel ein, und schon können Sie CAI verwenden.

Liste der Umgebungsvariablen

OpenRouter-Integration

Die Cybersecurity AI (CAI)-Plattform bietet eine nahtlose Integration mit OpenRouter, einer einheitlichen Schnittstelle für Large Language Models (LLMs). Diese Integration ist entscheidend für Benutzer, die erweiterte KI-Fähigkeiten in ihren Cybersicherheitsaufgaben nutzen möchten. OpenRouter fungiert als Brücke, die es CAI ermöglicht, mit verschiedenen LLMs zu kommunizieren, wodurch die Flexibilität und Leistungsfähigkeit der in CAI verwendeten KI-Agenten verbessert wird.

Um die OpenRouter-Unterstützung in CAI zu aktivieren, müssen Sie Ihre Umgebung konfigurieren, indem Sie spezifische Einträge zu Ihrer .env-Datei hinzufügen. Diese Einrichtung stellt sicher, dass CAI mit der OpenRouter-API interagieren kann, was die Verwendung anspruchsvoller Modelle wie Meta-LLaMA ermöglicht. So konfigurieren Sie es:```bash CAI_AGENT_TYPE=redteam_agent CAI_MODEL=openrouter/meta-llama/llama-4-maverick OPENROUTER_API_KEY= # note, add yours OPENROUTER_API_BASE=https://openrouter.ai/api/v1

### Azure OpenAI

Die Cybersecurity AI (CAI)-Plattform integriert sich nahtlos mit Azure OpenAI und ermöglicht es Organisationen, CAI gegen unternehmensgehostete Modelle (z. B. gpt-4o) auszuführen. Dieser Weg ist ideal für Teams, die innerhalb der Azure-Governance arbeiten müssen, während sie fortgeschrittene Modellfähigkeiten nutzen.
Um die Azure-OpenAI-Unterstützung in CAI zu aktivieren, konfigurieren Sie Ihre Umgebung, indem Sie die folgenden Einträge zu Ihrer .env-Datei hinzufügen. Dies stellt sicher, dass CAI Ihren Azure-Bereitstellungsendpunkt erreichen und sich korrekt authentifizieren kann.```bash
CAI_AGENT_TYPE=redteam_agent
CAI_MODEL=azure/<model-name-deployed>
# Required: keep non-empty even when using Azure
OPENAI_API_KEY=dummy
# Azure credentials and endpoint
AZURE_API_KEY=<your-azure-openai-key>
AZURE_API_BASE=https://<resource>.openai.azure.com/openai/deployments/<deployment-name>/chat/completions?api-version=2025-01-01-preview

MCP

CAI unterstützt das Model Context Protocol (MCP) zur Integration externer Werkzeuge und Dienste mit KI-Agenten. MCP wird über zwei Transportmechanismen unterstützt:

1. SSE (Server-Sent Events) - Für webbasierte Server, die Updates über HTTP-Verbindungen pushen:```bash CAI>/mcp load http://localhost:9876/sse burp

2. **STDIO (Standard Input/Output)** - Für lokale Interprozesskommunikation:```bash
CAI>/mcp load stdio myserver python mcp_server.py

Sobald die Verbindung hergestellt ist, können Sie die MCP-Tools zu jedem Agenten hinzufügen:```bash CAI>/mcp add burp redteam_agent Adding tools from MCP server 'burp' to agent 'Red Team Agent'... Adding tools to Red Team Agent ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓ ┃ Tool ┃ Status ┃ Details ┃ ┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩ │ send_http_request │ Added │ Available as: send_http_request │ │ create_repeater_tab │ Added │ Available as: create_repeater_tab │ │ send_to_intruder │ Added │ Available as: send_to_intruder │ │ url_encode │ Added │ Available as: url_encode │ │ url_decode │ Added │ Available as: url_decode │ │ base64encode │ Added │ Available as: base64encode │ │ base64decode │ Added │ Available as: base64decode │ │ generate_random_string │ Added │ Available as: generate_random_string │ │ output_project_options │ Added │ Available as: output_project_options │ │ output_user_options │ Added │ Available as: output_user_options │ │ set_project_options │ Added │ Available as: set_project_options │ │ set_user_options │ Added │ Available as: set_user_options │ │ get_proxy_http_history │ Added │ Available as: get_proxy_http_history │ │ get_proxy_http_history_regex │ Added │ Available as: get_proxy_http_history_regex │ │ get_proxy_websocket_history │ Added │ Available as: get_proxy_websocket_history │ │ get_proxy_websocket_history_regex │ Added │ Available as: get_proxy_websocket_history_regex │ │ set_task_execution_engine_state │ Added │ Available as: set_task_execution_engine_state │ │ set_proxy_intercept_state │ Added │ Available as: set_proxy_intercept_state │ │ get_active_editor_contents │ Added │ Available as: get_active_editor_contents │ │ set_active_editor_contents │ Added │ Available as: set_active_editor_contents │ └───────────────────────────────────┴────────┴─────────────────────────────────────────────────┘ Added 20 tools from server 'burp' to agent 'Red Team Agent'. CAI>/agent 13 CAI>Create a repeater tab

Sie können alle aktiven MCP-Verbindungen und deren Transporttypen auflisten:```bash
CAI>/mcp list

https://github.com/user-attachments/assets/386a1fd3-3469-4f84-9396-2a5236febe1f

Entwicklung

Die Entwicklung wird durch VS Code-Entwicklungsumgebungen ermöglicht. Um unsere Entwicklungsumgebung auszuprobieren, klonen Sie das Repository, öffnen Sie VS Code und wechseln Sie in den dev. Container-Modus:

Beiträge

Wenn Sie zu diesem Projekt beitragen möchten, verwenden Sie Pre-commit vor Ihrem MR```bash pip install pre-commit pre-commit # files staged pre-commit run --all-files # all files

### Optional Requirements: caiextensions

Derzeit sind die Erweiterungen nicht öffentlich verfügbar, da der dafür nötige Entwicklungsaufwand beträchtlich ist. Stattdessen stellen wir ausgewählte benutzerdefinierte caiextensions für Partnerunternehmen im Rahmen von Kooperationen zur Verfügung.

### :information_source: Nutzungsdatenerfassung

CAI wird Forschern kostenlos zur Verfügung gestellt. Um die Erkennungsgenauigkeit von CAI zu verbessern, offene Sicherheitsforschung voranzutreiben und zukünftige Modelle zu entwickeln und zu trainieren, bitten wir Sie, zur CAI-Community beizutragen, indem Sie die Erhebung von Nutzungsdaten zulassen. Diese Daten helfen uns, Verbesserungsbereiche zu identifizieren, zu verstehen, wie das Framework genutzt wird, neue Funktionen zu priorisieren und Modelltraining und Evaluierungsbemühungen zu unterstützen.

Die Rechtsgrundlage für die Datenerhebung ist Art. 6 (1)(f) DSGVO – das berechtigte Interesse von CAI an der Wartung, Verbesserung und Weiterentwicklung von Sicherheitstools und -forschung – unter Anwendung der Sicherheitsvorkehrungen gemäß Art. 89 für Forschungszwecke.

Die erhobenen Daten umfassen:

- Grundlegende Systeminformationen (Betriebssystemtyp, Python-Version)
- Benutzername und IP-Informationen
- Nutzungsmuster des Tools und Leistungskennzahlen
- Modellinteraktionen und Token-Nutzungsstatistiken

Wir nehmen Ihren Datenschutz ernst und erheben nur das, was notwendig ist, um CAI zu verbessern, Forschung zu unterstützen und Modelle verantwortungsbewusst zu trainieren und zu evaluieren. Für weitere Informationen kontaktieren Sie research＠aliasrobotics.com. Sie können einige Datenerhebungsfunktionen über die Umgebungsvariable `CAI_TELEMETRY` deaktivieren, auch wenn wir Sie ermutigen, sie aktiviert zu lassen, um zur laufenden Forschung und Modellentwicklung beizutragen:```bash
CAI_TELEMETRY=False cai

CI-Setup lokal reproduzieren

Um die CI/CD-Pipeline zu simulieren, können Sie Folgendes auf den Gitlab-Runner-Maschinen ausführen:```bash docker run --rm -it
--privileged
--network=exploitflow_net
--add-host="host.docker.internal:host-gateway"
-v /cache:/cache
-v /var/run/docker.sock:/var/run/docker.sock:rw
registry.gitlab.com/aliasrobotics/alias_research/cai:latest bash

## FAQ
 OLLAMA gibt mir 404-Fehler

Die Ollama-API im OpenAI-Modus verwendet `/v1/chat/completions`, während die `openai`-Bibliothek `base_url` + `/chat/completions` verwendet.

Wir übernehmen letzteres für eine allgemeine Ausrichtung an der generativen KI-Community und ermöglichen ersteres, indem Benutzer das `v1` selbst hinzufügen können über:```bash
OLLAMA_API_BASE=http://IP:PORT/v1

Siehe die folgenden Issues, die dieses Thema detaillierter behandeln:

• https://github.com/aliasrobotics/cai/issues/76
• https://github.com/aliasrobotics/cai/issues/83
• https://github.com/aliasrobotics/cai/issues/82

Wo sind alle caiextensions?

Siehe alle caiextensions

Wie installiere ich die report caiextension?

Siehe hier

Wie richte ich SSH-Zugriff für Gitlab ein?

Generieren Sie einen neuen SSH-Schlüssel```bash ssh-keygen -t ed25519

Fügen Sie den Schlüssel zum SSH-Agenten hinzu```bash
ssh-add ~/.ssh/id_ed25519

Öffentlichen Schlüssel zu Gitlab hinzufügen Schlüssel kopieren und unter https://gitlab.com/-/user_settings/ssh_keys zu Gitlab hinzufügen```bash cat ~/.ssh/id_ed25519.pub

Um es zu verifizieren:```bash
ssh -T [email protected]
Welcome to GitLab, @vmayoral!

Wie lösche ich den Python-Cache?```bash find . -name "*.pyc" -delete && find . -name "pycache" -delete

Wenn Host-Netzwerk mit ollama nicht funktioniert, überprüfen Sie, ob es in Docker deaktiviert wurde, weil Sie nicht angemeldet sind.

Docker unter OS X verhält sich manchmal seltsam. Prüfen Sie, ob die folgende Meldung erschienen ist:

*Host-Netzwerk wurde deaktiviert, weil Sie nicht angemeldet sind. Bitte melden Sie sich an, um es zu aktivieren*.

Stellen Sie sicher, dass dies behoben wurde und dass der Dev Container den Port 8000 nicht weiterleitet (klicken Sie ggf. im Bereich „Ports“ auf das x).

Um die Verbindung zu überprüfen, führen Sie innerhalb des VSCode-Devcontainers Folgendes aus:```bash
curl -v http://host.docker.internal:8000/api/version

CAI gegen ein beliebiges Ziel ausführen

cai-004-first-message

Der anfängliche Benutzerprompt lautet in diesem Fall: Target IP: 192.168.3.10, perform a full network scan.

Der Agent begann mit der Durchführung eines Nmap-Scans. Du kannst entweder mit dem Agenten interagieren und ihm weitere Anweisungen geben oder ihn laufen lassen, um zu sehen, was er als Nächstes erkundet.

Wie interagiere ich mit dem Agenten? Zweimal STRG + C drücken

cai-005-ctrl-c

Wenn du den HITL-Modus verwenden möchtest, kannst du dies tun, indem du zweimal Ctrl + C drückst. Dadurch kannst du jederzeit mit dem Agenten interagieren (Aufforderung eingeben). Der Agent verliert nicht den vorherigen Kontext, da er in der Variable history gespeichert ist, die sowohl an ihn als auch an jeden aufgerufenen Agenten übergeben wird. Dies ermöglicht es jedem Agenten, die vorherigen Informationen zu nutzen und genauer sowie effizienter zu arbeiten.

Kann ich das Modell während der Ausführung von CAI ändern? /model

Verwende /model, um das Modell zu wechseln.

cai-007-model-change

Wie kann ich alle verfügbaren Agenten auflisten? /agent

Verwende /agent, um alle verfügbaren Agenten aufzulisten.

cai-010-agents-menu

Wo kann ich alle Umgebungsvariablen auflisten? /env

cai-008-config

Wie kann ich Token-Nutzung und Kosten überwachen?

Verwende /cost in der REPL für Sitzungsausgaben und Token-Statistiken, /compact, wenn Gespräche lang werden, und (im TUI-Modus) die Kosten- und Modusanzeigen pro Terminal in der Benutzeroberfläche.```bash CAI> /cost

Siehe die [CLI-Befehlsreferenz](https://github.com/aliasrobotics/cai/blob/HEAD/docs/cli/commands_reference.md) für die vollständige Befehlsliste.
 

 
 Wie erfahre ich mehr über die CLI? /help 

cai-006-help
 

 
 Wie kann ich die gesamte Ausführung verfolgen? 
Die Umgebungsvariable `CAI_TRACING` erlaubt es dem Benutzer, sie auf `CAI_TRACING=true` zu setzen, um die Verfolgung zu aktivieren, oder auf `CAI_TRACING=false`, um sie zu deaktivieren.
Wenn CAI zum ersten Mal aufgerufen wird, werden dem Benutzer zwei Pfade bereitgestellt: das Ausführungsprotokoll und das Verfolgungsprotokoll.

cai-009-logs

 

 
 Kann ich die Fähigkeiten von CAI mithilfe von Protokollen früherer Ausführungen erweitern? 

Ja. Derzeit funktioniert CAI am besten durch die Verwendung von In‑Context Learning (ICL). Anstatt langfristige Speicher aufzubauen, besteht der empfohlene Arbeitsablauf darin, relevante frühere Protokolle direkt in die aktuelle Sitzung zu laden, damit das Modell mit ihnen im Kontext argumentieren kann.

Verwenden Sie den Befehl `/load`, um JSONL-Protokolle in den Kontext von CAI zu laden (dies ersetzt das alte Tool zum Laden von Speicher):```bash
CAI>/load logs/cai_20250408_111856.jsonl         # Load into current agent
CAI>/load <file> agent <name>                    # Load into a specific agent
CAI>/load <file> all                             # Distribute across all agents
CAI>/load <file> parallel                        # Match to configured parallel agents
# Tip: if you omit <file>, /load uses `logs/last`. Alias: /l

CAI gibt den Pfad zum JSONL-Log des aktuellen Durchlaufs beim Start aus (orange hervorgehoben), den Sie an /load übergeben können:

cai-009-logs

Legacy-Hinweise: Frühere „Speichererweiterungs“-Mechanismen (episodische/semantische Speicher und Offline-Erfassung) werden nur als Referenz beibehalten. Siehe src/cai/agents/memory.py für Hintergrundinformationen und Legacy-Details. Unsere aktuelle Ausrichtung priorisiert ICL gegenüber persistentem Speicher.

Kann ich CAI-Funktionen mit Skripten oder zusätzlichen Informationen erweitern?

Derzeit unterstützt CAI textbasierte Informationen. Sie können dem System oder dem Benutzer-Prompt alle zusätzlichen Informationen zum Ziel, das Sie bearbeiten, hinzufügen, indem Sie sie direkt per Copy & Paste einfügen.

Wie? Indem Sie sie dem System- (system_master_template.md) oder dem Benutzer-Prompt (user_master_template.md) hinzufügen. Sie können den Pfad zum Modell immer direkt angeben, und es wird cat ausführen.

Wie funktioniert die CAI-Lizenz?

Die aktuelle Lizenz von CAI schränkt die Nutzung für Forschungszwecke nicht ein. Sie können CAI frei für Sicherheitsbewertungen (Pentests) verwenden, zusätzliche Funktionen entwickeln und es in Ihre Forschungsaktivitäten integrieren, solange Sie die lokalen Gesetze einhalten.

Wenn Sie oder Ihre Organisation kommerziell von CAI profitieren (z. B. durch das Anbieten von Pentesting-Diensten, die auf CAI basieren), ist eine kommerzielle Lizenz erforderlich, um das Projekt zu unterstützen.

CAI selbst ist keine gewinnorientierte Initiative. Unser Ziel ist es, ein nachhaltiges Open-Source-Projekt aufzubauen. Wir bitten lediglich darum, dass diejenigen, die mit CAI Gewinn erzielen, zurückgeben und unsere laufende Entwicklung unterstützen.

Ich erhalte eine Unable to locate package python3.12-venv-Meldung, wenn ich die Voraussetzungen auf meinem Debian-basierten System installiere!

Der einfachste Weg, dies zu umgehen, ist, python3.12 aus dem Quellcode zu installieren.

Zitierung

Wenn Sie unsere Arbeit zitieren möchten, verwenden Sie bitte die folgenden (sortiert nach Veröffentlichungsdatum):```bibtex @article{mayoral2025cai, title={CAI: An Open, Bug Bounty-Ready Cybersecurity AI}, author={Mayoral-Vilches, V{'\i}ctor and Navarrete-Lozano, Luis Javier and Sanz-G{'o}mez, Mar{'\i}a and Espejo, Lidia Salas and Crespo-{'A}lvarez, Marti{~n}o and Oca-Gonzalez, Francisco and Balassone, Francesco and Glera-Pic{'o}n, Alfonso and Ayucar-Carbajo, Unai and Ruiz-Alcalde, Jon Ander and Rass, Stefan and Pinzger, Martin and Gil-Uriarte, Endika}, journal={arXiv preprint arXiv:2504.06017}, year={2025} }

@article{mayoral2025automation, title={Cybersecurity AI: The Dangerous Gap Between Automation and Autonomy}, author={Mayoral-Vilches, V{'\i}ctor}, journal={arXiv preprint arXiv:2506.23592}, year={2025} }

@article{mayoral2025fluency, title={CAI Fluency: A Framework for Cybersecurity AI Fluency}, author={Mayoral-Vilches, V{'\i}ctor and Wachter, Jasmin and Chavez, Crist{'o}bal RJ and Schachner, Cathrin and Navarrete-Lozano, Luis Javier and Sanz-G{'o}mez, Mar{'\i}a}, journal={arXiv preprint arXiv:2508.13588}, year={2025} }

@article{mayoral2025hacking, title={Cybersecurity AI: Hacking the AI Hackers via Prompt Injection}, author={Mayoral-Vilches, V{'\i}ctor and Rynning, Per Mannermaa}, journal={arXiv preprint arXiv:2508.21669}, year={2025} }

@article{mayoral2025humanoid, title={Cybersecurity AI: Humanoid Robots as Attack Vectors}, author={Mayoral-Vilches, V{'\i}ctor}, journal={arXiv preprint arXiv:2509.14139}, year={2025} }

@article{balassone2025evaluation, title={Cybersecurity AI: Evaluating Agentic Cybersecurity in Attack/Defense CTFs}, author={Balassone, Francesco and Mayoral-Vilches, V{'\i}ctor and Rass, Stefan and Pinzger, Martin and Perrone, Gaetano and Romano, Simon Pietro and Schartner, Peter}, journal={arXiv preprint arXiv:2510.17521}, year={2025} }

@article{mayoral2025caibench, title={CAIBench: A Meta-Benchmark for Evaluating Cybersecurity AI Agents}, author={Mayoral-Vilches, V{'\i}ctor and Balassone, Francesco and Navarrete-Lozano, Luis Javier and Sanz-G{'o}mez, Mar{'\i}a and Crespo-{'A}lvarez, Marti{~n}o and Rass, Stefan and Pinzger, Martin}, journal={arXiv preprint arXiv:2510.24317}, year={2025} }

## Danksagungen

CAI wurde ursprünglich von [Alias Robotics](https://aliasrobotics.com) entwickelt und vom europäischen EIC-Beschleunigerprojekt RIS (GA 101161136) – Förderaufruf HORIZON-EIC-2023-ACCELERATOR-01 – kofinanziert. Die ursprünglichen agentischen Prinzipien sind von OpenAIs [`swarm`](https://github.com/openai/swarm)-Bibliothek inspiriert und in neuere Prototypen übersetzt. Dieses Projekt nutzt auch andere relevante Open-Source-Bausteine wie [`LiteLLM`](https://github.com/BerriAI/litellm) und [`phoenix`](https://github.com/Arize-ai/phoenix).

### Akademische Kooperationen
CAI profitiert von laufenden Forschungskooperationen mit akademischen Einrichtungen. Forscher, die an gemeinsamen Projekten, Datenzugriff oder akademischen Lizenzen interessiert sind, wenden sich bitte an [email protected]. Wir bieten spezielle Unterstützung für:
- Promotionsforschungsprojekte
- Akademische Benchmark-Studien
- Initiativen zur Sicherheitsausbildung
- Open-Source-Beiträge von Forschungslaboren


[^1]: Das Chain-of-Thought-Agentenmuster ist wohl ein Sonderfall des hierarchischen Agentenmusters.
[^2]: Kamhoua, C. A., Leslie, N. O., & Weisman, M. J. (2018). Game theoretic modeling of advanced persistent threat in internet of things. Journal of Cyber Security and Information Systems.
[^3]: Yao, S., Zhao, J., Yu, D., Du, N., Shafran, I., Narasimhan, K., & Cao, Y. (2023, January). React: Synergizing reasoning and acting in language models. In International Conference on Learning Representations (ICLR).
[^4]: Deng, G., Liu, Y., Mayoral-Vilches, V., Liu, P., Li, Y., Xu, Y., ... & Rass, S. (2024). {PentestGPT}: Evaluating and harnessing large language models for automated penetration testing. In 33rd USENIX Security Symposium (USENIX Security 24) (pp. 847-864).