v1.0.1 live scan & discover progress output

The red team framework for AI agent infrastructure.

One open-source tool runs the full offensive lifecycle (recon, credential looting, modelfile / system-prompt / fine-tune inventory, inversion, tool/instruction poisoning, config implants) across every layer of the agentic stack: MCP, A2A, gateways, inference servers, vector stores and notebooks. Then proves the attack paths in one Neo4j graph.

$ curl -sSfL https://raw.githubusercontent.com/adithyan-ak/agenthound/main/install.sh | sh
Apache 2.0 Single ~9.9 MiB collector 8 service planes 22 modules
Full-spectrum coverage

Maps and attacks every layer across MCP servers, A2A agents, LiteLLM, Ollama, vLLM, Qdrant, MLflow, Jupyter, Open WebUI, and LangServe.

The agentic stack

One framework, spanning every layer.

AgentHound treats the entire agentic estate as one target set: client configs, protocols, gateways, inference, vector stores, MLOps, notebooks, frontends. No single-protocol scanner, A2A scanner, or LLM-gateway tool covers this surface.

The agentic stack: AgentHound spans all of it targetsmodules
AgentHound
Agent clientplane
12 MCP client configsCLAUDE.md · .cursorrulesconfig
Protocolplane
MCP (stdio + HTTP/SSE)A2A agent cards · JWSmcpa2aprotoscan
Model gatewayplane
LiteLLM (master key + credential references)litellmfplitellmloot
Inferenceplane
Ollama (model inventory)vLLMollamalootvllmfp
Vector / RAGplane
Qdrant collectionsqdrantfpqdrantloot
MLOpsplane
MLflow experiments/runsmlflowfpmlflowloot
Notebookplane
Jupyter sessions + treejupyterfpjupyterloot
Frontendplane
Open WebUI (RAG, keys)LangServeopenwebuilootlangservefp
A framework, not a scanner

The full offensive lifecycle. One graph.

AgentHound sweeps, harvests, exploits, analyzes and cleans up. Recon and loot land structured evidence in one Neo4j graph; dry-run-first exploit, campaign and recovery workflows carry the engagement through without manual stitching.

01

scan

Scan local configs and MCP/A2A targets, or fingerprint AI/ML services across networks.

02

discover

JSON-RPC initialize probes + A2A agent-card fetches over the wire.

03

loot

Read-only credential, model and service inventory across LiteLLM, Ollama, Open WebUI, MLflow, Qdrant and Jupyter.

04

poison

Mutate tool descriptions or instruction files. --commit required.

05

implant

Plant persistence in .cursor/mcp.json & friends.

06

revert

Idempotent rollback by engagement-id. Receipts gate every mutation.

07

extract

Embedding inversion on locally obtained GGUF weights. Detect fine-tune training signals.

08

campaign

Verify predicted credential reach and reversible MCP poisoning with bounded live probes.

Loot becomes paths. Paths become proof.

Run a query. Get a critical path.

19 prebuilt attack-path queries, crosswalked to OWASP MCP & Agentic Top 10 and 7 MITRE ATLAS techniques. Findings snapshot to Postgres for retest-as-diff, proving a path is gone, not just re-reported.

Graph schema, in motion

23 node labels · 32 edge kinds
AgentInstance TRUSTS_SERVER MCPServer
MCPServer AUTHENTICATES_WITH Identity
Identity USES_CREDENTIAL Credential
LiteLLMGateway EXPOSES_CREDENTIAL Credential
AgentInstance CAN_REACH ⚡ Credential
MCPTool SHADOWS MCPTool
AgentInstance CAN_EXFILTRATE_VIA MCPTool
Credential records correlate across collectors through approved value_hash joins.
The offensive primitives

The capabilities that make it a framework.

Modelfile, system-prompt and fine-tune inventory, local model inversion, credential looting across gateways, tool and instruction poisoning, config implants, RAG enumeration, and the cross-protocol graph analysis that ties the loot together at the end.

Critical

Ollama model intelligence

The Ollama looter inventories model names, digests, sizes, modelfiles, templates and system prompts, and flags likely fine-tunes through the HTTP API. Raw model weights are not available through Ollama's HTTP API; obtaining them requires authorized filesystem access to the Ollama model store.

Critical

Credential looting

One LiteLLM master key → observed master-key exposure, masked provider references and hashed virtual-key inventory. Observed credential material correlates across collectors by value_hash.

Experimental

Model inversion

A pure-Go GGUF parser runs statistical inversion on the embedding matrix to recover likely fine-tune vocabulary tokens. Provide a GGUF copied through authorized filesystem access, then invert locally.

High

Tool & instruction poisoning

Rewrite an MCP tool description, or inject a sentinel block into CLAUDE.md / .cursorrules. Reversible, --commit-gated.

High

Config implant: persistence

Add a malicious MCP server to .cursor/mcp.json; the IDE auto-trusts the attacker's server on every future launch.

High

RAG / vector & notebook

Inventory Qdrant collections and Jupyter sessions/notebook trees; AgentHound records anonymous access only after a credential-free probe succeeds.

Critical

Cross-protocol CAN_REACH

15 post-processors compute 12 composite edges. CAN_REACH ties the loot together: the last-mile join, up to 6 hops, not the headline.

Safe by design

Receipt-backed reversibility

Every poison and implant persists a Receipt before mutation. revert is idempotent, Reverters are compile-time mandatory, and unsafe target-state conflicts fail closed.

The arsenal at a glance

Breadth, quantified.

22 self-registering modules, the protoscan discovery engine and 2 campaign scenarios converge on one queryable, pathfindable graph, crosswalked to OWASP MCP & Agentic Top 10 and 7 MITRE ATLAS techniques.

8
Service planes covered
client → frontend, end to end
22
Self-registering modules
+ the protoscan discovery engine
8
Lifecycle CLI commands
scan · discover · loot · extract · poison · implant · revert · campaign
12
AI-client config formats
Claude · Cursor · VS Code · Windsurf · Zed · Kiro…
23
Graph node labels
32 edge kinds · 15 post-processors
19
Prebuilt attack-path queries
credential-chain · rug-pull · exfil-routes…
35
Detection rules
+ 7 YAML fingerprint rules + 1 Jupyter detector
~9.9
MiB static collector
no DB/UI/server deps · offline by default
Get started in 60 seconds

Two binaries. Local-first. No product telemetry.

Prerequisites: Docker + Compose v2 — no Go, no Node.js, no git clone. The server runs from a prebuilt image and binds 127.0.0.1:8080; the collector is a single static binary, offline by default and sends no product telemetry.

1

Start the analysis server

Neo4j + Postgres + UI · binds 127.0.0.1:8080
$curl -sSfL https://raw.githubusercontent.com/adithyan-ak/agenthound/main/docker/docker-compose.public.yml | docker compose -f - -p agenthound up -d --wait
2

Install the collector

single static binary → ~/.local/bin
$curl -sSfL https://raw.githubusercontent.com/adithyan-ak/agenthound/main/install.sh | sh
$export PATH="$HOME/.local/bin:$PATH"
3

Scan local configs and stream them in

offline, read-only, raw credential values omitted
$agenthound scan --config --output - | curl -sSf --data-binary @- -H "Content-Type: application/json" http://127.0.0.1:8080/api/v1/ingest
4

Open the graph

http://127.0.0.1:8080
$(command -v open >/dev/null && open http://127.0.0.1:8080) || xdg-open http://127.0.0.1:8080

Attack the whole agentic stack from one tool.

Open source, Apache 2.0. Run the full offensive lifecycle, then prove every path. Built for red teams running real engagements against real MCP/A2A deployments.