# Which AI Agent Hosts Are Supported by Ponytail? A Complete Adapter Guide

> Discover which AI agent hosts Ponytail's adapter system supports. Explore a comprehensive guide to 10 full-skill and 6 instruction-only adapters.

- Repository: [DietrichGebert/ponytail](https://github.com/DietrichGebert/ponytail)
- Tags: api-reference
- Published: 2026-08-29

---

**Ponytail supports 10 full-skill adapters for AI agents including Claude Code, Codex, Devin CLI, OpenCode, Gemini, pi, Swival, Hermes Agent, Qoder, and Grok Build, plus 6 instruction-only adapters for Cursor, Windsurf, Cline, Copilot, Kiro, and Antigravity.**

Ponytail is an open-source framework that normalizes AI agent behavior across different hosts through its modular adapter system. The repository at **DietrichGebert/ponytail** implements a thin abstraction layer that allows the same skills and rules to execute on multiple **AI agent hosts** without requiring host-specific code duplication.

## Full-Skill Adapters (Skill-Capable Hosts)

Ponytail provides **full-skill adapters** for hosts that support Node.js lifecycle hooks and dynamic skill loading. These adapters point to the shared `skills/` directory while providing minimal glue code for their specific environment.

The following hosts support full skill execution:

- **Claude Code** — Uses [`hooks/claude-codex-hooks.json`](https://github.com/DietrichGebert/ponytail/blob/main/hooks/claude-codex-hooks.json) to run Node.js lifecycle hooks
- **Codex** — Shares the same manifest as Claude Code via [`hooks/claude-codex-hooks.json`](https://github.com/DietrichGebert/ponytail/blob/main/hooks/claude-codex-hooks.json)
- **Devin CLI** — Loads from the `hooks/` directory with identical structure to Claude/Codex
- **OpenCode** — Configured through the `hooks/` directory
- **Gemini** — Auto-discovers via [`gemini-extension.json`](https://github.com/DietrichGebert/ponytail/blob/main/gemini-extension.json) without requiring a root [`hooks.json`](https://github.com/DietrichGebert/ponytail/blob/main/hooks.json)
- **pi** — Loads through [`pi-extension/index.js`](https://github.com/DietrichGebert/ponytail/blob/main/pi-extension/index.js)
- **Swival** — Uses the standard `hooks/` structure
- **Hermes Agent** — Configured via `hooks/`
- **Qoder** — Uses [`hooks/qoder-hooks.json`](https://github.com/DietrichGebert/ponytail/blob/main/hooks/qoder-hooks.json) for specific hook definitions
- **Grok Build** — Loads from `hooks/`

According to the Ponytail source code, these adapters keep host-specific glue code minimal while ensuring all heavy lifting happens in the shared `skills/` directory.

## Instruction-Only Adapters

For hosts that only support static instruction sets without dynamic skill execution, Ponytail ships **instruction-only adapters**. These hosts load the always-on ruleset from [`AGENTS.md`](https://github.com/DietrichGebert/ponytail/blob/main/AGENTS.md) but cannot invoke specific skills at runtime.

The instruction-only adapters support:

- **Cursor**
- **Windsurf**
- **Cline**
- **Copilot**
- **Kiro**
- **Antigravity**

These hosts read the central manifest at [`AGENTS.md`](https://github.com/DietrichGebert/ponytail/blob/main/AGENTS.md) directly, providing the base ruleset without skill command functionality.

## How the Adapter System Works

The core behavior lives in the **`skills/`** directory at the repository root. Host-specific adapter files point to this shared logic while providing the minimal connection code required for that environment.

For example:
- In [`hooks/claude-codex-hooks.json`](https://github.com/DietrichGebert/ponytail/blob/main/hooks/claude-codex-hooks.json), Claude Code and Codex find their Node.js lifecycle hook definitions
- In [`gemini-extension.json`](https://github.com/DietrichGebert/ponytail/blob/main/gemini-extension.json), Gemini discovers extension metadata without requiring a traditional [`hooks/hooks.json`](https://github.com/DietrichGebert/ponytail/blob/main/hooks/hooks.json) file
- In [`pi-extension/index.js`](https://github.com/DietrichGebert/ponytail/blob/main/pi-extension/index.js), the pi host finds its adapter entry point

This architecture ensures that updates to the skill logic propagate to all supported **AI agent hosts** simultaneously, while adapter maintenance remains isolated to thin configuration files.

## Implementation Examples

### Configuring Claude Code or Codex

For skill-capable hosts like Claude Code or Codex, place the appropriate hook file in your plugin directory:

```javascript
// The repo ships hooks/claude-codex-hooks.json
// Place this in your Claude/Codex plugin folder, then invoke:
@ponytail-review   // opens the review skill
@ponytail-help     // shows help for Ponytail

```

All heavy lifting is executed by the shared `skills/` folder; the host only needs the small JSON hook configuration.

### Setting Up Gemini CLI

Gemini uses auto-discovery and deliberately omits a root [`hooks/hooks.json`](https://github.com/DietrichGebert/ponytail/blob/main/hooks/hooks.json):

```bash

# Install the Gemini adapter (the repo ships gemini-extension.json)

pony install gemini

# Gemini automatically loads the extension; use the same commands:

ponytail-review     // runs the review skill
ponytail-gain       // runs the gain skill

```

Gemini’s adapter auto-discovers the extension file without explicit hook registration.

### VS Code with Codex Extension (Instruction-Only)

For instruction-only environments, copy the ruleset to your agent configuration:

```json
// Place AGENTS.md in ~/.codex/AGENTS.md
{
  "agents": [
    { "name": "ponytail", "path": "/path/to/ponytail/AGENTS.md" }
  ]
}

```

The Codex extension reads [`AGENTS.md`](https://github.com/DietrichGebert/ponytail/blob/main/AGENTS.md) directly, loading the always-on ruleset without requiring skill commands.

## Summary

- Ponytail supports **10 full-skill adapters** for dynamic AI agents including Claude Code, Codex, Gemini, and Devin CLI.
- **6 instruction-only adapters** provide ruleset support for Cursor, Windsurf, Cline, Copilot, Kiro, and Antigravity.
- The `skills/` directory contains shared logic reused across all **AI agent hosts**.
- Adapter-specific files like [`hooks/claude-codex-hooks.json`](https://github.com/DietrichGebert/ponytail/blob/main/hooks/claude-codex-hooks.json) and [`gemini-extension.json`](https://github.com/DietrichGebert/ponytail/blob/main/gemini-extension.json) provide thin glue code without duplicating business logic.
- Full-skill adapters support runtime skill invocation via `@ponytail-*` commands, while instruction-only adapters provide static guidance through [`AGENTS.md`](https://github.com/DietrichGebert/ponytail/blob/main/AGENTS.md).

## Frequently Asked Questions

### What is the difference between full-skill and instruction-only adapters in Ponytail?

Full-skill adapters support dynamic Node.js lifecycle hooks and runtime skill invocation through commands like `@ponytail-review`. They load active logic from the `skills/` directory. Instruction-only adapters, used by hosts like Cursor and Windsurf, can only load the static ruleset defined in [`AGENTS.md`](https://github.com/DietrichGebert/ponytail/blob/main/AGENTS.md) and do not support interactive skill commands.

### How do I configure Ponytail for Claude Code or Codex?

Copy [`hooks/claude-codex-hooks.json`](https://github.com/DietrichGebert/ponytail/blob/main/hooks/claude-codex-hooks.json) from the DietrichGebert/ponytail repository into your Claude or Codex plugin folder. This JSON file provides the Node.js lifecycle hooks required to bridge the host with Ponytail's shared `skills/` directory. Once installed, you can invoke skills using `@ponytail-*` commands in any prompt.

### Does Ponytail support Gemini's auto-discovery mechanism?

Yes. Unlike other hosts that require explicit hook registration via [`hooks/hooks.json`](https://github.com/DietrichGebert/ponytail/blob/main/hooks/hooks.json), the Gemini adapter uses [`gemini-extension.json`](https://github.com/DietrichGebert/ponytail/blob/main/gemini-extension.json) which the host auto-discovers and loads automatically. This eliminates the need for manual hook configuration while providing full access to Ponytail's skill set.

### Where are the shared skill implementations stored in the Ponytail repository?

All shared logic resides in the **`skills/`** directory at the repository root. This directory contains the implementations used by every adapter, ensuring that skill updates propagate simultaneously to Claude Code, Codex, Gemini, Devin CLI, and all other supported hosts without requiring individual adapter modifications.