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

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) 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 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 ruleset directly into its context window, or
• Execute the Node.js hooks in 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 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:

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

The 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 inject the ruleset before every LLM turn, registering the /ponytail namespace.

Codex follows an identical pattern:

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

GitHub Copilot CLI

GitHub Copilot CLI users register Ponytail through the copilot command:

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:

pi install git:github.com/DietrichGebert/ponytail

OpenCode supports Ponytail through its JSON-based configuration. Add the following to your opencode.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:

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

# Or for Antigravity:

agy plugin install DietrichGebert/ponytail

Both platforms read the AGENTS.md ruleset and execute the hooks to maintain context across conversation turns.

Qoder, Hermes, and CodeWhale

Qoder auto-loads AGENTS.md from the repository root. For per-project customization, copy the rules to .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:

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.

CodeWhale requires no installation steps; simply clone the repository and start CodeWhale. The agent automatically detects and reads 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:

  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 (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 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 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 or executes 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) for IDE agents.
• Core files: AGENTS.md contains the ruleset, hooks/ provides injection logic, skills/ defines the six slash-commands, and 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 text file and require no runtime. However, CLI agents like Claude Code or GitHub Copilot CLI execute the hooks in hooks/ponytail-instructions.js, which requires Node.js to be installed on the system. The 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 file directly. Copy the file contents into the agent's "Rules" section in settings, or place AGENTS.md in your project root. The repository's 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 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.

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