IA de Cibersegurança (CAI)

Edição Profissional com tokens alias1 ilimitados | 📊 Ver Benchmarks | 🚀 Saiba Mais

🔓 Edição Comunitária Pesquisa e Aprendizagem · Perfeita para Pesquisadores e Estudantes pip install cai-framework

✅ Gratuita para pesquisa 🤖 Mais de 300 modelos de IA 🌍 Orientada pela comunidade 📚 Código aberto 🔧 Framework extensível

🚀 Edição Profissional Empresarial e Produção · €350/mês · Tokens alias1 Ilimitados

→ Atualizar para PRO

⚡ modelo alias1 - tokens ilimitados ∞ 🚫 Zero recusas - IA sem restrições 🏆 Supera GPT-5 em benchmarks CTF 🛡️ Suporte profissional incluído 🇪🇺 Soberania de dados europeia

CAI PRO com modelo alias1 supera GPT-5 em benchmarks de IA vs IA em cibersegurança | Ver Benchmarks Completos →

-->

A IA de Cibersegurança (CAI) é um framework leve e de código aberto que capacita profissionais de segurança a construir e implantar automação ofensiva e defensiva baseada em IA. A CAI é o framework de facto para Segurança de IA, já utilizado por milhares de usuários individuais e centenas de organizações. Seja você um pesquisador de segurança, hacker ético, profissional de TI ou organização que busca aprimorar sua postura de segurança, a CAI fornece os blocos de construção para criar agentes de IA especializados que podem auxiliar na mitigação, descoberta de vulnerabilidades, exploração e avaliação de segurança.

🔓 Executar CAI sem uma Chave de API Alias (CAI_LICENSE_OFF)

CAI pode ser executado sem uma ALIAS_API_KEY (ou seja, sem uma licença da Alias Robotics) definindo a variável de ambiente CAI_LICENSE_OFF=1.

Quando CAI_LICENSE_OFF é definido como 1, true ou yes:

• A verificação de licença na inicialização é ignorada — nenhuma ALIAS_API_KEY é necessária.
• CAI é executado em modo de código aberto e as operações de atualização visam o pacote público PyPI cai-framework em vez do índice de pacotes privado da Alias.
• Você pode usar qualquer outro provedor de modelo suportado (OpenAI, Anthropic, DeepSeek, Ollama, etc.) configurando CAI_MODEL e a chave de API do provedor correspondente.

Início rápido sem licença:```bash export CAI_LICENSE_OFF=1 cai

Ou em linha:```bash
CAI_LICENSE_OFF=1 cai

Nota: O modelo alias1 ainda requer uma chave ALIAS_API_KEY válida. CAI_LICENSE_OFF apenas contorna a verificação de licença do framework — não concede acesso a modelos hospedados pela Alias.

Funcionalidades Principais:

• 🤖 Mais de 300 Modelos de IA: Suporte para OpenAI, Anthropic, DeepSeek, Ollama e mais
• 🔧 Ferramentas de Segurança Integradas: Ferramentas prontas para reconhecimento, exploração e escalada de privilégios
• 🏆 Testado em Batalha: Comprovado em CTFs do HackTheBox, programas de bug bounty e estudos de caso de segurança reais
• 🎯 Arquitetura Baseada em Agentes: Design modular do framework para construir agentes especializados para diferentes tarefas de segurança
• 🛡️ Proteção com Guardrails: Defesas integradas contra injeção de prompt e execução de comandos perigosos
• 📚 Orientado à Pesquisa: Base de pesquisa para democratizar a IA de cibersegurança para a comunidade

[!NOTE] Leia o relatório técnico: CAI: Uma IA de Cibersegurança Aberta e Pronta para Bug Bounty Uma edição HTML para leitura com figuras e referências é mantida pelo Robot Cybersecurity Lab.

Para leituras adicionais, consulte nossas seções de impacto e citação do CAI.

[!WARNING] ⚠️ O CAI está em desenvolvimento ativo, portanto não espere que funcione perfeitamente. Em vez disso, contribua abrindo uma issue ou enviando um PR.

O acesso a esta biblioteca e o uso das informações, materiais (ou partes deles) não é destinado e é proibido onde tal acesso ou uso viole leis ou regulamentos aplicáveis. Os autores não incentivam nem promovem a adulteração não autorizada de sistemas em funcionamento. Isso pode causar sérios danos humanos e danos materiais.

Os autores do CAI não incentivam nem promovem a adulteração não autorizada de sistemas computacionais. Por favor, não use o código-fonte aqui para crimes cibernéticos. Pentest pelo bem em vez disso. Ao baixar, usar ou modificar este código-fonte, você concorda com os termos do LICENSE e as limitações descritas no arquivo DISCLAIMER.

🔖 Índice

• IA de Cibersegurança (CAI)
• 🔖 Índice
• 🎯 Impacto
• 🏆 Competições e Desafios
• 📊 Impacto na Pesquisa
• 📚 Produtos de Pesquisa: IA de Cibersegurança
• PoCs
• Motivação
• 👤 Por que CAI?
• Princípios éticos por trás do CAI
• Alternativas de código fechado
• Aprenda - Fluência em CAI
• 🔩 Instalar
• OS X
• Ubuntu 24.04
• Ubuntu 20.04
• Windows WSL
• Android
• 🔩 Configurar arquivo .env
• 🔹 Suporte a URL Base Personalizada da OpenAI
• 📐 Arquitetura:
• 🔹 Agente
• 🔹 Ferramentas
• 🔹 Transferências (Handoffs)
• 🔹 Padrões
• 🔹 Turnos e Interações
• 🔹 Rastreamento (Tracing)
• 🔹 Guardrails
• 🔹 Humano-no-Loop (HITL)

