Instruction-Tier Platforms for Ponytail: How Aggressiveness Levels Work Across AI Agent Hosts

Ponytail's instruction-tier system lets you select from four aggressiveness levels—lite, full, ultra, or off—to control how strictly its code-review ruleset is applied to an AI agent.

The open-source Ponytail repository (DietrichGebert/ponytail) provides a portable instruction-tier platform that adapts to numerous AI coding assistants. Each instruction-tier platform implements the same core mechanism: a selectable mode that injects the Ponytail ruleset before every LLM turn, enabling consistent code quality enforcement regardless of which host environment you use.

What Are Instruction-Tier Platforms?

An instruction-tier platform in Ponytail terminology is any AI agent host capable of loading the ruleset and exposing the /ponytail [lite|full|ultra|off] command family. The repository currently supports 13 distinct platforms, each with its own adapter glue but sharing identical tier behavior.

The four tiers determine rule enforcement intensity:

• lite: Critical YAGNI and native-feature checks only
• full: Complete ladder (YAGNI → stdlib → native → one-liner)
• ultra: Aggressive pruning with performance-cost benchmarks
• off: No ruleset injection; standard agent behavior

Claude Code and Codex

Claude Code was the original target platform. The plugin registers via /plugin marketplace add DietrichGebert/ponytail followed by /plugin install ponytail@ponytail. Once installed, the lifecycle hook UserPromptSubmit prepends the ruleset from AGENTS.md to every user prompt.

/ponytail ultra          # enable ultra-mode for current session

/ponytail                # report current mode (defaults to full)

/ponytail-review         # prune the current diff

Codex follows an identical pattern. According to the source in docs/agent-portability.md, Codex reads the hooks/ folder and injects the ruleset using the same slash command interface:

codex plugin marketplace add DietrichGebert/ponytail
codex plugin add ponytail@ponytail

GitHub Copilot CLI

The GitHub Copilot CLI loads the plugin through its marketplace system. Commands appear as either slash commands or $ponytail-prefixed shortcuts during interactive sessions.

# Start interactive session

copilot chat

# Activate ultra mode

$ponytail ultra

# Request review

$ponytail-review

The implementation lives in the hooks/ directory, with platform-specific JSON definitions controlling hook registration timing.

Pi Agent Harness

Pi installs Ponytail directly from source: pi install git:github.com/DietrichGebert/ponytail. The Pi runtime consumes hooks/qoder-hooks.json (or equivalent) to automatically activate the selected mode before each turn.

This instruction-tier platform requires no marketplace intermediate—installation is git-based and immediate.

OpenCode

OpenCode adds instruction-tier support through a simple JSON entry. In opencode.json:

{
  "plugin": ["@dietrichgebert/ponytail"]
}

The ruleset becomes part of active context for every prompt. OpenCode also exposes /ponytail commands through .opencode/command/ponytail.md for mode switching.

Gemini CLI and Antigravity CLI

Both Gemini CLI and Antigravity CLI (agy) use extension-based installation:

gemini extensions install DietrichGebert/ponytail
agy plugin install DietrichGebert/ponytail

The plugin registers /ponytail commands and injects the ruleset each turn. The instruction-tier mechanism remains identical to Claude Code's implementation.

Qoder

Qoder has unique integration: it automatically reads AGENTS.md at the repository root. The plugin adds six skills to .qoder/rules/ponytail.md:

• /ponytail (mode toggle)
• /ponytail-review
• /ponytail-audit
• /ponytail-debt
• /ponytail-gain
• /ponytail-help

Default mode is configurable via ~/.config/ponytail/config.json or the PONYTAIL_DEFAULT_MODE environment variable.

{
  "defaultMode": "full"
}

Qoder's hook PreToolUse triggers ruleset injection, as specified in hooks/qoder-hooks.json.

Hermes Agent

After hermes plugins install DietrichGebert/ponytail --enable, the Hermes Agent instruction-tier platform injects the active mode into every LLM turn. Skills expose as ponytail:<skill> slash commands rather than the standard / prefix.

