SEC-AF
An AI-native code security auditor built on AgentField that proves exploitability with verdicts, taint traces, and actionable evidence — not just flagged patterns.
- Source repo
- Agent-Field/sec-af
- Stars
- ★ 200
- Last updated
- 6d ago
- License
- Apache-2.0
- Primary language
- Go
- FA score
- 52/100 · Major gaps
At a glance
- How it runs
- Works with
- Universal · cross-platformCodex · Claude Code
- Cost
- Free software; you pay for model usage
- Setup effort
- Medium · a few setup steps
- You'll need
- Typical use
- Development teams running verified SAST audits on GitHub repos before merge, wired into GitHub Actions with SARIF upload to Code Scanning to cut false positives from traditional scanners.
- Not a fit if
- Teams wanting runtime or protocol-level detection such as GraphQL batch queries
- Users unwilling to run an AgentField control plane and the af CLI
- Source review
- 52/100 · Major gaps
What does this agent do, and when should you use it?
SEC-AF (repository Agent-Field/sec-af, Apache-2.0) is an AI-native security auditor that runs as an agent on the AgentField control plane. A single API call (sec-af.audit) audits a GitHub repository by composing roughly 200–300 focused LLM reasoners into a directed acyclic call graph spanning RECON, HUNT, DEDUP, PROVE, and REMEDIATION phases. Every finding ships with a verdict (confirmed / likely / inconclusive / not_exploitable), a full taint data-flow trace, and an exact code location, with SARIF 2.1.0, JSON, and Markdown outputs plus mappings to PCI-DSS, SOC2, OWASP, HIPAA, and ISO27001. On the DVGA benchmark it compresses 106 raw findings into 28–30 verified ones — 94% noise reduction — at an estimated $0.18–$0.90 per standard audit on Kimi K2.5 via OpenRouter. It is SAST-focused and does not cover runtime/protocol-level attacks such as GraphQL batch queries or deep recursion. Deployment options include Docker Compose, one-click Railway, or af install; the maintained implementation is Go, with a Python implementation still available.
SEC-AF takes a repo_url (plus optional parameters), clones the target repository, and runs a five-phase pipeline. RECON maps architecture, dependencies, data flows, and security context in parallel. HUNT runs 10+ specialized strategy hunters (injection, crypto, auth, etc.), activated by AI gates that read recon output. DEDUP fingerprints and then semantically deduplicates findings. PROVE runs a 4-agent adversarial chain per finding — a tracer reconstructs the data flow, a sanitization analyzer looks for missed mitigations, an exploit hypothesizer builds a concrete attack, and a verdict agent weighs the evidence. REMEDIATION generates fix suggestions for confirmed/likely findings. Invocation is via af call sec-af.audit --in '{"repo_url": ...}' or POST http://localhost:8080/api/v1/execute/async/sec-af.audit, with options for depth (quick/standard/thorough), scan_types, severity_threshold, max_cost_usd, max_provers, include/exclude_paths, output_formats, and compliance_frameworks. Results include verdict, proof (with data_flow_trace), location, and SARIF/JSON/Markdown reports.
- Development teams running verified SAST audits on GitHub repos before merge, wired into GitHub Actions with SARIF upload to Code Scanning to cut false positives from traditional scanners.
- Security engineers auditing GraphQL applications (DVGA-style), receiving confirmed findings for command injection, SQL injection, SSRF, and auth bypass with taint-trace evidence.
- DevSecOps teams needing compliance-mapped reports using the pci-dss, soc2, owasp, or hipaa framework options.
- Open-source maintainers running a cheap quick-depth health check (~$0.10–$0.40, 2–5 minutes) on their projects.
- AgentField users with a running control plane installing SEC-AF as a node via af install https://github.com/Agent-Field/sec-af to fold auditing into their agent orchestration.
- Security researchers extending coverage with a new vulnerability class by adding a single hunter file, which the orchestrator auto-discovers and routes into the dedup → prove → remediation pipeline.
How do you install or deploy this agent?
Option 1 (existing AgentField): af install https://github.com/Agent-Field/sec-af && af run sec-af; the first run prompts for OPENROUTER_API_KEY (stored encrypted). Option 2 (Docker Compose): git clone https://github.com/Agent-Field/sec-af.git && cd sec-af && cp .env.example .env (add OPENROUTER_API_KEY) && docker compose up --build. Option 3 (Railway): use the one-click deploy button in the README; requires OPENROUTER_API_KEY. Option 4 (local Python): with Python 3.11+, clone the repo, run python3 -m venv .venv && source .venv/bin/activate && pip install -e ., copy .env.example to .env and add OPENROUTER_API_KEY, then run af server in one terminal and python3 main.py in another. Note: the maintained implementation is the Go node under go/ (default port 8013); the Python version is available via python -m sec_af.app or a local-path install.
How do you use this agent?
Simplest invocation: af call sec-af.audit --in '{"repo_url": "https://github.com/dolevf/Damn-Vulnerable-GraphQL-Application"}' (requires af ≥ 0.1.87), or curl -X POST http://localhost:8080/api/v1/execute/async/sec-af.audit -H 'Content-Type: application/' -d '{"input": {"repo_url": ...}}', then poll GET /api/v1/executions/<execution_id>. Optional parameters: branch, depth (quick/standard/thorough), severity_threshold, scan_types (sast/sca/secrets/config), output_formats (sarif//markdown), compliance_frameworks, max_cost_usd, max_provers, max_duration_seconds, include_paths, exclude_paths. Key environment variables: AGENTFIELD_SERVER (default http://localhost:8080), OPENROUTER_API_KEY (required), HARNESS_MODEL and AI_MODEL (default deepseek/deepseek-v4-flash-0731; any OpenRouter-compatible model works), HARNESS_PROVIDER (default aforge). In CI, trigger audits from GitHub Actions and upload the SARIF result to GitHub Code Scanning.
What are this agent's strengths and limitations?
- Adversarial verification architecture: HUNT and PROVE are structurally separate, and every finding passes a 4-agent verification chain (tracer, sanitization analyzer, exploit hypothesizer, verdict agent), delivering 94% noise reduction on DVGA.
- Actionable evidence per finding: verdict, full taint data-flow trace, and exact code location — not vague 'might be a problem' alerts.
- Transparent, low cost: a standard audit with 30 verified findings costs about $0.18–$0.90 (Kimi K2.5), with a published composite scoring formula and documented depth-based pricing.
- Composable and observable: a new vulnerability class is one hunter file; every reasoner call flows through the control plane as a complete DAG you can audit for timing and reasoning.
- Native SARIF 2.1.0 output with a documented GitHub Actions integration path and multi-framework compliance mapping.
- Strong ecosystem lock-in: requires a running AgentField control plane, the af CLI, and an OPENROUTER_API_KEY; default models point at specific OpenRouter-hosted models.
- SAST only: cannot detect the GraphQL protocol-level attacks the README itself lists (batch queries, deep recursion, alias abuse, introspection exposure); protocol-level detection is still on the roadmap.
- Slow audits: standard depth took ~78 minutes with ~166–255 agent calls and 82 DAG edges on DVGA; thorough runs 30–120 minutes.
- Inconclusive verdicts still require manual review, and the benchmark (1 correctly rejected, 1 inconclusive) shows the verification chain is not infallible.
- Dual implementations (Go primary, Python secondary) create migration considerations: a bare-URL af install installs the Go version and replaces any older Python node, while local-path installs do not follow superseded_by.
How does this agent compare with similar options?
Key facts side by side with the most closely related agents.
| Agent | Source review | Form / cost | Stars | Updated | Language | Full support on |
|---|---|---|---|---|---|---|
| SEC-AF This agent | 52 · Major gaps | CLIFree + model costs | ★ 200 | 6d ago | Go | Codex · Claude Code |
| ControlKeel | 58 · Major gaps | CLIFreemium | ★ 11 | 3d ago | Elixir | Codex |
| LintLang | 81 · Good | CLIFree | ★ 144 | 2d ago | Python | Claude Code |
| AWS Agent Toolkit | 61 · Some gaps | Agent plugin / skillFree + model costs | ★ 3.4k | 2d ago | Python | Codex · Claude Code |
How does FollowAgents rate this agent?
Why each dimension lost points
The code clones repositories from HTTP or remote Git URLs and runs git pull when reusing a workspace. It starts the harness with permission_mode set to auto and exposes optional PR comments, indicating a broad permission and side-effect surface, though cost, duration, and path limits are configurable. The excerpt does not explain isolation of untrusted repository content or confirmation before actions. The README describes traces, evidence, and DAG observability; API keys are read from the environment, but full secret protection and log redaction are not shown. Dependencies have open-ended lower bounds with no visible lock or security policy. Cloning, LLM calls, and PR comments are documented, but defaults, impacts, and recovery are incomplete. Apache-2.0 and project/organization names are visible, while publisher identity and maintenance responsibility remain limited.
The README documents phases, outputs, and parameters, and the code provides error unwrapping, payload type checks, and a clone failure message. However, benchmark cost and call-count claims are not fully consistent, and Python and Go implementations coexist while this sample gives limited API and dependency detail. Dependencies have minimum versions only, with no visible lock file. Some failure paths are clear, but other errors and recovery guidance are not established by this sample.
The documentation covers security audits, depth profiles, scan types, output formats, compliance frameworks, and repository path filters, and identifies SAST focus and known GraphQL protocol gaps. The sec-af.audit trigger and its options are concrete. Environment variables and Docker, AgentField, Python, and Go setup paths are described. Scores are not full because the sample does not fully establish all input constraints, compatibility ranges, or deployment boundaries.
The README is organized around output, benchmark, architecture, installation, and API, with command examples, FAQ-like guidance, and known limitations. The full Apache-2.0 license is present, justifying full marks there. Python and Go implementations coexist, while URL installation selects Go and Python remains available, creating some ambiguity in implementation paths and naming. Version 0.1.0 appears in configuration, but the sample shows no clear changelog or maintenance policy; author metadata and AgentField links provide limited attribution.
The result shape includes verdicts, evidence levels, data-flow traces, code locations, and SARIF/JSON/Markdown formats that support review and action. Multi-stage verification and configurable scanning appear useful, but the benchmark and differentiation claims are mainly asserted in the README and cannot be independently confirmed from this sample. Cost claims differ, and audits may take tens of minutes to hours, so cost-benefit is only partly supported.
The sample output, audit parameters, phase descriptions, and entry-point code make some claims traceable; the test excerpt covers compliance mappings but does not validate end-to-end audits. The README gives specific benchmark, noise-reduction, cost, and architecture claims without independent corroboration in the supplied material, and cost and call estimates vary between passages. Fact and inference are not consistently separated, so these criteria receive partial credit.
- The tool clones and updates the supplied repository and calls an external LLM; confirm the target repository, workspace, and API-key setup are appropriate for your environment.
- README benchmark cost and call estimates differ, and protocol-level GraphQL attacks are documented as currently out of scope; manually review results used for security decisions.
Maintain this project? Add the FARS badge to your README
[](https://followagents.com/en/agents/sec-af)<a href="https://followagents.com/en/agents/sec-af"><img src="https://followagents.com/badge/sec-af.svg" alt="FARS review"></a>Thanks — we use this to improve the page.