Cybersecurity AI (CAI)

Edición Profesional con tokens alias1 ilimitados | 📊 Ver Benchmarks | 🚀 Más información

🔓 Edición Comunitaria Investigación y Aprendizaje · Perfecta para Investigadores y Estudiantes pip install cai-framework

✅ Gratuito para investigación 🤖 Más de 300 modelos de IA 🌍 Impulsado por la comunidad 📚 Código abierto 🔧 Framework extensible

🚀 Edición Profesional Empresas y Producción · 350€/mes · Tokens alias1 ilimitados

→ Actualizar a PRO

⚡ modelo alias1 - tokens ilimitados ∞ 🚫 Cero rechazos - IA sin restricciones 🏆 Supera a GPT-5 en benchmarks de CTF 🛡️ Soporte profesional incluido 🇪🇺 Soberanía de datos europea

CAI PRO con modelo alias1 supera a GPT-5 en benchmarks de ciberseguridad IA vs IA | Ver Benchmarks completos →

-->

Cybersecurity AI (CAI) es un framework ligero y de código abierto que permite a los profesionales de seguridad construir y desplegar automatización ofensiva y defensiva impulsada por IA. CAI es el framework de facto para Seguridad en IA, ya utilizado por miles de usuarios individuales y cientos de organizaciones. Ya sea que seas un investigador de seguridad, hacker ético, profesional de TI u organización que busca mejorar su postura de seguridad, CAI proporciona los componentes básicos para crear agentes de IA especializados que pueden ayudar con mitigación, descubrimiento de vulnerabilidades, explotación y evaluación de seguridad.

🔓 Ejecuta CAI sin una clave de API de Alias (CAI_LICENSE_OFF)

CAI puede ejecutarse sin una ALIAS_API_KEY (es decir, sin una licencia de Alias Robotics) configurando la variable de entorno CAI_LICENSE_OFF=1.

Cuando CAI_LICENSE_OFF está configurado como 1, true o yes:

• La verificación de licencia al inicio es omitida — no se requiere ALIAS_API_KEY.
• CAI se ejecuta en modo de código abierto y las operaciones de actualización apuntan al paquete público cai-framework de PyPI en lugar del índice privado de paquetes de Alias.
• Puedes usar cualquier otro proveedor de modelos compatible (OpenAI, Anthropic, DeepSeek, Ollama, etc.) configurando CAI_MODEL y la clave de API del proveedor correspondiente.

Inicio rápido sin licencia:```bash export CAI_LICENSE_OFF=1 cai

O inline:```bash
CAI_LICENSE_OFF=1 cai

Nota: El modelo alias1 aún requiere una clave ALIAS_API_KEY válida. CAI_LICENSE_OFF solo omite la puerta de licencia del framework — no otorga acceso a modelos alojados por Alias.

Características principales:

• 🤖 Más de 300 modelos de IA: Compatibilidad con OpenAI, Anthropic, DeepSeek, Ollama y más
• 🔧 Herramientas de seguridad integradas: Herramientas listas para usar para reconocimiento, explotación y escalada de privilegios
• 🏆 Probado en batalla: Comprobado en CTF de HackTheBox, programas de bug bounty y en el mundo real casos de estudio
• 🎯 Arquitectura basada en agentes: Diseño modular del framework para crear agentes especializados para diferentes tareas de seguridad
• 🛡️ Protección con Guardrails: Defensas integradas contra inyección de prompts y ejecución de comandos peligrosos
• 📚 Orientado a la investigación: Base de investigación para democratizar la IA en ciberseguridad para la comunidad

[!NOTE] Lee el informe técnico: CAI: An Open, Bug Bounty-Ready Cybersecurity AI El Laboratorio de Ciberseguridad Robótica mantiene una edición de lectura en HTML con figuras y referencias.

Para lecturas adicionales, consulta nuestras secciones de impacto y citación de CAI.

[!WARNING] ⚠️ CAI está en desarrollo activo, así que no esperes que funcione perfectamente. En su lugar, contribuye reportando un problema o enviando un PR.

El acceso a esta biblioteca y el uso de la información, materiales (o partes de ellos), no está destinado y está prohibido, cuando dicho acceso o uso viola las leyes o regulaciones aplicables. Los autores no fomentan ni promueven la manipulación no autorizada de sistemas en funcionamiento. Esto puede causar daños humanos graves y daños materiales.

Los autores de CAI no fomentan ni promueven la manipulación no autorizada de sistemas informáticos. Por favor, no uses el código fuente aquí para ciberdelincuencia. Haz pentesting para el bien. Al descargar, usar o modificar este código fuente, aceptas los términos de la LICENCIA y las limitaciones descritas en el archivo DESCARGO DE RESPONSABILIDAD.

🔖 Tabla de Contenidos

