Marq

Your universal cyber assistant

Ask anything across security and get the right tools and current expertise to answer it — on whatever model you choose, local or frontier.

"Threat-model this payment API."                       → architecture
"Map our pentest findings to ISO 27001 and SOC 2."     → GRC + standards
"What does this malware sample actually do?"           → malware
"Run an authorized pentest of *.acme.com."             → offensive
"Our breach-notification clock under GDPR + US law?"   → regulation
"Build the ransomware incident runbook."               → IR + resilience

~80 security tools + ~80 expert playbooks (current 2026 standards), in one auditable binary. You bring the model; marq brings the tools and the knowledge.

Start

Pick your path — start simple, add a layer only when you need it:

Just the skills — cyber expertise for your LLM (no Docker)

The lowest-friction way in: add the skills library + advisory tools to any MCP client and skip the offensive tool suite entirely. MARQ_SKILLS_ONLY=1 loads only the in-process knowledge tools (skills, findings, files) — no scan capabilities and no Kali binaries, so it's a single static Go binary you run natively:

go install github.com/rhaist/marq/cmd/marq@latest   # ~10 MB, skills embedded
marq skills                                          # browse all 80, by domain
marq skills nis2-dora                                # read one, no client needed

claude mcp add marq-skills \
  -e MARQ_SKILLS_ONLY=1 -e MARQ_WORK_DIR=$HOME/.marq \
  -e MARQ_AUDIT_LOG=$HOME/.marq/audit.jsonl \
  -- marq serve

Now ask "Map our pentest findings to ISO 27001 and SOC 2" or "What's our breach-notification clock under GDPR and NIS2?" and the model loads the right playbook (current 2026 standards) and drafts the deliverable. Scripted end-to-end demo: scripts/demo-skills.sh.

Prefer containers, or already pulled the image? The same mode runs there too — use the marq-skills entry in mcp.json.example. Add the full tool suite below when you need to run something, not just reason about it.

The full tool suite

To run tools (recon, web, AD, exploitation…), not just reason, get the image:

# prebuilt — or build from source: docker build -t marq .
docker pull ghcr.io/rhaist/marq && docker tag ghcr.io/rhaist/marq marq

# first check: which build, and how many tools/skills did it come with
docker run --rm marq version

# the catalog — add a name (`marq tools nmap`) for one tool's schema
docker run --rm marq tools

No Docker Desktop needed — OrbStack (macOS) or Podman / Colima (Linux) run it just as well (docs/SETUP.md). Then drive it fully local (below) or point a frontier MCP client at it.

Run it fully local

Your own model, on your box: no cloud, nothing leaves the host — the recommended setup for hands-on offensive work. Drive marq from Pi over llama.cpp:

# 1. the model — full flags matter: --reasoning-format keeps chain-of-thought
#    out of the reply, --jinja makes tool calls parse (see docs/SETUP.md §2a)
llama-server -hf google/gemma-4-12B-it-qat-q4_0-gguf \
  --host 127.0.0.1 --port 8080 -ngl 99 --ctx-size 65536 --jinja \
  --reasoning-format deepseek \
  -fa on -ctk q8_0 -ctv q8_0 \
  --temp 1.0 --top-p 0.95 --top-k 64

# 2. marq in a long-lived container bound to your workspace. The shim ships
#    inside the image, so it always matches the marq it drives — no clone.
mkdir -p ~/.local/bin && docker run --rm marq shim > ~/.local/bin/marq
chmod +x ~/.local/bin/marq

marq up ~/work

# 3. one-time Pi config — marq's system prompt. Without it a small model
#    narrates instead of driving marq. → docs/SETUP.md §4
mkdir -p ~/.pi/agent && marq prompt system > ~/.pi/agent/SYSTEM.md

# then run `pi`

Then just talk to it: "Set scope to scanme.nmap.org and run a quick nmap," or "Load the nis2-dora skill — what's our breach clock?" Full local walkthrough (Pi provider, skill, tuning) → docs/SETUP.md.

Or fall back to a frontier model

For the heaviest reasoning (architecture, GRC, IR write-ups), point a frontier MCP client at marq instead:

claude mcp add marq -- docker run --rm -i \
  --security-opt no-new-privileges:true --cap-drop ALL \
  --cap-add NET_RAW --cap-add NET_ADMIN --cap-add NET_BIND_SERVICE \
  -v marq-audit:/var/log/marq -v marq-work:/work -e MARQ_OPERATOR="$USER" marq

Any MCP client works (Codex, Claude Desktop) → docs/CLIENTS.md. (The caps are only what SYN scans need. No keys or config required; optional API keys in docs/USAGE.md.)

Authorized use. Advisory/knowledge is open; scanning & exploitation are authorized-only and audit-logged — docs/SECURITY.md.

What you get

• Execution — ~80 wrapped Kali tools (recon, web, AD/internal, exploitation, cred cracking, malware static analysis, OSINT), each audit-logged and sandboxed; findings render to findings.md / .csv (with optional CVSS + CWE).
• Knowledge — ~80 load_skill playbooks across 14 domains, web-researched to current (2026) standards, telling the model how to use the tools and what to do where there's no tool: offensive, malware, threat-intel, sec-ops, architecture, GRC, standards & EU/US regulation, CISO, red/purple, resilience, human factors, DevSecOps/privacy. Run these standalone with MARQ_SKILLS_ONLY=1 — no tool suite, no Kali binaries.
• Auditable by design — every external-tool call funnels through one choke point: an append-only, fsync'd audit log, a timeout, and an output cap. File access is sandboxed to /work+/tmp, and the image runs non-root (the recommended run args also drop all Linux capabilities + no-new-privileges).

MCP client  ──stdio JSON-RPC──▶  marq serve  ┐
terminal agent (Pi) ──bash──▶  pi/marq shim ─┤   both hit the same registry
                              (docker exec)  │
                                             ▼
                              registry.All() ── one Tool list
                                ├─ recon     nmap, naabu, dnsx, masscan…
                                ├─ osint     theHarvester, spiderfoot, shodan, gitleaks…
                                ├─ people    sherlock, maigret, user-scanner, phoneinfoga…
                                ├─ web       nuclei, katana, feroxbuster, sqlmap…
                                ├─ exploit   donut, hydra, searchsploit
                                ├─ internal  impacket, netexec, certipy, bloodhound, enum4linux…
                                ├─ creds     john, hashcat, name-that-hash
                                ├─ malware   capa, yara_scan, olevba, bin_headers
                                ├─ files     read/write/list (sandboxed /work)
                                └─ extras    report_finding, render_report, list_jobs, load_skill
                                             │
                                  runner.Run ──▶ audit.jsonl (every call)

           load_skill ──▶ skills library (markdown, ~80 playbooks / 14 domains)

Every exec tool funnels through internal/runner/runner.go::Run — the single point for audit logging, timeouts, and output truncation.

Documentation

License

GNU AGPLv3 — see LICENSE. © 2026 marq contributors. Free software; run a modified version as a network service and you must offer users its source. For authorized security testing and education, no warranty — use responsibly.