GSD Core is a framework that guides AI coding agents through a repeatable cycle of discussing decisions, planning, executing, verifying, and shipping software work. It is used with coding-agent runtimes to organize research and implementation in fresh-context subagents and reduce context degradation. The catalogue entries are its skills, agents, hooks, plugin, and instructions for those workflows.
Getting it into your agent
One page per mod, every tool's command on it. A separate URL per tool would split the same page into five that compete with each other.
git clone --depth 1 https://github.com/open-gsd/gsd-coreWrote this? Show the measurements
A badge with what this costs and how it scanned, read live from this page, so it follows the numbers instead of freezing them. Markdown for a README, HTML for a documentation site or a project page.
[](https://agentmods.dev/agents/open-gsd/gsd-core/gsd-verifier)<a href="https://agentmods.dev/agents/open-gsd/gsd-core/gsd-verifier"><img src="https://agentmods.dev/badge/agents/open-gsd/gsd-core/gsd-verifier/github.svg" alt="Measured on agentmods" height="20"></a>Or the 80×15 button, for a site that already has a row of RSS and ATOM ones. Only the verdict fits; the numbers stay here.
<a href="https://agentmods.dev/agents/open-gsd/gsd-core/gsd-verifier"><img src="https://agentmods.dev/badge/agents/open-gsd/gsd-core/gsd-verifier.svg" alt="Reviewed on agentmods" width="80" height="20"></a>What it costs to keep this loaded
Counted locally with the o200k_base tokenizer, which is exact for GPT models; Claude uses its own tokenizer and its counts differ. Treat this as one consistent yardstick across the catalogue rather than a bill. Prices are per million input tokens.
| Model | Per session | Once invoked |
|---|---|---|
| Fable 5.1 | $0.00036 | $0.11998 |
| Opus 5.5 | $0.00014 | $0.04799 |
| Sonnet 5.5 | $0.00007 | $0.02400 |
| Haiku 4.5 | $0.00004 | $0.01200 |
Grade C, and why
gsd-verifier scanned grade C with 2 findings against 26 rules in 11 categories — prompt injection, anti-refusal, data exfiltration, privilege escalation, supply chain, agent snooping, system-prompt leakage, SSRF and excessive agency — measured 3d ago.
A static scan of the body, not an audit. Every finding is printed with the line that produced it so you can judge whether it matters here. A mod is markdown that instructs an agent; that is exactly why what it instructs is worth reading.
Downloads and executes remote codehighSupply chain
curl | sh runs whatever the server returns today, which is not necessarily what it returned when this was reviewed.
curl -s http://localhost:$PORT/api/$ENDPOINT 2>/dev/null | node -e "let b='';process.stdin.setEncoding('utf8');process.stdin.on('data',c=>b+=c);process.stdin.on('end',()=>{const d=JSON.parse(b);process.exit(Array.isArray Makes network callslowCapability
Not a fault in itself. Listed so you know the mod talks to something, and to what.
curl -s http://localhost:$PORT/api/$ENDPOINT 2>/dev/null | node -e "let b='';process.stdin.setEncoding('utf8');process.stdin.on('data',c=>b+=c);process.stdin.on('end',()=>{const d=JSON.parse(b);process.exit(Array.isArray How it starts
The opening of the file, as written. The whole thing — 969 lines — stays where its author put it; the contents beside it link to each section on GitHub.
Goal-backward verification. Start from what the phase SHOULD deliver, verify it actually exists and works in the codebase.
@~/.claude/gsd-core/references/mandatory-initial-read.md
Critical mindset: Do NOT trust SUMMARY.md claims. SUMMARYs document what Claude SAID it did. You verify what ACTUALLY exists in the code. These often differ.
<adversarial_stance> FORCE stance: Assume the phase goal was not achieved until codebase evidence proves it. Your starting hypothesis: tasks completed, goal missed. Falsify the SUMMARY.md narrative.
Common failure modes — how verifiers go soft:
- Trusting SUMMARY.md bullet points without reading the actual code files they describe
- Accepting "file exists" as "truth verified" — a stub file satisfies existence but not behavior
- Choosing UNCERTAIN instead of FAILED when absence of implementation is observable
- Letting high task-completion percentage bias judgment toward PASS before truths are checked
- Anchoring on truths that passed early and giving less scrutiny to later ones
Required finding classification:
- BLOCKER — a must-have truth is FAILED; phase goal not achieved; must not proceed to next phase
- WARNING — a must-have is UNCERTAIN or an artifact exists but wiring is incomplete Every truth must resolve to VERIFIED, FAILED (BLOCKER), or UNCERTAIN (WARNING with human decision requested. </adversarial_stance>
<required_reading>
@/.claude/gsd-core/references/verification-overrides.md
@/.claude/gsd-core/references/gates.md
@/.claude/gsd-core/references/verifier-phase-gates.md
@/.claude/gsd-core/references/verifier-evidence-gate.md
</required_reading>
This agent implements the Escalation Gate pattern (surfaces unresolvable gaps to the developer for decision). <project_context> Before verifying, discover project context:
Project instructions: Read ./CLAUDE.md if it exists in the working directory. Follow all project-specific guidelines, security requirements, and coding conventions.
Project skills: @~/.claude/gsd-core/references/project-skills-discovery.md
- Load
rules/*.mdas needed during verification. - Apply skill rules when scanning for anti-patterns and verifying quality.
agent_skills: self-load per @~/.claude/gsd-core/references/agent-skills-bootstrap.md (agent type: gsd-verifier)
</project_context>
<core_principle> Task completion ≠ Goal achievement
A "create chat component" task can be complete with a placeholder file — task done, goal "working chat interface" missed.
Start from the outcome and work backwards:
- What must be TRUE for the goal to be achieved?
- What must EXIST for those truths to hold?
- What must be WIRED for those artifacts to function?
Then verify each level against the actual codebase. </core_principle>
<verification_process>
At verification decision points, apply structured reasoning: @~/.claude/gsd-core/references/thinking-models-verification.md
At verification decision points, reference calibration examples: @~/.claude/gsd-core/references/few-shot-examples/verifier.md
Resolver Bootstrap (Every Mode)
gsd_run is used in initial and re-verification mode alike, so it is defined here, before Step 0, not inside a mode-specific step. Each Bash call is a fresh shell, so a gsd_run function defined in one call does not exist in the next: every Bash snippet below that calls gsd_run (in any step, in any mode) must begin with this resolver block in the same call. If gsd-tools.cjs cannot be found, never search the filesystem (no find /, no find "$HOME"): use the runtime config directory's gsd-core/bin/gsd-tools.cjs (${CLAUDE_CONFIG_DIR:-$HOME/.claude}/gsd-core/bin/gsd-tools.cjs on Claude Code) or stop and report.
@~/.claude/gsd-core/references/gsd-run-resolver.md
What this file has done since we first saw it
Hashed on every crawl. A supply-chain change to an agent config is a question of when, not whether, so the history is kept rather than the latest state alone.
- 3d ago Changed 09ee6a8722c4
- 16d ago Changed · +5 lines c303f26f3ab5
- 17d ago Changed 2a9ed1c184ff
- 19d ago Changed · +17 lines 9e7810f3aedd
- 21d ago Changed ee0541220574
- 25d ago Changed 2ae954f5ccae
- 28d ago Changed · +1 lines 1a97a846cec5
- 1mo ago Changed 89b629c49af7
- 1mo ago Changed · +5 lines 31f229e29100
- 1mo ago First seen · 941 lines · 36 tokens per session scan C c8b35390ef37
gsd-verifier is an agent published in the GitHub repository open-gsd/gsd-core (10,687 stars, last pushed today), licensed MIT. It adds 36 tokens to every session and 11,998 once invoked, about $0.0001 per session on Opus 5.5. A static security scan graded it C with 2 findings (downloads and executes remote code, makes network calls). No closer match exists in the catalogue, so it is treated as the original; first seen 2026-08-30.
Other agents, from other repositories
reviewer
Structured code review with severity ratings and actionable fixes.
gsd-code-fixer
Applies fixes to code review findings from REVIEW.md. Reads source files, applies intelligent fixes, and commits each fix atomically. Spawned by /gsd:code-review --fix.
gsd-code-reviewer
Reviews source files for bugs, security issues, and code quality problems. Produces structured REVIEW.md with severity-classified findings. Spawned by /gsd:code-review.
gsd-ui-auditor
Retroactive 6-pillar visual audit of implemented frontend code. Produces scored UI-REVIEW.md. Spawned by /gsd:ui-review orchestrator.
gsd-security-auditor
Verifies threat mitigations from PLAN.md threat model exist in implemented code. Produces SECURITY.md. Spawned by /gsd:secure-phase.
gsd-doc-verifier
Verifies factual claims in generated docs against the live codebase. Returns structured JSON per doc.