• Cybersecurity AI (CAI)
• 🔖 Tabla de Contenidos
• 🎯 Impacto
• 🏆 Competiciones y desafíos
• 📊 Impacto en la Investigación
• 📚 Productos de investigación: Cybersecurity AI
• PoCs
• Motivación
• 👤 ¿Por qué CAI?
• Principios éticos detrás de CAI
• Alternativas de código cerrado
• Aprende - Fluidez en CAI
• 🔩 Instalar
• OS X
• Ubuntu 24.04
• Ubuntu 20.04
• Windows WSL
• Android
• 🔩 Configurar archivo .env
• 🔹 Soporte de URL Base Personalizada para OpenAI
• 📐 Arquitectura:
• 🔹 Agente
• 🔹 Herramientas
• �5 Handoffs
• 🔹 Patrones
• 🔹 Turnos e Interacciones
• 🔹 Trazado
• 🔹 Guardrails
• 🔹 Humano en el Bucle (HITL)

🎯 Impacto

🏆 Competiciones y desafíos

📊 Impacto en la Investigación

• Pionero en seguridad IA potenciada por LLM con PentestGPT, estableciendo la base para el dominio de investigación Cybersecurity AI

• Estableció la línea de investigación Cybersecurity AI con 8 artículos e informes técnicos, con colaboraciones activas de investigación

📚 Productos de investigación: Cybersecurity AI

Ediciones de lectura extendidas en HTML: CAI · CAIBench · Humanoid robots as attack vectors · The cybersecurity of a humanoid robot · Hacking consumer robots in the AI era

PoCs

CAI con alias0 en ataques de inyección de mensajes ROS en el robot MiR-100	CAI con alias0 en descubrimiento de vulnerabilidades en API en Mercado Libre

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

Hay más casos de estudio y PoCs disponibles en https://aliasrobotics.com/case-studies-robot-cybersecurity.php.

Motivación

👤 ¿Por qué CAI?

El panorama de la ciberseguridad está experimentando una transformación dramática a medida que la IA se integra cada vez más en las operaciones de seguridad. Predecimos que para 2028, las herramientas de pruebas de seguridad impulsadas por IA superarán en número a los pentesters humanos. Este cambio representa un cambio fundamental en cómo abordamos los desafíos de ciberseguridad. La IA no es solo otra herramienta: se está volviendo esencial para abordar vulnerabilidades de seguridad complejas y mantenerse por delante de amenazas sofisticadas. A medida que las organizaciones enfrentan ciberataques más avanzados, las pruebas de seguridad mejoradas con IA serán cruciales para mantener defensas robustas.

Este trabajo se basa en esfuerzos anteriores[^4] y, de manera similar, creemos que democratizar el acceso a herramientas avanzadas de IA en ciberseguridad es vital para toda la comunidad de seguridad. Por eso estamos liberando Cybersecurity AI (CAI) como un framework de código abierto. Nuestro objetivo es empoderar a investigadores de seguridad, hackers éticos y organizaciones para construir e implementar potentes herramientas de seguridad impulsadas por IA. Al hacer que estas capacidades estén disponibles abiertamente, buscamos nivelar el campo de juego y asegurar que la tecnología de IA de seguridad de vanguardia no se limite a empresas privadas bien financiadas o actores estatales.

Los programas Bug Bounty se han convertido en una piedra angular de la ciberseguridad moderna, proporcionando un mecanismo crucial para que las organizaciones identifiquen y corrijan vulnerabilidades en sus sistemas antes de que puedan ser explotadas. Estos programas han demostrado ser altamente efectivos para asegurar tanto la infraestructura pública como la privada, con investigadores descubriendo vulnerabilidades críticas que de otro modo podrían haber pasado desapercibidas. CAI está específicamente diseñado para potenciar estos esfuerzos proporcionando un framework ligero y ergonómico para construir agentes de IA especializados que puedan ayudar en varios aspectos de la caza de Bug Bounty, desde el reconocimiento inicial hasta la validación de vulnerabilidades y la elaboración de informes. Nuestro framework busca aumentar la experiencia humana con capacidades de IA, ayudando a los investigadores a trabajar de manera más eficiente y exhaustiva en su búsqueda por hacer que los sistemas digitales sean más seguros.

Principios éticos detrás de CAI

Quizás te estés preguntando si liberar CAI en la naturaleza dadas sus capacidades e implicaciones de seguridad es ético. Nuestra decisión de hacer este framework de código abierto se guía por dos principios éticos fundamentales:

1. Democratizar la IA en ciberseguridad: Creemos que las herramientas avanzadas de IA en ciberseguridad deberían ser accesibles para toda la comunidad de seguridad, no solo para empresas privadas bien financiadas o actores estatales. Al liberar CAI como un framework de código abierto, buscamos empoderar a investigadores de seguridad, hackers éticos y organizaciones para construir e implementar potentes herramientas de seguridad impulsadas por IA, nivelando el campo de juego en ciberseguridad.

2. Transparencia en las capacidades de seguridad de la IA: Basándonos en nuestros resultados de investigación, comprensión de la tecnología y análisis de los principales informes técnicos, argumentamos que los proveedores actuales de LLM están subestimando sus capacidades de ciberseguridad. Esto es extremadamente peligroso y engañoso. Al desarrollar CAI abiertamente, proporcionamos un punto de referencia transparente de lo que los sistemas de IA pueden realmente hacer en contextos de ciberseguridad, permitiendo decisiones más informadas sobre las posturas de seguridad.CAI se basa en los siguientes principios fundamentales:

