SecAgent MCP server
Commit Nov 9, 2026An autonomous offensive security framework that lets AI clients drive red team operations, vulnerability research, and penetration testing via MCP.
Also known as gl1tch0x1/SecAgent
- Stars
- 3
- Tools
- β
- Downloads, 30 days
- β
- Latest version
- β
- Last commit
- Nov 9, 2026
- License
- MIT
What is SecAgent MCP?
SecAgent is an autonomous offensive security framework that lets AI clients drive red team operations, vulnerability research, and penetration testing via MCP.
Summary generated from the project's README
About SecAgent MCP server
Red teams and security researchers can drive autonomous offensive security operations directly from AI clients like Claude Code, Cursor, or VS Code Copilot. By using the native JSON-RPC stdio server mode, these tools allow an AI to manage vulnerability research, penetration testing, and scoped discovery within a controlled environment. The framework is designed for headless execution in Docker containers, SSH sessions, or CI/CD pipelines, prioritizing a CLI-first approach over complex web interfaces.
Security professionals can define complex methodologies using declarative YAML playbooks or interact with the system through a human-in-the-loop teleoperation mode by using a double Ctrl+C command. The system includes specialized agents for web security, API inventory, and Web3 smart contract auditing. To manage operational costs, a built-in budget guard monitors real-time token pricing across providers like OpenAI, Anthropic, and Gemini, enforcing limits via the SECAGENT_PRICE_LIMIT configuration.
What you can do with it
- 1Automated Red Team OperationsAn AI client can execute complex penetration testing methodologies using predefined YAML files.
- 2Smart Contract Security AuditingDevelopers can use the specialized Web3 agent to find vulnerabilities in EVM or Solana contracts.
- 3Controlled Vulnerability VerificationUsers can replay specific proof capsules to validate findings against a control.
- 4Managing AI Token ExpensesSecurity teams can prevent unexpected costs by setting strict limits on LLM usage.
Written from the project's README. Every use case is checked against a quote from it.
Configuration
ALLOWED_DOMAINSANTHROPIC_API_KEYDEEPSEEK_API_KEYGEMINI_API_KEYGROQ_API_KEYOLLAMA_HOSTOLLAMA_MODELOPENAI_API_KEYREDIS_URLRESULTS_DIRSECAGENT_LLM_MODELSECAGENT_LLM_PROVIDERSECAGENT_VERIFY_SSL
| Name | Description | |
|---|---|---|
| ALLOWED_DOMAINS | β | |
| ANTHROPIC_API_KEY | β | |
| DEEPSEEK_API_KEY | β | |
| GEMINI_API_KEY | β | |
| GROQ_API_KEY | β | |
| OLLAMA_HOST | β | |
| OLLAMA_MODEL | β | |
| OPENAI_API_KEY | β | |
| REDIS_URL | β | |
| RESULTS_DIR | β | |
| SECAGENT_LLM_MODEL | β | |
| SECAGENT_LLM_PROVIDER | β | |
| SECAGENT_VERIFY_SSL | β |
Automated checks
Ran Nov 14, 2026Full report βNot verified yet. A server needs a score of 80, no serious finding, and enough data for us to check. How checks work Β· What to fix for more points
- Source repository linked and reachablegl1tch0x1/secagent is public and reachablegithub.com/gl1tch0x1/secagent βPass
- Package names this repository as its sourceNot checked
- Build provenance (Sigstore attestation)Not checked
- Open source license (OSI)MITspdx.org/licenses/MIT.html βPass
- Commit or release in the last yearLast commit or release 2026-11-09github.com/gl1tch0x1/secagent βPass
- OpenSSF ScorecardNot checked
- Package name not close to a popular packageNot checked
- No critical advisory in the package or its dependenciesNot checked
- No hidden instructions to the model0 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPass
- Destructive tools are labelledNot checked
- Remote endpoint answers the MCP handshakeNot checked
README
View on GitHubAuthorized offensive security assessment toolkit
SecAgent combines scoped discovery, bounded HTTP checks, proof replay, optional browser inspection, and operator-controlled identity, state, and callback workflows. Findings and manual leads are reported separately.
LEGAL DISCLAIMER β SecAgent is designed exclusively for authorized security testing, red team engagements, and vulnerability research on systems you own or have explicit written permission to test. Unauthorized use against systems without permission is illegal. The authors assume no liability for misuse.
Table of Contents
- What Is SecAgent
- Key Differentiators
- Capabilities Matrix
- Comprehensive System Architecture
- Quick Start Guide
- Installation Guide
- Releases, Deployments & Packages
- Configuration & Operational Manifest
- Complete CLI Usage Reference
- Sample Deliverables & Deliverable Schemas
- Project Directory Layout
- Troubleshooting & Operations Guide
- Contributing & Security Policy
- License
What Is SecAgent
SecAgent is a CLI toolkit for authorized security assessments. The default pipeline discovers scoped web routes, imports read-only API requests, runs bounded checks, and replays supported findings under explicit proof policies. Optional agents and native components provide additional workflows, but their presence in the repository does not imply that they run in the bounded default pipeline.
Built for:
- Red Teams operating within an approved scope and traffic budget
- Security Researchers examining web and API attack surfaces
- Bug Bounty Hunters reviewing candidate issues and proof evidence
- Offensive AI Researchers auditing AI supply chains, prompt injections, and RAG pipelines
Key Differentiators
- Pure CLI-First Architecture: No bloated web UI or complex database setup required. Designed for headless VPS execution, Docker containers, SSH sessions, and CI/CD pipelines.
- Optional Native Components: Go, Rust, and C++ components exist in the repository; the bounded Python default scan does not depend on all of them.
- Aura Cognitive Memory Engine: Target DNA layering, payload pattern crystallization, decay-reinforcement mechanisms, and WAF fingerprint memory across scan missions (
secagent memory). - Typed Live Validation:
CrucibleValidatorreplays supported checks and compares active probes with an unmodified control. XSS uses a scoped real-browser canary replay. Identity, state and SSRF proof require explicit operator contracts. - Bounded Built-in Traffic: Shared request count, per-host rate, concurrency, and deadline limits cover built-in discovery, checks, and proof replay.
- Headless Browser Inspection:
BrowserAgentautomated Chrome DOM extraction & dynamic Playwright form parsing with fallback HTTP inspection. - TLS Verification: The default HTTP scan verifies TLS unless
--insecureis set. - Hardware-Aware Local Fallback: Automatically detects GPU/CPU capabilities to provision local Ollama models (
llama3,mistral,codellama) when cloud APIs are unavailable. - Model Context Protocol (MCP) Server Mode: Native JSON-RPC stdio server (
secagent mcp) allowing Claude Code, Cursor, and VS Code Copilot to drive SecAgent with zero API cost. - Declarative YAML Playbooks: Define and version-control complex pentesting methodologies with conditional rules and LLM decision gates (
secagent playbook). - Proof Capsule Replay Engine: Replay a supplied typed
.jsonproof capsule withsecagent replay. The scan pipeline does not yet generate capsules automatically. - Human-In-The-Loop (HITL) Teleoperation: Intercept double
Ctrl+Cduring scan execution to drop into an interactive operator REPL (step,inspect,inject,resume,abort). - LLM Budget Guard & Cost Safeguard: Real-time token cost accounting and configurable budget limit enforcement (
SECAGENT_PRICE_LIMIT).
Capabilities Matrix
| Module | Sub-Components | Operational Description |
|---|---|---|
| Neural Swarm Orchestration | Orchestrator, ArmadaSwarm, TaskDAG |
Decomposes high-level objectives into directed acyclic execution graphs (DAGs) with retry and circuit breaker logic. |
| MCP Server Mode | MCPServer, JSON-RPC stdio |
Exposes SecAgent tools to Claude Code, Cursor, and Copilot via Model Context Protocol (secagent mcp). |
| Declarative Playbooks | Playbook, PlaybookRunner |
Executes YAML-defined scanning methodologies with dependency ordering and conditional execution (secagent playbook). |
| Proof Capsules & Replay | ProofCapsule, ProofCapsuleReplayer |
Serializes supplied capsules and replays registered typed checks under scope and request limits. Authenticated capsules use environment references for session headers. |
| HITL Teleoperation | TeleoperationController |
Intercepts double Ctrl+C to pause scan and launch interactive REPL shell. |
| LLM Cost Safeguard | BudgetGuard |
Real-time token pricing and cost limit enforcement across OpenAI, Anthropic, Gemini, Groq, and OpenRouter. |
| Aura Cognitive Memory | AuraMemoryManager, Target DNA |
Target DNA fingerprinting, WAF memory, payload pattern crystallization, automatic confidence reinforcement & decay (secagent memory). |
| Active Recon Engine | ReconAgent, GoRecon, httpx Prober |
Scoped HTTP probing, bounded subdomain checks, HTML link and form parameter discovery. |
| Headless Browser Engine | BrowserAgent, Playwright |
Chromium DOM tree inspection, dynamic JS error tracking, and automated HTML form input extraction. |
| Web Security Scanner | CVEScanner, CVEChecks |
Check catalog with typed policies; unsupported or capability-dependent checks remain manual leads or coverage gaps. |
| API Inventory | OpenAPI, Swagger, HAR | Preserves methods and bodies in memory; default active probes use GET templates only. Stateful writes require an explicit contract. |
| Bounded Fuzzing | Binary input mutator, GET payload variants, AURA feedback | Mutates local input files, records byte and bit changes plus program outcomes, and optionally tests encoded GET variants under the shared scan budget and proof policy. |
| 12 Specialized Swarm Agents | specialized.py |
Functional AI swarm agents for intelligent tool selection, CTF challenge solving, exploit generation, vulnerability correlation, and rate-limit detection. |
| Web3 & Contract Auditor | Web3SecurityAgent |
EVM & Solana smart contract security analysis for reentrancy, integer overflow, delegatecall vulnerabilities, and access control bypasses. |
| PoC Verification | CrucibleValidator |
Typed replay, controls, and evidence hashes for supported checks. This reduces unproven findings but does not establish a zero false-positive rate. |
| Exploit Chain Correlation | ChainCorrelator |
Suggests hypotheses for operator review; a chain is not proof of exploitability. |
| Impact-First Reporting | ReportAgent |
Generates executive Markdown reports and machine-readable JSON artifacts. |
Comprehensive System Architecture
The diagrams below show repository components and optional integrations. They are not a claim that every component executes during secagent scan; the bounded default path is the Python scan pipeline described above.
1. High-Level System Topology & Polyglot Engine
graph TB
subgraph CLI_LAYER["π₯οΈ CLI & Interface Control Plane"]
CLI["secagent CLI (Rich TUI)"]
MCP["π MCPServer (JSON-RPC stdio)"]
PLAYBOOK["π Playbook Engine (YAML Methodologies)"]
CAPSULE["π¦ Proof Capsule Engine & Replayer"]
HITL["πΉοΈ Teleoperation Controller (Double Ctrl+C)"]
BUDGET["π° BudgetGuard (Token & Cost Accounting)"]
SCOPE["Scope Gate (Fail-Closed Enforcer)"]
VAULT["Vault Key Manager (.env Loader)"]
PREFLIGHT["Preflight Integrity Checker"]
end
subgraph MEMORY_LAYER["π§ Cognitive Memory Subsystem"]
AURA["AuraMemoryManager (Target DNA & Pattern Engine)"]
DB[("πΎ SQLite / aura-memory SDK Database")]
end
subgraph SWARM_LAYER["π Python Agent Swarm"]
PLANNER["π― Planner Agent (Armada DAG Builder)"]
RECON["π Recon Agent (httpx + Async Prober)"]
WEB["π Web Security Agent"]
API["β‘ API Security Agent"]
WEB3["πΈοΈ Web3 Security Agent"]
VALIDATOR["π¬ Validator Agent (Crucible)"]
REPORTER["π Report Agent"]
end
subgraph ENGINE_LAYER["βοΈ Polyglot Core Engine"]
CPP["β‘ C/C++ Foundational Core (cpp-core)"]
RUST["π¦ Rust Engine & Priority Scheduler"]
GO["πΉ Go Subdomain & Network Prober"]
REDIS[("π΄ Redis Pub/Sub Event Bus")]
end
CLI --> SCOPE
MCP --> SCOPE
PLAYBOOK --> SCOPE
CAPSULE --> VALIDATOR
HITL --> SWARM_LAYER
BUDGET --> SWARM_LAYER
SCOPE --> PREFLIGHT
PREFLIGHT --> VAULT
VAULT --> PLANNER
AURA <--> DB
PLANNER <-->|Recall Target DNA| AURA
PLANNER --> RECON
PLANNER --> WEB
PLANNER --> API
PLANNER --> WEB3
RECON --> GO
RECON --> RUST
RECON --> CPP
SWARM_LAYER --> REDIS
SWARM_LAYER --> VALIDATOR
VALIDATOR -->|Export Proof Capsule| CAPSULE
VALIDATOR -->|Crystallize Exploits| AURA
VALIDATOR --> REPORTER
5. C/C++ Foundational Core Engine (cpp-core) & Native Bridge Demonstration
SecAgent incorporates a compiled C++20 Foundational Core (cpp-core) for sub-millisecond execution tasks, SIMD-accelerated regex/signature matching, and asynchronous raw socket probing.
C++ Core Architecture Topology
graph LR
subgraph PYTHON_BRIDGE["π Python Native Bridge"]
PY_NATIVE["secagents.core.native"]
CTYPES["ctypes C-ABI Loader"]
end
subgraph CPP_ENGINE["β‘ C++ Foundational Engine (secagent_core)"]
C_API["c_api.cpp (extern 'C' Exported API)"]
MATCHER["FastMatcher (C++20 SIMD Regex Engine)"]
PROBER["RawSocketProber (Non-Blocking Socket Engine)"]
end
subgraph OS_KERNEL["π» OS Kernel"]
SOCKETS["Raw Sockets / AF_PACKET / Winsock2"]
end
PY_NATIVE --> CTYPES
CTYPES ==>|Direct C-ABI Calls| C_API
C_API --> MATCHER
C_API --> PROBER
PROBER ==>|Non-Blocking I/O| SOCKETS
Code Demonstration 1 β High-Speed C++ Signature Matching (fast_matcher.cpp)
#include "fast_matcher.hpp"
#include <regex>
namespace SecAgentCore {
bool FastMatcher::scan_signature(const std::string& buffer, const std::string& pattern) {
if (buffer.empty() || pattern.empty()) return false;
try {
std::regex re(pattern, std::regex_constants::icase | std::regex_constants::optimize);
return std::regex_search(buffer, re);
} catch (...) {
return buffer.find(pattern) != std::string::npos;
}
}
}
Code Demonstration 2 β Non-Blocking C++ Socket Prober (raw_socket.cpp)
#include "raw_socket.hpp"
#include <chrono>
namespace SecAgentCore {
ProbeResult RawSocketProber::probe_port(const std::string& host, int port, int timeout_ms) {
auto start = std::chrono::high_resolution_clock::now();
int sock = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
// Execute non-blocking socket connect with select() timeout monitoring...
auto elapsed = std::chrono::high_resolution_clock::now() - start;
double latency = std::chrono::duration<double, std::milli>(elapsed).count();
return {true, port, "open", latency};
}
}
Code Demonstration 3 β Exported C-ABI Bridge (c_api.cpp)
#include "c_api.h"
#include "fast_matcher.hpp"
#include "raw_socket.hpp"
extern "C" {
SECAGENT_EXPORT int secagent_match_signature(const char* buffer, const char* pattern) {
return SecAgentCore::FastMatcher::scan_signature(buffer, pattern) ? 1 : 0;
}
SECAGENT_EXPORT SecAgentProbeResult secagent_probe_port(const char* host, int port, int timeout_ms) {
auto res = SecAgentCore::RawSocketProber::probe_port(host, port, timeout_ms);
return {res.open ? 1 : 0, res.port, res.latency_ms};
}
}
Code Demonstration 4 β Python Native Bridge Invocation (native.py)
from secagents.core.native import native_engine
# High-speed C++ signature scanning
matched = native_engine.match_signature(response_body, r"Apache/\d+\.\d+")
# High-speed native socket probing
result = native_engine.probe_port("127.0.0.1", 80, timeout_ms=500)
print(f"Port Open: {result['open']}, Latency: {result['latency_ms']}ms")
2. Autonomous Scan Lifecycle Sequence
sequenceDiagram
autonumber
actor Operator as Operator / CLI
participant Pipeline as ScanPipeline
participant Memory as Aura Cognitive Memory
participant Swarm as Agent Swarm
participant Recon as Recon Agent (Go/httpx)
participant Validator as Crucible Validator
participant Reporter as Report Generator
Operator->>Pipeline: secagent scan -t target.com --depth standard
Pipeline->>Pipeline: Enforce Scope & Run Preflight System Checks
Pipeline->>Memory: Recall Target DNA & WAF Signature
Memory-->>Pipeline: Return Historical Fingerprints & High-Confidence Payloads
Pipeline->>Swarm: Initialize Swarm DAG with Recalled Memory
Swarm->>Recon: Execute Active Subdomain & HTTP Probing
Recon-->>Swarm: Return Active Hosts, Services & Parameters
Swarm->>Swarm: Run Parallel Scans (Web, API, Web3, CVE Checks)
Swarm-->>Validator: Submit Raw Finding Signals
Validator->>Validator: Replay PoC Payloads & Linear-Scale Latency Checks
Validator->>Memory: Crystallize Validated Exploit Patterns & Update Target DNA
Validator-->>Reporter: Return 100% Confirmed Vulnerabilities
Reporter->>Operator: Render Mission Intelligence Summary & Save Deliverables
3. Multi-Agent Swarm Decision Logic
graph LR
SUB["Supervisor Agent"] -->|Classify Intent| PLAN["Planner Agent"]
PLAN -->|Execution Graph| WORKERS["Worker Swarm"]
subgraph WORKERS["Worker Swarm"]
direction TB
R["Recon Agent"]
W["Web Security"]
A["API Security"]
W3["Web3 Security"]
end
WORKERS -->|Raw Signals| VAL["Crucible Validator"]
VAL -->|Confirmed PoC| REP["Report Agent"]
style SUB fill:#0f3460,stroke:#e94560,color:#fff
style PLAN fill:#16213e,stroke:#00ffff,color:#fff
style VAL fill:#1a6b1a,stroke:#00ff00,color:#fff
style REP fill:#533483,stroke:#ff00ff,color:#fff
4. Multi-Provider LLM Fallback & Consensus Engine
flowchart TD
REQ["Agent Task Request"] --> PROVIDER{"Primary LLM Configured?"}
PROVIDER -- "OpenAI" --> OAI["OpenAI (GPT-4o)"]
PROVIDER -- "Anthropic" --> ANT["Anthropic (Claude 3.5)"]
PROVIDER -- "Gemini" --> GEM["Google (Gemini 1.5 Pro)"]
PROVIDER -- "Groq" --> GROQ["Groq (Llama-3 70B)"]
OAI -- "Fail / Rate Limit" --> ANT
ANT -- "Fail / Rate Limit" --> GEM
GEM -- "Fail / Rate Limit" --> GROQ
GROQ -- "Fail / Offline" --> LOCAL["Local Ollama Fallback"]
OAI --> CONSENSUS["Consensus Engine (Min Agreement: 2)"]
ANT --> CONSENSUS
GEM --> CONSENSUS
LOCAL --> CONSENSUS
CONSENSUS --> OUT["Validated Agent Decision"]
Quick Start Guide
# 1. Clone the repository
git clone https://github.com/gl1tch0x1/SecAgent.git
cd SecAgent
# 2. Run the automated deployment engine
python installer.py
# 3. Explicitly authorize the domain you own or have permission to assess
./secagent scope --add app.example
# 4. Initiate an autonomous red-team scan
./secagent scan --target app.example --depth standard
For an explicitly authorized one-off target, add --authorize-targets to scan; this authorizes only that command and still respects BLOCKED_DOMAINS. For a list, place one domain or root URL per line in a UTF-8 file, then run ./secagent scan --targets-file targets.txt --authorize-targets. Batch scans validate all targets before starting, run serially, and accept up to 100 targets. Session headers and identity, state, or callback contracts must be scanned separately per target. To persist a larger approved scope, use ./secagent scope --add app.example --add api.example or ./secagent scope --file approved-domains.txt (up to 1000 entries). The default remains fail-closed when no scope is supplied.
Installation Guide
Prerequisites
| Requirement | Minimum | Recommended | Notes |
|---|---|---|---|
| OS | Windows / Linux / macOS | Linux / macOS / WSL2 | Fully supported on native Windows PowerShell & Linux |
| Python | 3.11+ | Python 3.11, 3.12, 3.13 | Verified compatibility across environments |
| Git | Installed | Latest | Version control & update engine |
| Docker | (Optional) | 20.10+ | Not used for the Python scan path; scan handlers execute on the host |
Method 1 β Automated Installation Engine (Recommended)
The installer sets up a virtual environment, installs the Python package, creates entrypoints, and verifies that the CLI starts:
python installer.py --allowed-domains app.example
The installer shows a live phase board, timestamped execution events, active work and elapsed time. It adapts to narrow terminals and shows a deployment summary and first commands when finished. It creates .env without authorizing a target by default. Use --allowed-domains during setup or ./secagent scope --add DOMAIN afterward; scans remain blocked until the target is explicitly allowed. On Windows, use .\secagent.bat in place of ./secagent. Run ./secagent --help to verify the entrypoint.
In an interactive terminal, installation asks Yes / Skip for LLM setup when no saved provider configuration exists. Yes offers OpenAI, Claude, DeepSeek, Gemini, Ollama, and Other. Enter the provider's model ID; cloud keys are entered without terminal echo. Ollama uses a local host and does not require a key. Other expects an OpenAI-compatible chat-completions endpoint URL (including its route), model ID, provider name, and Bearer API key. Remote endpoints must use HTTPS; loopback HTTP is allowed. The installer saves the selected primary provider in the ignored local .env with owner-only permissions on Unix and reuses it on later installs or updates. Use python installer.py --configure-llm to replace that selection, or --skip-llm-setup for automation. The installer does not send a test prompt or validate a paid key.
Method 2 β Manual Package Installation
For developer control or integration into existing Python environments:
# 1. Create and activate virtual environment
python -m venv venv
# Windows PowerShell:
.\venv\Scripts\Activate.ps1
# Linux / macOS:
source venv/bin/activate
# 2. Install secagents package in editable mode
pip install -e ./python-agents[dev,browser]
Releases, Deployments & Packages
Releases
- Current Version:
v0.3.0 - Release Tracking: Managed via CHANGELOG.md
- Tagging: Follows Semantic Versioning (
MAJOR.MINOR.PATCH).
Deployment Models
SecAgent is engineered for flexible deployment across local machines, remote servers, and containerized clusters.
Docker Compose Deployment
Run the local API health service and background components:
docker compose up -d
Container inventory:
api: FastAPI health and metrics endpoints bound to127.0.0.1:8000;/healthreports degraded when optional services are not configuredredis: Pub/Sub event bus (:6379)rust-core: Rust priority task schedulerrecon: Go high-concurrency network proberworker: Python workflow processor
The CD workflow builds the API image from python-agents/Dockerfile. Staging deployment runs only when STAGING_SSH_ENABLED=true is configured; its smoke tests use the routes implemented by the API.
Standalone CLI Binary Deployment
The installer generates executable binary wrappers for quick invocation:
- Windows:
secagent.bat - Linux/macOS:
./secagent
Package Artifacts
The Python agent core is packaged as a standard PyPI wheel:
# Build python package wheel
cd python-agents
python -m build
Artifact generated: python-agents/dist/secagents-0.3.0-py3-none-any.whl.
Configuration & Operational Manifest
Operational parameters and API credentials are read from .env:
# βββ Primary LLM Provider Keys βββ
SECAGENT_LLM_PROVIDER=openai
SECAGENT_LLM_MODEL=gpt-4o-mini
OPENAI_API_KEY=sk-proj-...
ANTHROPIC_API_KEY=sk-ant-...
GEMINI_API_KEY=AIzaSy...
GROQ_API_KEY=gsk_...
DEEPSEEK_API_KEY=sk-...
# βββ Local LLM Configuration βββ
OLLAMA_HOST=http://localhost:11434
OLLAMA_MODEL=llama3.2:3b
# βββ Operational Scope & Infrastructure βββ
ALLOWED_DOMAINS=example.com,target.local
REDIS_URL=redis://localhost:6379/0
RESULTS_DIR=cog-ai-results
SECAGENT_VERIFY_SSL=true
Set SECAGENT_LLM_PROVIDER to openai, anthropic (Claude), deepseek, google (Gemini), ollama, or custom. For a custom OpenAI-compatible service, set SECAGENT_LLM_PROVIDER=custom, SECAGENT_LLM_NAME, SECAGENT_LLM_MODEL, SECAGENT_LLM_API_KEY, and SECAGENT_LLM_ENDPOINT=https://your-host/v1/chat/completions. SecAgent sends the custom key as a Bearer token. The CLI reads .env in the current directory first, then the installation directory; SECAGENT_ENV_FILE can select a specific file. Keep API keys out of committed files and command-line arguments.
SecAgent MCP questions
Can I use SecAgent for web3 security?
Yes, it includes a Web3SecurityAgent for EVM and Solana smart contract security analysis, covering vulnerabilities like reentrancy and integer overflow.