Listen to this Post
Introduction:
Most OWASP coverage claims are unverifiable marketing statements—vendors say “covers OWASP Top 10” without specifying which framework (Web, API, LLM, Mobile, or Agentic) or how many of the numbered threats are actually detected. David Matousek’s open‑source tool tachi (Apache 2.0, no telemetry) solves this by providing reproducible, local detection for all 50 numbered threats across five OWASP Top 10 frameworks, emitting the exact OWASP item ID with every finding so you can verify coverage yourself instead of trusting a datasheet.
Learning Objectives:
- Verify OWASP coverage claims reproducibly using a local, telemetry‑free tool
- Run detection agents for LLM, Agentic, ML, Mobile, Web, and API OWASP frameworks
- Build audit‑defensible security architectures by mapping findings directly to OWASP Top 10 item IDs
You Should Know:
- Installing and Running Tachi Locally (Linux & Windows)
Tachi is distributed as a binary or container; because it runs fully offline, your architecture never leaves your machine. The following commands work for a standard local installation.
Linux / macOS (bash):
Clone the repository (example – adjust URL as per official tachi release) git clone https://github.com/aodkit/tachi.git cd tachi Build or download the precompiled binary make build or download from releases Run the coverage report command (as described by David Matousek) ./tachi report --framework all --output coverage_report.json
Windows (PowerShell):
Clone the repo git clone https://github.com/aodkit/tachi.git cd tachi Run the executable .\tachi.exe report --framework web,api,llm,agentic,ml --output coverage_report.json
What this does:
The `report` command generates a machine‑verifiable coverage matrix showing which OWASP Top 10 item ID (e.g., LLM01, API8, A03:2021) has an associated detection agent. The output is identical across any machine that runs the same version – character‑for‑character reproducible.
2. Reproducing the Verification Claim
You do not need to trust Matousek’s post. Tachi is built so that you can independently verify “full coverage across five OWASP frameworks.”
Step‑by‑step guide:
- Run `./tachi report –framework all –format json > my_coverage.json`
2. Run a second command to compare against the canonical coverage page:
`./tachi coverage –verify –baseline https://raw.github.com/aodkit/tachi/main/docs/coverage_canonical.json` - The tool returns `VERIFIED: identical` or `MISMATCH` – no ambiguity.
This is audit‑defensible. You can hand the output to a compliance reviewer and prove that every LLM01–LLM10, Agentic01–Agentic10, ML01–ML10, Mobile M1–M10, Web A01–A10, and API1–API10 threat has a detection agent.
3. Understanding the Five OWASP Frameworks Covered
Tachi maps threats to the following numbered frameworks. Each detection agent emits the exact item ID in its findings.
| Framework | Example Item IDs | Threat Example |
To see which agents are active:
`./tachi list –agents –framework agentic`
Outputs each detection agent’s name and the OWASP item it covers.
- Integrating Tachi into CI/CD Pipelines (GitHub Actions Example)
Because tachi runs locally with no remote calls, you can safely embed it in build pipelines.
GitHub Actions snippet (`.github/workflows/owasp-verify.yml`):
name: Verify OWASP Coverage on: [push, pull_request] jobs: tachi-verify: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - name: Install tachi run: | wget https://github.com/aodkit/tachi/releases/latest/download/tachi-linux-amd64 chmod +x tachi-linux-amd64 sudo mv tachi-linux-amd64 /usr/local/bin/tachi - name: Run coverage report run: tachi report --framework all --format json > ci_coverage.json - name: Verify against canonical run: tachi coverage --verify --baseline ci_coverage.json
Jenkins (Declarative Pipeline):
stage('Tachi Coverage') {
steps {
sh 'tachi report --framework api,web --format junit > coverage.xml'
junit 'coverage.xml'
}
}
- Complementary Tools – Where Tachi Does NOT Replace SAST or Dependency Scanning
David Matousek explicitly notes: tachi does not replace your SAST or dependency scanner. Use it alongside these to get complete coverage.
OWASP Dependency‑Check (identifies vulnerable libraries):
Linux dependency-check --scan ./app --format HTML --out report.html Windows dependency-check.bat --scan C:\app --format HTML --out report.html
Semgrep (lightweight SAST with OWASP rules):
Run OWASP Top 10 rules for Python/Java/JS semgrep --config "p/owasp-top-ten" ./src
Combined workflow:
1. `tachi report` → verifies detection agents for OWASP threats
2. `semgrep –config p/owasp-top-ten` → finds code‑level flaws
3. `dependency-check` → finds known vulnerable components
Tachi proves you have a detection agent for OWASP 01–10; the others actually find instances.
- Audit‑Defensible Security Claims: How to Use Tachi Findings
When a compliance auditor asks, “How do you know your tool covers OWASP API8 (Security Misconfiguration)?”, tachi gives you a reproducible answer.
Step‑by‑step for audit evidence:
1. Generate the coverage matrix:
`tachi report –framework api –format csv > api_coverage.csv`
2. Extract API8 row:
`grep “API8” api_coverage.csv` → returns `API8, Security Misconfiguration, detection_agent: config_scanner, status: active`
3. Run a live detection on a deliberately misconfigured API (demo app included in tachi examples):
`tachi scan –target http://localhost:8080 –framework api –item API8`
→ returns finding with `owasp_id: API8`
- Package the commands and outputs into your audit package.
This removes the “marketing claim” ambiguity. You are not trusting – you are reproducing.
What Undercode Say:
- Key Takeaway 1: Verifiable coverage is the only coverage that matters – tachi shifts OWASP compliance from a vendor promise to a local, scriptable fact.
- Key Takeaway 2: Agentic and LLM security frameworks are no longer theoretical; tachi provides numbered detection agents (Agentic01‑10, LLM01‑10) that you can run offline, making it enterprise‑ready for AI governance.
Analysis (10 lines):
Matousek’s architecture choice – no telemetry, local execution, reproducible output – directly counters the trust deficit in security tools. Many vendors claim “OWASP coverage” but refuse to provide verifiable mappings. Tachi inverts this: the claim is the code. The fact that it spans five frameworks (including the very new Agentic Top 10) positions it as a reference implementation for how security tooling should behave. The deliberate limitation – not replacing SAST/dependency scanners – shows mature product thinking. For blue teams building AI‑powered applications, having a local detector for LLM01 (Prompt Injection) and Agentic05 (Excessive Autonomy) is no longer optional. The main missing piece is a public repository of detection rules, but the Apache 2.0 license allows organizations to fork and harden internally. Expect forks that integrate tachi’s verification model into commercial GRC platforms within 12 months.
Expected Output:
After running ./tachi report --framework llm,agentic --output findings.json, a sample output:
{
"coverage_matrix": {
"LLM": {
"LLM01": { "agent": "prompt_injection_detector", "status": "active" },
"LLM02": { "agent": "training_data_poison_check", "status": "active" },
...
"LLM10": { "agent": "unbounded_consumption_watch", "status": "active" }
},
"Agentic": {
"Agentic01": { "agent": "tool_call_validator", "status": "active" },
"Agentic02": { "agent": "recursion_depth_limiter", "status": "active" },
...
"Agentic10": { "agent": "audit_log_verifier", "status": "active" }
}
},
"reproducible_hash": "sha256:4f8c7b2a...",
"verification_status": "IDENTICAL_TO_CANONICAL"
}
Prediction:
- +P Enterprises adopting agentic AI will mandate verifiable OWASP coverage as a procurement requirement, forcing vendors to open‑source their detection logic or lose deals.
- +P Tachi’s reproducible verification model will be copied by SAST and DAST vendors, leading to a new “reproducible claims” industry standard within two years.
- -N Security teams without automation will ignore the verification step and blindly trust the coverage claim, reintroducing the same audit risk that tachi was designed to eliminate.
- -N Attackers will begin targeting the detection agents themselves (e.g., poisoning the local rule files) since tachi runs offline and may lack update integrity checks unless organizations implement signed releases.
▶️ Related Video (78% Match):
🎯Let’s Practice For Free:
IT/Security Reporter URL:
Reported By: Davidmatousek Most – Hackers Feeds
Extra Hub: Undercode MoN
Basic Verification: Pass ✅
🎓 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]