• Framework de IA orientado a la ciberseguridad: CAI está diseñado específicamente para casos de uso de ciberseguridad, con el objetivo de automatizar tareas de seguridad ofensivas y defensivas de forma semi y totalmente automatizada.
• Código abierto, gratuito para investigación: CAI es de código abierto y gratuito con fines de investigación. Buscamos democratizar el acceso a la IA y la Ciberseguridad. Para uso profesional o comercial, incluyendo despliegues on-premise, soporte técnico dedicado y extensiones personalizadas, contacta para obtener una licencia.
• Ligero: CAI está diseñado para ser rápido y fácil de usar.
• Diseño modular y centrado en agentes: CAI opera sobre la base de agentes y patrones agentivos, lo que permite flexibilidad y escalabilidad. Puedes añadir fácilmente los agentes y patrones más adecuados para tu caso de uso de ciberseguridad.
• Integración de herramientas: CAI integra herramientas ya incorporadas y permite al usuario integrar sus propias herramientas con su lógica de forma sencilla.
• Registro y trazado integrados: mediante phoenix, la herramienta de trazado y registro de código abierto para LLMs. Esto proporciona al usuario una trazabilidad detallada de los agentes y su ejecución.
• Soporte multi-modelo: más de 300 modelos compatibles y potenciados por LiteLLM. Los proveedores más populares:
• Anthropic: Claude 3.7, Claude 3.5, Claude 3, Claude 3 Opus
• OpenAI: O1, , , ,

Alternativas de código cerrado

La IA de ciberseguridad es un campo crítico, sin embargo, muchos grupos lo están abordando erróneamente mediante métodos de código cerrado por puro beneficio económico, aprovechando técnicas similares y construyendo sobre modelos existentes de código cerrado (a menudo propiedad de terceros). Este enfoque no solo desperdicia valiosos recursos de ingeniería, sino que también representa un despilfarro económico y da lugar a esfuerzos redundantes, ya que a menudo terminan reinventando la rueda. Estas son algunas de las iniciativas de código cerrado que seguimos y que intentan aprovechar la IA generativa y los frameworks agentivos en la IA de ciberseguridad:

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

Aprende - Dominio de CAI

[!NOTE]

El informe técnico de CAI Fluency (arXiv:2508.13588) establece marcos educativos formales para la alfabetización en IA de ciberseguridad.

🔩 Instalación

[!NOTE] Usuarios de CAI Professional Edition: Si tienes una suscripción activa de CAI Pro, proporcionamos guías de instalación dedicadas para las versiones 0.5 y 0.6. El soporte oficial está disponible para Ubuntu 24.04 (x86_64). Las instrucciones de instalación para otros sistemas operativos se proporcionan tal cual, sin soporte oficial:

• Guía de instalación de CAI Pro v0.6
• Guía de instalación de CAI Pro v0.5

Instalación de la Edición Comunitaria```bash

pip install cai-framework

Siempre cree un nuevo entorno virtual para garantizar la instalación adecuada de dependencias al actualizar CAI.

Las siguientes subsecciones proporcionan un tutorial más detallado sobre sistemas operativos populares seleccionados. Consulte la sección [Desarrollo](#development) para obtener instrucciones de instalación relacionadas con desarrolladores.
Para la sintaxis de env de claves API, consulte la documentación de litellm. [Documentación de 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

Ve a la página de Microsoft: https://learn.microsoft.com/en-us/windows/wsl/install. Aquí encontrarás todas las instrucciones para instalar WSL.

Desde Powershell escribe: 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

Puede encontrar problemas al ejecutar cai en ubuntu, ya que algunos agentes asumen que se están ejecutando en una instancia de Kali y no pueden encontrar las herramientas necesarias.
Por lo tanto, como alternativa, puede usar el archivo docker compose en la carpeta dockerized en su lugar. Esto también funciona desde wsl si docker está instalado.
En ese caso, obtenga la carpeta dockerized (no necesita todo el repositorio) y ejecútela desde su interior.
Para la sintaxis de variables de entorno de las claves API, consulte la documentación de LiteLLM. [Documentación de 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

Recomendamos tener al menos 8 GB de RAM:

1. En primer lugar, instala userland https://play.google.com/store/apps/details?id=tech.ula&hl=es

2. Instala Kali minimal en opciones básicas (de forma gratuita). [O cualquier otra opción de Kali si se prefiere]

3. Actualiza las claves de apt como en este ejemplo: https://superuser.com/questions/1644520/apt-get-update-issue-in-kali, dentro del terminal de Kali de UserLand ejecuta```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: Configurar el archivo `.env`

