Cybersecurity AI (CAI)

Édition Professionnelle avec jetons alias1 illimités | 📊 Voir les Benchmarks | 🚀 En savoir plus

🔓 Édition Communauté Recherche et Apprentissage · Parfait pour les chercheurs et les étudiants pip install cai-framework

✅ Gratuit pour la recherche 🤖 300+ modèles d'IA 🌍 Porté par la communauté 📚 Open source 🔧 Framework extensible

🚀 Édition Professionnelle Entreprise et Production · 350€/mois · Jetons alias1 illimités

→ Passer à la version PRO

⚡ Modèle alias1 - ∞ jetons illimités 🚫 Zéro refus - IA sans restriction 🏆 Dépasse GPT-5 dans les benchmarks CTF 🛡️ Support professionnel inclus 🇪🇺 Souveraineté des données européenne

CAI PRO avec le modèle alias1 surpasse GPT-5 dans les benchmarks de cybersécurité IA vs IA | Voir les Benchmarks Complets →

-->

Cybersecurity AI (CAI) est un framework léger et open-source qui permet aux professionnels de la sécurité de construire et déployer une automatisation offensive et défensive alimentée par l'IA. CAI est le framework de facto pour la sécurité IA, déjà utilisé par des milliers d'utilisateurs individuels et des centaines d'organisations. Que vous soyez chercheur en sécurité, hacker éthique, professionnel informatique ou organisation cherchant à renforcer votre posture de sécurité, CAI fournit les éléments de base pour créer des agents IA spécialisés pouvant assister dans l'atténuation, la découverte de vulnérabilités, l'exploitation et l'évaluation de sécurité.

🔓 Exécuter CAI sans clé API Alias (CAI_LICENSE_OFF)

