Listen to this Post
Introduction:
Traditional vulnerability research relies on manual code review—a process that is time-consuming, error-prone, and increasingly insufficient given the complexity of modern software. A two-person security team operating under the researcher name Blockian has demonstrated a fundamentally different approach: orchestrating AI agents to perform focused, parallelized security analysis. Their open-source platform, Open-Kritt, recently won a $250,000 bounty and discovered over 20 high and critical vulnerabilities across nine months of real-world security research. Instead of feeding entire codebases into a single model prompt, Open-Kritt breaks security research into small, well-defined tasks executed across multiple AI agents in isolated containers, producing de-duplicated, ranked findings that researchers can immediately validate.
Learning Objectives:
- Understand the architectural principles behind agent-based vulnerability discovery and why focused AI analysis outperforms monolithic prompting
- Master the installation, configuration, and deployment of Open-Kritt in isolated environments
- Learn to build custom security workflows with multi-depth prompt steps and post-script validation
- Implement threat-aware deployment strategies for AI-powered security tools handling sensitive code and credentials
You Should Know:
1. From Monolithic Prompts to Focused Agent Swarms
The fundamental insight behind Open-Kritt is simple yet profound: pointing an AI at an entire repository and asking it to find vulnerabilities rarely works well. However, pointing it at one function in one file and asking a focused question often yields actionable results. Open-Kritt operationalizes this insight through a four-stage pipeline:
- Entry-Point Mapping: One agent maps every reachable entry point in the repository—HTTP routes, API endpoints, input parsers, and privileged functions.
- Targeted Tracing: Separate agents trace individual code paths from each entry point, searching for specific failure modes such as injection flaws, authentication bypasses, or privilege escalation vectors.
- Isolated Execution: Each agent operates in its own disposable container with writable repository copies and direct internet access, enabling compilation, test execution, fuzzing, and Proof-of-Concept development without cross-contamination.
- Intelligent Deduplication: Raw findings are cross-checked, merged, and ranked by severity using configurable rankers, allowing researchers to focus on the most critical bugs first.
The results validate this approach: the Kritt team has earned over $1,500,000 in bug-bounty payouts, with Open-Kritt being the open-source distillation of the internal project behind that work.
2. Installation and Environment Setup
Open-Kritt runs locally with Docker Compose and includes an interactive CLI that handles environment configuration. The following prerequisites are required:
- Docker Desktop or Docker Engine with Docker Compose plugin
- Git
- Node.js 20 or newer (for the repository-local CLI)
Step-by-Step Installation:
Verify Docker access docker info >/dev/null docker compose version Clone the repository git clone https://github.com/Kritt-ai/open-kritt && cd open-kritt Launch the interactive CLI ./kritt
Use the arrow keys to select Setup and follow the prompts. The CLI creates `.env` from `.env.example` and guides you through choosing one model-access method—the recommended path is a guided Codex login, though provider API keys for OpenAI, Anthropic, or OpenRouter also work.
For Linux users on distributions with older Node.js defaults, install Node.js 22.x via NodeSource:
Ubuntu 24.04 / Debian 12 sudo apt-get update sudo apt-get install -y ca-certificates curl curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash - sudo apt-get install -y nodejs Rocky Linux 9 sudo dnf module reset -y nodejs sudo dnf module enable -y nodejs:20 sudo dnf install -y nodejs
A `GITHUB_TOKEN` is optional and only required for scanning private repositories. The default ports bind to 127.0.0.1, and the backend does not include application authentication—keep the stack private.
3. Building Custom Security Workflows
A workflow in Open-Kritt is a reusable blueprint: a tree of prompt steps the engine runs in order, feeding each step’s output into the next. Each step consists of two parts: prompt content with `{{variable}}` placeholders, and an output schema declaring the keys the step must emit.
Creating a Workflow:
- Navigate to Workflows → New workflow in the UI
- Choose Blank workflow or Generate with AI to draft from a description
- Structure steps by depth—Depth 0 runs once as the entry point, while deeper levels run on results produced above
- The terminal (deepest) step must emit the fixed finding schema:
explanation,file_path,line,malicious_input_example,summary,trigger_flow,vulnerability_type, and `malicious_actor` (plus optionalexploitable)
Example Two-Level Workflow Structure:
- Depth 0 – Enumerate: Ask the agent to list candidate entry points (e.g., every HTTP route). Mark it as multi-output so it can emit many results.
- Depth 1 – Analyze: For each entry point from Depth 0, ask a focused question about that one target. Reference Depth-0 keys directly using `{{entrypoint}}`
The builder validates references in real-time—referenced keys turn green when they resolve and red when they don’t. Once the banner reads “Workflow is valid and ready to save,” the workflow becomes a reusable blueprint any scan can reference.
4. Post-Scripts: Validation and Enrichment
After a workflow completes and findings are de-duplicated and ranked, post-scripts run on each canonical finding to add verdicts, reports, proofs of concept, and other structured context. Post-scripts enrich results rather than silently deleting them, providing a validation layer that distinguishes false positives from genuine vulnerabilities.
Common post-script use cases include:
- Building a working Proof-of-Concept to confirm exploitability
- Generating detailed reports with remediation guidance
- Running additional automated tests against the identified code path
- Cross-referencing findings against known CVE databases
Post-scripts execute in the same isolated container environment as the analysis agents, maintaining the security boundary while enabling deep validation.
5. Threat Model and Secure Deployment
Open-Kritt’s architecture introduces specific security considerations that must be addressed before deployment. The one-line summary is critical: scan agents run as root in disposable containers with writable workspaces and direct internet access. Treat repositories and model output as untrusted, isolate the Docker host, scope credentials minimally, and keep the API private.
Key Trust Boundaries:
| Boundary | Risk | Mitigation |
||||
| Operator ↔ backend/UI | API and UI are unauthenticated by default | Network isolation or reverse proxy with authentication |
| Engine ↔ analyzed code | Tool-enabled jobs run as root with writable checkouts and outbound internet | Run on dedicated Docker host or VM; job receives only its checkout and selected provider credential—not the Docker socket |
| Open-Kritt ↔ model/provider | Repository content sent to AI provider endpoints | Evaluate data-egress risks; avoid scanning sensitive code with external providers |
| Host ↔ secrets | Provider API keys and GITHUB_TOKEN live in `.env` | Limit credential scope; backend passes only selected provider credential into each harness job |
Assets to protect: Provider credentials (OPENAI_API_KEY, ANTHROPIC_API_KEY, OPENROUTER_API_KEY, CODEX_API_KEY), GITHUB_TOKEN, scanned repository source code, findings, and generation requests. Review the threat model documentation before scanning untrusted code.
6. Running Your First Scan
Once the stack is running (accessible at `http://localhost:5173`), initiate a scan by:
1. Selecting a target repository (local or remote)
2. Choosing a workflow (built-in or custom)
3. Configuring the AI provider and model
4. Running the scan and monitoring agent execution
The engine claims the scan, checks out the target repository, builds a workspace, and runs each workflow step through the selected AI harness. Results are written back to Postgres and displayed in the UI.
For development and testing, the full stack can be started with:
Using the CLI ./kritt start Or manually with Docker Compose cp .env.example .env docker compose up --build Add -f docker-compose.dev.yml for human-readable backend logs
7. Performance and Real-World Results
The Open-Kritt approach has demonstrated remarkable effectiveness in production security research:
- 20+ High and Critical vulnerabilities discovered in 9 months of operation
- 1st place in the Firedancer V1 audit competition—achieved using 100% AI-driven research with zero manual review
- $250,000 bounty won by the two-person security team
- $1,500,000+ total bug-bounty payouts earned under the Blockian researcher name
These results challenge conventional assumptions about AI-assisted security research, demonstrating that properly orchestrated agent swarms can match or exceed human-led audits while operating at dramatically higher scale.
What Undercode Say:
- Focused analysis beats comprehensive prompting. The core insight—that targeted, function-level queries outperform monolithic repository-wide prompts—represents a fundamental shift in how AI should be applied to security research. This is not about replacing human researchers but augmenting them with parallelized, focused analysis capabilities.
- Isolation is non-1egotiable for AI security tools. Open-Kritt’s containerized execution model, with disposable workspaces and strict credential separation, establishes a baseline for safely deploying AI agents that compile and execute untrusted code. Organizations adopting AI-powered security tools must prioritize this isolation layer.
The emergence of Open-Kritt signals a maturation in AI security applications. Early approaches treated AI as a black-box oracle; Open-Kritt treats it as an orchestrated workforce of specialized agents. This architectural shift has profound implications: security teams can now parallelize vulnerability discovery across hundreds of agents, each focusing on a specific attack surface, while maintaining human oversight through workflow design and post-script validation. The platform’s success in competitive audits suggests that AI-driven security research is not merely experimental but production-ready for organizations willing to invest in the infrastructure.
Prediction:
- +1 Agentic security workflows will become standard practice within 18–24 months, with major enterprises adopting orchestrated AI agents for continuous vulnerability assessment alongside traditional SAST/DAST tools.
-
+1 The $1.5M bug-bounty milestone will accelerate investment in AI-powered security research, with hedge funds and security firms deploying similar agent swarms to discover zero-day vulnerabilities at scale.
-
+1 Open-source security tooling will increasingly adopt agent-based architectures, as Open-Kritt demonstrates that focused, parallelized AI analysis can outperform both manual review and traditional automated scanners.
-
+1 Security researcher productivity will increase 5–10x as agents handle enumeration and initial analysis, allowing humans to focus on validation, exploitation, and remediation strategy.
-
+1 The barrier to entry for high-quality security research will lower dramatically, enabling smaller teams and independent researchers to compete with well-funded security organizations.
-
-1 Malicious actors will inevitably adapt these techniques, deploying agent swarms to discover vulnerabilities in target systems at scale, accelerating the window between vulnerability discovery and exploitation.
-
-1 Organizations that deploy Open-Kritt without proper isolation risk credential exfiltration and supply chain attacks, as tool-enabled agents have direct internet access and run as root in disposable containers.
-
-1 The unauthenticated default API surface will be exploited in misconfigured deployments, exposing findings, credentials, and repository content to unauthorized parties.
-
+1 AI provider economics will shift as security workloads demand high-volume, focused queries rather than monolithic prompts, potentially driving new pricing models for security-oriented AI consumption.
▶️ Related Video (72% Match):
https://www.youtube.com/watch?v=2YrIRdhCvCI
🎯Let’s Practice For Free:
🎓 Live Courses & Certifications:
Join Undercode Academy for Verified Certifications
🚀 Request a Custom Project:
Secure, high-velocity infrastructure and disruptive technological engineering. Contact our engineering team for high-tier development and proprietary systems:
[email protected]
💎 Smart Architecture | 🛡️ Secure by Design | ⭐ Trusted by Thousands
IT/Security Reporter URL:
Reported By: Joshua Nwachinemere – Hackers Feeds
Extra Hub: Undercode MoN
Basic Verification: Pass ✅