CodeWhale

CodeWhale requires zero plugin installation. It reads AGENTS.md automatically when present in the repository root. The ruleset is always active, though /ponytail commands still function for tier adjustment.

This makes CodeWhale the simplest instruction-tier platform to adopt—no manifest, no marketplace, no configuration.

Swival

Swival stages skills globally or per-project:

swival skills add ponytail

Skills activate with the $ponytail prefix explicitly. Mode changes use the same prefix: $ponytail ultra.

Devin CLI, OpenClaw, and Grok Build

These platforms share the standard installation pattern:

Platform	Installation Command	Command Prefix
Devin CLI	devin plugins install DietrichGebert/ponytail	/ponytail
OpenClaw	clawhub install ponytail	/ponytail or ponytail:<skill>
Grok Build	grok plugin install DietrichGebert/ponytail --trust	/ponytail

OpenClaw generates its skill package from the skills/ directory, placing files in .openclaw/skills/ponytail/. Grok Build requires explicit trust flags due to code execution permissions.

How Tier Selection Works Internally

Regardless of instruction-tier platform, the mechanism follows four consistent steps as implemented in the source:

1. Mode storage: The selected tier persists in session state—environment variable, JSON file, or host-specific state store
2. Ruleset injection: Lifecycle hooks (UserPromptSubmit, PreToolUse, etc.) prepend AGENTS.md content plus a mode directive (ponytail:lite, ponytail:full, etc.)
3. Command routing: Skills in skills/ponytail/SKILL.md handle slash command invocations
4. Enforcement variation: The injected directive modifies which rules in the ladder are active

The hooks/ directory contains platform-specific JSON definitions mapping these hooks to host events. All platforms consume the same AGENTS.md ruleset and skills/ implementation—only the adapter glue differs.

Key Implementation Files

Understanding these files clarifies how instruction-tier platforms function:

• AGENTS.md — Core ruleset injected on every turn; defines the tier ladder
• docs/agent-portability.md — Platform-to-file mapping documentation
• hooks/qoder-hooks.json (and variants) — Hook registration for each host
• skills/ponytail/SKILL.md — Six skill implementations (ponytail, ponytail-review, etc.)
• .opencode/command/ponytail.md — OpenCode-specific command definition
• .github/copilot-instructions.md — Fallback for instruction-only adapters (Cursor, Windsurf)

Summary

• Instruction-tier platforms are AI agent hosts that load Ponytail's ruleset and expose tier-selection commands
• Four tiers control enforcement: lite, full, ultra, off
• 13 supported platforms share identical core behavior through adapter-specific hook registration
• Installation varies: marketplace plugins, git-based installs, JSON configuration, or zero-setup AGENTS.md reading
• Consistent files: AGENTS.md for rules, hooks/ for integration points, skills/ for command implementations

Frequently Asked Questions

What happens if I select "off" on an instruction-tier platform?

The ruleset is not injected into prompts. The AI agent behaves normally without Ponytail's code quality enforcement. No errors occur—the hook simply returns early without prepending content.

Can I use different tiers for different projects?

Yes. Most platforms support project-specific configuration. Qoder reads from the working directory's context. OpenCode uses per-project opencode.json. Swival allows per-project skill staging. Environment variables like PONYTAIL_DEFAULT_MODE can also be set per-project in your shell configuration.

Why does CodeWhale not require installation while Claude Code does?

CodeWhale natively scans for AGENTS.md files in repository roots as a built-in feature. Claude Code's architecture requires explicit plugin registration through its marketplace system. Both ultimately consume the same AGENTS.md content, but the delivery mechanism differs according to each host's design philosophy.

Which instruction-tier platform is best for beginners?

CodeWhale requires zero configuration—place AGENTS.md in your repository and it activates immediately. Qoder offers the most granular control through its config.json and environment variable support. For IDE-integrated experiences, GitHub Copilot CLI provides familiar GitHub ecosystem integration.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}