Vet (Verify Everything) — Summary

Vet is a standalone, BYOK code-verification CLI (binary: vet, PyPI package: verify-everything) that uses LLM analysis to find issues in git diffs that linters and test suites miss. It ships a companion agent skill that installs into Claude Code, Codex, OpenCode, and Gemini CLI simultaneously, triggering automatically after every logical unit of code change. Unlike most quality tools that check syntax or style, Vet cross-examines the diff against the original stated goal and the agent's conversation history to catch intent-implementation mismatches — the case where code changed but not in the direction the user actually wanted. It supports BYOK via OpenAI-compatible endpoints, ships an --agentic mode that routes analysis through an installed agent harness instead of raw API calls, and publishes findings as GitHub PR review comments via a reusable GitHub Actions workflow. Exit code semantics (0 = clean, 10 = issues found, 1 = runtime error, 2 = usage error) are explicitly designed for CI and agent tool-loops.

Differs from seeds: Closest to superpowers (skills-only behavioral framework, zero commands, activates proactively). Key delta: Vet is a verification artifact — it produces a machine-readable JSON/text issue list — whereas superpowers produces behavioral Iron Laws. Vet also ships a real CLI binary that CI can invoke independently; superpowers has no binary. Most distinct from kiro and claude-flow which manage workflow phases; Vet inserts only at the verification gate.

Vet — Origin, Philosophy, and Manifesto

Origin

Built by Imbue AI (imbue.com), a lab focused on building AI systems with genuine reasoning capabilities. Vet emerged from the problem of AI coding agents confidently implementing the wrong thing — passing all tests while misreading user intent or introducing subtle logic errors. Released under AGPL-3.0, publicly available on PyPI as verify-everything.

Philosophy

"Vet reviews intent and code: checks agent conversations for goal adherence and code changes for correctness."

"Run vet immediately after ANY logical unit of code changes. Do not batch your changes, do not wait to be asked to run vet, make sure you are proactive."

The core opinion: tests and linters verify mechanical correctness; Vet verifies semantic intent. The SKILL.md explicitly instructs agents to not batch changes and not wait to be asked — treating verification as a continuous obligation, not a terminal step.

Multi-harness philosophy

Vet's install script deposits the same skill file into .agents/, .opencode/, .claude/, and .codex/ simultaneously. The stated goal is to work identically across all major coding agents so the user's choice of harness doesn't degrade verification quality.

Bring-Your-Own-Model

Vet explicitly rejects the model-lock pattern. Custom model definitions via OpenAI-compatible endpoints are supported through a JSON config file at $XDG_CONFIG_HOME/vet/models.json or .vet/models.json. A --update-models flag fetches community model definitions from a remote registry, decoupling model support updates from CLI version bumps.

Explicit design choice: argparse over click/typer

From the CLI source comments: "The choice to use argparse was primarily driven by the idea that vet will be called by agents / llms. Given this, we want to have the most standardized outputs possible." — a rare explicit statement of agent-first CLI design.

Vet — Architecture, Distribution, and Installation

Distribution

• PyPI package: verify-everything (pip/pipx/uv install)
• GitHub Action: imbue-ai/vet@main (reusable workflow for PR review)
• Agent skill: installed via install-skill.sh or manual curl loop into .claude/skills/vet/, .agents/skills/vet/, .opencode/skills/vet/, .codex/skills/vet/

Version analyzed: 0.2.12

Installation

# CLI
pip install verify-everything
pipx install verify-everything
uv tool install verify-everything

# Agent skill (project level)
curl -fsSL https://raw.githubusercontent.com/imbue-ai/vet/main/install-skill.sh | bash

# GitHub Actions (PR review bot)
# see .github/workflows/vet.yml with uses: imbue-ai/vet@main

Directory Tree

vet/
├── skills/
│   └── vet/
│       ├── SKILL.md            # Agent skill file (multi-harness)
│       └── scripts/
│           ├── export_claude_code_session.py
│           ├── export_codex_session.py
│           ├── export_opencode_session.py
│           └── export_gemini_cli_session.py
├── vet/                        # Python package
│   ├── cli/
│   │   ├── main.py             # argparse-based CLI (agent-first design)
│   │   └── config/
│   ├── issue_identifiers/      # issue detection logic
│   ├── imbue_core/             # LLM client abstraction
│   └── vet_types/
├── registry/
│   └── models.json             # community model definitions
├── action.yml                  # GitHub Actions reusable workflow
├── pyproject.toml              # entry: vet = "vet.cli.main:main"
└── .vet/                       # local config (models.json override)

Required Runtime

• Python >= 3.11
• Git (for diff computation)
• At least one: ANTHROPIC_API_KEY, OPENAI_API_KEY, or OpenAI-compatible endpoint, OR an installed agent harness (claude/codex/opencode) when using --agentic

Target AI Tools

