Plasma - Plasma AI is a next-generation, AI-powered cyberse

项目说明

Plasma AI

<di="center">
<p>
<a align="center" href="" target="
<img
width="100%"
src="
>
</a>
</p>

A next-generation, AI-powered cybersecurity platform with plasma-enhanced identity

⚡ Plasma-powered security agents • 🛡️ Ad threat detection • 🤖 AI-dri • 🚀 Modern indigo/ theme • 🦜 Parrot OS support

De by De Technologies

---

Plasma AI is a next-generation, AI-powered cybersecurity platform that empowers security professionals with plasma-enhanced offensive and defensi. Plasma AI represents the e of AI Security, featuring ad plasma energy effects and a modern identity while maintaining the battle-tested core that thousands of users trust. Whether you're a security researcher, ethical hacker, IT professional, or organization looking to enhance your security posture, Plasma AI provides the building blocks to create specialized AI agents that can assist with mitigation, discovery, exploitation, and security assessment.

Key Features:

⚡ Plasma-Powered AI: Enhanced with plasma energy effects and modern identity

🤖 300+ AI Models: Support for OpenAI, Anthropic, DeepSeek, Ollama, and more

🔧 Built-in Security Tools: Ready-to-use tools for reconnaissance, exploitation, and pri escalation

🏆 Battle-tested: Proven in HackTheBox CTFs, bug bounties, and real-world security case studies

🎯 Agent-based Architecture: Modular framework design to build specialized agents for different security tasks

🛡️ Guardrails Protection: Built-in defenses against prompt injection and dangerous command execution

📚 Research-oriented: Research foundation to democratize cybersecurity AI for the community

🌟 Ad Effects: Glassmorphism, particle systems, and plasma animations

> [!NOTE]
> Read the technical report: Plasma AI: An Open, Bug Bounty-Ready Cybersecurity Platform with Plasma Enhancement
>
> For further readings, refer to our impact and Plasma AI citation sections.

📊 Research Impact

Pioneered LLM-powered AI Security with PentestGPT, establishing the foundation for the Cybersecurity AI research domain ![arXiv]()

Established the Cybersecurity AI research line with 8 papers and technical reports, with acti collaborations ![arXiv]() ![arXiv]() ![arXiv]() ![arXiv]() ![arXiv]() ![arXiv]() ![arXiv]() ![arXiv]()

Demonstrated 3,600× performance impro o penetration testers in standardized CTF benchmark e ![arXiv]()

Identified CVSS 4.3-7.5 se in production systems through automated security assessment ![arXiv]()

Democratization of AI-empowered research: CAI enables both non-security domain experts and experienced researchers to conduct more efficient discovery, expanding the security research community while empowering small and medium enterprises to conduct autonomous security assessments ![arXiv]()

Systematic e of large language models across both proprietary and open-weight architectures, re <u>substantial gaps</u> between capabilities and empirical cybersecurity performance metrics ![arXiv]()

Established the autonomy levels in cybersecurity and argued about autonomy in the field ![arXiv]()

Collaborati initiatives with international academic institutions focused on de cybersecurity education curricula and training methodologies ![arXiv]()

Contributed a comprehensi framework against prompt injection in AI security agents: de and empirically a multi-layered defense system that addresses the identified prompt injection issues ![arXiv]()

Explord the Cybersecurity of Humanoid Robots with CAI and identified new attack showing how it (a) operates simultaneously as a covert sur node and (b) can be purposed as an acti operations platform ![arXiv]() ![arXiv]()

Moti

:bust_in_silhouette: Why Plasma AI?

The cybersecurity landscape is undergoing a dramatic transformation as AI becomes increasingly integrated into security operations. We predict that by 2028, AI-powered security testing tools will outnumber human pentesters. This shift represents a fundamental change in how we approach cybersecurity challenges. *AI is not just another tool - it's becoming essential for addressing complex security and staying ahead of sophisticated threats. As organizations face more ad cyber attacks, AI-enhanced security testing will be crucial for maintaining robust defenses.*