CAI utiliza el archivo `.env` para cargar la configuración al inicio. Para facilitar la configuración, el repositorio proporciona un archivo ejemplar [`.env.example`](https://github.com/aliasrobotics/cai/blob/HEAD/.env.example) que sirve como plantilla para configurar CAI y tus claves de API de LLM para trabajar con los modelos LLM deseados.

:warning: Importante:

CAI NO proporciona claves de API para ningún modelo por defecto. No nos pidas que proporcionemos claves, usa las tuyas propias o aloja tus propios modelos.

:warning: Nota:

La OPENAI_API_KEY no debe dejarse en blanco. Debe contener "sk-123" (como marcador de posición) o tu clave de API real. Consulta https://github.com/aliasrobotics/cai/issues/27.

:warning: Nota:

Si estás usando el modelo alias1, asegúrate de que CAI sea la versión >0.4.0 y aquí tienes un ejemplo de .env para poder usarlo.```bash
OPENAI_API_KEY="sk-1234"
OLLAMA=""
ALIAS_API_KEY="<sk-your-key>"  # note, add yours
CAI_STREAM=False
CAI_MODEL="alias1"

🔹 Soporte de URL Base Personalizada de OpenAI

CAI admite configurar una URL base personalizada de la API de OpenAI mediante la variable de entorno OPENAI_BASE_URL. Esto permite a los usuarios redirigir las llamadas a la API a un endpoint personalizado, como un proxy o un servicio compatible con OpenAI autogestionado.

Ejemplo de configuración de entrada .env:``` OLLAMA_API_BASE="https://custom-openai-proxy.com/v1"

O directamente desde la línea de comandos:```bash
OLLAMA_API_BASE="https://custom-openai-proxy.com/v1" cai

📐 Arquitectura:

CAI se centra en hacer que la coordinación y ejecución de agentes de ciberseguridad sea ligera, altamente controlable y útil para los humanos. Para ello se basa en 8 pilares: Agents, Tools, Handoffs, Patterns, Turns, Tracing, Guardrails y HITL.``` ┌───────────────┐ ┌───────────┐ │ HITL │◀─────-───▶│ Turns │ └───────┬───────┘ └───────────┘ │ ▼ ┌───────────┐ ┌───────────┐ ┌───────────┐ ┌───────────┐ │ Patterns │◀──-──▶│ Handoffs │◀──-─▶ │ Agents │◀──-─▶│ LLMs │ └───────────┘ └─────┬─────┘ └─────┬─────┘ └───────────┘ │ │ │ ▼ ┌────────────┐ ┌────┴──────┐ ┌───────────┐ ┌────────────┐ │ Extensions │◀────▶ │ Tracing │ │ Tools │◀──▶ │ Guardrails │ └────────────┘ └───────────┘ └───────────┘ └────────────┘ │ ┌─────────────┬─────┴────┬─────────────┐ ▼ ▼ ▼ ▼ ┌───────────┐┌───────────┐┌────────────┐┌───────────┐ │ LinuxCmd ││ WebSearch ││ Code ││ SSHTunnel │ └───────────┘└───────────┘└────────────┘└───────────┘

Si deseas profundizar en el código, revisa los siguientes archivos como punto de partida para usar 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) - punto de entrada para la interfaz de línea de comandos
* [util.py](https://github.com/aliasrobotics/cai/blob/main/src/cai/util.py) - funciones de utilidad
* [agents](https://github.com/aliasrobotics/cai/blob/main/src/cai/agents) - Implementaciones de Agentes
* [internal](https://github.com/aliasrobotics/cai/blob/main/src/cai/internal) - funciones internas de CAI (endpoints, métricas, registro, etc.)
* [prompts](https://github.com/aliasrobotics/cai/blob/main/src/cai/prompts) - Base de datos de prompts de Agentes
* [repl](https://github.com/aliasrobotics/cai/blob/main/src/cai/repl) - estética y comandos de la CLI
* [sdk](https://github.com/aliasrobotics/cai/blob/main/src/cai/sdk) - sdk de comandos de CAI
* [tools](https://github.com/aliasrobotics/cai/tree/main/src/cai/tools) - herramientas de agente

### 🔹 Agent

En esencia, CAI abstrae su comportamiento de ciberseguridad a través de `Agentes` y `Patrones` agentivos. Un Agente es *un sistema inteligente que interactúa con algún entorno*. Más técnicamente, dentro de CAI adoptamos una definición centrada en la robótica donde un agente es cualquier cosa que puede ser vista como un sistema que percibe su entorno a través de sensores, razona sobre sus metas y y actúa en consecuencia sobre ese entorno a través de actuadores (*adaptado* de Russel & Norvig, AI: A Modern Approach). En ciberseguridad, un `Agente` interactúa con sistemas y redes, utilizando periféricos e interfaces de red como sensores, razona en consecuencia y luego ejecuta acciones de red como si fueran actuadores. En correspondencia, en CAI, los `Agentes` implementan el modelo de agente `ReACT` (Razonamiento y Acción)[^3]. Para más información, consulta el [ejemplo aquí](https://github.com/aliasrobotics/cai/blob/main/examples/basic/hello_world.py) para el código de ejecución completo, y consulta este [jupyter notebook](https://github.com/aliasrobotics/cai/blob/main/fluency/my-first-hack/my_first_hack.ipynb) para un tutorial sobre cómo 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)

🔹 Herramientas

Las Herramientas permiten que los agentes de ciberseguridad tomen acciones al proporcionar interfaces para ejecutar comandos del sistema, realizar escaneos de seguridad, analizar vulnerabilidades e interactuar con sistemas objetivo y APIs – son las capacidades centrales que permiten a los agentes CAI realizar tareas de seguridad de manera efectiva; en CAI, las herramientas incluyen utilidades de ciberseguridad integradas (como LinuxCmd para ejecución de comandos, WebSearch para recolección de OSINT, Code para ejecución dinámica de scripts y SSHTunnel para acceso remoto seguro), mecanismos de llamada a funciones que permiten integrar cualquier función de Python como herramienta de seguridad, y funcionalidad agente-como-herramienta que permite que agentes de seguridad especializados (como agentes de reconocimiento o explotación) sean utilizados por otros agentes, creando poderosos flujos de trabajo colaborativos en seguridad sin requerir transferencias formales entre agentes. Para más información, consulte el ejemplo aquí para la configuración completa de funciones personalizadas.```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)

Puedes encontrar diferentes [herramientas](https://github.com/aliasrobotics/cai/blob/HEAD/tools). Están agrupados en 6 categorías principales inspiradas en la cadena de eliminación de seguridad [^2]:

1. Reconocimiento y armamentización - *reconnaissance* (crypto, listing, etc.)
2. Explotación - *exploitation*
3. Escalada de privilegios - *escalation*
4. Movimiento lateral - *lateral*
5. Exfiltración de datos - *exfiltration*
6. Comando y control - *control*

### 🔹 Traspasos

Los `Handoffs` permiten que un `Agent` delegue tareas a otro agente, lo cual es crucial en operaciones de ciberseguridad donde se necesita experiencia especializada para diferentes fases de un compromiso. En nuestro framework, los `Handoffs` se implementan como herramientas para el LLM, donde una **función de traspaso/transferencia** como `transfer_to_flag_discriminator` permite que el `ctf_agent` pase el control al `flag_discriminator_agent` una vez que cree haber encontrado la bandera. Esto crea una cadena de validación de seguridad donde el primer agente maneja la explotación y el descubrimiento de banderas, mientras que el segundo se especializa en la verificación de banderas, asegurando una segregación adecuada de funciones y aprovechando capacidades especializadas de diferentes modelos para tareas de seguridad distintas. Para más información, consulte el [ejemplo aquí](https://github.com/aliasrobotics/cai/blob/main/examples/cai/agent_patterns/handoffs.py) para el código completo de ejecución.```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]
)

🔹 Patrones

Un Pattern (patrón) agéntico es un paradigma de diseño estructurado en sistemas de inteligencia artificial donde agentes autónomos o semi-autónomos operan dentro de un marco de interacción (el patrón) definido para lograr un objetivo. Estos Patterns especifican la organización, coordinación y métodos de comunicación entre agentes, guiando la toma de decisiones, la ejecución de tareas y la delegación.

Un patrón agéntico (PA) se puede definir formalmente como una tupla:

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

donde:

• \(A\) (Agentes): Un conjunto de entidades autónomas, \( A = \{a_1, a_2, ..., a_n\} \), cada una con roles, capacidades y estados internos definidos.
• \(H\) (Transferencias): Una función \( H: A \times T \to A \) que gobierna cómo las tareas \( T \) se transfieren entre agentes basándose en lógica predefinida (p. ej., reglas, negociación, pujas).
• \(D\) (Mecanismo de Decisión): Una función de decisión \( D: S \to A \) donde \( S \) representa estados del sistema, y \( D \) determina qué agente actúa en un momento dado.
• \(C\) (Protocolo de Comunicación): Una función de mensajería \( C: A \times A \to M \), donde \( M \) es un espacio de mensajes, que define cómo los agentes comparten información.
• \(E\) (Modelo de Ejecución): Una función \( E: A \times I \to O \) donde \( I \) es el espacio de entrada y \( O \) el espacio de salida, que define cómo los agentes realizan tareas.

Al construir Patterns, generalmente los clasificamos en una de las siguientes categorías, aunque existen otras:

Para más información y ejemplos de patrones agénticos comunes, consulte la carpeta de ejemplos.

🔹 Turnos e Interacciones

Durante el flujo agéntico (conversación), distinguimos entre interacciones y turnos.

• Interacciones son intercambios secuenciales entre uno o múltiples agentes. Cada agente ejecutando su lógica corresponde con una interacción. Dado que un Agent en CAI generalmente implementa el modelo de agente ReACT[^3], cada interacción consiste en 1) un paso de razonamiento mediante una inferencia de LLM y 2) actuar llamando de cero a n Tools. Esto se define en process_interaction() en core.py.
• Turnos: Un turno representa un ciclo de una o más interacciones que finaliza cuando el Agent (o Pattern) en ejecución devuelve None, determinando que no hay más acciones que realizar. Esto se define en run(), ver core.py.

[!NOTA] Los Agentes CAI no están relacionados con los Asistentes en la API de Asistentes. Se nombran de manera similar por conveniencia, pero por lo demás no tienen ninguna relación. CAI está completamente impulsado por la API de Chat Completions y, por lo tanto, no tiene estado entre llamadas.

🔹 Trazabilidad

CAI implementa observabilidad de IA adoptando el estándar OpenTelemetry y para ello utiliza Phoenix que proporciona capacidades integrales de trazabilidad mediante instrumentación basada en OpenTelemetry, permitiéndole monitorear y analizar sus operaciones de seguridad en tiempo real. Esta integración permite una visibilidad detallada de las interacciones de los agentes, el uso de herramientas y los vectores de ataque a lo largo de los flujos de trabajo de pruebas de penetración, facilitando la depuración de cadenas de explotación complejas, el seguimiento de procesos de descubrimiento de vulnerabilidades y la optimización del rendimiento de los agentes para evaluaciones de seguridad más efectivas.

🔹 Guardarraíles

Los Guardarraíles proporcionan una capa crítica de seguridad para los agentes CAI, protegiendo contra ataques de inyección de prompt y previniendo la ejecución de comandos peligrosos. Estos guardarraíles se ejecutan en paralelo a los agentes, validando tanto la entrada como la salida para garantizar una operación segura. El framework incluye:

• Guardarraíles de entrada: Detectan y bloquean intentos de inyección de prompt antes de que lleguen a los agentes, utilizando coincidencia de patrones, detección de homógrafos Unicode y análisis impulsado por IA.
• Guardarraíles de salida: Validan las salidas de los agentes antes de la ejecución, evitando comandos peligrosos como reverse shells, fork bombs o exfiltración de datos.
• Defensa multicapa: Protección en las etapas de entrada, procesamiento y ejecución con validación a nivel de herramienta.
• Consciente de Base64/Base32: Decodifica y analiza automáticamente cargas útiles codificadas para detectar comandos maliciosos ocultos.
• Configurable: Se puede habilitar/deshabilitar mediante la variable de entorno CAI_GUARDRAILS.

Para una implementación detallada, consulte docs/guardrails.md y docs/cai_prompt_injection.md.

🔹 Humano en el Bucle (HITL)```

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

CAI proporciona un marco para construir IAs de Ciberseguridad con un fuerte énfasis en la operación *semiautónoma*, ya que la realidad es que los sistemas de ciberseguridad **totalmente autónomos** siguen siendo prematuros y enfrentan desafíos significativos al abordar tareas complejas. Si bien CAI explora capacidades autónomas, reconocemos que las operaciones de seguridad efectivas aún requieren teleoperación humana que brinde experiencia, juicio y supervisión en el proceso de seguridad.

En consecuencia, el módulo Human-In-The-Loop (`HITL`) es un principio de diseño central de CAI, reconociendo que la intervención humana y la teleoperación son componentes esenciales de las pruebas de seguridad responsables. A través de la interfaz `cli.py`, los usuarios pueden interactuar sin problemas con los agentes en cualquier punto durante la ejecución simplemente presionando `Ctrl+C`. Esto se implementa en [core.py](https://github.com/aliasrobotics/cai/blob/HEAD/cai/core.py) y también en las abstracciones REPL [REPL](https://github.com/aliasrobotics/cai/blob/HEAD/cai/repl).

## :rocket: Inicio rápido

Para iniciar CAI después de instalarlo, simplemente escriba `cai` en la 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 should initialize CAI and provide a prompt to execute any security task you want to perform. The navigation bar at the bottom displays important system information. This information helps you understand your environment while working with CAI.

Here's a quick demo video to help you get started with CAI. We'll walk through the basic steps — from launching the tool to running your first AI-powered task in the terminal. Whether you're a beginner or just curious, this guide will show you how easy it is to begin using CAI.

From here on, type on CAI and start your security exercise. Best way to learn is by example:

Variables de Entorno

Para usar modelos privados, se te proporciona un archivo .env.example. Cópialo y renómbralo como .env. Completa tus claves API correspondientes y estarás listo para usar CAI.

Lista de Variables de Entorno

Integración con OpenRouter

La plataforma de IA para Ciberseguridad (CAI) ofrece integración sin fisuras con OpenRouter, una interfaz unificada para Modelos de Lenguaje Grande (LLMs). Esta integración es crucial para los usuarios que desean aprovechar capacidades de IA avanzadas en sus tareas de ciberseguridad. OpenRouter actúa como puente, permitiendo que CAI se comunique con varios LLMs, mejorando así la flexibilidad y potencia de los agentes de IA utilizados dentro de CAI.

Para habilitar el soporte de OpenRouter en CAI, debes configurar tu entorno añadiendo entradas específicas a tu archivo .env. Esta configuración asegura que CAI pueda interactuar con la API de OpenRouter, facilitando el uso de modelos sofisticados como Meta-LLaMA. Así es como puedes 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 plataforma de IA de Ciberseguridad (CAI) se integra de forma fluida con Azure OpenAI, permitiendo a las organizaciones ejecutar CAI contra modelos alojados en la empresa (por ejemplo, gpt-4o). Esta vía es ideal para equipos que deben operar dentro del marco de gobierno de Azure mientras aprovechan capacidades avanzadas de modelos.
Para habilitar la compatibilidad con Azure OpenAI en CAI, configure su entorno añadiendo las siguientes entradas a su archivo .env. Esto asegura que CAI pueda acceder a su punto final de implementación de Azure y autenticarse correctamente.```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 admite el Protocolo de Contexto de Modelo (MCP) para integrar herramientas y servicios externos con agentes de IA. MCP es compatible a través de dos mecanismos de transporte:

1. SSE (Eventos Enviados por el Servidor) - Para servidores basados en web que envían actualizaciones a través de conexiones HTTP:```bash CAI>/mcp load http://localhost:9876/sse burp

2. **STDIO (Standard Input/Output)** - Para comunicación local entre procesos:```bash
CAI>/mcp load stdio myserver python mcp_server.py

Una vez conectado, puedes añadir las herramientas MCP a cualquier 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

Puedes listar todas las conexiones MCP activas y sus tipos de transporte:```bash
CAI>/mcp list

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

Desarrollo

El desarrollo se facilita mediante entornos de desarrollo de VS Code. Para probar nuestro entorno de desarrollo, clona el repositorio, abre VS Code e ingresa al modo de contenedor de desarrollo:

Contribuciones

Si deseas contribuir a este proyecto, usa Pre-commit antes de tu MR```bash pip install pre-commit pre-commit # files staged pre-commit run --all-files # all files

### Requisitos Opcionales: caiextensions

Actualmente, las extensiones no están disponibles públicamente, ya que el esfuerzo de ingeniería para mantenerlas es significativo. En su lugar, estamos poniendo a disposición extensiones caiextensions personalizadas seleccionadas para empresas colaboradoras a través de alianzas.

### :information_source: Recopilación de Datos de Uso

CAI se proporciona de forma gratuita para investigadores. Para mejorar la precisión de detección de CAI, avanzar en la investigación de seguridad abierta, y desarrollar y entrenar modelos futuros, te pedimos que contribuyas a la comunidad de CAI permitiendo la recopilación de datos de uso. Estos datos nos ayudan a identificar áreas de mejora, comprender cómo se está utilizando el marco, priorizar nuevas funciones y apoyar los esfuerzos de entrenamiento y evaluación de modelos.

La base legal para la recopilación de datos es el Art. 6 (1)(f) del RGPD — el interés legítimo de CAI en mantener, mejorar y avanzar en herramientas e investigación de seguridad — con las salvaguardas del Art. 89 aplicadas para fines de investigación.

Los datos recopilados incluyen:

- Información básica del sistema (tipo de SO, versión de Python)
- Información de nombre de usuario e IP
- Patrones de uso de la herramienta y métricas de rendimiento
- Interacciones con el modelo y estadísticas de uso de tokens

Tomamos tu privacidad en serio y solo recopilamos lo necesario para mejorar CAI, apoyar la investigación, y entrenar y evaluar modelos de manera responsable. Para más información, contacta a research＠aliasrobotics.com. Puedes desactivar algunas funciones de recopilación de datos mediante la variable de entorno `CAI_TELEMETRY`, aunque te animamos a mantenerla activada para contribuir a la investigación en curso y al desarrollo de modelos:```bash
CAI_TELEMETRY=False cai

Reproducir CI-Setup localmente

Para simular el pipeline de CI/CD, puedes ejecutar lo siguiente en las máquinas del 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

## Preguntas Frecuentes
 OLLAMA me está dando errores 404 

La API de Ollama en modo OpenAI usa `/v1/chat/completions` mientras que la librería `openai` usa `base_url` + `/chat/completions`.

Adoptamos el segundo para mantener la alineación general con la comunidad de IA generativa y potenciamos el primero permitiendo a los usuarios agregar el `v1` ellos mismos mediante:```bash
OLLAMA_API_BASE=http://IP:PORT/v1

Consulte los siguientes problemas que tratan este tema con más detalle:

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

¿Dónde están todas las caiextensions?

Consulte todas las caiextensions

¿Cómo instalo la caiextension de informes?

Vea aquí

¿Cómo configuro el acceso SSH para Gitlab?

Genere una nueva clave SSH```bash ssh-keygen -t ed25519

Agregar la clave al agente SSH```bash
ssh-add ~/.ssh/id_ed25519

Añadir la clave pública a Gitlab
Copiar la clave y añadirla a Gitlab en https://gitlab.com/-/user_settings/ssh_keys```bash cat ~/.ssh/id_ed25519.pub

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

¿Cómo limpio la caché de Python?```bash find . -name "*.pyc" -delete && find . -name "pycache" -delete

Si la red del host no funciona con ollama, verifica si se ha desactivado en Docker porque no has iniciado sesión.

Docker en OS X a veces se comporta de manera extraña. Comprueba si aparece el siguiente mensaje:

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

Asegúrate de que esto se haya solucionado y también de que el Dev Container no esté redirigiendo el puerto 8000 (haz clic en la x, si es necesario, en la sección de puertos).

Para verificar la conexión, desde dentro del devcontainer de VSCode:```bash
curl -v http://host.docker.internal:8000/api/version

Ejecutar CAI contra cualquier objetivo

cai-004-first-message

El prompt de usuario inicial en este caso es: Target IP: 192.168.3.10, perform a full network scan.

El agente comenzó a realizar un escaneo nmap. Puede interactuar con el agente y darle más instrucciones, o dejarlo ejecutar para ver qué explora a continuación.

¿Cómo interactúo con el agente? Presione dos veces Ctrl + C

cai-005-ctrl-c

Si desea usar el modo HITL, puede hacerlo presionando dos veces Ctrl + C. Esto le permitirá interactuar (dar instrucciones) con el agente cuando lo desee. El agente no perderá el contexto anterior, ya que se almacena en la variable history, que se le pasa a él y a cualquier agente que sea llamado. Esto permite que cualquier agente utilice la información previa y sea más preciso y eficiente.

¿Puedo cambiar el modelo mientras CAI se ejecuta? /model

Use /model para cambiar el modelo.

cai-007-model-change

¿Cómo puedo listar todos los agentes disponibles? /agent

Use /agent para listar todos los agentes disponibles.

cai-010-agents-menu

¿Dónde puedo listar todas las variables de entorno? /env

cai-008-config

¿Cómo puedo monitorear el uso de tokens y costos?

Use /cost en el REPL para el gasto de la sesión y estadísticas de tokens, /compact cuando las conversaciones se vuelvan largas, y (en modo TUI) los indicadores de costo y modelo por terminal en la interfaz de usuario.```bash CAI> /cost

Consulte la [referencia de comandos de la CLI](https://github.com/aliasrobotics/cai/blob/HEAD/docs/cli/commands_reference.md) para obtener la lista completa de comandos.
 

 
 ¿Cómo saber más sobre la CLI? /help 

cai-006-help
 

 
 ¿Cómo puedo rastrear toda la ejecución? 
La variable de entorno `CAI_TRACING` permite al usuario configurarla como `CAI_TRACING=true` para habilitar el rastreo, o `CAI_TRACING=false` para deshabilitarlo.
Cuando CAI se solicita por primera vez, se le proporcionan al usuario dos rutas: el registro de ejecución y el registro de rastreo.

cai-009-logs

 

 
 ¿Puedo expandir las capacidades de CAI usando registros de ejecuciones anteriores? 

Sí. Hoy en día, CAI funciona mejor apoyándose en el Aprendizaje en Contexto (ICL). En lugar de construir almacenes a largo plazo, el flujo de trabajo recomendado es cargar registros anteriores relevantes directamente en la sesión actual para que el modelo pueda razonar con ellos en contexto.

Use el comando `/load` para traer registros JSONL al contexto de CAI (esto reemplaza la herramienta heredada de carga de 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 imprime la ruta al archivo JSONL de la ejecución actual al inicio (resaltado en naranja), que puedes pasar a /load:

cai-009-logs

Notas heredadas: los mecanismos anteriores de "extensión de memoria" (almacenes episódico/semántico e ingesta fuera de línea) se conservan solo como referencia. Consulta src/cai/agents/memory.py para obtener antecedentes y detalles heredados. Nuestra dirección actual prioriza ICL sobre la memoria persistente.

¿Puedo ampliar las capacidades de CAI usando scripts o información adicional?

Actualmente, CAI admite información basada en texto. Puedes agregar cualquier información adicional sobre el objetivo que estás enfrentando copiándola y pegándola directamente en el prompt del sistema o del usuario.

¿Cómo? Agregándola al prompt del sistema (system_master_template.md) o al prompt del usuario (user_master_template.md). Siempre puedes indicar directamente la ruta al modelo, y este ejecutará cat sobre ella.

¿Cómo funciona la licencia de CAI?

La licencia actual de CAI no restringe su uso para fines de investigación. Eres libre de usar CAI para evaluaciones de seguridad (pentests), para desarrollar funcionalidades adicionales e integrarlo en tus actividades de investigación, siempre que cumplas con las leyes locales.

Si tú o tu organización comienzan a beneficiarse comercialmente de CAI (por ejemplo, ofreciendo servicios de pentesting impulsados por CAI), se requerirá una licencia comercial para ayudar a sostener el proyecto.

CAI en sí mismo no es una iniciativa con fines de lucro. Nuestro objetivo es construir un proyecto de código abierto sostenible. Simplemente pedimos que quienes se beneficien de CAI contribuyan y apoyen nuestro desarrollo continuo.

¡Obtengo un Unable to locate package python3.12-venv al instalar los requisitos previos en mi sistema basado en Debian!

La forma más fácil de solucionarlo es instalar python3.12 desde las fuentes.

Citación

Si deseas citar nuestro trabajo, utiliza lo siguiente (ordenado por fecha de publicación):```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} }

## Agradecimientos

CAI fue desarrollado inicialmente por [Alias Robotics](https://aliasrobotics.com) y cofinanciado por el proyecto acelerador europeo EIC RIS (GA 101161136) - convocatoria HORIZON-EIC-2023-ACCELERATOR-01. Los principios agentivos originales están inspirados en la biblioteca [`swarm`](https://github.com/openai/swarm) de OpenAI y traducidos a prototipos más nuevos. Este proyecto también hace uso de otros bloques de construcción de código abierto relevantes, incluyendo [`LiteLLM`](https://github.com/BerriAI/litellm) y [`phoenix`](https://github.com/Arize-ai/phoenix)

### Colaboraciones Académicas
CAI se beneficia de colaboraciones de investigación en curso con instituciones académicas. Los investigadores interesados en proyectos colaborativos, acceso a conjuntos de datos o licencias académicas deben contactar a [email protected]. Ofrecemos apoyo especial para:
- Proyectos de investigación de doctorado
- Estudios de evaluación comparativa académica
- Iniciativas de educación en seguridad
- Contribuciones de código abierto desde laboratorios de investigación

[^1]: Podría argumentarse que el patrón agentivo de Cadena de Pensamiento es un caso especial del patrón agentivo Jerárquico.
[^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).