0: An AI Security Harness That Treats Pentesting Like Workflow Orchestration
Hook
Most AI security tools lose context between prompts. 0 treats vulnerability research as a stateful workflow graph where each step builds on the last—making multi-stage exploitation reproducible instead of regenerating analysis from scratch every time.
Context
The current generation of AI security tools follows a predictable pattern: wrap ChatGPT or Claude in a web interface, paste some code, get vulnerability suggestions. Tools like this are fundamentally stateless—close the chat window and your investigation evaporates. Ask the same question twice and you might get different answers. Try to reproduce a multi-stage exploit chain and you're manually copy-pasting context between prompts.
This works fine for trivial code reviews but breaks down for real security work. Penetration testing isn't a single prompt—it's a multi-day investigation where you discover a low-privilege SQL injection on Monday, chain it with a deserialization bug on Tuesday, and write a privilege escalation exploit on Wednesday. Each phase depends on findings from the previous one. You need persistent state, reproducible analysis passes, and auditable decision trails. Chat interfaces can't provide this because they're designed for conversation, not orchestration. 0sec-labs/0 attacks this problem by treating security analysis as workflow graphs with explicit state management, making AI-driven pentesting look less like chatting and more like running a CI/CD pipeline for vulnerability research.
Technical Insight
At its core, 0 is a TypeScript-based workflow orchestration engine wrapped in a Next.js UI. Security tasks—code review, binary analysis, fuzzing campaign management—are decomposed into graphs of reusable steps. Each step can be deterministic (run a regex scanner) or AI-augmented (ask an LLM to classify severity), but crucially, state persists between steps. The workflow runner maintains a findings queue where discoveries are tagged with source locations, severity metadata, and cross-references to related issues.
Here's what a minimal workflow configuration looks like:
// Workflow definition for API security review
{
"id": "api-security-scan",
"steps": [
{
"name": "extract-endpoints",
"type": "deterministic",
"tool": "ast-parser",
"output": "endpoints"
},
{
"name": "classify-auth",
"type": "ai-augmented",
"input": "endpoints",
"prompt": "For each endpoint, determine authentication mechanism",
"output": "auth-model"
},
{
"name": "generate-test-cases",
"type": "ai-augmented",
"input": "auth-model",
"prompt": "Generate bypass attempts for each auth pattern",
"output": "test-suite"
},
{
"name": "execute-tests",
"type": "deterministic",
"tool": "sandbox-executor",
"input": "test-suite",
"output": "findings"
}
]
}
The graph model means you can re-run just the "generate-test-cases" step with a different LLM or temperature setting without re-parsing the AST. Findings from step 4 automatically populate the triage board with links back to the specific code locations identified in step 1. This is fundamentally different from asking Claude "review this API for security issues"—the workflow is reproducible, each phase is independently verifiable, and state doesn't disappear when you close your browser.
The architecture's killer feature is bidirectional MCP (Model Context Protocol) integration. 0 acts as both an MCP server and client simultaneously. As a server, it exposes workflow primitives—"start code review," "query findings," "add to learning memory"—to external agents like Claude Desktop. As a client, it consumes tools from specialized MCP servers, including its own binary analysis backend called 0verse.
0verse is a Python service wrapping Ghidra that exposes nine MCP tools for different reverse engineering phases: decompile_function, analyze_strings, find_crypto_constants, trace_taint_flow, etc. Instead of feeding raw disassembly to an LLM (which wastes context window on boilerplate), 0verse pre-processes binaries through Ghidra's decompiler and surfaces structured analysis results. When investigating a suspicious binary, the workflow might call find_suspicious_syscalls, get a list of candidate functions, then call decompile_function on each and ask the LLM to classify exploit potential.
This creates a security-focused orchestration layer where specialized analysis backends (static analyzers, fuzzers, decompilers) become composable tools in multi-stage workflows. The graph runner handles state management and finding correlation across tools that weren't designed to interoperate.
The memory subsystem addresses another chat-wrapper failure mode: learning from past investigations. When you discover that a particular deserialization library is vulnerable in one codebase, that insight should carry forward to future reviews. 0's "Learning" feature stores source-grounded notes indexed by code patterns and file paths rather than vector embeddings. Query "what do we know about JWT validation in Express apps" and you get deterministic recall of previous findings tied to specific lines of code, not semantic similarity matches that hallucinate context.
The UI layer reflects this workflow-first design. Instead of a chat window, you see a findings board (think JIRA for vulnerabilities) where each issue shows the workflow step that discovered it, the source location, suggested fixes, and cross-references to related findings. The browser interface and CLI can connect to the same workflow engine instance, so you can kick off a long-running analysis from the terminal, monitor progress in the browser, and have both interfaces share investigation state.
For GitHub integration, 0 runs as a PR check that executes workflow graphs on changed files, triages findings by severity, and posts in-PR comments with suggested fixes. Unlike traditional SAST tools that dump 200 alerts with 80% false positives, the workflow can include an AI-driven triage step that filters noise before surfacing results to developers. The fix suggestions include context from the Learning memory—if you've patched similar issues before, those patterns inform the recommendations.
Gotcha
The binary analysis capabilities sound impressive until you try to set them up. 0verse requires a pre-installed Ghidra instance, a compatible Java runtime, and manual service configuration. The documentation warns that "unavailable analysis is not a clean scan"—if 0verse fails to start (and on some platforms it silently fails), workflows depending on binary analysis will partially execute without clear error messages. For a tool positioning itself as an all-in-one security harness, the fragility of the reversing stack is jarring. You'll get great results if you're already running Ghidra in your workflow, but if you're new to binary analysis, the setup friction might push you back to uploading samples to VirusTotal.
Workflow execution is entirely local or self-hosted with no job scheduling system. Long-running tasks like fuzzing campaigns or parallel analysis across a 500k-line codebase will block on your laptop's resources. There's no built-in way to distribute workflow steps across a cluster or pause/resume investigations. The findings queue is per-run with no deduplication across investigations, so tracking whether a vulnerability recurs across releases requires manually comparing finding IDs. For teams doing continuous security monitoring, you'll need to build your own orchestration layer on top of 0's workflow primitives—which defeats the purpose of using a harness.
Extending workflows beyond the provided templates requires diving into TypeScript and understanding Next.js internals. There's no user-programmable DSL for defining custom analysis passes. If the built-in code review workflow doesn't cover your framework (say, Rust async or Kotlin coroutines), you're forking the repo and modifying source rather than dropping in a plugin. For a tool built on the idea of composable workflows, the lack of a scripting interface for security engineers feels like a missed opportunity.
Verdict
Use if: You're an appsec team doing manual security reviews and want to augment—not replace—human analysis with AI-driven triage and finding management. The workflow state management solves real problems if you're currently juggling Semgrep output, manual code review notes, and PoC scripts across separate tools. The MCP orchestration layer makes this a solid integration hub if you're already building custom security agents and need workflow primitives for multi-stage investigations. The GitHub PR integration is production-ready if your review process involves AI-suggested fixes and you need auditability. Skip if: You want fully autonomous security scanning (missing robust deduplication and distributed execution), your team doesn't already do manual pentesting (the UI assumes expertise), or you need industrial-grade binary analysis (0verse is a beta feature with fragile setup). Chat-wrapper tools like Cursor with security prompts will be faster for one-off code reviews, while Semgrep or Snyk are more appropriate for CI/CD pipelines that need deterministic, compliance-friendly scanning without LLM dependencies.