Cybersecurity AI (CAI)

Edizione Professionale con token alias1 illimitati | 📊 Vedi Benchmark | 🚀 Scopri di più

🔓 Community Edition Ricerca & Apprendimento · Perfetta per Ricercatori e Studenti pip install cai-framework

✅ Gratuito per la ricerca 🤖 300+ modelli AI 🌍 Guidato dalla comunità 📚 Open source 🔧 Framework estensibile

🚀 Edizione Professionale Enterprise & Produzione · €350/mese · Token alias1 Illimitati

→ Passa a PRO

⚡ Modello alias1 - token ∞ illimitati 🚫 Zero rifiuti - AI senza restrizioni 🏆 Supera GPT-5 nei benchmark CTF 🛡️ Supporto professionale incluso 🇪🇺 Sovranità dei dati europea

CAI PRO con modello alias1 supera GPT-5 nei benchmark di cybersicurezza AI vs AI | Vedi Benchmark Completi →

-->

Cybersecurity AI (CAI) è un framework leggero e open-source che consente ai professionisti della sicurezza di costruire e distribuire automazione offensiva e difensiva basata sull'AI. CAI è il framework de facto per la Sicurezza AI, già utilizzato da migliaia di utenti singoli e centinaia di organizzazioni. Che tu sia un ricercatore di sicurezza, un hacker etico, un professionista IT o un'organizzazione che desidera migliorare la propria postura di sicurezza, CAI fornisce gli elementi costitutivi per creare agenti AI specializzati in grado di assistere nella mitigazione, scoperta di vulnerabilità, sfruttamento e valutazione della sicurezza.

🔓 Esegui CAI senza una chiave API Alias (CAI_LICENSE_OFF)

CAI può essere eseguito senza ALIAS_API_KEY (cioè senza una licenza Alias Robotics) impostando la variabile d'ambiente CAI_LICENSE_OFF=1.

Quando CAI_LICENSE_OFF è impostato su 1, true o yes:

• Il controllo della licenza all'avvio viene saltato — non è richiesta alcuna ALIAS_API_KEY.
• CAI funziona in modalità open-source e le operazioni di aggiornamento puntano al pacchetto pubblico PyPI cai-framework invece dell'indice privato dei pacchetti Alias.
• Puoi utilizzare qualsiasi altro provider di modelli supportato (OpenAI, Anthropic, DeepSeek, Ollama, ecc.) configurando CAI_MODEL e la corrispondente chiave API del provider.

Avvio rapido senza licenza:```bash export CAI_LICENSE_OFF=1 cai

Oppure inline:```bash
CAI_LICENSE_OFF=1 cai

Nota: Il modello alias1 richiede comunque una chiave ALIAS_API_KEY valida. CAI_LICENSE_OFF bypassa solo il blocco della licenza del framework — non concede l'accesso ai modelli ospitati da Alias.

Caratteristiche principali:

• 🤖 300+ Modelli AI: Supporto per OpenAI, Anthropic, DeepSeek, Ollama e altri
• 🔧 Strumenti di sicurezza integrati: Strumenti pronti all'uso per ricognizione, sfruttamento e escalation dei privilegi
• 🏆 Testato sul campo: Provato in CTF di HackTheBox, bug bounty e case study di sicurezza reali
• 🎯 Architettura basata su agenti: Design modulare del framework per costruire agenti specializzati per diversi compiti di sicurezza
• 🛡️ Protezione con guardrail: Difese integrate contro l'iniezione di prompt e l'esecuzione di comandi pericolosi
• 📚 Orientato alla ricerca: Fondazione di ricerca per democratizzare l'AI per la cybersecurity per la comunità

[!NOTE] Leggi il rapporto tecnico: CAI: An Open, Bug Bounty-Ready Cybersecurity AI Una edizione HTML di lettura con figure e riferimenti è mantenuta dal Robot Cybersecurity Lab.

Per ulteriori letture, consulta le sezioni impatto e citazione di CAI.

[!WARNING] ⚠️ CAI è in fase di sviluppo attivo, quindi non aspettarti che funzioni perfettamente. Contribuisci invece aprendo una segnalazione o inviando una PR.

L'accesso a questa libreria e l'uso delle informazioni, dei materiali (o di loro porzioni) non è inteso ed è proibito laddove tale accesso o uso violi leggi o regolamenti applicabili. Gli autori non incoraggiano né promuovono in alcun modo la manomissione non autorizzata di sistemi in esecuzione. Ciò può causare gravi danni umani e materiali.

Gli autori di CAI non incoraggiano né promuovono in alcun modo la manomissione non autorizzata di sistemi informatici. Per favore, non utilizzare il codice sorgente qui per cybercriminalità. Fai pentest per il bene invece. Scaricando, utilizzando o modificando questo codice sorgente, accetti i termini della LICENSE e le limitazioni descritte nel file DISCLAIMER.

🔖 Table of Contents