🎯 Impacto

🏆 Competições e Desafios

📊 Impacto na Pesquisa

• Pioneirismo em segurança de IA com LLMs usando PentestGPT, estabelecendo a base para o domínio de pesquisa IA de Cibersegurança

• Estabeleceu a linha de pesquisa IA de Cibersegurança com 8 artigos e relatórios técnicos, com colaborações ativas de pesquisa

📚 Produtos de Pesquisa: IA de Cibersegurança

Edições HTML estendidas para leitura: CAI · CAIBench · Robôs humanoides como vetores de ataque · A cibersegurança de um robô humanoide · Hackeando robôs de consumo na era da IA

PoCs

CAI com alias0 em ataques de injeção de mensagens ROS no robô MiR-100	CAI com alias0 na descoberta de vulnerabilidades em API no Mercado Libre

CAI no JWT@PortSwigger CTF — IA de Cibersegurança	CAI no HackableII Boot2Root CTF — IA de Cibersegurança

Mais estudos de caso e PoCs estão disponíveis em https://aliasrobotics.com/case-studies-robot-cybersecurity.php.

Motivação

👤 Por que CAI?

O cenário da cibersegurança está passando por uma transformação dramática à medida que a IA se torna cada vez mais integrada às operações de segurança. Prevemos que até 2028, as ferramentas de teste de segurança baseadas em IA superarão em número os testadores de penetração humanos. Esta mudança representa uma alteração fundamental na forma como abordamos os desafios de cibersegurança. A IA não é apenas mais uma ferramenta - está se tornando essencial para lidar com vulnerabilidades de segurança complexas e ficar à frente de ameaças sofisticadas. À medida que as organizações enfrentam ataques cibernéticos mais avançados, os testes de segurança aprimorados por IA serão cruciais para manter defesas robustas.

Este trabalho se baseia em esforços anteriores[^4] e, da mesma forma, acreditamos que democratizar o acesso a ferramentas avançadas de IA de cibersegurança é vital para toda a comunidade de segurança. É por isso que estamos disponibilizando a IA de Cibersegurança (CAI) como um framework de código aberto. Nosso objetivo é capacitar pesquisadores de segurança, hackers éticos e organizações a construir e implantar ferramentas de segurança poderosas baseadas em IA. Ao disponibilizar essas capacidades abertamente, pretendemos nivelar o campo de atuação e garantir que a tecnologia de IA de segurança de ponta não seja limitada a empresas privadas bem financiadas ou atores estatais.

Os programas de Bug Bounty se tornaram uma pedra angular da cibersegurança moderna, fornecendo um mecanismo crucial para que as organizações identifiquem e corrijam vulnerabilidades em seus sistemas antes que possam ser exploradas. Esses programas se mostraram altamente eficazes na proteção de infraestruturas públicas e privadas, com pesquisadores descobrindo vulnerabilidades críticas que poderiam ter passado despercebidas. O CAI é projetado especificamente para aprimorar esses esforços, fornecendo um framework leve e ergonômico para construir agentes de IA especializados que podem auxiliar em vários aspectos da caça a Bug Bounties - desde o reconhecimento inicial até a validação e relato de vulnerabilidades. Nosso framework visa aumentar a expertise humana com capacidades de IA, ajudando os pesquisadores a trabalhar de forma mais eficiente e completa em sua busca para tornar os sistemas digitais mais seguros.

Princípios éticos por trás do CAI

Você pode estar se perguntando se disponibilizar o CAI em campo aberto dadas suas capacidades e implicações de segurança é ético. Nossa decisão de abrir o código deste framework é guiada por dois princípios éticos centrais:

1. Democratizando a IA de Cibersegurança: Acreditamos que ferramentas avançadas de IA de cibersegurança devem ser acessíveis a toda a comunidade de segurança, não apenas a empresas privadas bem financiadas ou atores estatais. Ao disponibilizar o CAI como um framework de código aberto, pretendemos capacitar pesquisadores de segurança, hackers éticos e organizações a construir e implantar ferramentas de segurança poderosas baseadas em IA, nivelando o campo de atuação na cibersegurança.

2. Transparência nas Capacidades de IA em Segurança: Com base em nossos resultados de pesquisa, compreensão da tecnologia e análise dos principais relatórios técnicos, argumentamos que os atuais fornecedores de LLM estão subestimando suas capacidades de cibersegurança. Isso é extremamente perigoso e enganoso. Ao desenvolver o CAI abertamente, fornecemos um benchmark transparente do que os sistemas de IA realmente podem fazer em contextos de cibersegurança, permitindo decisões mais informadas sobre posturas de segurança.CAI é construído sobre os seguintes princípios fundamentais:

• Framework de IA orientado para cibersegurança: CAI é especificamente projetado para casos de uso de cibersegurança, visando automatizar total ou parcialmente tarefas de segurança ofensiva e defensiva.
• Código aberto, gratuito para pesquisa: CAI é código aberto e gratuito para fins de pesquisa. Nosso objetivo é democratizar o acesso à IA e à Cibersegurança. Para uso profissional ou comercial, incluindo implantações on-premise, suporte técnico dedicado e extensões personalizadas, entre em contato para obter uma licença.
• Leve: CAI é projetado para ser rápido e fácil de usar.
• Design modular e centrado em agentes: CAI opera com base em agentes e padrões agentivos, o que permite flexibilidade e escalabilidade. Você pode adicionar facilmente os agentes e padrões mais adequados para o seu caso de cibersegurança.
• Integração de ferramentas: CAI integra ferramentas já incorporadas e permite que o usuário integre suas próprias ferramentas com sua própria lógica facilmente.
• Registro e rastreamento integrados: usando phoenix, a ferramenta de rastreamento e registro de código aberto para LLMs. Isso fornece ao usuário uma rastreabilidade detalhada dos agentes e sua execução.
• Suporte a Múltiplos Modelos: mais de 300 suportados e capacitados pelo LiteLLM. Os provedores mais populares:
• Anthropic: Claude 3.7, Claude 3.5, Claude 3, Claude 3 Opus
• OpenAI: O1, , , ,

Alternativas de código fechado

A IA de Cibersegurança é um campo crítico, mas muitos grupos estão equivocadamente seguindo-o por meio de métodos de código fechado para puro retorno econômico, utilizando técnicas semelhantes e construindo sobre modelos existentes de código fechado (frequentemente de terceiros). Essa abordagem não apenas desperdiça valiosos recursos de engenharia, mas também representa um desperdício econômico e resulta em esforços redundantes, pois muitas vezes acabam reinventando a roda. Aqui estão algumas das iniciativas de código fechado que acompanhamos e que tentam aproveitar a genAI e frameworks agentivos na IA de Cibersegurança:

• 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

Aprenda - Fluência em CAI

[!NOTE]

O relatório técnico CAI Fluency (arXiv:2508.13588) estabelece estruturas educacionais formais para alfabetização em IA de cibersegurança.

🔩 Instalar

[!NOTE] Usuários da Edição Profissional CAI: Se você possui uma assinatura ativa do CAI Pro, fornecemos guias de instalação dedicados para as versões 0.5 e 0.6. O suporte oficial está disponível para Ubuntu 24.04 (x86_64). As instruções de instalação para outros sistemas operacionais são fornecidas "como estão", sem suporte oficial:

• Guia de Instalação do CAI Pro v0.6
• Guia de Instalação do CAI Pro v0.5

Instalação da Edição Comunitária```bash

pip install cai-framework

Sempre crie um novo ambiente virtual para garantir a instalação adequada das dependências ao atualizar o CAI.

As subseções a seguir fornecem um passo a passo mais detalhado em Sistemas Operacionais populares selecionados. Consulte a seção [Desenvolvimento](#development) para instruções de instalação relacionadas ao desenvolvedor.
Para a sintaxe das variáveis de ambiente das chaves de API, consulte a documentação do litellm. [Documentação do 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

Vá para a página da Microsoft: https://learn.microsoft.com/en-us/windows/wsl/install. Aqui você encontrará todas as instruções para instalar o WSL

No Powershell, escreva: 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

Você pode encontrar problemas ao executar cai no ubuntu, já que alguns agentes presumem que estão sendo executados em uma Kali Instance e não são capazes de encontrar as ferramentas necessárias. 
Então, como alternativa, você pode usar o arquivo docker compose na pasta dockerized. Isso também funciona dentro do wsl se o docker estiver instalado.
Nesse caso, obtenha a pasta dockerized (não precisa de todo o repositório) e execute a partir dela.
Para verificar a sintaxe das variáveis de ambiente de chaves de API, consulte a documentação do litellm. [LiteLLM Documentation](https://docs.litellm.ai/docs/tutorials/installation)```bash
#build and run docker compose Build takes around 20 min.
docker compose build && docker compose up -d

#access cai
docker compose exec cai cai

Android

Recomendamos ter pelo menos 8 GB de RAM:

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

2. Instale o Kali minimal nas opções básicas (gratuitamente). [Ou qualquer outra opção do Kali, se preferir]

3. Atualize as chaves apt como neste exemplo: https://superuser.com/questions/1644520/apt-get-update-issue-in-kali, dentro do terminal Kali do UserLand execute```bash

Get new apt keys

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

Install new apt keys

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

Update APT repository

sudo apt-get update

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

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

Clone CAI's source code

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

Create virtual environment

python3.12 -m venv cai_env

Install the package from the local directory

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

Generate a .env file and set up

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

Launch CAI

cai

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