This work builds upon prior efforts[^4] and similarly, we believe that democratizing access to ad cybersecurity AI tools is vital for the entire security community. That's why we're releasing Plasma AI as an open source framework. Our goal is to empower security researchers, ethical hackers, and organizations to build and deploy powerful AI-dri tools with plasma-enhanced identity and ad effects. By making these capabilities openly a, we aim to level the playing field and ensure that cutting-edge security AI technology isn't limited to well-funded private companies or state actors.

Bug Bounty programs ha a cornerstone of modern cybersecurity, pro a crucial mechanism for organizations to identify and fix in their systems before they can be exploited. These programs ha highly effective at securing both public and private infrastructure, with researchers disco critical that might ha gone unnoticed. CAI is specifically designed to enhance these efforts by pro a lightweight, ergonomic framework for building specialized AI agents that can assist in aspects of Bug Bounty hunting - from initial reconnaissance to and reporting. Our framework aims to augment human expertise with AI capabilities, helping researchers work more efficiently and thoroughly in their quest to make digital systems more secure.

Closed-source alternatives

Cybersecurity AI is a critical field, yet many groups are misguidedly pursuing it through closed-source methods for pure economic return, le similar techniques and building upon existing closed-source (*often third-party owned*) models. This approach not only squanders engineering resources but also represents an economic waste and results in redundant efforts, as they often end up rein the wheel. Here are some of the closed-source initiatives we keep track of and attempting to le genAI and agentic frameworks in cybersecurity AI:

Autonomous Cyber

CrackenAGI

ETHIACK

Horizon3

Irregular

Kindo

Lakera

Mindfort

Mindgard

NDAY Security

Penligent

Runsybil

Selfhack

Sola Security

SQUR

Staris

Sxipher (seems discontinued)

Terra Security

Xint

XBOW

ZeroPath

Zynap

7ai

Installation

Always create a new en to ensure proper dependency installation when updating CAI.

The following subsections provide a more detailed walkthrough on selected popular Operating Systems. Refer to the De section for de install instructions.
For API Keys en check litellm Documentation. LiteLLM Documentation

OS X

Ubuntu 24.04

Parrot OS

Ubuntu 20.04

Windows WSL

Go to the Microsoft page: Here you will find all the instructions to install WSL

From Powershell write: wsl --install

You might run into issues running plasma on ubuntu since some agents assume they are running on a Kali Instance and are not able to find the tools needed.
So as an alternative you can use the docker compose file in the dockerized folder instead. This also works from within wsl if docker is installed.
in that case fetch the dockerized folder (no need for the whole repo) and run from within it.
For API Keys en check litellm Documentation. LiteLLM Documentation

Android

We recommend having at least 8 GB of RAM:

1. First of all, install userland

2. Install Kali minimal in basic options (for free). [Or any other kali option if preferred]

3. Update apt keys like in this example: inside UserLand's Kali terminal execute

:nut_and_bolt: Setup .env file

CAI le the .env file to load configuration at launch. To facilitate the setup, the repo provides an exemplary .en file provides a template for configuring CAI's setup and your LLM API keys to work with desired LLM models.

:warning: Important:

CAI does NOT provide API keys for any model by default. Don't ask us to provide keys, use your own or host your own models.

:warning: Note:

The OPENAI_API_KEY must not be left blank. It should contain either "sk-123" (as a placeholder) or your actual API key. See

:warning: Note:

If you are using alias1 model, make sure that CAI is >0.4.0 and here you have an .en to be able to use it.

🔹 Custom OpenAI Base URL Support

CAI supports configuring a custom OpenAI API base URL via the OPENAI_BASE_URL en . This allows users to redirect API calls to a custom endpoint, such as a proxy or self-hosted OpenAI-compatible service.

Example .env entry configuration:

Or directly from the command line:

:triangular_ruler: Architecture:

CAI focuses on making cybersecurity agent coordination and execution lightweight, highly controllable, and useful for humans. To do so it builds upon 8 pillars: Agents, Tools, Handoffs, Patterns, Turns, Tracing, Guardrails and HITL.

If you want to di into the code, check the following files as a start point for using CAI:

* __init__.py
* cli.py - entrypoint for command line interface
* util.py - utility functions
* agents - Agent implementations
* internal - CAI internal functions (endpoints, metrics, logging, etc.)
* prompts - Agent Prompt Database
* repl - CLI aesthetics and commands
* sdk - CAI command sdk
* tools - agent tools

🔹 Agent

At its core, CAI abstracts its cybersecurity behavior via Agents and agentic Patterns. An Agent in *an intelligent system that interacts with some en*. More technically, within CAI we embrace a robotics-centric definition wherein an agent is anything that can be as a system perceiving its en through sensors, reasoning about its goals and and acting accordingly upon that en through actuators (*adapted* from Russel & Norvig, AI: A Modern Approach). In cybersecurity, an Agent interacts with systems and networks, using peripherals and network interfaces as sensors, reasons accordingly and then executes network actions as if actuators. Correspondingly, in CAI, Agents implement the ReACT (Reasoning and Action) agent model[^3]. For more information, see the example here for the full execution code, and refer to this jupyter notebook for a tutorial on how to use it.

🔹 Tools

Tools let cybersecurity agents take actions by pro interfaces to execute system commands, run security scans, analyze , and interact with target systems and APIs - they are the core capabilities that enable CAI agents to perform security tasks effectively; in CAI, tools include built-in cybersecurity utilities (like LinuxCmd for command execution, WebSearch for OSINT gathering, Code for dynamic script execution, and SSHTunnel for secure remote access), function calling mechanisms that allow integration of any Python function as a security tool, and agent-as-tool functionality that enables specialized security agents (such as reconnaissance or exploit agents) to be used by other agents, creating powerful collaborati workflows without requiring formal handoffs between agents. For more information, please refer to the example here for the complete configuration of custom functions.

You may find different tools. They are grouped in 6 major categories inspired by the security kill chain [^2]:

1. Reconnaissance and weaponization - *reconnaissance* (crypto, listing, etc)
2. Exploitation - *exploitation*
3. Pri escalation - *escalation*
4. Lateral mo - *lateral*
5. Data exfiltration - *exfiltration*
6. Command and control - *control*

🔹 Handoffs

Handoffs allow an Agent to delegate tasks to another agent, which is crucial in cybersecurity operations where specialized expertise is needed for different phases of an engagement. In our framework, Handoffs are implemented as tools for the LLM, where a handoff/transfer function like transfer_to_flag_discriminator enables the ctf_agent to pass control to the flag_discriminator_agent once it believes it has found the flag. This creates a security chain where the first agent handles exploitation and flag discovery, while the second agent specializes in flag , ensuring proper segregation of duties and le specialized capabilities of different models for distinct security tasks. For more information, please refer to the example here for the full execution code.

🔹 Patterns

An agentic Pattern is a *structured design paradigm* in artificial intelligence systems where autonomous or semi-autonomous agents operate within a defined *interaction framework* (the pattern) to achieve a goal. These Patterns specify the organization, coordination, and communication
methods among agents, guiding decision-making, task execution, and delegation.

An agentic pattern (AP) can be formally defined as a tuple:

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

wherein:

\\(A\\) (Agents): A set of autonomous entities, \\( A = \\{a_1, a_2, ..., a_n\\} \\), each with defined roles, capabilities, and internal states.

\\(H\\) (Handoffs): A function \\( H: A \times T \to A \\) that governs how tasks \\( T \\) are transferred between agents based on predefined logic (e.g., rules, negotiation, bidding).

\\(D\\) (Decision Mechanism): A decision function \\( D: S \to A \\) where \\( S \\) represents system states, and \\( D \\) determines which agent takes action at any given time.

\\(C\\) (Communication Protocol): A messaging function \\( C: A \times A \to M \\), where \\( M \\) is a message space, defining how agents share information.

\\(E\\) (Execution Model): A function \\( E: A \times I \to O \\) where \\( I \\) is the input space and \\( O \\) is the output space, defining how agents perform tasks.

When building Patterns, we generall y classify them among one of the following categories, though others exist:

| Agentic Pattern categories | Description |
|--------------------|------------------------|
| Swarm (Decentralized) | Agents share tasks and self-assign responsibilities without a central orchestrator. Handoffs occur dynamically. *An example of a peer-to-peer agentic pattern is the CTF Agentic Pattern, which in a team of agents working together to solve a CTF challenge with dynamic handoffs.* |
| Hierarchical | A top-le (e.g., "PlannerAgent") assigns tasks handoffs to specialized sub-agents. Alternatively, the structure of the agents is harcoded into the agentic pattern with pre-defined handoffs. |
| Chain-of-Thought (Sequential Workflow) | A structured pipeline where Agent A produces an output, hands it to Agent B for reuse or refinement, and so on. Handoffs follow a linear sequence. *An example of a chain-of-thought agentic pattern is the ReasonerAgent, which in a Reasoning-type LLM that provides context to the main agent to solve a CTF challenge with a linear sequence.*[^1] |
| Auction-Based (Competiti) | Agents "bid" on tasks based on priority, capability, or cost. A decision agent e bids and hands off tasks to the best-fit agent. |
| Recursive | A single agent continuously refines its own output, treating itself as both executor and e, with handoffs (internal or external) to itself. *An example of a recursi pattern is the CodeAgent (when used as a recursi), which continuously refines its own output by executing code and updating its own instructions.* |

For more information and examples of common agentic patterns, see the examples folder.

🔹 Turns and Interactions

During the agentic flow (con), we distinguish between interactions and turns.

Interactions are sequential exchanges between one or multiple agents. Each agent executing its logic corresponds with one *interaction*. Since an Agent in CAI generally implements the ReACT agent model[^3], each *interaction* consists of 1) a reasoning step via an LLM inference and 2) act by calling zero-to-n Tools. This is defined inprocess_interaction() in core.py.

Turns: A turn represents a cycle of one ore more interactions which finishes when the Agent (or Pattern) executing returns None, judging there're no further actions to undertake. This is defined in run(), see core.py.

> [!NOTE]
> CAI Agents are not related to Assistants in the Assistants API. They are named similarly for con, but are otherwise completely unrelated. CAI is entirely powered by the Chat Completions API and is hence stateless between calls.

🔹 Tracing

CAI implements AI obser by adopting the OpenTelemetry standard and to do so, it le Phoenix which provides comprehensi capabilities through OpenTelemetry-based instrumentation, allowing you to monitor and analyze your security operations in real-time. This integration enables detailed into agent interactions, tool usage, and attack throughout penetration testing workflows, making it easier to debug complex exploitation chains, track discovery processes, and optimize agent performance for more effecti assessments.


🔹 Guardrails

Guardrails provide a critical security layer for CAI agents, protecting against prompt injection attacks and pre execution of dangerous commands. These guardrails run in parallel to agents, both input and output to ensure safe operation. The framework includes:

Input Guardrails: Detect and block prompt injection attempts before they reach agents, using pattern matching, Unicode homograph detection, and AI-powered analysis

Output Guardrails: agent outputs before execution, pre dangerous commands like reverse shells, fork bombs, or data exfiltration

Multi-layered Defense: Protection at input, processing, and execution stages with tool-le

Base64/Base32 Aware: Automatically decodes and analyzes encoded payloads to detect hidden malicious commands

Configurable: Can be enabled/disabled via CAI_GUARDRAILS en

For detailed implementation, see docs/guardrails.md and docs/cai_prompt_injection.md.

🔹 Human-In-The-Loop (HITL)

CAI delivers a framework for building Cybersecurity AIs with a strong emphasis on *semi-autonomous* operation, as the reality is that fully-autonomous cybersecurity systems remain premature and face significant challenges when tackling complex tasks. While CAI explores autonomous capabilities, we recognize that effecti operations still require human teleoperation pro expertise, judgment, and o in the security process.

Accordingly, the Human-In-The-Loop (HITL) module is a core design principle of CAI, acknowledging that human inter and teleoperation are essential components of responsible security testing. Through the cli.py interface, users can seamlessly interact with agents at any point during execution by simply pressing Ctrl+C. This is implemented across core.py and also in the REPL abstractions REPL.

:rocket: Quickstart

To start CAI after installing it, just type cai in the CLI:

That should initialize CAI and provide a prompt to execute any security task you want to perform. The na bar at the bottom displays important system information. This information helps you understand your en 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:

En

For using private models, you are given a .en file. Copy it and rename it as .env. Fill in your corresponding API keys, and you are ready to use CAI.
<details>
<summary>List of En </summary>

| | Description |
|----------|-------------|
| CTF_NAME | Name of the CTF challenge to run (e.g. "picoctf_static_flag") |
| CTF_CHALLENGE | Specific challenge name within the CTF to test |
| CTF_SUBNET | Network subnet for the CTF container |
| CTF_IP | IP address for the CTF container |
| CTF_INSIDE | Whether to conquer the CTF from within container |
| CAI_MODEL | Model to use for agents |
| CAI_DEBUG | Set debug output level (0: Only tool outputs, 1: debug output, 2: CLI debug output) |
| CAI_BRIEF | Enable/disable brief output mode |
| CAI_MAX_TURNS | Maximum number of turns for agent interactions |
| CAI_TRACING | Enable/disable OpenTelemetry tracing |
| CAI_AGENT_TYPE | Specify the agents to use (boot2root, one_tool...) |
| CAI_STATE | Enable/disable stateful mode |
| CAI_MEMORY | Enable/disable memory mode (episodic, semantic, all) |
| CAI_MEMORY_ONLINE | Enable/disable online memory mode |
| CAI_MEMORY_OFFLINE | Enable/disable offline memory |
| CAI_EN | Add dirs and current env to llm context |
| CAI_MEMORY_ONLINE_INTERVAL | Number of turns between online memory updates |
| CAI_PRICE_LIMIT | Price limit for the con in dollars |
| CAI_REPORT | Enable/disable reporter mode (ctf, nis2, pentesting) |
| CAI_SUPPORT_MODEL | Model to use for the support agent |
| CAI_SUPPORT_INTERVAL | Number of turns between support agent executions |
| CAI_WORKSPACE | Defines the name of the workspace |
| CAI_WORKSPACE_DIR | Specifies the directory path where the workspace is located |
| CAI_GUARDRAILS | Enable/disable guardrails for prompt injection protection (default: true) |

</details>

OpenRouter Integration

The Cybersecurity AI (CAI) platform offers seamless integration with OpenRouter, a unified interface for Large Language Models (LLMs). This integration is crucial for users who wish to le ad AI capabilities in their cybersecurity tasks. OpenRouter acts as a bridge, allowing CAI to communicate with LLMs, thereby enhancing the flexibility and power of the AI agents used within CAI.

To enable OpenRouter support in CAI, you need to configure your en by adding specific entries to your .env file. This setup ensures that CAI can interact with the OpenRouter API, facilitating the use of sophisticated models like Meta-LLaMA. Here’s how you can configure it:

Azure OpenAI

The Cybersecurity AI (CAI) platform integrates seamlessly with Azure OpenAI, enabling organizations to run CAI against enterprise-hosted models (e.g., gpt-4o). This pathway is ideal for teams that must operate within Azure go while le ad model capabilities.
To enable Azure OpenAI support in CAI, configure your en by adding the following entries to your .env. This ensures CAI can reach your Azure deployment endpoint and authenticate correctly.

MCP

CAI supports the Model Context Protocol (MCP) for integrating external tools and services with AI agents. MCP is supported via two transport mechanisms:

1. SSE (Ser Events) - For web-based servers that push updates over HTTP connections:

2. STDIO (Standard Input/Output) - For local inter-process communication:

Once connected, you can add the MCP tools to any agent:

You can list all active MCP connections and their transport types:

De

De is facilitated via VS Code de. To try out our de en, clone the repository, open VS Code and enter de de mode:

!CAI De En

Contributions

If you want to contribute to this project, use Pre-commit before your MR

Optional Requirements: caiextensions

Currently, the extensions are not publicly a as the engineering endeavour to maintain them is significant. Instead, we're making selected custom caiextensions a for partner companies across collaborations.

:information_source: Usage Data Collection

CAI is provided free of charge for researchers. To improve CAI’s detection accuracy and publish open security research, instead of payment for research use cases, we ask you to contribute to the CAI community by allowing usage data collection. This data helps us identify areas for impro, understand how the framework is being used, and prioritize new features. Legal basis of data collection is under Art. 6 (1)(f) GDPR — CAI’s legitimate interest in maintaining and improving security tooling, with Art. 89 safeguards for research. The collected data includes:

Basic system information (OS type, Python )

Username and IP information

Tool usage patterns and performance metrics

Model interactions and token usage statistics

We take your privacy seriously and only collect what's needed to make CAI better. For further info, reach out to research＠aliasrobotics.com. You can disable some of the data collection features via the CAI_TELEMETRY en but we encourage you to keep it enabled and contribute back to research:

Reproduce CI-Setup locally

To simulate the CI/CD pipeline, you can run the following in the Gitlab runner machines:

FAQ

<details><summary>OLLAMA is giving me 404 errors</summary>

Ollama's API in OpenAI mode uses /v1/chat/completions whereas the openai library uses base_url + /chat/completions.

We adopt the latter for o alignment with the gen AI community and empower the former by allowing users to add the v1 themselves via:

See the following issues that treat this topic in more detail:

</details>

<details><summary>Where are all the caiextensions?</summary>

See all caiextensions

</details>

<details><summary>How do I install the report caiextension?</summary>

See here
</details>

<details><summary>How do I set up SSH access for Gitlab?</summary>

Generate a new SSH key

Add the key to the SSH agent

Add the public key to Gitlab
Copy the key and add it to Gitlab under

To it:

</details>

<details><summary>How do I clear Python cache?</summary>

</details>

<details><summary>If host networking is not working with ollama check whether it has been disabled in Docker because you are not signed in</summary>

Docker in OS X beha sometimes. Check if the following message has shown up:

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

Make sure this has been addressed and also that the De is not forwarding the 8000 port (click on x, if necessary in the ports section).

To connection, from within the de:

</details>

<details>
<summary>Run CAI against any target</summary>

!cai-004-first-message

The starting user prompt in this case is: Target IP: 192.168.3.10, perform a full network scan.

The agent started performing a nmap scan. You could either interact with the agent and give it more instructions, or let it run to see what it explores next.
</details>

<details>
<summary>How do I interact with the agent? Type twice CTRL + C </summary>

!cai-005-ctrl-c

If you want to use the HITL mode, you can do it by presssing twice .
This will allow you to interact (prompt) with the agent whenever you want. The agent will not lose the previous context, as it is stored in the history , which is passed to it and any agent that is called. This enables any agent to use the previous information and be more accurate and efficient.
</details>

<details>
<summary> Can I change the model while CAI is running? /model </summary>

Use to change the model.

!cai-007-model-change

</details>

<details>
<summary>How can I list all the agents a? /agent </summary>

Use to list all the agents a.

!cai-010-agents-menu

</details>

<details>
<summary> Where can I list all the en ? /config </summary>

!cai-008-config
</details>

<details>
<summary> How can I monitor context usage and token consumption? /context or /ctx 🚀 CAI PRO </summary>

> ⚡ CAI PRO Exclusi
> The /context command is a exclusively in CAI PRO. To access this feature and unlock ad monitoring capabilities, visit Alias Robotics for more information.

Use (or the short form ) to view your current context window usage and token statistics.

This command displays:

Total context usage (used tokens / max tokens) with percentage

grid representation with the CAI logo showing filled context

Detailed breakdown by category:

- System prompt tokens
- Tool definitions tokens
- Memory/RAG tokens
- User prompts tokens
- Assistant responses tokens
- Tool calls tokens
- Tool results tokens

Free space a

Why this matters: Different models ha context limits (e.g., GPT-4: 128k tokens, Claude: 200k tokens). Monitoring your context usage helps you avoid hitting these limits during long con, which could cause errors or require con truncation.

</details>

<details>
<summary> How to know more about the CLI? /help </summary>

!cai-006-help
</details>

<details>
<summary>How can I trace the whole execution?</summary>
The en CAI_TRACING allows the user to set it to CAI_TRACING=true to enable tracing, or CAI_TRACING=false to disable it.
When CAI is prompted by the first time, the user is provided with two paths, the execution log, and the tracing log.

!cai-009-logs

</details>