• Cybersecurity AI (CAI)
• 🔖 Table of Contents
• 🎯 Impact
• 🏆 Competitions and challenges
• 📊 Research Impact
• 📚 Research products: Cybersecurity AI
• PoCs
• Motivation
• 👤 Why CAI?
• Ethical principles behind CAI
• Closed-source alternatives
• Learn - CAI Fluency
• 🔩 Install
• OS X
• Ubuntu 24.04
• Ubuntu 20.04
• Windows WSL
• Android
• 🔩 Setup .env file
• 🔹 Custom OpenAI Base URL Support
• 📐 Architecture:
• 🔹 Agent
• 🔹 Tools
• 🔹 Handoffs
• 🔹 Patterns
• 🔹 Turns and Interactions
• 🔹 Tracing
• 🔹 Guardrails
• 🔹 Human-In-The-Loop (HITL)
• 🚀 Quickstart
• Environment Variables

🎯 Impact

🏆 Competitions and challenges

📊 Research Impact

• Pioniere della sicurezza AI basata su LLM con PentestGPT, stabilendo le fondamenta per il dominio di ricerca Cybersecurity AI

• Ha stabilito la linea di ricerca Cybersecurity AI con 8 articoli e rapporti tecnici, con collaborazioni di ricerca attive

📚 Research products: Cybersecurity AI

Edizioni HTML di lettura estese: CAI · CAIBench · Humanoid robots as attack vectors · The cybersecurity of a humanoid robot · Hacking consumer robots in the AI era

PoCs

CAI con alias0 su attacchi di iniezione di messaggi ROS nel robot MiR-100	CAI con alias0 sulla scoperta di vulnerabilità delle API su Mercado Libre

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

Altri case study e PoC sono disponibili su https://aliasrobotics.com/case-studies-robot-cybersecurity.php.

Motivation

👤 Why CAI?

Il panorama della cybersecurity sta subendo una trasformazione drammatica poiché l'AI diventa sempre più integrata nelle operazioni di sicurezza. Prevediamo che entro il 2028 gli strumenti di test di sicurezza basati su AI supereranno in numero i pentester umani. Questo cambiamento rappresenta un mutamento fondamentale nel modo in cui affrontiamo le sfide della cybersecurity. L'AI non è solo un altro strumento - sta diventando essenziale per affrontare vulnerabilità di sicurezza complesse e stare al passo con minacce sofisticate. Mentre le organizzazioni affrontano attacchi informatici più avanzati, i test di sicurezza potenziati dall'AI saranno cruciali per mantenere difese robuste.

Questo lavoro si basa su sforzi precedenti[^4] e, similmente, crediamo che democratizzare l'accesso a strumenti avanzati di AI per la cybersecurity sia vitale per l'intera comunità della sicurezza. Ecco perché rilasciamo Cybersecurity AI (CAI) come framework open source. Il nostro obiettivo è potenziare ricercatori di sicurezza, hacker etici e organizzazioni per costruire e distribuire potenti strumenti di sicurezza guidati dall'AI. Rendendo queste capacità apertamente disponibili, miriamo a livellare il campo di gioco e garantire che la tecnologia AI all'avanguardia per la sicurezza non sia limitata ad aziende private ben finanziate o attori statali.

I programmi Bug Bounty sono diventati un pilastro della cybersecurity moderna, fornendo un meccanismo cruciale per le organizzazioni per identificare e correggere le vulnerabilità nei loro sistemi prima che possano essere sfruttate. Questi programmi si sono dimostrati estremamente efficaci nel mettere in sicurezza sia le infrastrutture pubbliche che private, con ricercatori che scoprono vulnerabilità critiche che altrimenti sarebbero passate inosservate. CAI è specificamente progettato per potenziare questi sforzi fornendo un framework leggero ed ergonomico per costruire agenti AI specializzati che possono assistere in vari aspetti della caccia ai bug bounty - dalla ricognizione iniziale alla validazione e segnalazione delle vulnerabilità. Il nostro framework mira ad aumentare le competenze umane con le capacità dell'AI, aiutando i ricercatori a lavorare in modo più efficiente e approfondito nella loro missione di rendere i sistemi digitali più sicuri.

Ethical principles behind CAI

Potresti chiederti se rilasciare CAI in the wild date le sue capacità e implicazioni per la sicurezza sia etico. La nostra decisione di rendere open source questo framework è guidata da due principi etici fondamentali:

1. Democratizzare l'AI per la cybersecurity: Crediamo che gli strumenti avanzati di AI per la cybersecurity dovrebbero essere accessibili all'intera comunità della sicurezza, non solo ad aziende private ben finanziate o attori statali. Rilasciando CAI come framework open source, miriamo a potenziare ricercatori di sicurezza, hacker etici e organizzazioni per costruire e distribuire potenti strumenti di sicurezza guidati dall'AI, livellando il campo di gioco nella cybersecurity.

2. Trasparenza nelle capacità di sicurezza dell'AI: Basandoci sui nostri risultati di ricerca, sulla comprensione della tecnologia e sulla dissezione dei migliori rapporti tecnici, sosteniamo che gli attuali fornitori di LLM stanno minando le loro capacità di cybersecurity. Questo è estremamente pericoloso e fuorviante. Sviluppando CAI apertamente, forniamo un benchmark trasparente di ciò che i sistemi AI possono effettivamente fare nei contesti di cybersecurity, consentendo decisioni più informate sulle posture di sicurezza.CAI è costruito sui seguenti principi fondamentali:

• Framework IA orientato alla cybersecurity: CAI è specificamente progettato per casi d'uso di cybersecurity, mirando all'automazione semi- e completamente automatizzata di compiti di sicurezza offensivi e difensivi.
• Open source, gratuito per la ricerca: CAI è open source e gratuito per scopi di ricerca. Miriamo a democratizzare l'accesso all'IA e alla cybersecurity. Per uso professionale o commerciale, incluse implementazioni on-premise, supporto tecnico dedicato ed estensioni personalizzate contattare per ottenere una licenza.
• Leggero: CAI è progettato per essere veloce e facile da usare.
• Design modulare e incentrato sugli agenti: CAI opera sulla base di agenti e pattern agentici, che consentono flessibilità e scalabilità. Puoi facilmente aggiungere gli agenti e i pattern più adatti al tuo caso target di cybersecurity.
• Integrazione di strumenti: CAI integra strumenti già incorporati e consente all'utente di integrare facilmente i propri strumenti con la propria logica.
• Logging e tracciamento integrati: utilizzando phoenix, lo strumento open source di tracciamento e logging per LLM. Questo fornisce all'utente una tracciabilità dettagliata degli agenti e della loro esecuzione.
• Supporto multi-modello: più di 300 modelli supportati e potenziati da LiteLLM. I provider più popolari:
• Anthropic: Claude 3.7, Claude 3.5, Claude 3, Claude 3 Opus
• OpenAI: O1, , , ,

Alternative closed-source

La cybersecurity IA è un campo critico, ma molti gruppi lo stanno perseguendo erroneamente con metodi closed-source per puro ritorno economico, sfruttando tecniche simili e basandosi su modelli closed-source esistenti (spesso di proprietà di terze parti). Questo approccio non solo spreca preziose risorse ingegneristiche, ma rappresenta anche uno spreco economico e produce sforzi ridondanti, poiché spesso finiscono per reinventare la ruota. Ecco alcune delle iniziative closed-source che teniamo d'occhio e che tentano di sfruttare genAI e framework agentici nella cybersecurity IA:

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

Impara - CAI Fluency

[!NOTE]

Il report tecnico di CAI Fluency (arXiv:2508.13588) stabilisce framework educativi formali per l'alfabetizzazione alla cybersecurity IA.

🔩 Installazione

[!NOTE] Utenti dell'Edizione Professionale di CAI: Se hai un abbonamento CAI Pro attivo, forniamo guide di installazione dedicate per le versioni 0.5 e 0.6. Il supporto ufficiale è disponibile per Ubuntu 24.04 (x86_64). Le istruzioni di installazione per altri sistemi operativi sono fornite così come sono senza supporto ufficiale:

• CAI Pro v0.6 Installation Guide
• CAI Pro v0.5 Installation Guide

Installazione dell'Edizione Community```bash

pip install cai-framework

Creare sempre un nuovo ambiente virtuale per garantire una corretta installazione delle dipendenze quando si aggiorna CAI.

Le seguenti sottosezioni forniscono una guida più dettagliata su alcuni sistemi operativi popolari. Fare riferimento alla sezione [Sviluppo](#development) per le istruzioni di installazione relative agli sviluppatori.
Per la sintassi delle variabili d'ambiente per le chiavi API, consulta la documentazione di litellm. [Documentazione di LiteLLM](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

Vai alla pagina Microsoft: https://learn.microsoft.com/en-us/windows/wsl/install. Qui troverai tutte le istruzioni per installare WSL

Da Powershell scrivi: 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

Potresti incontrare problemi eseguendo cai su ubuntu poiché alcuni agenti presumono di essere in esecuzione su un'istanza Kali e non riescono a trovare gli strumenti necessari. Quindi in alternativa puoi utilizzare il file docker compose nella cartella dockerized. Questo funziona anche da wsl se docker è installato. In tal caso recupera la cartella dockerized (non serve l'intero repository) ed esegui da essa. Per la sintassi delle variabili d'ambiente delle chiavi API, controlla litellm Documentazione. [Documentazione LiteLLM](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

Consigliamo di avere almeno 8 GB di RAM:

1. Innanzitutto, installa userland https://play.google.com/store/apps/details?id=tech.ula&hl=es

2. Installa Kali minimal nelle opzioni di base (gratuitamente). [O qualsiasi altra opzione kali se preferisci]

3. Aggiorna le chiavi apt come in questo esempio: https://superuser.com/questions/1644520/apt-get-update-issue-in-kali, all'interno del terminale Kali di UserLand esegui```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: Configurazione del file `.env`

CAI sfrutta il file `.env` per caricare la configurazione all'avvio. Per facilitare la configurazione, il repository fornisce un file esemplificativo [`.env.example`](https://github.com/aliasrobotics/cai/blob/HEAD/.env.example) che funge da modello per configurare l'impostazione di CAI e le tue chiavi API LLM per lavorare con i modelli LLM desiderati.

:warning: Importante:

CAI NON fornisce chiavi API per nessun modello di default. Non chiederci di fornire chiavi, usa le tue o ospita i tuoi modelli.

:warning: Nota:

OPENAI_API_KEY non deve essere lasciato vuoto. Dovrebbe contenere "sk-123" (come segnaposto) o la tua chiave API reale. Vedi https://github.com/aliasrobotics/cai/issues/27.

:warning: Nota:

Se stai usando il modello alias1, assicurati che CAI sia nella versione >0.4.0 e qui hai un esempio di .env per poterlo usare.```bash
OPENAI_API_KEY="sk-1234"
OLLAMA=""
ALIAS_API_KEY="<sk-your-key>"  # note, add yours
CAI_STREAM=False
CAI_MODEL="alias1"

🔹 Supporto per URL di base OpenAI personalizzato

CAI supporta la configurazione di un URL di base API OpenAI personalizzato tramite la variabile d'ambiente OPENAI_BASE_URL. Ciò consente agli utenti di reindirizzare le chiamate API a un endpoint personalizzato, come un proxy o un servizio compatibile con OpenAI auto-ospitato.

Esempio di configurazione della voce .env:``` OLLAMA_API_BASE="https://custom-openai-proxy.com/v1"

O direttamente dalla riga di comando:```bash
OLLAMA_API_BASE="https://custom-openai-proxy.com/v1" cai

📐 Architettura:

CAI si concentra sul rendere il coordinamento e l'esecuzione degli agenti di cybersecurity leggeri, altamente controllabili e utili per gli umani. Per farlo si basa su 8 pilastri: Agents, Tools, Handoffs, Patterns, Turns, Tracing, Guardrails e HITL.``` ┌───────────────┐ ┌───────────┐ │ HITL │◀─────-───▶│ Turns │ └───────┬───────┘ └───────────┘ │ ▼ ┌───────────┐ ┌───────────┐ ┌───────────┐ ┌───────────┐ │ Patterns │◀──-──▶│ Handoffs │◀──-─▶ │ Agents │◀──-─▶│ LLMs │ └───────────┘ └─────┬─────┘ └─────┬─────┘ └───────────┘ │ │ │ ▼ ┌────────────┐ ┌────┴──────┐ ┌───────────┐ ┌────────────┐ │ Extensions │◀────▶ │ Tracing │ │ Tools │◀──▶ │ Guardrails │ └────────────┘ └───────────┘ └───────────┘ └────────────┘ │ ┌─────────────┬─────┴────┬─────────────┐ ▼ ▼ ▼ ▼ ┌───────────┐┌───────────┐┌────────────┐┌───────────┐ │ LinuxCmd ││ WebSearch ││ Code ││ SSHTunnel │ └───────────┘└───────────┘└────────────┘└───────────┘

