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

> Explore Ponytail's instruction-tier platforms. Learn how lite, full, ultra, and off aggressiveness levels control AI agent code review rulesets for better efficiency.

- Repository: [DietrichGebert/ponytail](https://github.com/DietrichGebert/ponytail)
- Tags: deep-dive
- Published: 2026-09-07

---

**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`](https://github.com/DietrichGebert/ponytail/blob/main/AGENTS.md) to every user prompt.

```text
/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`](https://github.com/DietrichGebert/ponytail/blob/main/docs/agent-portability.md), Codex reads the `hooks/` folder and injects the ruleset using the same slash command interface:

```bash
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.

```bash

# 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`](https://github.com/DietrichGebert/ponytail/blob/main/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`](https://github.com/DietrichGebert/ponytail/blob/main/opencode.json):

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

```

The ruleset becomes part of active context for every prompt. OpenCode also exposes `/ponytail` commands through [`.opencode/command/ponytail.md`](https://github.com/DietrichGebert/ponytail/blob/main/.opencode/command/ponytail.md) for mode switching.

## Gemini CLI and Antigravity CLI

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

```bash
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`](https://github.com/DietrichGebert/ponytail/blob/main/AGENTS.md) at the repository root. The plugin adds six skills to [`.qoder/rules/ponytail.md`](https://github.com/DietrichGebert/ponytail/blob/main/.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.

```json
{
  "defaultMode": "full"
}

```

Qoder's hook `PreToolUse` triggers ruleset injection, as specified in [`hooks/qoder-hooks.json`](https://github.com/DietrichGebert/ponytail/blob/main/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`](https://github.com/DietrichGebert/ponytail/blob/main/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:

```bash
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`](https://github.com/DietrichGebert/ponytail/blob/main/AGENTS.md) content plus a mode directive (`ponytail:lite`, `ponytail:full`, etc.)
3. **Command routing**: Skills in [`skills/ponytail/SKILL.md`](https://github.com/DietrichGebert/ponytail/blob/main/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`](https://github.com/DietrichGebert/ponytail/blob/main/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`](https://github.com/DietrichGebert/ponytail/blob/main/AGENTS.md)** — Core ruleset injected on every turn; defines the tier ladder
- **[`docs/agent-portability.md`](https://github.com/DietrichGebert/ponytail/blob/main/docs/agent-portability.md)** — Platform-to-file mapping documentation
- **[`hooks/qoder-hooks.json`](https://github.com/DietrichGebert/ponytail/blob/main/hooks/qoder-hooks.json)** (and variants) — Hook registration for each host
- **[`skills/ponytail/SKILL.md`](https://github.com/DietrichGebert/ponytail/blob/main/skills/ponytail/SKILL.md)** — Six skill implementations (`ponytail`, `ponytail-review`, etc.)
- **[`.opencode/command/ponytail.md`](https://github.com/DietrichGebert/ponytail/blob/main/.opencode/command/ponytail.md)** — OpenCode-specific command definition
- **[`.github/copilot-instructions.md`](https://github.com/DietrichGebert/ponytail/blob/main/.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`](https://github.com/DietrichGebert/ponytail/blob/main/AGENTS.md) reading
- **Consistent files**: [`AGENTS.md`](https://github.com/DietrichGebert/ponytail/blob/main/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`](https://github.com/DietrichGebert/ponytail/blob/main/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`](https://github.com/DietrichGebert/ponytail/blob/main/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`](https://github.com/DietrichGebert/ponytail/blob/main/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`](https://github.com/DietrichGebert/ponytail/blob/main/AGENTS.md) in your repository and it activates immediately. **Qoder** offers the most granular control through its [`config.json`](https://github.com/DietrichGebert/ponytail/blob/main/config.json) and environment variable support. For IDE-integrated experiences, **GitHub Copilot CLI** provides familiar GitHub ecosystem integration.