CAI peut être exécuté sans ALIAS_API_KEY (c'est-à-dire sans licence Alias Robotics) en définissant la variable d'environnement CAI_LICENSE_OFF=1.

Lorsque CAI_LICENSE_OFF est défini sur 1, true ou yes :

• La vérification de licence au démarrage est ignorée — aucune ALIAS_API_KEY n'est requise.
• CAI fonctionne en mode open-source et les opérations de mise à jour ciblent le package public PyPI cai-framework au lieu de l'index de packages privé Alias.
• Vous pouvez utiliser tout autre fournisseur de modèles supporté (OpenAI, Anthropic, DeepSeek, Ollama, etc.) en configurant CAI_MODEL et la clé API du fournisseur correspondant.

Démarrage rapide sans licence :```bash export CAI_LICENSE_OFF=1 cai

Ou inline:```bash
CAI_LICENSE_OFF=1 cai

Note : Le modèle alias1 nécessite toujours une clé ALIAS_API_KEY valide. CAI_LICENSE_OFF ne fait que contourner la porte de licence du framework — il n'accorde pas l'accès aux modèles hébergés par Alias.

Key Features:

• 🤖 300+ modèles IA : Prise en charge d'OpenAI, Anthropic, DeepSeek, Ollama, et plus
• 🔧 Outils de sécurité intégrés : Outils prêts à l'emploi pour la reconnaissance, l'exploitation et l'élévation de privilèges
• 🏆 Éprouvé sur le terrain : Validé dans les CTF HackTheBox, les programmes de bug bounty et des études de cas de sécurité réelles case studies
• 🎯 Architecture basée sur des agents : Conception modulaire du framework pour construire des agents spécialisés pour différentes tâches de sécurité
• 🛡️ Protection par garde-fous : Défenses intégrées contre l'injection de prompt et l'exécution de commandes dangereuses
• 📚 Orienté recherche : Fondation de recherche pour démocratiser l'IA de cybersécurité pour la communauté

[!NOTE] Lisez le rapport technique : CAI: An Open, Bug Bounty-Ready Cybersecurity AI Une édition de lecture HTML avec figures et références est maintenue par le Robot Cybersecurity Lab.

Pour des lectures complémentaires, référez-vous à nos sections impact et citation CAI.

[!WARNING] ⚠️ CAI est en cours de développement actif, ne vous attendez donc pas à ce qu'il fonctionne parfaitement. Contribuez plutôt en soumettant un problème ou en envoyant une PR.

L'accès à cette bibliothèque et l'utilisation des informations, matériaux (ou parties de ceux-ci) ne sont pas destinés et sont interdits là où cet accès ou cette utilisation enfreint les lois ou réglementations applicables. Les auteurs n'encouragent ni ne promeuvent en aucun cas la modification non autorisée de systèmes en fonctionnement. Cela peut causer des dommages humains graves et des dégâts matériels.

Les auteurs de CAI n'encouragent ni ne promeuvent en aucun cas la modification non autorisée de systèmes informatiques. Veuillez ne pas utiliser le code source ici pour la cybercriminalité. Faites plutôt du pentest pour le bien. En téléchargeant, utilisant ou modifiant ce code source, vous acceptez les termes de la LICENSE et les limitations décrites dans le fichier DISCLAIMER.

🔖 Table of Contents

• IA de cybersécurité (CAI)
• 🔖 Table des matières
• 🎯 Impact
• 🏆 Compétitions et défis
• 📊 Impact de la recherche
• 📚 Produits de recherche : Cybersecurity AI
• PoCs
• Motivation
• 👤 Pourquoi CAI ?
• Principes éthiques derrière CAI
• Alternatives propriétaires
• Apprendre - CAI Fluency
• 🔩 Installation
• OS X
• Ubuntu 24.04
• Ubuntu 20.04
• Windows WSL
• Android
• 🔩 Configuration du fichier .env
• 🔹 Support d'URL de base OpenAI personnalisé
• 📐 Architecture :
• 🔹 Agent
• 🔹 Outils
• 🔹 Handoffs
• 🔹 Patterns
• 🔹 Tours et interactions
• 🔹 Tracing
• 🔹 Guardrails
• 🔹 Humain dans la boucle (HITL)
• 🚀 Démarrage rapide

🎯 Impact

🏆 Compétitions et défis

📊 Impact de la recherche

• A pionné la sécurité IA alimentée par LLM avec PentestGPT, établissant les bases du domaine de recherche Cybersecurity AI

• A établi la ligne de recherche Cybersecurity AI avec 8 articles et rapports techniques, avec des collaborations de recherche actives

📚 Produits de recherche : Cybersecurity AI

Éditions de lecture HTML étendues : CAI · CAIBench · Robots humanoïdes comme vecteurs d'attaque · La cybersécurité d'un robot humanoïde · Pirater les robots grand public à l'ère de l'IA

PoCs

CAI avec alias0 sur les attaques d'injection de messages ROS dans le robot MiR-100	CAI avec alias0 sur la découverte de vulnérabilités API chez Mercado Libre

CAI sur le CTF JWT@PortSwigger — IA de cybersécurité	CAI sur le CTF HackableII Boot2Root — IA de cybersécurité

Plus d'études de cas et de PoCs sont disponibles sur https://aliasrobotics.com/case-studies-robot-cybersecurity.php.

Motivation

👤 Pourquoi CAI ?

Le paysage de la cybersécurité subit une transformation dramatique à mesure que l'IA s'intègre de plus en plus dans les opérations de sécurité. Nous prévoyons qu' d'ici 2028, les outils de test de sécurité alimentés par IA dépasseront en nombre les testeurs d'intrusion humains. Ce changement représente une modification fondamentale de notre approche des défis de cybersécurité. L'IA n'est pas seulement un outil supplémentaire - elle devient essentielle pour traiter les vulnérabilités de sécurité complexes et garder une longueur d'avance sur les menaces sophistiquées. Alors que les organisations font face à des cyberattaques plus avancées, les tests de sécurité améliorés par l'IA seront cruciaux pour maintenir des défenses robustes.

Ce travail s'appuie sur des efforts antérieurs[^4] et de la même manière, nous pensons que démocratiser l'accès aux outils avancés d'IA de cybersécurité est vital pour toute la communauté de la sécurité. C'est pourquoi nous publions Cybersecurity AI (CAI) en tant que framework open source. Notre objectif est de donner aux chercheurs en sécurité, aux hackers éthiques et aux organisations les moyens de construire et de déployer des outils de sécurité puissants pilotés par l'IA. En rendant ces capacités librement disponibles, nous visons à équilibrer les chances et à garantir que la technologie de pointe en IA de sécurité ne soit pas limitée à des entreprises privées bien financées ou à des acteurs étatiques.

Les programmes de Bug Bounty sont devenus une pierre angulaire de la cybersécurité moderne, offrant un mécanisme crucial aux organisations pour identifier et corriger les vulnérabilités de leurs systèmes avant qu'elles ne soient exploitées. Ces programmes se sont révélés très efficaces pour sécuriser à la fois les infrastructures publiques et privées, les chercheurs découvrant des vulnérabilités critiques qui auraient autrement pu passer inaperçues. CAI est spécifiquement conçu pour améliorer ces efforts en fournissant un framework léger et ergonomique pour construire des agents IA spécialisés capables d'assister dans divers aspects de la chasse aux Bug Bounty - de la reconnaissance initiale à la validation et au rapport de vulnérabilités. Notre framework vise à augmenter l'expertise humaine avec des capacités IA, aidant les chercheurs à travailler plus efficacement et plus en profondeur dans leur quête pour sécuriser les systèmes numériques.

Principes éthiques derrière CAI

Vous vous demandez peut-être si la publication de CAI in-the-wild compte tenu de ses capacités et implications en matière de sécurité est éthique. Notre décision de rendre ce framework open source est guidée par deux principes éthiques fondamentaux :

1. Démocratisation de l'IA de cybersécurité : Nous pensons que les outils avancés d'IA de cybersécurité devraient être accessibles à toute la communauté de la sécurité, pas seulement aux entreprises privées bien financées ou aux acteurs étatiques. En publiant CAI en tant que framework open source, nous visons à donner aux chercheurs en sécurité, aux hackers éthiques et aux organisations les moyens de construire et de déployer des outils de sécurité puissants pilotés par l'IA, équilibrant ainsi les chances en cybersécurité.

2. Transparence des capacités de sécurité de l'IA : Sur la base de nos résultats de recherche, de notre compréhension de la technologie et de l'analyse des meilleurs rapports techniques, nous soutenons que les fournisseurs actuels de LLM sapent leurs capacités en matière de cybersécurité. C'est extrêmement dangereux et trompeur. En développant CAI ouvertement, nous fournissons un benchmark transparent de ce que les systèmes d'IA peuvent réellement faire dans des contextes de cybersécurité, permettant des décisions plus éclairées sur les postures de sécurité.CAI est construit sur les principes fondamentaux suivants :

• Framework IA orienté cybersécurité : CAI est spécifiquement conçu pour les cas d'usage de cybersécurité, visant à automatiser semi- et totalement les tâches de sécurité offensives et défensives.
• Open source, gratuit pour la recherche : CAI est open source et gratuit à des fins de recherche. Nous visons à démocratiser l'accès à l'IA et à la cybersécurité. Pour un usage professionnel ou commercial, y compris les déploiements sur site, un support technique dédié et des extensions personnalisées contactez-nous pour obtenir une licence.
• Léger : CAI est conçu pour être rapide et facile à utiliser.
• Conception modulaire et centrée sur les agents : CAI fonctionne sur la base d'agents et de schémas agentiques, ce qui permet flexibilité et évolutivité. Vous pouvez facilement ajouter les agents et schémas les plus adaptés à votre cible de cybersécurité.
• Intégration d'outils : CAI intègre des outils déjà intégrés et permet à l'utilisateur d'intégrer facilement ses propres outils avec sa propre logique.
• Journalisation et traçage intégrés : en utilisant phoenix, l'outil open source de traçage et de journalisation pour les LLM. Cela offre à l'utilisateur une traçabilité détaillée des agents et de leur exécution.
• Support multi-modèles : plus de 300 modèles supportés et renforcés par LiteLLM. Les fournisseurs les plus populaires :
• Anthropic : Claude 3.7, Claude 3.5, Claude 3, Claude 3 Opus
• OpenAI : O1, , , ,

Alternatives propriétaires

L'IA en cybersécurité est un domaine critique, pourtant de nombreux groupes s'y engagent de manière erronée via des méthodes propriétaires pour un pur retour économique, en utilisant des techniques similaires et en s'appuyant sur des modèles propriétaires existants (souvent détenus par des tiers). Cette approche gaspille non seulement des ressources précieuses en ingénierie, mais représente également un gaspillage économique et aboutit à des efforts redondants, car ils finissent souvent par réinventer la roue. Voici quelques-unes des initiatives propriétaires que nous suivons et qui tentent d'utiliser l'IA générative et les frameworks agentiques dans l'IA de cybersécurité :

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

Apprentissage - CAI Fluency

[!NOTE]

Le rapport technique CAI Fluency (arXiv:2508.13588) établit des cadres éducatifs formels pour la littératie en IA de cybersécurité.

🔩 Installer

[!NOTE] Utilisateurs de l'édition professionnelle de CAI : Si vous avez un abonnement CAI Pro actif, nous fournissons des guides d'installation dédiés pour les versions 0.5 et 0.6. Le support officiel est disponible pour Ubuntu 24.04 (x86_64). Les instructions d'installation pour d'autres systèmes d'exploitation sont fournies telles quelles sans support officiel :

• Guide d'installation de CAI Pro v0.6
• Guide d'installation de CAI Pro v0.5

Installation de l'édition communautaire```bash

pip install cai-framework

Toujours créer un nouvel environnement virtuel pour garantir une installation correcte des dépendances lors de la mise à jour de CAI.

Les sous-sections suivantes fournissent une procédure pas à pas plus détaillée sur certains systèmes d'exploitation populaires. Reportez-vous à la section [Development](#development) pour les instructions d'installation relatives aux développeurs.
Pour la syntaxe des clés API, consultez la documentation litellm. [LiteLLM Documentation](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

Rendez-vous sur la page Microsoft : https://learn.microsoft.com/en-us/windows/wsl/install. Vous y trouverez toutes les instructions pour installer WSL.

Depuis Powershell, écrivez : 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

Vous pourriez rencontrer des problèmes en exécutant cai sur ubuntu car certains agents supposent qu'ils s'exécutent sur une instance Kali et ne parviennent pas à trouver les outils nécessaires. 
En alternative, vous pouvez utiliser le fichier docker compose dans le dossier dockerized à la place. Cela fonctionne également depuis wsl si docker est installé.
Dans ce cas, récupérez le dossier dockerized (pas besoin de tout le dépôt) et exécutez-le depuis celui-ci.
Pour la syntaxe des variables d'environnement des clés API, consultez la documentation de litellm. [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

Nous recommandons d'avoir au moins 8 Go de RAM :

1. Tout d'abord, installez UserLand https://play.google.com/store/apps/details?id=tech.ula&hl=es

2. Installez Kali minimal dans les options de base (gratuitement). [Ou toute autre option Kali si préféré]

3. Mettez à jour les clés apt comme dans cet exemple : https://superuser.com/questions/1644520/apt-get-update-issue-in-kali, à l'intérieur du terminal Kali de UserLand, exécutez```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: Configuration du fichier `.env`

CAI utilise le fichier `.env` pour charger la configuration au lancement. Pour faciliter la configuration, le dépôt fournit un fichier exemplaire [`.env.example`](https://github.com/aliasrobotics/cai/blob/HEAD/.env.example) qui sert de modèle pour configurer le setup de CAI et vos clés API LLM afin de fonctionner avec les modèles LLM souhaités.

:warning: Important :

CAI ne fournit PAS de clés API pour aucun modèle par défaut. Ne nous demandez pas de fournir des clés, utilisez les vôtres ou hébergez vos propres modèles.

:warning: Note :

La variable OPENAI_API_KEY ne doit pas être laissée vide. Elle doit contenir soit "sk-123" (comme espace réservé) soit votre véritable clé API. Voir https://github.com/aliasrobotics/cai/issues/27.

:warning: Note :

Si vous utilisez le modèle alias1, assurez-vous que CAI est en version >0.4.0 et voici un exemple de .env pour pouvoir l'utiliser.```bash
OPENAI_API_KEY="sk-1234"
OLLAMA=""
ALIAS_API_KEY="<sk-your-key>"  # note, add yours
CAI_STREAM=False
CAI_MODEL="alias1"

🔹 Prise en charge d'une URL de base OpenAI personnalisée

CAI prend en charge la configuration d'une URL de base OpenAI personnalisée via la variable d'environnement OPENAI_BASE_URL. Cela permet aux utilisateurs de rediriger les appels API vers un point de terminaison personnalisé, tel qu'un proxy ou un service compatible OpenAI auto-hébergé.

Exemple de configuration dans .env :``` OLLAMA_API_BASE="https://custom-openai-proxy.com/v1"

Ou directement depuis la ligne de commande :```bash
OLLAMA_API_BASE="https://custom-openai-proxy.com/v1" cai

📐 Architecture:

CAI se concentre sur la légèreté, la haute contrôlabilité et l'utilité pour les humains de la coordination et de l'exécution des agents de cybersécurité. Pour ce faire, il s'appuie sur 8 piliers: Agents, Tools, Handoffs, Patterns, Turns, Tracing, Guardrails et HITL.``` ┌───────────────┐ ┌───────────┐ │ HITL │◀─────-───▶│ Turns │ └───────┬───────┘ └───────────┘ │ ▼ ┌───────────┐ ┌───────────┐ ┌───────────┐ ┌───────────┐ │ Patterns │◀──-──▶│ Handoffs │◀──-─▶ │ Agents │◀──-─▶│ LLMs │ └───────────┘ └─────┬─────┘ └─────┬─────┘ └───────────┘ │ │ │ ▼ ┌────────────┐ ┌────┴──────┐ ┌───────────┐ ┌────────────┐ │ Extensions │◀────▶ │ Tracing │ │ Tools │◀──▶ │ Guardrails │ └────────────┘ └───────────┘ └───────────┘ └────────────┘ │ ┌─────────────┬─────┴────┬─────────────┐ ▼ ▼ ▼ ▼ ┌───────────┐┌───────────┐┌────────────┐┌───────────┐ │ LinuxCmd ││ WebSearch ││ Code ││ SSHTunnel │ └───────────┘└───────────┘└────────────┘└───────────┘

Si vous souhaitez approfondir le code, consultez les fichiers suivants comme point de départ pour utiliser CAI :

* [__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) - point d'entrée de l'interface en ligne de commande
* [util.py](https://github.com/aliasrobotics/cai/blob/main/src/cai/util.py) - fonctions utilitaires
* [agents](https://github.com/aliasrobotics/cai/blob/main/src/cai/agents) - implémentations d'agents
* [internal](https://github.com/aliasrobotics/cai/blob/main/src/cai/internal) - fonctions internes de CAI (points de terminaison, métriques, journalisation, etc.)
* [prompts](https://github.com/aliasrobotics/cai/blob/main/src/cai/prompts) - base de données de prompts d'agent
* [repl](https://github.com/aliasrobotics/cai/blob/main/src/cai/repl) - esthétique et commandes de l'interface CLI
* [sdk](https://github.com/aliasrobotics/cai/blob/main/src/cai/sdk) - SDK de commande CAI
* [tools](https://github.com/aliasrobotics/cai/tree/main/src/cai/tools) - outils d'agent

### 🔹 Agent

À la base, CAI abstrait son comportement en cybersécurité via des `Agents` et des `Patterns` agentiques. Un Agent est *un système intelligent qui interagit avec un environnement*. Plus techniquement, au sein de CAI, nous adoptons une définition centrée sur la robotique selon laquelle un agent est tout ce qui peut être considéré comme un système percevant son environnement à l'aide de capteurs, raisonnant sur ses objectifs et agissant en conséquence sur cet environnement via des actionneurs (*adapté* de Russel & Norvig, AI: A Modern Approach). En cybersécurité, un `Agent` interagit avec les systèmes et réseaux, en utilisant les périphériques et interfaces réseau comme capteurs, raisonne en conséquence puis exécute des actions réseau comme des actionneurs. En conséquence, dans CAI, les `Agents` implémentent le modèle d'agent `ReACT` (Reasoning and Action)[^3]. Pour plus d'informations, consultez [l'exemple ici](https://github.com/aliasrobotics/cai/blob/main/examples/basic/hello_world.py) pour le code d'exécution complet, et référez-vous à ce [jupyter notebook](https://github.com/aliasrobotics/cai/blob/main/fluency/my-first-hack/my_first_hack.ipynb) pour un tutoriel sur la façon de l'utiliser.```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)

🔹 Outils

Les Outils permettent aux agents de cybersécurité d'agir en fournissant des interfaces pour exécuter des commandes système, lancer des scans de sécurité, analyser des vulnérabilités et interagir avec les systèmes cibles et les API – ils constituent les capacités fondamentales permettant aux agents CAI d’effectuer efficacement des tâches de sécurité ; dans CAI, les outils incluent des utilitaires de cybersécurité intégrés (comme LinuxCmd pour l’exécution de commandes, WebSearch pour la collecte de renseignements en sources ouvertes, Code pour l’exécution dynamique de scripts et SSHTunnel pour l’accès distant sécurisé), des mécanismes d’appel de fonctions qui permettent d’intégrer n’importe quelle fonction Python en tant qu’outil de sécurité, et la fonctionnalité agent-as-tool qui permet à des agents de sécurité spécialisés (tels que des agents de reconnaissance ou d’exploitation) d’être utilisés par d’autres agents, créant ainsi des workflows collaboratifs puissants sans nécessiter de transferts formels entre agents. Pour plus d’informations, veuillez vous référer à l’exemple ici pour la configuration complète des fonctions personnalisées.```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)

Vous pouvez trouver différents [outils](https://github.com/aliasrobotics/cai/blob/HEAD/tools). Ils sont regroupés en 6 grandes catégories inspirées de la chaîne d'attaque [^2] :

1. Reconnaissance et weaponisation - *reconnaissance* (crypto, listing, etc)
2. Exploitation - *exploitation*
3. Élévation de privilèges - *escalation*
4. Mouvement latéral - *lateral*
5. Exfiltration de données - *exfiltration*
6. Commande et contrôle - *control*

### 🔹 Handoffs

Les `Handoffs` permettent à un `Agent` de déléguer des tâches à un autre agent, ce qui est crucial dans les opérations de cybersécurité où une expertise spécialisée est nécessaire pour différentes phases d'un engagement. Dans notre framework, les `Handoffs` sont implémentés comme des outils pour le LLM, où une **fonction de handoff/transfert** comme `transfer_to_flag_discriminator` permet à `ctf_agent` de passer le contrôle à `flag_discriminator_agent` une fois qu'il pense avoir trouvé le flag. Cela crée une chaîne de validation de sécurité où le premier agent gère l'exploitation et la découverte de flags, tandis que le second agent se spécialise dans la vérification des flags, assurant une ségrégation appropriée des tâches et exploitant les capacités spécialisées de différents modèles pour des tâches de sécurité distinctes. Pour plus d'informations, veuillez vous référer à l'[exemple ici](https://github.com/aliasrobotics/cai/blob/main/examples/cai/agent_patterns/handoffs.py) pour le code d'exécution complet.```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]
)

🔹 Modèles

Un Pattern agentique est un paradigme de conception structurée dans les systèmes d'intelligence artificielle où des agents autonomes ou semi-autonomes opèrent dans un cadre d'interaction défini (le pattern) pour atteindre un objectif. Ces Patterns spécifient l'organisation, la coordination et les méthodes de communication entre agents, guidant la prise de décision, l'exécution des tâches et la délégation.

Un pattern agentique (AP) peut être formellement défini comme un tuple :

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

où :

• \(A\) (Agents) : Un ensemble d'entités autonomes, \( A = \{a_1, a_2, ..., a_n\} \), chacune avec des rôles, capacités et états internes définis.
• \(H\) (Transferts) : Une fonction \( H: A \times T \to A \) qui régit la manière dont les tâches \( T \) sont transférées entre agents selon une logique prédéfinie (ex. règles, négociation, enchères).
• \(D\) (Mécanisme de décision) : Une fonction de décision \( D: S \to A \) où \( S \) représente les états du système, et \( D \) détermine quel agent agit à un moment donné.
• \(C\) (Protocole de communication) : Une fonction de messagerie \( C: A \times A \to M \), où \( M \) est un espace de messages, définissant comment les agents partagent des informations.
• \(E\) (Modèle d'exécution) : Une fonction \( E: A \times I \to O \) où \( I \) est l'espace d'entrée et \( O \) l'espace de sortie, définissant comment les agents effectuent des tâches.

Lors de la construction de Patterns, nous les classons généralement dans l'une des catégories suivantes, bien que d'autres existent :

Pour plus d'informations et des exemples de patterns agentiques courants, consultez le dossier examples.

🔹 Tours et Interactions

Pendant le flux agentique (conversation), nous distinguons les interactions et les tours.

• Interactions : échanges séquentiels entre un ou plusieurs agents. Chaque exécution de la logique d'un agent correspond à une interaction. Comme un Agent dans CAI implémente généralement le modèle d'agent ReACT[^3], chaque interaction consiste en 1) une étape de raisonnement via une inférence LLM et 2) une action en appelant zéro à n Tools. Ceci est défini dans process_interaction() dans core.py.
• Tours : Un tour représente un cycle d'une ou plusieurs interactions qui se termine lorsque l'Agent (ou le Pattern) en cours d'exécution retourne None, jugeant qu'il n'y a plus d'actions à entreprendre. Ceci est défini dans run(), voir core.py.

[!NOTE] Les Agents CAI ne sont pas liés aux Assistants de l'API Assistants. Ils sont nommés de manière similaire par commodité, mais sont par ailleurs complètement indépendants. CAI est entièrement alimenté par l'API Chat Completions et est donc sans état entre les appels.

🔹 Traçage

CAI implémente l'observabilité de l'IA en adoptant la norme OpenTelemetry et pour ce faire, il utilise Phoenix qui fournit des capacités de traçage complètes via une instrumentation basée sur OpenTelemetry, vous permettant de surveiller et d'analyser vos opérations de sécurité en temps réel. Cette intégration permet une visibilité détaillée sur les interactions des agents, l'utilisation des outils et les vecteurs d'attaque tout au long des workflows de tests de pénétration, facilitant le débogage de chaînes d'exploitation complexes, le suivi des processus de découverte de vulnérabilités et l'optimisation des performances des agents pour des évaluations de sécurité plus efficaces.

🔹 Garde-fous

Les Garde-fous fournissent une couche de sécurité critique pour les agents CAI, protégeant contre les attaques par injection de prompt et empêchant l'exécution de commandes dangereuses. Ces garde-fous s'exécutent en parallèle des agents, validant à la fois l'entrée et la sortie pour garantir un fonctionnement sûr. Le framework comprend :

• Garde-fous d'entrée : Détectent et bloquent les tentatives d'injection de prompt avant qu'elles n'atteignent les agents, en utilisant la correspondance de motifs, la détection d'homoglyphes Unicode et une analyse basée sur l'IA.
• Garde-fous de sortie : Valident les sorties des agents avant exécution, empêchant les commandes dangereuses comme les shells inversés, les fork bombs ou l'exfiltration de données.
• Défense multicouche : Protection aux étapes d'entrée, de traitement et d'exécution avec validation au niveau des outils.
• Conscient du Base64/Base32 : Décode et analyse automatiquement les charges utiles encodées pour détecter les commandes malveillantes cachées.
• Configurable : Peut être activé/désactivé via la variable d'environnement CAI_GUARDRAILS.

Pour une mise en œuvre détaillée, consultez docs/guardrails.md et docs/cai_prompt_injection.md.

🔹 Humain dans la boucle (HITL)```

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

CAI fournit un cadre pour la création d'IA de cybersécurité avec un fort accent sur le fonctionnement *semi-autonome*, car la réalité est que les systèmes de cybersécurité **totalement autonomes** restent prématurés et font face à des défis importants lorsqu'il s'agit de tâches complexes. Bien que CAI explore les capacités autonomes, nous reconnaissons que les opérations de sécurité efficaces nécessitent toujours une téléopération humaine apportant expertise, jugement et supervision dans le processus de sécurité.

En conséquence, le module Human-In-The-Loop (`HITL`) est un principe de conception central de CAI, reconnaissant que l'intervention humaine et la téléopération sont des composants essentiels de tests de sécurité responsables. Via l'interface `cli.py`, les utilisateurs peuvent interagir de manière transparente avec les agents à tout moment pendant l'exécution en appuyant simplement sur `Ctrl+C`. Ceci est implémenté dans [core.py](https://github.com/aliasrobotics/cai/blob/HEAD/cai/core.py) ainsi que dans les abstractions REPL [REPL](https://github.com/aliasrobotics/cai/blob/HEAD/cai/repl).

## :rocket: Démarrage rapide

Pour démarrer CAI après l'avoir installé, tapez simplement `cai` dans le CLI:```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>

That devrait initialiser CAI et fournir une invite pour exécuter toute tâche de sécurité que vous souhaitez effectuer. La barre de navigation en bas affiche des informations importantes sur le système. Ces informations vous aident à comprendre votre environnement lorsque vous travaillez avec CAI.

Voici une vidéo de démonstration rapide pour vous aider à démarrer avec CAI. Nous allons parcourir les étapes de base — du lancement de l'outil à l'exécution de votre première tâche alimentée par l'IA dans le terminal. Que vous soyez débutant ou simplement curieux, ce guide vous montrera à quel point il est facile de commencer à utiliser CAI.

À partir de là, tapez CAI et commencez votre exercice de sécurité. La meilleure façon d'apprendre est par l'exemple :

Variables d'environnement

Pour utiliser des modèles privés, un fichier .env.example vous est fourni. Copiez-le et renommez-le en .env. Remplissez vos clés API correspondantes, et vous êtes prêt à utiliser CAI.

Liste des variables d'environnement

Intégration OpenRouter

La plateforme Cybersecurity AI (CAI) offre une intégration transparente avec OpenRouter, une interface unifiée pour les grands modèles de langage (LLM). Cette intégration est cruciale pour les utilisateurs qui souhaitent tirer parti des capacités avancées de l'IA dans leurs tâches de cybersécurité. OpenRouter agit comme un pont, permettant à CAI de communiquer avec divers LLM, améliorant ainsi la flexibilité et la puissance des agents IA utilisés dans CAI.

Pour activer le support d'OpenRouter dans CAI, vous devez configurer votre environnement en ajoutant des entrées spécifiques à votre fichier .env. Cette configuration garantit que CAI peut interagir avec l'API OpenRouter, facilitant l'utilisation de modèles sophistiqués comme Meta-LLaMA. Voici comment la configurer :```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

La plateforme CAI (Cybersecurity AI) s'intègre de manière transparente avec Azure OpenAI, permettant aux organisations d'exécuter CAI sur des modèles hébergés en entreprise (par exemple, gpt-4o). Cette voie est idéale pour les équipes qui doivent opérer dans le cadre de la gouvernance Azure tout en exploitant les capacités avancées des modèles.
Pour activer la prise en charge d'Azure OpenAI dans CAI, configurez votre environnement en ajoutant les entrées suivantes à votre fichier `.env`. Cela garantit que CAI peut atteindre votre point de terminaison de déploiement Azure et s'authentifier correctement.```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 prend en charge le Model Context Protocol (MCP) pour l'intégration d'outils et services externes avec les agents IA. MCP est pris en charge via deux mécanismes de transport :

1. SSE (Server-Sent Events) - Pour les serveurs web qui poussent des mises à jour via des connexions HTTP :```bash CAI>/mcp load http://localhost:9876/sse burp

2. **STDIO (Entrée/Sortie standard)** - Pour la communication inter-processus locale :```bash
CAI>/mcp load stdio myserver python mcp_server.py

Une fois connecté, vous pouvez ajouter les outils MCP à n'importe quel agent :```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

Vous pouvez lister toutes les connexions MCP actives et leurs types de transport :```bash
CAI>/mcp list

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

Développement

Le développement est facilité via les environnements de développement VS Code. Pour essayer notre environnement de développement, clonez le dépôt, ouvrez VS Code et entrez en mode conteneur de développement :

Contributions

Si vous souhaitez contribuer à ce projet, utilisez Pre-commit avant votre MR```bash pip install pre-commit pre-commit # files staged pre-commit run --all-files # all files

### Exigences optionnelles : caiextensions

Actuellement, les extensions ne sont pas accessibles au public car l'effort d'ingénierie pour les maintenir est important. Au lieu de cela, nous mettons à disposition des extensions caiextensions personnalisées sélectionnées pour les entreprises partenaires dans le cadre de collaborations.

### :information_source: Collecte de données d'utilisation

CAI est fourni gratuitement aux chercheurs. Pour améliorer la précision de détection de CAI, faire progresser la recherche ouverte en sécurité, et développer et former les futurs modèles, nous vous demandons de contribuer à la communauté CAI en autorisant la collecte de données d'utilisation. Ces données nous aident à identifier les domaines d'amélioration, comprendre comment le framework est utilisé, prioriser les nouvelles fonctionnalités, et soutenir les efforts de formation et d'évaluation des modèles.

La base légale de la collecte de données est l'Art. 6 (1)(f) du RGPD — l'intérêt légitime de CAI à maintenir, améliorer et faire progresser les outils et la recherche en sécurité — avec les garanties de l'Art. 89 appliquées à des fins de recherche.

Les données collectées incluent :

- Informations système de base (type de système d'exploitation, version Python)
- Informations sur le nom d'utilisateur et l'adresse IP
- Modèles d'utilisation des outils et mesures de performance
- Interactions avec les modèles et statistiques d'utilisation des jetons

Nous prenons votre vie privée au sérieux et ne collectons que ce qui est nécessaire pour améliorer CAI, soutenir la recherche, et former et évaluer les modèles de manière responsable. Pour plus d'informations, contactez research＠aliasrobotics.com. Vous pouvez désactiver certaines fonctionnalités de collecte de données via la variable d'environnement `CAI_TELEMETRY`, mais nous vous encourageons à la laisser activée pour contribuer à la recherche en cours et au développement des modèles :```bash
CAI_TELEMETRY=False cai

Reproduire CI-Setup localement

Pour simuler le pipeline CI/CD, vous pouvez exécuter les commandes suivantes sur les machines Gitlab runner :```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 me donne des erreurs 404 

L'API d'Ollama en mode OpenAI utilise `/v1/chat/completions` tandis que la bibliothèque `openai` utilise `base_url` + `/chat/completions`.

Nous adoptons cette dernière pour un alignement global avec la communauté de l'IA générative et donnons les moyens à la première en permettant aux utilisateurs d'ajouter le `v1` eux-mêmes via :```bash
OLLAMA_API_BASE=http://IP:PORT/v1

Consultez les issues suivantes qui traitent ce sujet plus en détail :

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

Où sont tous les caiextensions ?

Voir tous les caiextensions

Comment installer le caiextension report ?

Voir ici

Comment configurer un accès SSH pour Gitlab ?

Générer une nouvelle clé SSH```bash ssh-keygen -t ed25519

Ajoutez la clé à l'agent SSH```bash
ssh-add ~/.ssh/id_ed25519

Ajouter la clé publique à Gitlab Copier la clé et l'ajouter à Gitlab sous https://gitlab.com/-/user_settings/ssh_keys```bash cat ~/.ssh/id_ed25519.pub

Pour le vérifier :```bash
ssh -T [email protected]
Welcome to GitLab, @vmayoral!

Comment puis-je vider le cache Python ?```bash find . -name "*.pyc" -delete && find . -name "pycache" -delete

Si le réseau hôte ne fonctionne pas avec ollama, vérifiez s'il a été désactivé dans Docker parce que vous n'êtes pas connecté 

Docker sous OS X se comporte parfois étrangement. Vérifiez si le message suivant est apparu :

*Host networking has been disabled because you are not signed in. Please sign in to enable it*.

Assurez-vous que cela a été traité et aussi que le conteneur de développement ne transfère pas le port 8000 (cliquez sur x, si nécessaire dans la section des ports).

Pour vérifier la connexion, depuis l'intérieur du conteneur de développement VSCode :```bash
curl -v http://host.docker.internal:8000/api/version

Exécutez CAI contre n'importe quelle cible

cai-004-first-message

L'invite utilisateur de départ dans ce cas est : Target IP: 192.168.3.10, perform a full network scan.

L'agent a commencé à effectuer un scan nmap. Vous pouvez soit interagir avec l'agent et lui donner plus d'instructions, soit le laisser s'exécuter pour voir ce qu'il explore ensuite.

Comment interagir avec l'agent ? Tapez deux fois CTRL + C

cai-005-ctrl-c

Si vous souhaitez utiliser le mode HITL, vous pouvez le faire en appuyant deux fois Ctrl + C. Cela vous permettra d'interagir (inviter) avec l'agent quand vous le souhaitez. L'agent ne perdra pas le contexte précédent, car il est stocké dans la variable history, qui lui est transmise ainsi qu'à tout agent appelé. Cela permet à tout agent d'utiliser les informations précédentes et d'être plus précis et efficace.

Puis-je changer le modèle pendant que CAI est en cours d'exécution ? /model

Utilisez /model pour changer le modèle.

cai-007-model-change

Comment puis-je lister tous les agents disponibles ? /agent

Utilisez /agent pour lister tous les agents disponibles.

cai-010-agents-menu

Où puis-je lister toutes les variables d'environnement ? /env

cai-008-config

Comment puis-je surveiller l'utilisation des tokens et les coûts ?

Utilisez /cost dans le REPL pour les dépenses de session et les statistiques de tokens, /compact lorsque les conversations deviennent longues, et (en mode TUI) les indicateurs de coût et de modèle par terminal dans l'interface utilisateur.```bash CAI> /cost

Consultez la [référence des commandes CLI](https://github.com/aliasrobotics/cai/blob/HEAD/docs/cli/commands_reference.md) pour la liste complète des commandes.
 

 
 Comment en savoir plus sur la CLI ? /help 

cai-006-help
 

 
 Comment puis-je tracer toute l'exécution ? 
La variable d'environnement `CAI_TRACING` permet à l'utilisateur de la définir sur `CAI_TRACING=true` pour activer le traçage, ou sur `CAI_TRACING=false` pour le désactiver.
Lorsque CAI est sollicité pour la première fois, l'utilisateur se voit proposer deux chemins, le journal d'exécution et le journal de traçage.

cai-009-logs

 

 
 Puis-je étendre les capacités de CAI en utilisant les journaux des exécutions précédentes ? 

Oui. Aujourd'hui, CAI fonctionne mieux en s'appuyant sur l'apprentissage contextuel (ICL). Plutôt que de construire des stockages à long terme, le flux de travail recommandé consiste à charger les journaux pertinents antérieurs directement dans la session en cours afin que le modèle puisse raisonner avec eux en contexte.

Utilisez la commande `/load` pour importer les journaux JSONL dans le contexte de CAI (cela remplace l'ancien outil de chargement mémoire) :```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 affiche le chemin du journal JSONL de la session en cours au démarrage (surligné en orange), que vous pouvez passer à /load :

cai-009-logs

Notes héritées : les anciens mécanismes d’« extension mémoire » (stockages épisodique/sémantique et ingestion hors ligne) sont conservés à titre de référence uniquement. Voir src/cai/agents/memory.py pour le contexte et les détails historiques. Notre direction actuelle privilégie l’ICL à la mémoire persistante.

Puis-je étendre les capacités de CAI à l’aide de scripts ou d’informations supplémentaires ?

Actuellement, CAI prend en charge les informations textuelles. Vous pouvez ajouter toute information supplémentaire sur la cible que vous affrontez en la copiant-collant directement dans l’invite système ou utilisateur.

Comment ? En l’ajoutant à l’invite système (system_master_template.md) ou utilisateur (user_master_template.md). Vous pouvez toujours indiquer directement le chemin vers le modèle, et il exécutera cat dessus.

Comment fonctionne la licence de CAI ?

La licence actuelle de CAI ne restreint pas l’utilisation à des fins de recherche. Vous êtes libre d’utiliser CAI pour des évaluations de sécurité (tests d’intrusion), de développer des fonctionnalités supplémentaires et de l’intégrer à vos activités de recherche, à condition de respecter les lois locales.

Si vous ou votre organisation commencez à bénéficier commercialement de CAI (par exemple, en proposant des services de test d’intrusion basés sur CAI), une licence commerciale sera alors requise pour aider à soutenir le projet.

CAI lui-même n’est pas une initiative à but lucratif. Notre objectif est de construire un projet open-source durable. Nous demandons simplement à ceux qui profitent de CAI de contribuer en retour et de soutenir notre développement continu.

J’obtiens une erreur Unable to locate package python3.12-venv lors de l’installation des prérequis sur mon système basé sur Debian !

La façon la plus simple de contourner ce problème est d’installer python3.12 à partir des sources.

Citation

Si vous souhaitez citer notre travail, veuillez utiliser ce qui suit (classé par date de publication) :```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} }

## Remerciements

CAI a été initialement développé par [Alias Robotics](https://aliasrobotics.com) et cofinancé par le projet européen d'accélérateur EIC RIS (GA 101161136) - appel HORIZON-EIC-2023-ACCELERATOR-01. Les principes agentiques originaux sont inspirés de la bibliothèque [`swarm`](https://github.com/openai/swarm) d'OpenAI et ont été transposés dans des prototypes plus récents. Ce projet utilise également d'autres blocs open source pertinents, notamment [`LiteLLM`](https://github.com/BerriAI/litellm) et [`phoenix`](https://github.com/Arize-ai/phoenix)

### Collaborations Académiques
CAI bénéficie de collaborations de recherche en cours avec des institutions académiques. Les chercheurs intéressés par des projets collaboratifs, l'accès aux ensembles de données ou des licences académiques doivent contacter [email protected]. Nous offrons un soutien spécial pour :
- Projets de recherche doctorale
- Études comparatives académiques
- Initiatives de formation en sécurité
- Contributions open source de laboratoires de recherche

 
[^1]: On pourrait dire que le motif agentique « Chain-of-Thought » est un cas particulier du motif agentique hiérarchique.
[^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).