CAI usa o arquivo `.env` para carregar a configuração na inicialização. Para facilitar a configuração, o repositório fornece um arquivo exemplar [`.env.example`](https://github.com/aliasrobotics/cai/blob/HEAD/.env.example) que fornece um modelo para configurar a configuração do CAI e suas chaves de API LLM para trabalhar com os modelos LLM desejados.

:warning: Importante:

CAI NÃO fornece chaves de API para nenhum modelo por padrão. Não nos peça para fornecer chaves, use as suas próprias ou hospede seus próprios modelos.

:warning: Nota:

A OPENAI_API_KEY não deve ficar em branco. Ela deve conter "sk-123" (como espaço reservado) ou sua chave de API real. Veja https://github.com/aliasrobotics/cai/issues/27.

:warning: Nota:

Se você estiver usando o modelo alias1, certifique-se de que a versão do CAI seja >0.4.0 e aqui você tem um exemplo de .env para poder usá-lo.```bash
OPENAI_API_KEY="sk-1234"
OLLAMA=""
ALIAS_API_KEY="<sk-your-key>"  # note, add yours
CAI_STREAM=False
CAI_MODEL="alias1"

🔹 Suporte a URL Base Personalizada do OpenAI

O CAI suporta configurar uma URL base personalizada da API OpenAI através da variável de ambiente OPENAI_BASE_URL. Isso permite que os usuários redirecionem as chamadas da API para um endpoint personalizado, como um proxy ou serviço compatível com OpenAI auto-hospedado.

Exemplo de configuração de entrada .env:``` OLLAMA_API_BASE="https://custom-openai-proxy.com/v1"

Ou diretamente da linha de comando:```bash
OLLAMA_API_BASE="https://custom-openai-proxy.com/v1" cai

📐 Arquitetura:

A CAI foca em tornar a coordenação e execução de agentes de cibersegurança leve, altamente controlável e útil para os humanos. Para isso, baseia-se em 8 pilares: Agents, Tools, Handoffs, Patterns, Turns, Tracing, Guardrails e HITL.``` ┌───────────────┐ ┌───────────┐ │ HITL │◀─────-───▶│ Turns │ └───────┬───────┘ └───────────┘ │ ▼ ┌───────────┐ ┌───────────┐ ┌───────────┐ ┌───────────┐ │ Patterns │◀──-──▶│ Handoffs │◀──-─▶ │ Agents │◀──-─▶│ LLMs │ └───────────┘ └─────┬─────┘ └─────┬─────┘ └───────────┘ │ │ │ ▼ ┌────────────┐ ┌────┴──────┐ ┌───────────┐ ┌────────────┐ │ Extensions │◀────▶ │ Tracing │ │ Tools │◀──▶ │ Guardrails │ └────────────┘ └───────────┘ └───────────┘ └────────────┘ │ ┌─────────────┬─────┴────┬─────────────┐ ▼ ▼ ▼ ▼ ┌───────────┐┌───────────┐┌────────────┐┌───────────┐ │ LinuxCmd ││ WebSearch ││ Code ││ SSHTunnel │ └───────────┘└───────────┘└────────────┘└───────────┘

Se você quiser se aprofundar no código, verifique os seguintes arquivos como ponto de partida para usar o 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) - ponto de entrada para interface de linha de comando
* [util.py](https://github.com/aliasrobotics/cai/blob/main/src/cai/util.py) - funções utilitárias
* [agents](https://github.com/aliasrobotics/cai/blob/main/src/cai/agents) - Implementações de Agent
* [internal](https://github.com/aliasrobotics/cai/blob/main/src/cai/internal) - funções internas do CAI (endpoints, métricas, logging, etc.)
* [prompts](https://github.com/aliasrobotics/cai/blob/main/src/cai/prompts) - Banco de Dados de Prompts do Agent
* [repl](https://github.com/aliasrobotics/cai/blob/main/src/cai/repl) - estética e comandos da CLI
* [sdk](https://github.com/aliasrobotics/cai/blob/main/src/cai/sdk) - sdk de comandos do CAI
* [tools](https://github.com/aliasrobotics/cai/tree/main/src/cai/tools) - ferramentas de agent

### 🔹 Agent

No seu núcleo, o CAI abstrai seu comportamento de cibersegurança através de `Agents` e `Padrões` agentivos. Um Agent é *um sistema inteligente que interage com algum ambiente*. Mais tecnicamente, dentro do CAI adotamos uma definição centrada em robótica na qual um agente é qualquer coisa que pode ser vista como um sistema que percebe seu ambiente através de sensores, raciocina sobre seus objetivos e age de acordo com esse ambiente através de atuadores (*adaptado* de Russel & Norvig, AI: A Modern Approach). Em cibersegurança, um `Agent` interage com sistemas e redes, usando periféricos e interfaces de rede como sensores, raciocina adequadamente e então executa ações de rede como se fossem atuadores. Correspondentemente, no CAI, `Agents` implementam o modelo de agente `ReACT` (Raciocínio e Ação)[^3]. Para mais informações, veja o [exemplo aqui](https://github.com/aliasrobotics/cai/blob/main/examples/basic/hello_world.py) para o código de execução completo, e consulte este [jupyter notebook](https://github.com/aliasrobotics/cai/blob/main/fluency/my-first-hack/my_first_hack.ipynb) para um tutorial sobre como usá-lo.```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)

🔹 Ferramentas

Ferramentas permitem que agentes de cibersegurança realizem ações ao fornecer interfaces para executar comandos do sistema, executar varreduras de segurança, analisar vulnerabilidades e interagir com sistemas alvo e APIs - elas são as capacidades centrais que permitem que agentes CAI realizem tarefas de segurança de forma eficaz; no CAI, as ferramentas incluem utilitários de cibersegurança integrados (como LinuxCmd para execução de comandos, WebSearch para coleta de OSINT, Code para execução dinâmica de scripts e SSHTunnel para acesso remoto seguro), mecanismos de chamada de função que permitem a integração de qualquer função Python como uma ferramenta de segurança, e funcionalidade agente-como-ferramenta que permite que agentes de segurança especializados (como agentes de reconhecimento ou exploração) sejam usados por outros agentes, criando poderosos fluxos de trabalho colaborativos de segurança sem exigir handoffs formais entre agentes. Para mais informações, consulte o exemplo aqui para a configuração completa de funções 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)

Você pode encontrar diferentes [tools](https://github.com/aliasrobotics/cai/blob/HEAD/tools). Eles estão agrupados em 6 categorias principais inspiradas pela cadeia de kill de segurança [^2]:

1. Reconhecimento e weaponização - *reconhecimento* (cripto, listagem, etc)
2. Exploração - *exploração*
3. Escalonamento de privilégios - *escalonamento*
4. Movimento lateral - *lateral*
5. Exfiltração de dados - *exfiltração*
6. Comando e controle - *controle*

### 🔹 Handoffs

`Handoffs` permitem que um `Agent` delegue tarefas a outro agente, o que é crucial em operações de cibersegurança onde expertise especializada é necessária para diferentes fases de um engajamento. Em nossa estrutura, `Handoffs` são implementados como ferramentas para o LLM, onde uma **função de handoff/transferência** como `transfer_to_flag_discriminator` permite que o `ctf_agent` passe o controle para o `flag_discriminator_agent` assim que acreditar ter encontrado a flag. Isso cria uma cadeia de validação de segurança onde o primeiro agente lida com exploração e descoberta de flags, enquanto o segundo agente se especializa em verificação de flags, garantindo a segregação adequada de funções e aproveitando capacidades especializadas de diferentes modelos para tarefas de segurança distintas. Para mais informações, consulte o [exemplo aqui](https://github.com/aliasrobotics/cai/blob/main/examples/cai/agent_patterns/handoffs.py) para o código de execução 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

Um Pattern agêntico é um paradigma de design estruturado em sistemas de inteligência artificial onde agentes autônomos ou semi-autônomos operam dentro de uma estrutura de interação definida (o padrão) para alcançar um objetivo. Esses Patterns especificam os métodos de organização, coordenação e comunicação entre os agentes, orientando a tomada de decisão, execução de tarefas e delegação.

Um padrão agêntico (AP) pode ser formalmente definido como uma tupla:

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

onde:

• \(A\) (Agentes): Um conjunto de entidades autônomas, \( A = \{a_1, a_2, ..., a_n\} \), cada uma com papéis, capacidades e estados internos definidos.
• \(H\) (Handoffs): Uma função \( H: A \times T \to A \) que governa como as tarefas \( T \) são transferidas entre agentes com base em lógica predefinida (ex.: regras, negociação, licitação).
• \(D\) (Mecanismo de Decisão): Uma função de decisão \( D: S \to A \) onde \( S \) representa estados do sistema, e \( D \) determina qual agente age em um determinado momento.
• \(C\) (Protocolo de Comunicação): Uma função de mensagens \( C: A \times A \to M \), onde \( M \) é um espaço de mensagens, definindo como os agentes compartilham informações.
• \(E\) (Modelo de Execução): Uma função \( E: A \times I \to O \) onde \( I \) é o espaço de entrada e \( O \) é o espaço de saída, definindo como os agentes executam tarefas.

Ao construir Patterns, geralmente os classificamos em uma das seguintes categorias, embora outras existam:

Para mais informações e exemplos de patterns agênticos comuns, veja a pasta de exemplos.

🔹 Turns and Interactions

Durante o fluxo agêntico (conversa), distinguimos entre interações e turnos.

• Interações são trocas sequenciais entre um ou mais agentes. Cada agente executando sua lógica corresponde a uma interação. Como um Agent no CAI geralmente implementa o modelo de agente ReACT[^3], cada interação consiste em: 1) uma etapa de raciocínio via inferência de LLM e 2) agir chamando zero a Tools. Isso é definido em process_interaction() em core.py.
• Turnos: Um turno representa um ciclo de uma ou mais interações que termina quando o Agent (ou Pattern) em execução retorna None, julgando que não há mais ações a serem realizadas. Isso é definido em run(), veja core.py.

[!NOTE] Os Agentes CAI não estão relacionados aos Assistentes na API de Assistentes. Eles são nomeados de forma similar por conveniência, mas são completamente não relacionados. A CAI é totalmente alimentada pela API de Chat Completions e, portanto, sem estado entre chamadas.

🔹 Tracing

A CAI implementa observabilidade de IA adotando o padrão OpenTelemetry e, para isso, utiliza o Phoenix que fornece capacidades abrangentes de rastreamento através de instrumentação baseada em OpenTelemetry, permitindo monitorar e analisar suas operações de segurança em tempo real. Essa integração possibilita visibilidade detalhada nas interações dos agentes, uso de ferramentas e vetores de ataque em fluxos de teste de penetração, facilitando a depuração de cadeias de exploração complexas, rastreamento de processos de descoberta de vulnerabilidades e otimização do desempenho dos agentes para avaliações de segurança mais eficazes.

🔹 Guardrails

Os Guardrails fornecem uma camada de segurança crítica para os agentes CAI, protegendo contra ataques de injeção de prompt e prevenindo a execução de comandos perigosos. Esses guardrails são executados em paralelo aos agentes, validando tanto a entrada quanto a saída para garantir operação segura. O framework inclui:

• Guardrails de Entrada: Detectam e bloqueiam tentativas de injeção de prompt antes que atinjam os agentes, usando correspondência de padrões, detecção de homógrafos Unicode e análise alimentada por IA
• Guardrails de Saída: Validam saídas dos agentes antes da execução, prevenindo comandos perigosos como shells reversos, bombas de fork ou exfiltração de dados
• Defesa em Múltiplas Camadas: Proteção nos estágios de entrada, processamento e execução com validação em nível de ferramenta
• Consciente de Base64/Base32: Decodifica e analisa automaticamente payloads codificados para detectar comandos maliciosos ocultos
• Configurável: Pode ser ativado/desativado via variável de ambiente CAI_GUARDRAILS

Para implementação detalhada, veja docs/guardrails.md e docs/cai_prompt_injection.md.

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

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

A CAI fornece uma estrutura para construir IAs de Cibersegurança com forte ênfase em operação *semi-autônoma*, pois a realidade é que sistemas de cibersegurança **totalmente autônomos** ainda são prematuros e enfrentam desafios significativos ao lidar com tarefas complexas. Embora a CAI explore capacidades autônomas, reconhecemos que operações de segurança eficazes ainda requerem teleoperação humana, fornecendo expertise, julgamento e supervisão no processo de segurança.

Dessa forma, o módulo Human-In-The-Loop (`HITL`) é um princípio central de design da CAI, reconhecendo que a intervenção humana e a teleoperação são componentes essenciais de testes de segurança responsáveis. Através da interface `cli.py`, os usuários podem interagir perfeitamente com os agentes em qualquer ponto durante a execução, simplesmente pressionando `Ctrl+C`. Isso é implementado em [core.py](https://github.com/aliasrobotics/cai/blob/HEAD/cai/core.py) e também nas abstrações REPL [REPL](https://github.com/aliasrobotics/cai/blob/HEAD/cai/repl).

## :rocket: Início Rápido

Para iniciar a CAI após instalá-la, basta digitar `cai` no 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>

Isso deve inicializar o CAI e fornecer um prompt para executar qualquer tarefa de segurança que você desejar. A barra de navegação na parte inferior exibe informações importantes do sistema. Essas informações ajudam você a entender seu ambiente enquanto trabalha com o CAI.

Aqui está um vídeo de demonstração rápido para ajudá-lo a começar com o CAI. Vamos percorrer os passos básicos — desde a inicialização da ferramenta até a execução da sua primeira tarefa com IA no terminal. Seja você um iniciante ou apenas curioso, este guia mostrará como é fácil começar a usar o CAI.

A partir daqui, digite CAI e comece seu exercício de segurança. A melhor maneira de aprender é pelo exemplo:

Variáveis de Ambiente

Para usar modelos privados, você recebe um arquivo .env.example. Copie-o e renomeie-o como .env. Preencha suas chaves de API correspondentes e você estará pronto para usar o CAI.

Lista de Variáveis de Ambiente

Integração OpenRouter

A plataforma Cybersecurity AI (CAI) oferece integração perfeita com o OpenRouter, uma interface unificada para Grandes Modelos de Linguagem (LLMs). Essa integração é crucial para usuários que desejam aproveitar recursos avançados de IA em suas tarefas de segurança cibernética. O OpenRouter atua como uma ponte, permitindo que o CAI se comunique com vários LLMs, aumentando assim a flexibilidade e o poder dos agentes de IA usados dentro do CAI.

Para habilitar o suporte ao OpenRouter no CAI, você precisa configurar seu ambiente adicionando entradas específicas ao seu arquivo .env. Essa configuração garante que o CAI possa interagir com a API do OpenRouter, facilitando o uso de modelos sofisticados como Meta-LLaMA. Veja como você pode configurá-lo:```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

A plataforma Cybersecurity AI (CAI) integra-se perfeitamente com o Azure OpenAI, permitindo que as organizações executem o CAI em modelos hospedados na empresa (por exemplo, gpt-4o). Este caminho é ideal para equipas que precisam operar dentro da governança do Azure enquanto aproveitam as capacidades avançadas dos modelos.
Para ativar o suporte ao Azure OpenAI no CAI, configure o seu ambiente adicionando as seguintes entradas ao seu ficheiro .env. Isto garante que o CAI consiga alcançar o seu endpoint de implantação do Azure e autenticar corretamente.```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

O CAI suporta o Model Context Protocol (MCP) para integrar ferramentas e serviços externos com agentes de IA. O MCP é suportado por meio de dois mecanismos de transporte:

1. SSE (Server-Sent Events) - Para servidores baseados na web que enviam atualizações através de conexões HTTP:```bash CAI>/mcp load http://localhost:9876/sse burp

2. **STDIO (Standard Input/Output)** - Para comunicação local entre processos:```bash
CAI>/mcp load stdio myserver python mcp_server.py

Uma vez conectado, você pode adicionar as ferramentas MCP a qualquer 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

Você pode listar todas as conexões MCP ativas e seus tipos de transporte:```bash
CAI>/mcp list

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

Desenvolvimento

O desenvolvimento é facilitado por ambientes de desenvolvimento do VS Code. Para experimentar o nosso ambiente de desenvolvimento, clone o repositório, abra o VS Code e entre no modo de contêiner de desenvolvimento:

Contribuições

Se você quiser contribuir para este projeto, use Pre-commit antes do seu MR```bash pip install pre-commit pre-commit # files staged pre-commit run --all-files # all files

### Requisitos Opcionais: caiextensions

Atualmente, as extensões não estão disponíveis publicamente, pois o esforço de engenharia para mantê-las é significativo. Em vez disso, estamos disponibilizando extensões caiextensions personalizadas selecionadas para empresas parceiras em colaborações.

### :information_source: Coleta de Dados de Uso

O CAI é fornecido gratuitamente para pesquisadores. Para melhorar a precisão de detecção do CAI, avançar a pesquisa aberta em segurança e desenvolver e treinar modelos futuros, pedimos que você contribua com a comunidade CAI permitindo a coleta de dados de uso. Esses dados nos ajudam a identificar áreas de melhoria, entender como a estrutura está sendo usada, priorizar novos recursos e apoiar os esforços de treinamento e avaliação de modelos.

A base legal para a coleta de dados é o Art. 6 (1)(f) do GDPR — o interesse legítimo do CAI em manter, melhorar e avançar ferramentas e pesquisas de segurança — com as salvaguardas do Art. 89 aplicadas para fins de pesquisa.

Os dados coletados incluem:

- Informações básicas do sistema (tipo de SO, versão do Python)
- Informações de nome de usuário e IP
- Padrões de uso da ferramenta e métricas de desempenho
- Interações do modelo e estatísticas de uso de tokens

Levamos sua privacidade a sério e coletamos apenas o necessário para melhorar o CAI, apoiar a pesquisa e treinar e avaliar modelos de forma responsável. Para mais informações, entre em contato com research＠aliasrobotics.com. Você pode desativar alguns recursos de coleta de dados através da variável de ambiente `CAI_TELEMETRY`, embora incentivemos que a mantenha ativada para contribuir com a pesquisa contínua e o desenvolvimento de modelos:```bash
CAI_TELEMETRY=False cai

Reproduzir CI-Setup localmente

Para simular o pipeline de CI/CD, você pode executar o seguinte nas máquinas de runner do Gitlab:```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
 O OLLAMA está me dando erros 404 

A API do Ollama no modo OpenAI usa `/v1/chat/completions` enquanto a biblioteca `openai` usa `base_url` + `/chat/completions`.

Adotamos este último para alinhamento geral com a comunidade de IA generativa e capacitamos o primeiro permitindo que os usuários adicionem o `v1` por conta própria através de:```bash
OLLAMA_API_BASE=http://IP:PORT/v1

Veja as seguintes issues que tratam deste tópico em mais detalhes:

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

Onde estão todas as caiextensions?

Veja todas as caiextensions

Como instalo a caiextension de relatório?

Veja aqui

Como configuro acesso SSH para o Gitlab?

Gere uma nova chave SSH```bash ssh-keygen -t ed25519

Adicione a chave ao agente SSH```bash
ssh-add ~/.ssh/id_ed25519

Adicione a chave pública ao Gitlab

Copie a chave e adicione-a ao Gitlab em https://gitlab.com/-/user_settings/ssh_keys```bash cat ~/.ssh/id_ed25519.pub

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

Como limpar o cache do Python?```bash find . -name "*.pyc" -delete && find . -name "pycache" -delete

Se o host networking não estiver funcionando com o ollama, verifique se ele foi desabilitado no Docker porque você não está logado

O Docker no OS X às vezes se comporta de forma estranha. Verifique se a seguinte mensagem apareceu:

*O host networking foi desabilitado porque você não está logado. Faça login para habilitá-lo*.

Certifique-se de que isso foi resolvido e também que o Dev Container não está encaminhando a porta 8000 (clique em x, se necessário, na seção de portas).

Para verificar a conexão, de dentro do devcontainer do VSCode:```bash
curl -v http://host.docker.internal:8000/api/version

Execute CAI contra qualquer alvo

cai-004-first-message

O prompt inicial do usuário neste caso é: IP alvo: 192.168.3.10, realize uma varredura completa de rede.

O agente começou a realizar uma varredura nmap. Você pode interagir com o agente e dar mais instruções, ou deixá-lo executar para ver o que ele explora em seguida.

Como interajo com o agente? Digite duas vezes CTRL + C

cai-005-ctrl-c

Se quiser usar o modo HITL, pode fazê-lo pressionando duas vezes Ctrl + C. Isso permitirá que você interaja (dê comandos) com o agente sempre que desejar. O agente não perderá o contexto anterior, pois ele é armazenado na variável history, que é passada para ele e para qualquer agente que seja chamado. Isso permite que qualquer agente use as informações anteriores e seja mais preciso e eficiente.

Posso alterar o modelo enquanto o CAI está em execução? /model

Use /model para alterar o modelo.

cai-007-model-change

Como listar todos os agentes disponíveis? /agent

Use /agent para listar todos os agentes disponíveis.

cai-010-agents-menu

Onde posso listar todas as variáveis de ambiente? /env

cai-008-config

Como posso monitorar o uso de tokens e custos?

Use /cost no REPL para gastos da sessão e estatísticas de tokens, /compact quando as conversas se tornarem longas, e (no modo TUI) os indicadores de custo e modelo por terminal na interface.```bash CAI> /cost

Consulte a [referência de comandos da CLI](https://github.com/aliasrobotics/cai/blob/HEAD/docs/cli/commands_reference.md) para a lista completa de comandos.
 
 

Como saber mais sobre a CLI? /help 

cai-006-help
 

 
Como posso rastrear toda a execução? 
A variável de ambiente `CAI_TRACING` permite que o usuário a defina como `CAI_TRACING=true` para ativar o rastreamento, ou `CAI_TRACING=false` para desativá-lo.
Quando o CAI é iniciado pela primeira vez, o usuário recebe dois caminhos: o log de execução e o log de rastreamento.

cai-009-logs

 

 
Posso expandir as capacidades do CAI usando logs de execuções anteriores? 

Sim. Atualmente, o CAI funciona melhor ao depender do Aprendizado em Contexto (ICL). Em vez de construir armazenamentos de longo prazo, o fluxo de trabalho recomendado é carregar logs relevantes de execuções anteriores diretamente na sessão atual, para que o modelo possa raciocinar com eles em contexto.

Use o comando `/load` para trazer logs JSONL para o contexto do CAI (isso substitui a ferramenta de carregamento de memória legada):```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 o caminho para o log JSONL da execução atual na inicialização (destacado em laranja), que você pode passar para /load:

cai-009-logs

Notas legadas: mecanismos anteriores de “extensão de memória” (armazenamentos episódico/semântico e ingestão offline) são mantidos apenas para referência. Veja src/cai/agents/memory.py para contexto e detalhes legados. Nossa direção atual prioriza ICL sobre memória persistente.

Can I expand CAI capabilities using scripts or extra information?

Atualmente, o CAI suporta informações baseadas em texto. Você pode adicionar qualquer informação extra sobre o alvo que está enfrentando copiando e colando diretamente no prompt do sistema ou do usuário.

Como? Adicionando ao sistema (system_master_template.md) ou ao prompt do usuário (user_master_template.md). Você sempre pode passar diretamente o caminho para o modelo, e ele executará cat.

Como funciona a licença do CAI?

A licença atual do CAI não restringe o uso para fins de pesquisa. Você está livre para usar o CAI para avaliações de segurança (pentests), para desenvolver funcionalidades adicionais e para integrá-lo em suas atividades de pesquisa, desde que cumpra as leis locais.

Se você ou sua organização começarem a se beneficiar comercialmente do CAI (por exemplo, oferecendo serviços de pentest baseados no CAI), então uma licença comercial será necessária para ajudar a sustentar o projeto.

O CAI em si não é uma iniciativa com fins lucrativos. Nosso objetivo é construir um projeto de código aberto sustentável. Simplesmente pedimos que aqueles que lucram com o CAI contribuam de volta e apoiem nosso desenvolvimento contínuo.

Recebo um Unable to locate package python3.12-venv ao instalar os pré-requisitos no meu sistema baseado em Debian!

A maneira mais fácil de contornar isso é simplesmente instalar o python3.12 a partir do código fonte.

Citation

Se você quiser citar nosso trabalho, por favor, use o seguinte (ordenado por data de publicação):```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} }

## Agradecimentos

A CAI foi inicialmente desenvolvida pela [Alias Robotics](https://aliasrobotics.com) e cofinanciada pelo projeto acelerador europeu EIC RIS (GA 101161136) - chamada HORIZON-EIC-2023-ACCELERATOR-01. Os princípios agentivos originais são inspirados na biblioteca [`swarm`](https://github.com/openai/swarm) da OpenAI e traduzidos em protótipos mais recentes. Este projeto também faz uso de outros blocos de construção de código aberto relevantes, incluindo [`LiteLLM`](https://github.com/BerriAI/litellm) e [`phoenix`](https://github.com/Arize-ai/phoenix)

### Colaborações Académicas
A CAI beneficia de colaborações de investigação contínuas com instituições académicas. Investigadores interessados em projetos colaborativos, acesso a conjuntos de dados, ou licenças académicas devem contactar [email protected]. Oferecemos apoio especial para:
- Projetos de investigação de doutoramento
- Estudos de benchmarking académico
- Iniciativas de educação em segurança
- Contribuições de código aberto de laboratórios de investigação

 
[^1]: Pode-se argumentar que o padrão agentivo Chain-of-Thought é um caso especial do padrão agentivo Hierárquico.
[^2]: Kamhoua, C. A., Leslie, N. O., & Weisman, M. J. (2018). Modelagem teórica de jogos de ameaça persistente avançada na Internet das Coisas. Journal of Cyber Security and Information Systems.
[^3]: Yao, S., Zhao, J., Yu, D., Du, N., Shafran, I., Narasimhan, K., & Cao, Y. (2023, Janeiro). React: Sinergizando raciocínio e ação em modelos de linguagem. 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}: Avaliando e aproveitando grandes modelos de linguagem para testes de penetração automatizados. In 33rd USENIX Security Symposium (USENIX Security 24) (pp. 847-864).