# What Platforms Does Ponytail Support? A Complete Guide to AI Agent Integration

> Discover the extensive platform support of Ponytail AI. Integrate with over 20 AI agents and CLI tools like Claude Code, GitHub Copilot CLI, Gemini CLI, and more via native plugins or config files.

- Repository: [DietrichGebert/ponytail](https://github.com/DietrichGebert/ponytail)
- Tags: how-to-guide
- Published: 2026-09-08

---

**Ponytail supports more than 20 AI agents and CLI tools—including Claude Code, GitHub Copilot CLI, Codex, Gemini CLI, Qoder, Hermes, Pi, OpenCode, and instruction-only editors like Cursor and Windsurf—by loading its rule set through either native plugins or plain-text configuration files.**

Ponytail is engineered as a **platform-agnostic AI-agent assistant** that enforces a consistent "lazy senior dev" methodology across diverse development environments. Because its core logic resides entirely in portable rule files ([`AGENTS.md`](https://github.com/DietrichGebert/ponytail/blob/main/AGENTS.md)) and lightweight Node.js lifecycle hooks rather than platform-specific binaries, any environment capable of reading plain text or loading a small plugin can run Ponytail. The DietrichGebert/ponytail repository maintains first-class integrations for modern coding assistants through two primary mechanisms: plugin-based installation for CLI agents and direct rule-file ingestion for IDE-embedded agents.

## The Platform-Agnostic Architecture

Ponytail achieves universal compatibility by separating its logic from its host environment. The repository's [`AGENTS.md`](https://github.com/DietrichGebert/ponytail/blob/main/AGENTS.md) file contains the complete rule set that defines Ponytail's behavior, while the `hooks/` directory provides JavaScript injection points for plugin-capable agents.

According to the source code, the only runtime requirement is a host that can either:
- Load the [`AGENTS.md`](https://github.com/DietrichGebert/ponytail/blob/main/AGENTS.md) ruleset directly into its context window, or
- Execute the Node.js hooks in [`hooks/ponytail-instructions.js`](https://github.com/DietrichGebert/ponytail/blob/main/hooks/ponytail-instructions.js) to inject those rules before each LLM turn

This architecture means **no compilation or binary dependencies** are required beyond the host agent itself. The [`package.json`](https://github.com/DietrichGebert/ponytail/blob/main/package.json) in the repository root declares minimal Node dependencies, ensuring the plugin loads quickly on any platform that supports JavaScript execution.

## First-Class Plugin Integrations

Ponytail ships with documented installation workflows for AI-native CLI tools and agent harnesses. Each integration exposes six core slash-commands (`/ponytail`, `/ponytail-review`, `/ponytail-gain`, etc.) through the host's skill system.

### Claude Code and Codex

For **Claude Code**, install Ponytail using the built-in plugin marketplace:

```bash
/plugin marketplace add DietrichGebert/ponytail
/plugin install ponytail@ponytail

```

The [`plugin.yaml`](https://github.com/DietrichGebert/ponytail/blob/main/plugin.yaml) metadata file in the repository root allows Claude Code to discover available commands automatically. Once installed, the hooks in [`hooks/ponytail-instructions.js`](https://github.com/DietrichGebert/ponytail/blob/main/hooks/ponytail-instructions.js) inject the ruleset before every LLM turn, registering the `/ponytail` namespace.

**Codex** follows an identical pattern:

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

```

### GitHub Copilot CLI

**GitHub Copilot CLI** users register Ponytail through the `copilot` command:

```bash
copilot plugin marketplace add DietrichGebert/ponytail
copilot plugin install ponytail@ponytail

```

This loads the same lifecycle hooks used by Claude Code, mapping the six Ponytail skills to slash-commands within the Copilot CLI environment.

### Pi and OpenCode

**Pi** (the agent harness from Applied Labs) installs Ponytail directly from the repository URL:

```bash
pi install git:github.com/DietrichGebert/ponytail

```

**OpenCode** supports Ponytail through its JSON-based configuration. Add the following to your [`opencode.json`](https://github.com/DietrichGebert/ponytail/blob/main/opencode.json):

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

```

Alternatively, copy the local `.opencode/plugins/ponytail.mjs` file into your OpenCode plugins directory. The source code indicates OpenCode loads the plugin on startup, exposing `/ponytail` commands without additional configuration.

### Gemini CLI and Antigravity CLI

**Gemini CLI** (and its successor **Antigravity CLI**) install Ponytail via extension commands:

```bash
gemini extensions install https://github.com/DietrichGebert/ponytail

# Or for Antigravity:

agy plugin install DietrichGebert/ponytail

```

Both platforms read the [`AGENTS.md`](https://github.com/DietrichGebert/ponytail/blob/main/AGENTS.md) ruleset and execute the hooks to maintain context across conversation turns.

### Qoder, Hermes, and CodeWhale

**Qoder** auto-loads [`AGENTS.md`](https://github.com/DietrichGebert/ponytail/blob/main/AGENTS.md) from the repository root. For per-project customization, copy the rules to [`.qoder/rules/ponytail.md`](https://github.com/DietrichGebert/ponytail/blob/main/.qoder/rules/ponytail.md). Qoder exposes Ponytail's six skills through its native Skill system without requiring a marketplace installation.

**Hermes Agent** uses a dedicated plugin command:

```bash
hermes plugins install DietrichGebert/ponytail --enable

```

Hermes registers the skills as `ponytail:<skill>` (e.g., `ponytail:review`) and explicitly injects the ruleset before each LLM interaction, as documented in [`docs/agent-portability.md`](https://github.com/DietrichGebert/ponytail/blob/main/docs/agent-portability.md).

**CodeWhale** requires no installation steps; simply clone the repository and start CodeWhale. The agent automatically detects and reads [`AGENTS.md`](https://github.com/DietrichGebert/ponytail/blob/main/AGENTS.md) from the working directory.

### Emerging Platforms: Devin, Grok Build, OpenClaw, and Swival

Newer agent platforms are supported through similar plugin mechanisms:

- **Devin CLI**: `devin plugins install DietrichGebert/ponytail`
- **Grok Build**: `grok plugin install DietrichGebert/ponytail --trust`, then add to the `plugins` array in Grok's config file
- **OpenClaw**: Publish to ClawHub (`clawhub install ponytail`) or manually copy `.openclaw/skills/ponytail*` to `~/.openclaw/skills/`
- **Swival**: Stage globally then install locally:
  ```bash
  swival skills add --global https://github.com/DietrichGebert/ponytail
  swival skills add ponytail
  ```

## Instruction-Only Agents

For agents that do not support plugin marketplaces but accept system instructions or rule files, Ponytail works through **file-based ingestion**. These platforms read the shipped [`AGENTS.md`](https://github.com/DietrichGebert/ponytail/blob/main/AGENTS.md) (or copied Markdown rule files) and apply the always-on ruleset without additional installation.

Supported instruction-only agents include:
- **Cursor**
- **Windsurf**
- **Cline**
- **Roo Code**
- **Aider**

To use Ponytail with these editors, simply copy the contents of [`AGENTS.md`](https://github.com/DietrichGebert/ponytail/blob/main/AGENTS.md) into the agent's "Rules" or "System Prompt" configuration panel, or place the file in the project root where the agent can read it. The [`docs/agent-portability.md`](https://github.com/DietrichGebert/ponytail/blob/main/docs/agent-portability.md) file provides specific paths for each editor's configuration directory.

## How Ponytail Works Across Platforms

Regardless of the host platform, Ponytail operates through a consistent three-phase lifecycle defined in the `hooks/` directory:

1. **Rule Injection**: The host loads [`AGENTS.md`](https://github.com/DietrichGebert/ponytail/blob/main/AGENTS.md) or executes [`hooks/ponytail-instructions.js`](https://github.com/DietrichGebert/ponytail/blob/main/hooks/ponytail-instructions.js) to prepend the ruleset to the LLM context
2. **Command Registration**: The `skills/` directory exposes six standardized commands (`ponytail`, `ponytail-review`, `ponytail-gain`, `ponytail-spill`, `ponytail-cpu`, `ponytail-ram`) that map to the host's slash-command or skill system
3. **Context Preservation**: Hooks ensure the ruleset persists across conversation turns, maintaining the "lazy senior dev" constraints on every code generation request

This architecture ensures that **benchmark impact scores**, **over-engineering detection**, and **performance optimization prompts** behave identically whether you are using Claude Code, GitHub Copilot CLI, or Cursor.

## Summary

- **Ponytail supports 20+ platforms** including Claude Code, Codex, GitHub Copilot CLI, Pi, OpenCode, Gemini CLI, Antigravity CLI, Qoder, Hermes, CodeWhale, Devin, Grok Build, OpenClaw, Swival, and instruction-only agents like Cursor and Windsurf.
- **Two integration modes**: Plugin installation for CLI agents (`/plugin install`, `copilot plugin install`, etc.) and file-based rules ([`AGENTS.md`](https://github.com/DietrichGebert/ponytail/blob/main/AGENTS.md)) for IDE agents.
- **Core files**: [`AGENTS.md`](https://github.com/DietrichGebert/ponytail/blob/main/AGENTS.md) contains the ruleset, `hooks/` provides injection logic, `skills/` defines the six slash-commands, and [`plugin.yaml`](https://github.com/DietrichGebert/ponytail/blob/main/plugin.yaml) enables marketplace discovery.
- **Zero binary dependencies**: Requires only Node.js for plugin hosts or plain-text reading capability for instruction-only hosts.

## Frequently Asked Questions

### Does Ponytail require Node.js to run?

**No for instruction-only agents, yes for plugin-based installations.** Agents like Cursor or Windsurf simply read the [`AGENTS.md`](https://github.com/DietrichGebert/ponytail/blob/main/AGENTS.md) text file and require no runtime. However, CLI agents like Claude Code or GitHub Copilot CLI execute the hooks in [`hooks/ponytail-instructions.js`](https://github.com/DietrichGebert/ponytail/blob/main/hooks/ponytail-instructions.js), which requires Node.js to be installed on the system. The [`package.json`](https://github.com/DietrichGebert/ponytail/blob/main/package.json) specifies minimal dependencies to ensure fast loading.

### Can I use Ponytail with Cursor or other VS Code-based agents?

**Yes.** Cursor, Windsurf, Cline, and similar instruction-only agents load Ponytail by reading the [`AGENTS.md`](https://github.com/DietrichGebert/ponytail/blob/main/AGENTS.md) file directly. Copy the file contents into the agent's "Rules" section in settings, or place [`AGENTS.md`](https://github.com/DietrichGebert/ponytail/blob/main/AGENTS.md) in your project root. The repository's [`docs/agent-portability.md`](https://github.com/DietrichGebert/ponytail/blob/main/docs/agent-portability.md) details specific configuration paths for each editor.

### How do I install Ponytail on Claude Code?

**Use the plugin marketplace commands.** Within a Claude Code session, run `/plugin marketplace add DietrichGebert/ponytail` followed by `/plugin install ponytail@ponytail`. This registers the six Ponytail commands and injects the ruleset before each LLM turn. The [`plugin.yaml`](https://github.com/DietrichGebert/ponytail/blob/main/plugin.yaml) file in the repository enables this discovery mechanism.

### Is Ponytail free and open source?

**Yes.** The DietrichGebert/ponytail repository is open source and available under a permissive license. You can clone it, copy the rule files into proprietary agent setups, or install it through any supported marketplace without licensing fees. The source code includes all hooks, skills, and documentation needed for self-hosting or custom platform integration.