LeoAI: an AI-driven post-exploitation console with Java and PHP Puppet runtimes
An AI-driven, all-in-one post-exploitation management platform with deep LLM agent integration, ready to use out of the box.
At a glance
- What is it?
- LeoAI is a GPL-3.0 Spring Boot platform that puts host management, a Puppet operations console and LLM agents in one web workbench. It is built for authorised red team work, and the documentation is explicit about what it needs on the target.
- Who is it for?
- Adopt LeoAI if you run authorised red team engagements and want host assets, a Puppet console and LLM-driven task planning in one Spring Boot workbench, and if you can run Java 17 or later on the platform side. Do not adopt it if you need a supported upgrade path from an older deployment: the README states v1.0.0 is a fresh-install baseline and that old data directories, Component caches and generated artefacts are not upgrade inputs.
- Can I use it commercially?
- Yes, with conditions. GPL-3.0 is a copyleft licence: if you distribute software that includes it, you must release that software's source code under the same licence. Running it internally without distributing it does not trigger that obligation.
- Is it still maintained?
- Yes. The repository last received commits 4 days ago.
- What is it written in?
- Mainly Java, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 19, 2026, and from our analysis. They are not legal advice.
Star history
- cha0upup/LeoAI333 ★ · +27
| Repository | 2026-09-21 | 2026-11-19 |
|---|---|---|
| cha0upup/LeoAI | 306 | 333 |
27 Stars in the last 59 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
What LeoAI is for, and the operator it assumes
LeoAI targets authorised red team and security research engagements. The README frames it as a post-exploitation and host coordination platform, and the feature set backs that up: a host asset directory, online and cached sessions, a console of modular tools, a shell and memory-shell builder, and an AI layer that can plan and execute tasks. It is not a scanner and not a vulnerability manager. The product assumes you already have access to a host and now need somewhere to manage that access, the operators using it, and the evidence it produces.
The team features make the intended user clearer. Hosts can be shared between team members with controlled permissions, operations are audited, and AI activity is audited separately. That is a workbench for a group running an engagement together, not a single-operator script collection. The same design shows in the host directory, which tracks connection and update state across online sessions and offline caches rather than treating each session as disposable.
The PuppetRuntimeModule SPI and how the two runtimes stay equal
The architectural decision that shapes everything else is that Java and PHP are treated as equal Puppet runtimes rather than one being the real implementation and the other a compatibility shim. The shared modules define the protocol, session handling and capability contracts. Concrete implementations live in javacore and phpcore, and the web module performs final assembly. The README describes the contract as a single PuppetRuntimeModule SPI with a Capability contract and a shared RPC response protocol, so upper-layer services work against declared capabilities rather than against a specific runtime.
That matters operationally because the console is assembled from the runtime profile a node reports. A PHP node that lacks a PDO driver for a given database simply does not advertise that capability, and the interface reflects it. The README is direct about the dependencies: database work needs the matching PDO driver, compression needs ZipArchive, and persistent proxy or tunnel workers need at least one of shell_exec, exec or popen. Java Puppet uses ProcessBuilder and PTY or pipe sessions; PHP Puppet uses proc_open with a Python PTY or command backend. Both expose the same file, database, network and discovery surfaces on paper, but the PHP side is bounded by what the host's PHP build actually enables.
Platform AI, Puppet AI, and where the tools actually run
There are two distinct agent roles. Platform AI analyses and dispatches work. Puppet AI runs inside a target session and calls tools with that session's context. The README states that platform AI can select a target Puppet, hand it a task, watch sub-task status and execution progress from the platform session, and receive the final deliverable. Node-level AI returns execution progress continuously and accumulates reconnaissance results into context.
The implementation is built on LangChain4j 1.16.1, with multi-turn tool calling and parallel execution. The README claims more than 100 atomic tools spanning command execution, files, network, credentials, scanning, HTTP requests, databases, scripting and plugins. Model support covers OpenAI, Qwen, DeepSeek and Claude, with runtime switching, and the README says the context window is adapted dynamically up to 1M with automatic compression of history. Treat the 1M figure as a ceiling that depends on which model you point it at, not a property of the platform. Skills are prompt sets for two scopes, puppet-node and platform, and the skill manager lets you view, edit, tag, enable, disable, search, import and export them with changes taking effect without a restart.
Running LeoAI with docker-compose and reaching the console
The repository ships a Dockerfile and a docker-compose.yml. The compose file builds an image whose runtime base and JAR source are both build arguments, so you can pin or override them. Note that the compose default JAR_URL points at v2.1.1 while the Dockerfile's own default points at v2.1.0; set JAR_URL explicitly rather than relying on either default.
services:
leoai:
build:
context: .
args:
RUNTIME_IMAGE: ${RUNTIME_IMAGE:-eclipse-temurin:17-jre}
JAR_URL: ${JAR_URL:-https://github.com/cha0upup/LeoAI/releases/download/v2.1.1/LeoAi-2.1.1.jar}
ports:
- "${LEOAI_PORT:-8082}:8082"The container listens on port 8082 and persists state in a named volume. The Spring datasource and the virtual file system root are set through environment variables, and the Dockerfile declares /app/data as the volume and runs the process as a non-root leoai user.
environment:
LEO_PLUGIN_ENCRYPT_KEY: ${LEO_PLUGIN_ENCRYPT_KEY:-ikunikunikunikun}
LEO_DATABASE_MASTER_KEY: ${LEO_DATABASE_MASTER_KEY:-}
SPRING_DATASOURCE_URL: jdbc:sqlite:/app/data/data.db
VFSPATH: /app/data/root
JAVA_OPTS: ${JAVA_OPTS:-}
volumes:
- leoai-data:/app/dataTwo keys deserve attention before you start. LEO_PLUGIN_ENCRYPT_KEY has a default value of ikunikunikunikun in the compose file, which is a placeholder you should replace. LEO_DATABASE_MASTER_KEY defaults to empty. The README states that first startup creates the SQLite database, base configuration and an administrator account, and that the first login forces a password change. If you prefer to run the JAR directly, the README names the release artefact as LeoAi-1.0.0.jar for the v1.0.0 line, so check the release you are actually deploying rather than copying that filename.
Where LeoAI is the wrong tool
The upgrade story is the sharpest limitation. The README states that v1.0.0 was released as a fresh installation baseline and that when deploying a formal version you should use a new data directory, because data files, Component caches and generated artefacts from older test versions are not treated as upgrade inputs. If you are running a long engagement and expect to patch the platform in place, that is a real constraint, not a footnote. Plan for export and re-import of what matters rather than an in-place migration.
PHP capability is the second boundary. The runtime is a PHP 5.6+ single-file HTTP entry point, and what it can do depends on the extensions and system functions the target exposes. A hardened PHP build without ZipArchive, without a PDO driver, or with shell_exec disabled will present a much smaller console than the capability table suggests. The README documents this dependency explicitly, which is better than most projects manage, but it means the feature matrix is a maximum rather than a guarantee. Finally, the whole platform is aimed at post-exploitation. If your task is external reconnaissance or asset discovery before any foothold exists, the host directory and session model have nothing to attach to.
How LeoAI differs from Cobalt Strike and Metasploit
LeoAI sits in the same operational slot as Cobalt Strike or a Metasploit session manager, but the differences are structural rather than cosmetic. Cobalt Strike centres on a Beacon with a malleable C2 profile; LeoAI centres on a Puppet runtime that reports a capability profile, and the console is assembled from that profile. That is why the same platform can drive a Java agent and a PHP entry point without the operator switching tools.
Metasploit's model is a module catalogue with sessions attached to exploits. LeoAI's model is a host asset directory with sessions, offline caches and HostId switching, where one node can manage several internal hosts. The AI layer is the other split: neither Cobalt Strike nor Metasploit ships an LLM agent that plans multi-step post-exploitation tasks and delegates to a node-level agent, and LeoAI's audit trail covers AI activity as a separate category. The trade-off is maturity and ecosystem. Cobalt Strike and Metasploit have years of third-party tooling and documented operational practice behind them; LeoAI is at v2.0.2 with a fresh-install baseline behind it.
Licence and the cost of keeping it current
LeoAI is GPL-3.0. That is a copyleft licence, so if you modify and distribute the platform, or ship a derivative work, the GPL's source-availability terms apply to the whole derivative. Running it internally for an engagement is a different question from redistributing a modified build to a client, and the licence text is the authority here, not a summary. The repository includes a SECURITY.md and a CONTRIBUTING.md, so there is a stated route for reporting issues and contributing changes.
Maintenance looks current: the last push to main was on 2026-09-14, and releases v2.0.2, v2.0.0 and v1.0.1 landed between 2026-07-24 and 2026-08-17. The upgrade cost is where you should budget. Because the README treats v1.0.0 as a fresh-install baseline, moving between major lines can mean standing up a new data directory and re-establishing configuration rather than applying a migration. Container-based deployment softens that, since the JAR is fetched at build time from a URL you control, but the SQLite database and the VFSPATH directory under /app/data are the state you have to carry forward yourself.
Editorial conclusion
Adopt LeoAI if you run authorised red team engagements and want host assets, a Puppet console and LLM-driven task planning in one Spring Boot workbench, and if you can run Java 17 or later on the platform side. Do not adopt it if you need a supported upgrade path from an older deployment: the README states v1.0.0 is a fresh-install baseline and that old data directories, Component caches and generated artefacts are not upgrade inputs. Before deploying, verify three things in this order: the RUNTIME_IMAGE and JAR_URL values you pass to docker-compose, whether the target PHP host exposes the extensions a given capability needs, and which of the 24 middleware targets your memory-shell build actually has to cover.
Frequently asked questions
What does LeoAI do?
It is an AI-driven post-exploitation and host coordination platform. It combines a host asset directory, a Puppet operations console, platform-level and node-level AI agents, and team collaboration features in one web workbench aimed at authorised red team and security research work.
Is LeoAI free?
The repository is licensed under GPL-3.0, so the source is available under that licence. The README does not describe a paid tier or a hosted service.
How accurate is LeoAI?
The README does not publish accuracy figures, and there is no benchmark data in the repository to cite. The platform's results depend on the model you connect it to, since it supports OpenAI, Qwen, DeepSeek and Claude with runtime switching.
Which AI tool is best for engineering design?
That question is about engineering design tools, not about this project. LeoAI is a post-exploitation and host coordination platform for authorised red team work, and the README does not cover engineering design.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/cha0upup-leoai)Star history chart for your README
[](https://hysenlabs.com/projects/cha0upup-leoai)Was this useful?