• Claude Code (primary — SKILL.md installs to ~/.claude/skills/)
• Codex CLI (~/.codex/skills/)
• OpenCode (~/.opencode/skills/)
• Gemini CLI (~/.gemini/skills/ — via export script)
• GitHub Actions CI (via reusable workflow)

Config Files

• $XDG_CONFIG_HOME/vet/models.json — custom model definitions
• .vet/models.json — per-repo model override
• Supports --config flag for preset selection

Vet — Components

CLI Binary: vet

Single-binary CLI with no subcommands — all configuration is via flags.

Key flags:

• vet "goal" — run verification against current git diff
• --base-commit REF — diff base (default: HEAD)
• --staged — only analyze staged changes
• --history-loader "cmd" — shell command that outputs agent conversation history
• --model MODEL — LLM to use (default: claude-opus-4-7)
• --agentic — route analysis through locally installed agent harness
• --agent-harness claude|codex|opencode — select harness for --agentic mode
• --confidence-threshold N — minimum confidence 0.0–1.0 (default: 0.8)
• --output-format text|json|github — output format
• --max-spend — spending cap in USD
• --list-models — list all supported models
• --update-models — fetch community model definitions from remote registry
• --list-issue-codes, --enabled-issue-codes, --disabled-issue-codes — selective check control

Exit codes: 0 = clean, 1 = runtime error, 2 = usage error, 10 = issues found.

Agent Skill: vet/SKILL.md

One skill file compatible with Claude Code, Codex, OpenCode, and Gemini CLI. Instruction: run proactively after every logical unit of code changes. Contains:

• Session export commands per harness (using history-loader scripts)
• --session-file / --session-id discovery instructions per harness
• Interpretation notes (filter issues from other agents in same repo)
• Update instructions when CLI/skill becomes stale

Session Export Scripts (4)

• export_claude_code_session.py — reads .claude/projects/<encoded-path>/<session-uuid>.jsonl
• export_codex_session.py — reads ~/.codex/sessions/YYYY/MM/DD/<file>.jsonl
• export_opencode_session.py — uses opencode session list --format json
• export_gemini_cli_session.py — reads ~/.gemini/tmp/<project>/chats/

GitHub Action: imbue-ai/vet@main

Reusable GitHub Actions workflow. Inputs: agentic (bool). Handles: Python setup, vet install, merge-base computation, posting review comments to PR. Requires ANTHROPIC_API_KEY as repo secret.

Model Registry: registry/models.json

Community-maintained model definitions for OpenAI-compatible endpoints. Fetched remotely via --update-models flag.

Issue Identifiers Module

vet/issue_identifiers/ — Python modules implementing individual check types (goal adherence, code correctness, etc.). Not enumerated publicly in README; internal implementation detail.

Vet — Uniqueness and Positioning

Differs from Seeds

Vet is closest to superpowers in distribution pattern (skills-only, zero commands, proactive activation via skill description). The fundamental delta: Vet produces a machine-checkable verification artifact (JSON issue list with confidence scores) while superpowers produces behavioral instructions. Vet ships a real CLI binary that CI, pre-commit hooks, and human engineers can invoke independently of any agent — superpowers has no such external interface. Compared to spec-kit (Archetype 2: mirror commands + skills with hooks), Vet has no commands and no hooks — just a skill and a binary. Compared to claude-flow (MCP-anchored toolserver), Vet has no MCP layer. The closest analogy across all seeds would be a lightweight insertion at the verification gate only, without touching planning, spec, or commit phases.

Positioning

Vet occupies the narrow but technically interesting position of "goal-intent verifier" — it is not a linter (no syntax rules), not a formatter, not a test runner. It uses an LLM to answer the question "did the code change actually accomplish what was requested?" This positions it as a post-implementation sanity check that can catch the failure mode where all tests pass but the wrong behavior was implemented.

The multi-harness install (Claude Code + Codex + OpenCode + Gemini simultaneously) is unusual — most tools in this corpus are single-harness. Vet explicitly avoids harness lock-in as a design principle.

Observable Failure Modes

1. Session file mismatch: The history-loader grep can match the wrong session, causing Vet to analyze a different conversation's context. The SKILL.md has explicit disambiguation warnings for this.
2. Cost blowup on large diffs: No automatic diff size limit mentioned; --max-spend is the only governor.
3. AGPL copyleft: The AGPL-3.0 license means any product that ships Vet as a service must also open-source their integration. This limits commercial adoption in closed products.
4. False positives on shared repos: Multi-agent repos where several agents edit the same codebase will cause Vet to flag other agents' changes, requiring manual filtering.
5. No replay capability: Findings are not persisted; re-running on the same diff may return different results if the model response varies.

Explicit Antipatterns

• Batching changes before running Vet (contradicts the skill's Iron Law)
• Using Vet as a replacement for running tests (explicitly stated in SKILL.md: "not a replacement for running tests")