Se vuoi approfondire il codice, controlla i seguenti file come punto di partenza per utilizzare 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) - entrypoint for command line interface
* [util.py](https://github.com/aliasrobotics/cai/blob/main/src/cai/util.py) - utility functions
* [agents](https://github.com/aliasrobotics/cai/blob/main/src/cai/agents) - Agent implementations
* [internal](https://github.com/aliasrobotics/cai/blob/main/src/cai/internal) - CAI internal functions (endpoints, metrics, logging, etc.)
* [prompts](https://github.com/aliasrobotics/cai/blob/main/src/cai/prompts) - Agent Prompt Database
* [repl](https://github.com/aliasrobotics/cai/blob/main/src/cai/repl) - CLI aesthetics and commands
* [sdk](https://github.com/aliasrobotics/cai/blob/main/src/cai/sdk) - CAI command sdk
* [tools](https://github.com/aliasrobotics/cai/tree/main/src/cai/tools) - agent tools

### 🔹 Agente

Alla base, CAI astrae il suo comportamento di cybersecurity tramite `Agents` e `Patterns` agentici. Un Agent in *un sistema intelligente che interagisce con qualche ambiente*. Più tecnicamente, all'interno di CAI adottiamo una definizione incentrata sulla robotica in cui un agente è tutto ciò che può essere visto come un sistema che percepisce il suo ambiente attraverso sensori, ragiona sui suoi obiettivi e agisce di conseguenza su quell'ambiente attraverso attuatori (*adattato* da Russel & Norvig, AI: A Modern Approach). In cybersecurity, un `Agent` interagisce con sistemi e reti, utilizzando periferiche e interfacce di rete come sensori, ragiona di conseguenza e poi esegue azioni di rete come se fossero attuatori. Di conseguenza, in CAI, gli `Agent` implementano il modello agente `ReACT` (Reasoning and Action)[^3]. Per ulteriori informazioni, vedi [l'esempio qui](https://github.com/aliasrobotics/cai/blob/main/examples/basic/hello_world.py) per il codice di esecuzione completo, e fai riferimento a questo [jupyter notebook](https://github.com/aliasrobotics/cai/blob/main/fluency/my-first-hack/my_first_hack.ipynb) per un tutorial su come usarlo.```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)

🔹 Strumenti

Strumenti permettono agli agenti di cybersecurity di eseguire azioni fornendo interfacce per eseguire comandi di sistema, scansioni di sicurezza, analizzare vulnerabilità e interagire con sistemi target e API - sono le capacità fondamentali che abilitano gli agenti CAI a svolgere compiti di sicurezza in modo efficace; in CAI, gli strumenti includono utility di cybersecurity integrate (come LinuxCmd per l'esecuzione di comandi, WebSearch per la raccolta OSINT, Code per l'esecuzione dinamica di script e SSHTunnel per l'accesso remoto sicuro), meccanismi di chiamata di funzioni che consentono l'integrazione di qualsiasi funzione Python come strumento di sicurezza, e funzionalità agente-come-strumento che permette ad agenti di sicurezza specializzati (come agenti di ricognizione o exploit) di essere utilizzati da altri agenti, creando potenti flussi di lavoro collaborativi di sicurezza senza richiedere passaggi formali tra agenti. Per maggiori informazioni, si prega di fare riferimento all'esempio qui per la configurazione completa delle funzioni personalizzate.```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)

Potresti trovare diversi [strumenti](https://github.com/aliasrobotics/cai/blob/HEAD/tools). Sono raggruppati in 6 categorie principali ispirate alla kill chain di sicurezza [^2]:

1. Ricognizione e armamento - *reconnaissance* (crypto, listing, ecc.)
2. Sfruttamento - *exploitation*
3. Escalation dei privilegi - *escalation*
4. Movimento laterale - *lateral*
5. Esfiltrazione di dati - *exfiltration*
6. Comando e controllo - *control*

### 🔹 Handoffs

`Handoffs` consentono a un `Agent` di delegare compiti a un altro agente, il che è cruciale nelle operazioni di cybersecurity dove è necessaria competenza specializzata per diverse fasi di un impegno. Nel nostro framework, `Handoffs` sono implementati come strumenti per l'LLM, dove una **funzione di handoff/trasferimento** come `transfer_to_flag_discriminator` permette al `ctf_agent` di passare il controllo al `flag_discriminator_agent` una volta che ritiene di aver trovato la flag. Questo crea una catena di validazione di sicurezza in cui il primo agente gestisce lo sfruttamento e la scoperta della flag, mentre il secondo agente si specializza nella verifica della flag, garantendo una corretta separazione dei compiti e sfruttando le capacità specializzate di diversi modelli per compiti di sicurezza distinti. Per maggiori informazioni, si prega di fare riferimento all'[esempio qui](https://github.com/aliasrobotics/cai/blob/main/examples/cai/agent_patterns/handoffs.py) per il codice di esecuzione completo.```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

Un Pattern agente è un paradigma di progettazione strutturata nei sistemi di intelligenza artificiale in cui agenti autonomi o semi-autonomi operano all'interno di un quadro di interazione definito (il pattern) per raggiungere un obiettivo. Questi Pattern specificano l'organizzazione, il coordinamento e i metodi di comunicazione tra gli agenti, guidando il processo decisionale, l'esecuzione dei compiti e la delega.

Un pattern agente (AP) può essere definito formalmente come una tupla:

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

dove:

• \(A\) (Agenti): Un insieme di entità autonome, \( A = \{a_1, a_2, ..., a_n\} \), ciascuna con ruoli, capacità e stati interni definiti.
• \(H\) (Passaggi di consegna): Una funzione \( H: A \times T \to A \) che governa come i compiti \( T \) vengono trasferiti tra gli agenti in base a una logica predefinita (es. regole, negoziazione, offerte).
• \(D\) (Meccanismo Decisionale): Una funzione decisionale \( D: S \to A \) dove \( S \) rappresenta gli stati del sistema, e \( D \) determina quale agente agisce in un dato momento.
• \(C\) (Protocollo di Comunicazione): Una funzione di messaggistica \( C: A \times A \to M \), dove \( M \) è uno spazio di messaggi, che definisce come gli agenti condividono le informazioni.
• \(E\) (Modello di Esecuzione): Una funzione \( E: A \times I \to O \) dove \( I \) è lo spazio di input e \( O \) è lo spazio di output, che definisce come gli agenti svolgono i compiti.

Quando si costruiscono Pattern, li classifichiamo generalmente in una delle seguenti categorie, sebbene ne esistano altre:

Per maggiori informazioni ed esempi di pattern agenti comuni, consulta la cartella degli esempi.

🔹 Turni e Interazioni

Durante il flusso agente (conversazione), distinguiamo tra interazioni e turni.

• Interazioni sono scambi sequenziali tra uno o più agenti. Ogni agente che esegue la propria logica corrisponde a una interazione. Poiché un Agente in CAI implementa generalmente il modello agente ReACT[^3], ogni interazione consiste in 1) un passaggio di ragionamento tramite un'inferenza LLM e 2) un'azione chiamando da zero a n Strumenti. Questo è definito in process_interaction() in core.py.
• Turni: Un turno rappresenta un ciclo di una o più interazioni che termina quando l'Agente (o Pattern) in esecuzione restituisce None, giudicando che non ci siano ulteriori azioni da intraprendere. Questo è definito in run(), vedi core.py.

[!NOTA] Gli agenti CAI non sono correlati agli Assistants nell'API Assistants. Sono chiamati in modo simile per comodità, ma per il resto sono completamente non correlati. CAI è interamente basato sull'API Chat Completions ed è quindi apolide tra le chiamate.

🔹 Tracciamento

CAI implementa l'osservabilità dell'IA adottando lo standard OpenTelemetry e, per farlo, sfrutta Phoenix che fornisce capacità di tracciamento complete tramite strumentazione basata su OpenTelemetry, permettendoti di monitorare e analizzare le tue operazioni di sicurezza in tempo reale. Questa integrazione consente una visibilità dettagliata delle interazioni degli agenti, dell'uso degli strumenti e dei vettori di attacco durante i flussi di lavoro di penetration testing, rendendo più facile il debug di catene di sfruttamento complesse, il tracciamento dei processi di scoperta delle vulnerabilità e l'ottimizzazione delle prestazioni degli agenti per valutazioni di sicurezza più efficaci.

🔹 Guardrail

I Guardrail forniscono un livello di sicurezza critico per gli agenti CAI, proteggendo da attacchi di prompt injection e prevenendo l'esecuzione di comandi pericolosi. Questi guardrail operano in parallelo agli agenti, validando sia l'input che l'output per garantire un funzionamento sicuro. Il framework include:

• Guardrail di Input: Rilevano e bloccano i tentativi di prompt injection prima che raggiungano gli agenti, utilizzando pattern matching, rilevamento di omografi Unicode e analisi basata su IA
• Guardrail di Output: Validano gli output degli agenti prima dell'esecuzione, prevenendo comandi pericolosi come reverse shell, fork bomb o esfiltrazione di dati
• Difesa a più livelli: Protezione nelle fasi di input, elaborazione ed esecuzione con validazione a livello di strumento
• Consapevole di Base64/Base32: Decodifica e analizza automaticamente i payload codificati per rilevare comandi dannosi nascosti
• Configurabile: Può essere abilitato/disabilitato tramite la variabile d'ambiente CAI_GUARDRAILS

Per una implementazione dettagliata, vedi docs/guardrails.md e docs/cai_prompt_injection.md.

🔹 Umano-Nel-Circuito (HITL)```

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

CAI offre un framework per costruire IA per la sicurezza informatica con una forte enfasi sull'operatività *semi-autonoma*, poiché la realtà è che i sistemi di cybersecurity **completamente autonomi** rimangono prematuri e affrontano sfide significative nell'affrontare compiti complessi. Sebbene CAI esplori capacità autonome, riconosciamo che le operazioni di sicurezza efficaci richiedono ancora la teleoperazione umana, che fornisce competenza, giudizio e supervisione nel processo di sicurezza.

Di conseguenza, il modulo Human-In-The-Loop (`HITL`) è un principio di progettazione fondamentale di CAI, riconoscendo che l'intervento umano e la teleoperazione sono componenti essenziali di un test di sicurezza responsabile. Attraverso l'interfaccia `cli.py`, gli utenti possono interagire senza soluzione di continuità con gli agenti in qualsiasi punto durante l'esecuzione semplicemente premendo `Ctrl+C`. Questo è implementato in [core.py](https://github.com/aliasrobotics/cai/blob/HEAD/cai/core.py) e anche nelle astrazioni REPL [REPL](https://github.com/aliasrobotics/cai/blob/HEAD/cai/repl).

## :rocket: Quickstart

Per avviare CAI dopo averlo installato, basta digitare `cai` nella 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>

Ciò dovrebbe inizializzare CAI e fornire un prompt per eseguire qualsiasi attività di sicurezza desiderata. La barra di navigazione in basso mostra informazioni importanti sul sistema. Queste informazioni ti aiutano a comprendere il tuo ambiente mentre lavori con CAI.

Ecco un breve video dimostrativo per aiutarti a iniziare con CAI. Ti guideremo attraverso i passaggi di base, dal lancio dello strumento all'esecuzione del tuo primo task basato su AI nel terminale. Che tu sia un principiante o solo curioso, questa guida ti mostrerà quanto sia facile iniziare a usare CAI.

Da questo punto in poi, digita CAI e inizia il tuo esercizio di sicurezza. Il modo migliore per imparare è con l'esempio:

Variabili d'Ambiente

Per utilizzare modelli privati, ti viene fornito un file .env.example. Copialo e rinominalo come .env. Inserisci le tue chiavi API corrispondenti e sei pronto per usare CAI.

Elenco delle Variabili d'Ambiente

Integrazione con OpenRouter

La piattaforma Cybersecurity AI (CAI) offre un'integrazione senza soluzione di continuità con OpenRouter, un'interfaccia unificata per i Large Language Models (LLM). Questa integrazione è cruciale per gli utenti che desiderano sfruttare capacità AI avanzate nei loro compiti di cybersecurity. OpenRouter funge da ponte, permettendo a CAI di comunicare con vari LLM, migliorando così la flessibilità e la potenza degli agenti AI utilizzati all'interno di CAI.

Per abilitare il supporto OpenRouter in CAI, devi configurare il tuo ambiente aggiungendo voci specifiche al tuo file .env. Questa configurazione assicura che CAI possa interagire con l'API OpenRouter, facilitando l'uso di modelli sofisticati come Meta-LLaMA. Ecco come configurarlo:```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 piattaforma Cybersecurity AI (CAI) si integra perfettamente con Azure OpenAI, consentendo alle organizzazioni di eseguire CAI su modelli ospitati in azienda (ad es. gpt-4o). Questo percorso è ideale per i team che devono operare all'interno della governance di Azure sfruttando al contempo le capacità avanzate dei modelli.
Per abilitare il supporto di Azure OpenAI in CAI, configura il tuo ambiente aggiungendo le seguenti voci al tuo file .env. Ciò garantisce che CAI possa raggiungere il tuo endpoint di distribuzione Azure e autenticarsi correttamente.```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 supporta il Model Context Protocol (MCP) per integrare strumenti e servizi esterni con agenti AI. MCP è supportato tramite due meccanismi di trasporto:

1. SSE (Server-Sent Events) - Per server basati sul web che inviano aggiornamenti tramite connessioni HTTP:```bash CAI>/mcp load http://localhost:9876/sse burp

2. **STDIO (Standard Input/Output)** - Per la comunicazione inter-processo locale:```bash
CAI>/mcp load stdio myserver python mcp_server.py

Una volta connesso, puoi aggiungere gli strumenti MCP a qualsiasi agente:```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

Puoi elencare tutte le connessioni MCP attive e i loro tipi di trasporto:```bash
CAI>/mcp list

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

Sviluppo

Lo sviluppo è facilitato tramite ambienti di sviluppo VS Code. Per provare il nostro ambiente di sviluppo, clona il repository, apri VS Code e entra nella modalità container di sviluppo:

Contributi

Se vuoi contribuire a questo progetto, usa Pre-commit prima del tuo MR```bash pip install pre-commit pre-commit # files staged pre-commit run --all-files # all files

### Requisiti Opzionali: caiextensions

Attualmente, le estensioni non sono disponibili pubblicamente poiché l'impegno ingegneristico per mantenerle è significativo. Invece, stiamo rendendo disponibili specifiche caiextensions personalizzate per aziende partner nell'ambito di collaborazioni.

### :information_source: Raccolta Dati di Utilizzo

CAI è fornito gratuitamente per i ricercatori. Per migliorare l'accuratezza di rilevamento di CAI, far progredire la ricerca sulla sicurezza aperta e sviluppare e addestrare futuri modelli, ti chiediamo di contribuire alla comunità CAI consentendo la raccolta dei dati di utilizzo. Questi dati ci aiutano a identificare aree di miglioramento, capire come viene utilizzato il framework, dare priorità a nuove funzionalità e supportare gli sforzi di addestramento e valutazione dei modelli.

La base giuridica per la raccolta dei dati è ai sensi dell'Art. 6 (1)(f) GDPR — l'interesse legittimo di CAI nel mantenere, migliorare e far progredire gli strumenti di sicurezza e la ricerca — con le garanzie dell'Art. 89 applicate per scopi di ricerca.

I dati raccolti includono:

- Informazioni di base sul sistema (tipo di OS, versione di Python)
- Informazioni su nome utente e IP
- Modelli di utilizzo degli strumenti e metriche di prestazione
- Interazioni con i modelli e statistiche di utilizzo dei token

Prendiamo sul serio la tua privacy e raccogliamo solo ciò che è necessario per migliorare CAI, supportare la ricerca e addestrare e valutare i modelli in modo responsabile. Per ulteriori informazioni, contatta research＠aliasrobotics.com. Puoi disabilitare alcune funzionalità di raccolta dati tramite la variabile d'ambiente `CAI_TELEMETRY`, anche se ti incoraggiamo a tenerla attiva per contribuire alla ricerca in corso e allo sviluppo dei modelli:```bash
CAI_TELEMETRY=False cai

Riproduci CI-Setup localmente

Per simulare la pipeline CI/CD, puoi eseguire il seguente nelle macchine 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 sta dando errori 404

L'API di Ollama in modalità OpenAI usa `/v1/chat/completions` mentre la libreria `openai` usa `base_url` + `/chat/completions`.

Adottiamo quest'ultima per un allineamento complessivo con la comunità di AI generativa e potenziamo la prima permettendo agli utenti di aggiungere il `v1` manualmente tramite:```bash
OLLAMA_API_BASE=http://IP:PORT/v1

Vedi i seguenti issue che trattano questo argomento in modo più dettagliato:

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

Dove sono tutte le caiextensions?

Vedi tutte le caiextensions

Come installo la caiextension report?

Vedi qui

Come configuro l'accesso SSH per Gitlab?

Genera una nuova chiave SSH```bash ssh-keygen -t ed25519

Aggiungi la chiave all'agente SSH```bash
ssh-add ~/.ssh/id_ed25519

Aggiungi la chiave pubblica a Gitlab Copia la chiave e aggiungila a Gitlab all'indirizzo https://gitlab.com/-/user_settings/ssh_keys```bash cat ~/.ssh/id_ed25519.pub

Per verificarlo:```bash
ssh -T [email protected]
Welcome to GitLab, @vmayoral!

Come faccio a cancellare la cache di Python?```bash find . -name "*.pyc" -delete && find . -name "pycache" -delete

Se il networking host non funziona con ollama, verifica se è stato disabilitato in Docker perché non hai effettuato l'accesso

Docker su OS X a volte si comporta in modo strano. Controlla se è apparso il seguente messaggio:

*Il networking host è stato disabilitato perché non hai effettuato l'accesso. Effettua l'accesso per abilitarlo*.

Assicurati che questo sia stato risolto e che il Dev Container non stia inoltrando la porta 8000 (fai clic su x, se necessario, nella sezione delle porte).

Per verificare la connessione, dall'interno del devcontainer di VSCode:```bash
curl -v http://host.docker.internal:8000/api/version

Esegui CAI contro qualsiasi target

cai-004-first-message

Il prompt utente iniziale in questo caso è: Target IP: 192.168.3.10, perform a full network scan.

L'agente ha iniziato a eseguire una scansione nmap. Puoi interagire con l'agente e dargli ulteriori istruzioni, oppure lasciarlo eseguire per vedere cosa esplora successivamente.

Come interagisco con l'agente? Digita due volte CTRL + C

cai-005-ctrl-c

Se vuoi utilizzare la modalità HITL, puoi farlo premendo due volte Ctrl + C. Questo ti permetterà di interagire (prompt) con l'agente quando vuoi. L'agente non perderà il contesto precedente, poiché è memorizzato nella variabile history, che viene passata a esso e a qualsiasi agente venga chiamato. Ciò consente a qualsiasi agente di utilizzare le informazioni precedenti e di essere più preciso ed efficiente.

Posso cambiare il modello mentre CAI è in esecuzione? /model

Usa /model per cambiare modello.

cai-007-model-change

Come posso elencare tutti gli agenti disponibili? /agent

Usa /agent per elencare tutti gli agenti disponibili.

cai-010-agents-menu

Dove posso elencare tutte le variabili d'ambiente? /env

cai-008-config

Come posso monitorare l'uso dei token e i costi?

Usa /cost nel REPL per le spese della sessione e le statistiche dei token, /compact quando le conversazioni diventano lunghe, e (in modalità TUI) gli indicatori di costo per terminale e modello nell'interfaccia utente.```bash CAI> /cost

Vedi il [riferimento ai comandi CLI](https://github.com/aliasrobotics/cai/blob/HEAD/docs/cli/commands_reference.md) per l'elenco completo dei comandi.
 

 
 Come saperne di più sulla CLI? /help 

cai-006-help
 

 
 Come posso tracciare l'intera esecuzione? 
La variabile d'ambiente `CAI_TRACING` permette all'utente di impostarla a `CAI_TRACING=true` per abilitare il tracciamento, o `CAI_TRACING=false` per disabilitarlo.
Quando CAI viene avviato per la prima volta, all'utente vengono forniti due percorsi: il log di esecuzione e il log di tracciamento.

cai-009-logs

 

 
 Posso espandere le capacità di CAI utilizzando i log delle esecuzioni precedenti? 

Sì. Oggi CAI funziona meglio basandosi sull'In‑Context Learning (ICL). Invece di costruire archivi a lungo termine, il flusso di lavoro consigliato è caricare i log pertinenti precedenti direttamente nella sessione corrente, in modo che il modello possa ragionarci sopra nel contesto.

Usa il comando `/load` per portare i log JSONL nel contesto di CAI (questo sostituisce il vecchio strumento di caricamento della memoria):```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 stampa il percorso del log JSONL dell'esecuzione corrente all'avvio (evidenziato in arancione), che puoi passare a /load:

cai-009-logs

Note legacy: i precedenti meccanismi di "estensione della memoria" (archivi episodici/semantici e ingestione offline) sono conservati solo come riferimento. Vedi src/cai/agents/memory.py per dettagli storici e di background. La nostra direzione attuale privilegia l'ICL rispetto alla memoria persistente.

Posso espandere le capacità di CAI usando script o informazioni extra?

Attualmente, CAI supporta informazioni basate su testo. Puoi aggiungere qualsiasi informazione extra sul target che stai affrontando copiandola direttamente nel prompt di sistema o utente.

Come? Aggiungendola al prompt di sistema (system_master_template.md) o al prompt utente (user_master_template.md). Puoi sempre digitare direttamente il percorso del modello, e lui eseguirà cat su di esso.

Come funziona la licenza di CAI?

La licenza attuale di CAI non limita l'uso per scopi di ricerca. Sei libero di usare CAI per valutazioni di sicurezza (pentest), per sviluppare funzionalità aggiuntive e per integrarlo nelle tue attività di ricerca, purché tu rispetti le leggi locali.

Se tu o la tua organizzazione iniziate a trarre benefici commerciali da CAI (ad esempio, offrendo servizi di pentest basati su CAI), sarà necessaria una licenza commerciale per sostenere il progetto.

CAI stesso non è un'iniziativa volta al profitto. Il nostro obiettivo è costruire un progetto open-source sostenibile. Chiediamo semplicemente a chi trae profitto da CAI di contribuire e supportare il nostro sviluppo continuo.

Ricevo un Unable to locate package python3.12-venv durante l'installazione dei prerequisiti sul mio sistema basato su Debian!

Il modo più semplice per aggirare il problema è installare python3.12 dai sorgenti.

Citazione

Se vuoi citare il nostro lavoro, utilizza i seguenti riferimenti (ordinati per data di pubblicazione):```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} }

## Riconoscimenti

CAI è stato inizialmente sviluppato da [Alias Robotics](https://aliasrobotics.com) e co-finanziato dal progetto europeo EIC accelerator RIS (GA 101161136) - bando HORIZON-EIC-2023-ACCELERATOR-01. I principi agentici originali sono ispirati alla libreria [`swarm`](https://github.com/openai/swarm) di OpenAI e tradotti in nuovi prototipi. Questo progetto utilizza anche altri rilevanti blocchi costruttivi open source tra cui [`LiteLLM`](https://github.com/BerriAI/litellm) e [`phoenix`](https://github.com/Arize-ai/phoenix)

### Collaborazioni Accademiche
CAI beneficia di collaborazioni di ricerca in corso con istituzioni accademiche. I ricercatori interessati a progetti collaborativi, accesso a dataset o licenze accademiche dovrebbero contattare [email protected]. Forniamo supporto speciale per:
- Progetti di ricerca di dottorato
- Studi di benchmarking accademico 
- Iniziative di educazione alla sicurezza
- Contributi open source da laboratori di ricerca

 
[^1]: Si può sostenere che il pattern agentico Chain-of-Thought sia un caso speciale del pattern agentico gerarchico.
[^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).