Aurite Agent Verifier — Summary

Agent Verifier is a coding agent skill that runs automated verification on AI-generated code, specifically targeting agent-specific failure patterns (hallucinated tools, unbounded loops, missing retry limits) alongside security gaps and language-specific quality checks. It is installed once via npx skills add aurite-ai/agent-verifier and thereafter triggered by natural-language commands like "verify agent" or "audit agent."

The skill is structured as a modular orchestrator that dispatches to four focused sub-skills: verify-security, verify-patterns, verify-quality, and verify-language. Checks are classified as either pattern-matched (deterministic, same result every run) or heuristic (judgment-based, may vary). The tool is explicitly not a replacement for linters — it catches what static analysis tools cannot: context-size analysis, tool-registry consistency, and LangGraph cycle detection.

All analysis runs locally; no code leaves the user's machine. The skill supports Claude Code, Cursor, Windsurf, Roo Code, Codex, and 30+ other agents.

Compared to seeds: closest to spec-kit's pre-ship validation gates, but agent-verifier focuses exclusively on correctness-of-AI-agent-code (loops, tool hallucinations, context limits) rather than spec compliance. Unlike superpowers' verification-before-completion (which is a process skill), agent-verifier applies deterministic check patterns derived from framework detection (LangGraph, CrewAI, AutoGen, LangChain).

Aurite Agent Verifier — Overview

Origin

Built by Aurite AI (aurite.ai), a startup focused on enterprise-grade secure agent infrastructure. The tool was released as open source (MIT) as a community offering; enterprise capabilities (shared context pools, administrative controls, centralized hosting) are available commercially.

Philosophy

AI coding agents are powerful but skip linting, ignore security basics, and hallucinate tool calls. Code reviews catch some of this, but not consistently. Agent Verifier acts as an automated reviewer that specifically checks for patterns no static analyzer can detect: AI agent anti-patterns that only exist because code is generated by an AI operating in an agent loop.

"AI coding agents are powerful — but they skip linting, ignore security basics, and hallucinate tool calls."

"Agent Verifier is an AI agent skill that acts as an automated reviewer."

Two-Tier Reliability Model

The skill introduces a formal distinction between check types:

• Pattern-matched checks [P]: Mechanical rule applied to code structure — same answer on every run (high reliability)
• Heuristic checks [H]: Requires interpretation of intent or quality — best-effort (may vary)

This explicit reliability tagging lets users understand which findings are authoritative vs. advisory.

Supported Agent Frameworks

The skill auto-detects the agent framework used:

• langgraph imports → LangGraph (enables cycle analysis)
• crewai imports → CrewAI
• autogen imports → AutoGen
• langchain imports → LangChain
• Direct SDK usage → Custom agent

Explicit Antipatterns Targeted

• Hardcoded API keys and secrets
• Unbounded retry loops (@retry without explicit stop)
• while True / for {} without break in scope
• Tool names referenced in prompts but not defined in registry
• System prompts exceeding recommended token limits
• Unpinned dependencies
• TypeScript any types
• Go errors silently discarded (_ = fn())
• LangGraph cycles with no reachable END node

Aurite Agent Verifier — Architecture

Distribution

• Type: skill-pack (multi-agent skill with orchestrator + 4 sub-skills)
• License: MIT
• Install complexity: one-liner via npx skills

Install Commands

# Primary (npx skills CLI)
npx skills add aurite-ai/agent-verifier -a claude-code -a cursor -a <your-agent>

# Then trigger via natural language:
verify agent

Directory Layout

skills/
├── verification/
│   └── SKILL.md          # Orchestrator: full verification suite
├── verify-security/      # Security checks (secrets, deps, input validation)
├── verify-patterns/      # Agent pattern checks (loops, retries, tools, context)
├── verify-quality/       # Code quality (naming, org, documentation)
├── verify-language/      # Language-specific (Python type hints, TS strict, Go errors)
docs/
├── getting-started.md
└── tutorials/
    └── 01-installation.md
tests/
└── fixtures/             # Test directories with known issues for validation
assets/
└── agent_verifier.gif    # Demo animation

Target AI Tools

• Claude Code (primary)
• Cursor
• Windsurf
• Roo Code
• Codex
• 30+ other agents

Required Runtime

No runtime dependencies beyond the AI agent (runs locally via agent's existing capabilities — Read, Glob, Grep tools).

Config Files

• .kahuna/context-guide.md — optional organizational rules (Kahuna integration)

Aurite Agent Verifier — Components

Skills (Sub-skill Architecture)

Pattern-Matched Checks (Deterministic)

Heuristic Checks (Best-Effort)

• Code organization appropriateness
• Naming convention consistency
• Input validation sufficiency
• Docstring quality/usefulness
• Tool error handling adequacy

Report Format

# Verification Report
✅ 8 checks passed | ⚠️ 3 warnings | ❌ 2 issues

### By Category
| Category | Pass | Warn | Issue |
| Code Quality | 5 | 1 | 0 |
| Security | 2 | 0 | 1 |
| Agent Patterns | 1 | 2 | 1 |

Aurite Agent Verifier — Uniqueness & Positioning

Differs From Seeds

Closest seed: superpowers (verification-before-completion skill). But superpowers' verification skill is a process guide — it tells the agent how to verify work (run tests, check linting, etc.). Agent Verifier is a content checker — it applies specific rules to detect specific anti-patterns in AI-generated code. Unlike superpowers, agent-verifier introduces a formal reliability taxonomy (pattern-matched [P] vs heuristic [H]) and targets AI-agent-specific failure modes (hallucinated tools, unbounded loops) that no seed framework explicitly covers.

Also distinct from spec-kit (spec compliance validation) and kiro (IDE-level steering hooks). Agent Verifier operates after implementation, not during it, and focuses on agent code specifically rather than general code quality.

Observable Failure Modes

1. Heuristic variability: [H]-tagged checks may give different results on successive runs — users must know which findings to trust.
2. No auto-fix: The tool reports but never applies fixes; remediation is entirely manual.
3. No continuous integration: Must be manually triggered; cannot be wired as a pre-commit hook.
4. Framework detection may fail: Custom agent patterns not matching known frameworks treated as "Direct SDK usage" — may miss framework-specific issues.
5. Token context limits: Very large codebases may cause context overflow during Glob/Read phases.

Distinctive Opinion

AI agent code has a distinct failure category not covered by any existing linter: the class of errors that only exist because the code was generated by an AI in an agent loop (hallucinated tool references, context size mismanagement, missing termination in retry/loop patterns). Static analyzers cannot detect these. Dedicated AI-agent verification tooling is a new required layer in the quality stack.

Positioning