Aegis Skills

A reusable security-audit skillset that any coding agent can execute, from top-tier models
down to basic file-reading assistants. It audits source code and the Linux servers that
serve it, writes standardized finding reports with proof and fixes, and covers the loop
from detection through incident response.

It targets solo developers and small teams protecting their own internet-facing services,
and scales to a shared team methodology. New to security terms? Start with
GUIDE.md; this file is the map and manual.

The project began in August 2026 as a distillation exercise with the ox-alpha model and is
now model-agnostic: any capable agent can run, audit, and extend it. There is nothing to
install and no accounts; you need bash, grep (ripgrep recommended), find, and
standard Unix tooling.

What's inside

Three orchestrators divide the work. Each is an entry point you hand to an agent, and each
owns one folder under skills/.

Supporting files: templates/ (mandatory report formats), tools/ (13 read-only evidence
sweep scripts plus a runner), GUIDE.md (human-readable concept guide), and
COVERAGE.md (standards-to-modules completeness matrix).

Install as agent skills

Every module follows the open agentskills.io format
(<name>/SKILL.md), so the kit installs directly into Claude Code, OpenCode, Cursor,
Codex, Windsurf and 40+ compatible agents:

npx skills add AS-FOSS/aegis-skills                        # all 40 modules
npx skills add AS-FOSS/aegis-skills -s injection -s AUTHN  # pick modules

Claude Code users can alternatively install it as a plugin:

/plugin marketplace add AS-FOSS/aegis-skills
/plugin install aegis-skills@aegis

The three orchestrator files stay at the repository root as entry-point documents; read
them in the agent chat instead of installing.

The check modules

Code and application audits (skills/code/, owned by SKILL-CODE.md)

Input handling and code execution

Identity and access

Web surface and protocols

Data, secrets and crypto

Logic, availability and platform

Supply chain and integrity

Specialized surfaces

Linux server audits (skills/server/, owned by SKILL-SERVER.md)

Operations loop (owned by SKILL-OPERATIONS.md)

Every module opens with a zero-background Prerequisites & Vocabulary primer, then follows
the same 12-section audit contract, from ripgrep-ready signatures through curl-based
reproduction steps to remediation diffs and fix-verification plans. See
SKILL-CODE.md §Registry for trigger conditions and priorities, and
GUIDE.md for plain-language explanations of each class.

Quick start

1. Audit a codebase

Point your agent at this repository with a prompt like:

Read SKILL-CODE.md fully, then execute a full security audit of <path-to-target-repo>.
Authorization: I own this code. Static analysis only.

The agent runs recon, dispatches the applicable check modules, and writes findings plus a
summary under security-audit/<run-id>/.

2. Audit a server

Read SKILL-SERVER.md fully, then audit host <host/IP> over SSH.
Authorization: I own this host. Read-only inspection only.

Same idea, host-flavored: exposure map first, then hardening checks, ending in a
prioritized checklist.

3. Collect evidence with the sweeps (recommended before a server audit)

The sweeps are shell scripts that pull the same set of facts from a host every time:
listeners, firewall state, config keys, secrets on disk. They write plain-text reports and
change nothing. Running them first means your agent only interprets results instead of
inventing commands, which matters most for weaker models.

Three steps. In every command below, replace user@host with your server login and
/opt/aegis-skills with wherever you want the toolkit to live on that server.

Step 1: put this toolkit onto your server. Run from your workstation, inside your
local clone of this repository (./ means "this folder"). Pick whichever line fits:

git clone https://github.com/AS-FOSS/aegis-skills /opt/aegis-skills   # host has git access? run it there
rsync -a --exclude .git ./ user@host:/opt/aegis-skills/                  # otherwise push the folder from here

Step 2: run every sweep on the server. This creates a folder of text reports on the
server itself:

ssh user@host 'cd /opt/aegis-skills && ./tools/run-all-sweeps.sh'

Step 3: copy those reports back to your workstation so you can hand them to your
agent. <timestamp> is the folder name step 2 printed, like sweep-evidence-20260825-0700:

rsync -a user@host:/opt/aegis-skills/sweep-evidence-<timestamp>/ ./evidence/

Give each report to the agent together with its matching skills/server/<name>/SKILL.md.

What you get per audit

security-audit/<run-id>/
├── PROGRESS.md          # resumable ledger of every step taken
├── TARGET-PROFILE.md    # languages, entry points, which modules apply and why
├── SUMMARY.md           # stats, top risks, chained attack paths, remediation roadmap
└── findings/
    └── INJ-001-sqli-in-search.md

Each finding file contains location, root cause, affected surface, a working PoC, impact,
a before/after fix, and a plan to verify the fix actually closes the hole. Statuses move
Needs-Review → Probable → Confirmed → Fixed → Verified-Fixed; severities come from
written rubrics with CVSS vectors.

Ground rules baked into the skillset

• Authorization gate: agents refuse targets the user doesn't own or have written
  permission to test.
• Evidence rule: no claim without captured command output or quoted file:line;
  otherwise the finding auto-downgrades to Needs-Review.
• Determinism protocol: closed-world execution, stop-and-record instead of
  improvising, lookup-table severities. A weak model following it produces a complete,
  honest, reviewable audit; a strong model produces the same with fewer false positives.
• Redaction rule: secret values never appear in reports or sweep output.
• Read-only default: applying fixes is a separate, explicitly requested phase.

Requirements

Versioning

Both orchestrators carry a version: frontmatter field. Bump the minor version when
adding or changing modules, the patch version for copy edits, and tag the commit
(vX.Y.Z). Audit runs record the version they executed, so posture can be diffed over
time. Current: v1.2.0.

Extending

New modules follow the 13-section skeleton and register in their orchestrator's registry;
see Appendix B in SKILL-CODE.md for the authoring spec. New sweeps must satisfy
tools/README.md. Design rule for additions: a basic agent following the letter of the
module must still produce a correct result, so prefer literal commands over prose and
downgrade uncertainty instead of guessing.

Scope and honesty

This covers the vulnerability classes behind most real-world breaches of internet-facing
services. It does not replace dynamic penetration testing, network-layer DDoS mitigation,
social-engineering defense, or a 24/7 SOC. It makes all of them cheaper by telling you
exactly where your weaknesses are.

Credits and license

Project layout and some domain surfaces were inspired by browsing
mukul975/Anthropic-Cybersecurity-Skills.
Every module here was written natively for this playbook's format and accuracy contract.
Licensed Apache-2.0 (LICENSE). Security tooling: use only against systems you own
or are authorized to test.