<details>
<summary>Can I expand CAI capabilities using previous run logs?</summary>

Yes. Today CAI performs best by relying on In‑Context Learning (ICL). Rather than building long‑term stores, the recommended workflow is to load relevant prior logs directly into the current session so the model can reason with them in context.

Use the /load command to bring JSONL logs into CAI’s context (this replaces the legacy memory-loading tool):

CAI prints the path to the current run’s JSONL log at startup (highlighted in orange), which you can pass to /load:

!cai-009-logs

Legacy notes: earlier “memory extension” mechanisms (episodic/semantic stores and offline ingestion) are retained for reference only. See src/cai/agents/memory.py for background and legacy details. Our current direction prioritizes ICL o memory.

</details>

<details>
<summary>Can I expand CAI capabilities using scripts or extra information?</summary>

Currently, CAI supports text based information. You can add any extra information on the target you are facing by copy-pasting it directly into the system or user prompt.

How? By adding it to the system (system_master_template.md) or the user prompt (user_master_template.md). You can always directly prompt the path to the model, and it will it.
</details>

<details><summary>How CAI licence works?</summary>

CAI’s current license does not restrict usage for research purposes. You are free to use CAI for security assessments (pentests), to develop additional features, and to integrate it into your research acti, as long as you comply with local laws.

If you or your organization start benefiting commercially from CAI (e.g., offering pentesting services powered by CAI), then a commercial license will be required to help sustain the project.

CAI itself is not a profit-seeking initiative. Our goal is to build a sustainable open-source project. We simply ask that those who profit from CAI contribute back and support our ongoing de.

</details>

<details><summary>I get a Unable to locate package python3.12-venv when installing the prerequisites on my debian based system!</summary>

The easiest way to get around this is to simply install python3.12 from source.

</details>

Citation

If you want to cite our work, please use the following (ordered by publication date):

Acknowledgements

CAI was initially de by Alias Robotics and co-funded by the European EIC accelerator project RIS (GA 101161136) - HORIZON-EIC-2023-ACCELERATOR-01 call. The original agentic principles are inspired from OpenAI's swarm library and translated into newer prototypes. This project also makes use of other relevant open source building blocks including LiteLLM, and phoenix

Academic Collaborations

CAI benefits from ongoing research collaborations with academic institutions. Researchers interested in collaborati, dataset access, or academic licenses should contact . We provide special support for:

PhD research projects

Academic benchmarking studies

Security education initiatives

Open-source contributions from research labs

<!-- Footnotes -->
[^1]: Arguably, the Chain-of-Thought agentic pattern is a special case of the Hierarchical agentic pattern.
[^2]: Kamhoua, C. A., Leslie, N. O., & Weisman, M. J. (2018). Game theoretic modeling of ad 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-, V., Liu, P., Li, Y., Xu, Y., ... & Rass, S. (2024). {PentestGPT}: E and harnessing large language models for automated penetration testing. In 33rd USENIX Security Symposium (USENIX Security 24) (pp. 847-864).

项目信息

开发语言：Python

Star 数：18

技术要点

该项目属于防护思路方向的开源资源，代码结构清晰，适合安全研究人员学习参考。项目围绕Plasma AI is a next-generation, AI-powered cybersecurity platform that empowers security professionals with plasma-enhanced offensive and defensive automation.展开，提供了可运行的实现，对理解相关安全机制、工具原理与攻防技术具有较高的研究价值。

从技术实现角度看，此类项目的核心在于对底层原理的深入理解与工程化落地。开发者在研究过程中可以结合官方文档与社区讨论，梳理项目的初始化流程、核心模块职责与数据流转，逐步掌握其中的技术细节与设计思路。

使用与学习建议

1. 下载源码压缩包，解压到本地环境。

2. 根据项目类型准备对应的运行环境与依赖。

3. 按照 README 中的步骤完成配置与部署。

4. 在隔离的测试环境中运行验证，避免影响生产系统。

免责声明

本资源来源于开源社区，仅供安全研究、技术学习与合法授权范围内的攻防演练使用，请勿用于任何非法或侵害他人权益的用途。使用本项目产生的一切后果由使用者自行承担。