Skip to main content
plugin CX Codex

espresso — Claude Code plugin: what it does, how to install

Espresso steers the model toward concise replies and smaller code changes, with Ponytail bundled. It suits project research and focused edits.

MIT ★ 1,596 updated 2026-10-29

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add hashgraph-online/awesome-codex-plugins
/plugin install espresso@awesome-codex-plugins
Open on GitHub

What espresso does

Espresso asks the model to answer directly and make the smallest correct change while retaining explanations, evidence and useful code comments. The plugin bundles Ponytail with six skills and lifecycle hooks. In Claude Code, it also provides espresso:scout, a read-only subagent that uses the current session model for research.

Ponytail starts in full mode unless an existing Ponytail setting or PONYTAIL_DEFAULT_MODE changes that. Espresso and Ponytail have separate switches, so enabling a standalone Ponytail extension alongside the bundled one can cause overlap. Espresso does not expand the context window, and whole-session token reduction has not been measured.

Node.js is required for hooks and the adapter installer. Restart Claude Code after installation or an update. Codex also gets the skill and a trusted session-start hook.

What it helps with

  • trim unnecessary explanation from agent replies
  • ask for the smallest correct code change
  • research several files without flooding the main conversation
  • keep useful comments and reasoning in code changes

Example prompts for the agent

  • Trace how these files connect and report the useful findings without editing anything.
  • Make the smallest correct fix while preserving error checks and comments that aid understanding.
  • Review this long log and identify the failure causes without changing files.

How to install espresso

Plugin marketplace

/plugin marketplace add hashgraph-online/awesome-codex-plugins
/plugin install espresso@awesome-codex-plugins

Step by step, with commands for each platform: Claude Code plugins: marketplaces, installing, and building your own

Questions about espresso

How do I install espresso in Claude Code?

Run these commands in order: /plugin marketplace add hashgraph-online/awesome-codex-plugins, then /plugin install espresso@awesome-codex-plugins.

What does espresso do?

It guides the model toward concise replies and minimal correct changes while retaining useful explanations and code comments. The bundle includes Ponytail and the espresso:scout research subagent for Claude Code.

What does espresso require?

Node.js is required for its hooks and adapter installer. Restart Claude Code after installing or updating the plugin.

Source text

espresso · MIT
# Espresso

![Espresso](https://raw.githubusercontent.com/mirkobozzetto/espresso/main/espresso-hero.jpeg)

**Less filler. Less unnecessary context. Same model, right effort.**

Lightweight workflows for Claude Code, Codex, OMP and Pi. Keep explanations,
evidence and useful code comments, without repetitive reminders or automatic
changes to your global settings.

## Where the savings come from

| Mechanism | What it changes | What we can honestly claim |
|---|---|---|
| No ordinary-prompt reminders | Removes Espresso's repeated reminder payload | Eliminates that input overhead compared with Espresso 1.x; total session savings are unmeasured |
| Concise policy | Asks for direct answers and the smallest correct change | Aims to reduce unnecessary prose and code; output length and quality remain model-dependent |
| Optional RTK | Filters supported command output before it enters context | Can reduce tool-output volume; RTK reports bytes removed and estimated tokens, not total session or subscription savings |
| Same-model delegation | Delegated agents keep the session model, except web-only research on Haiku in Claude Code | Avoids the quality loss and retries of cheaper workers on code; each agent still pays its own startup context |

Espresso does not enlarge the context window or erase existing history.
Its policy also occupies context. We have verified the integrations, not measured
an end-to-end token reduction. There is no universal savings percentage.

RTK is **off by default** in the OMP/Pi extension. The integration only considers
simple `git status` and `git log --oneline` commands with a small flag allowlist.
Diffs, tests, patch logs and scripts stay untouched. Missing RTK or a failed
rewrite leaves the original command intact. Existing RTK hooks are independent.
Checked with RTK 0.51.0.
See [RTK's measurement definition](https://github.com/rtk-ai/rtk/blob/develop/docs/guide/analytics/gain.md).

## Smaller code: Ponytail included

Espresso bundles the real [Ponytail](https://github.com/DietrichGebert/ponytail)
4.13.0 runtime and all six upstream skills, with its MIT license and pinned
source commit in `ponytail-upstream.json`. No separate installation or startup
download is needed. It starts in **full** mode unless an existing Ponytail
configuration or `PONYTAIL_DEFAULT_MODE` overrides that default.

In OMP and Pi, **`/ponytail` opens a selector**: full, lite, ultra, off or status.
`/ponytail off` disables it for the session; `/ponytail default off` changes the
default for future sessions. Use `/ponytail default full` to restore it.
Headless commands show status instead of opening a menu. Claude/Codex use the
bundled skills and lifecycle hooks; they do not get the OMP/Pi native selector.

Also included: `ponytail-review`, `ponytail-audit`, `ponytail-gain`,
`ponytail-debt` and `ponytail-help`. Use their slash commands in OMP/Pi,
plugin skill commands in Claude, and skill invocation in Codex.
Espresso and Ponytail have independent switches. Avoid enabling a second,
standalone Ponytail extension alongside the bundled one.

Its authors' [agentic benchmark](https://github.com/DietrichGebert/ponytail/blob/main/benchmarks/results/2026-06-18-agentic.md)
reports less code and fewer tokens on 12 feature tasks with Haiku 4.5, four runs
per task and condition. Gains are largest where custom code can be replaced by
native features, and small or absent where the implementation is already minimal.
These are Ponytail's results, not Espresso measurements.
The authors also warn that reasoning overhead can increase cost on GPT-5.5.

Use it to reduce unnecessary implementation, not to chase the fewest lines.
Shorter code is not automatically better code; validation, error handling,
security and accessibility must remain intact.

## Harness support

| Harness | Policy | Delegation |
|---|---|---|
| Claude Code | SessionStart hook and skill | Read-only `espresso:scout` and native subagents on the session model; web-only research on Haiku |
| Codex | Trusted SessionStart hook and skill | Native agents on the session model |
| OMP | Extension and skill | Native agents and an explicit text-only worker |
| Pi | Extension and skill | Explicit text-only worker; core Pi has no subagent tool |

In Claude Code, Espresso ships one agent, `espresso:scout`: read-only (no edit
tools), on the session model (`model: inherit`), at medium effort, in the
background. Claude picks it for research whose raw output would flood the
conversation (multi-file search, flow tracing with GitNexus, docs, long logs),
and you keep talking with the main thread while it works. Below the prompt,
each running agent shows its model, effort and tokens.

One exception: for web-only research (searching and reading pages, no code to
read), the lead passes `model: haiku` to the scout. With the same research
brief, Opus 5.5 took 62 s and 55 s, Haiku 5.5 took 55 s and 76 s, and the
answers were comparable. Haiku 5.5 costs $0.10 / $0.50 per million input /
output tokens, against $4 / $20 for Opus 5.5
([pricing](https://platform.claude.com/docs/en/about-claude/pricing)).
Reading and reviewing code stay on the session model: in a
[code-review comparison](https://postcutoff.com/v/dubibubi-haiku-5-5-subagents-vs-opus-5-5/),
Opus 5.5 alone found 122 bugs, Opus 5.5 with Haiku 5.5 workers found 103 and
reported 14 false positives.

Espresso no longer routes code work to a cheaper model. With a strong
session model, adding agents brings no gain or a loss on sequential coding
work ([260-configuration study](https://arxiv.org/abs/2512.08296)), and cheaper
workers can cost more per solved task once retries are counted. Delegate only
substantial read-only research or work whose output would flood the main
context; keep edits and consequential review on the main thread. Explicit model
choices and specialist agents are preserved.

In OMP/Pi, the text-only worker runs on the session model and follows the
session thinking level (low on OMP). Use `/espresso effort low|medium|high` to
set it for this session; `/espresso effort` and `/espresso status` report it.
This setting applies only to `/espresso worker`, not native named agents.
Before delegating, announce the agent, resolved model, effort and reason.

## Install

Node.js is required for hooks and the adapter installer. Restart the harness
after installing or updating.

| Harness | Install | Update |
|---|---|---|
| Claude Code | `claude plugin marketplace add mirkobozzetto/espresso`<br>`claude plugin install espresso@espresso` | `claude plugin marketplace update espresso`<br>`claude plugin update espresso@espresso` |
| Codex | `codex plugin marketplace add mirkobozzetto/espresso`<br>`codex plugin add espresso@espresso` | `codex plugin marketplace upgrade espresso`<br>`codex plugin add espresso@espresso` |
| Pi | `pi install npm:espresso-agent-tools` | `pi update` |
| Prime Agent | `prime-agent package install /path/to/espresso` (a checkout) | `git pull` in the checkout |
| OMP | `node src/hooks/install.js omp --apply` (from a checkout) | `git pull` in the checkout, then refresh the skill copies |

In Claude Code, the same commands work as `/plugin …` inside a session.

**Codex** runs plugin hooks only once you trust them. Review them in Codex
before starting a new thread, and again after an update: a changed hook gets a
new hash.

**Pi and Prime Agent** load the extension, the six Ponytail skills and the
Espresso skill from the package. Pi also accepts a checkout path
(`pi install /path/to/espresso`). Keep a checkout in place when you install
from it.

**OMP** needs a permanent checkout:
```sh
git clone https://github.com/mirkobozzetto/espresso.git
cd espresso
node src/hooks/install.js omp --apply
```
The OMP extension imports the checkout, so `git pull` updates it. The skills
are copies: the installer refuses to overwrite a copy that differs, so replace
`~/.omp/agent/skills/espresso` and `~/.omp/agent/skills/ponytail*` with the
checkout's `skills/` folders after pulling.

For Codex skills without the marketplace, run `node src/hooks/install.js codex --apply`.
Omit `--apply` to preview adapter files. Conflicting files are refused;
settings, credentials and model overrides are untouched.

See [INSTALL.md](INSTALL.md) for upgrade and removal precautions. Existing
Caveman/Ponytail installations and old global rules are not deleted automatically.

## OMP / Pi commands

```text
/espresso status
/espresso on
/espresso off
/espresso worker Summarize this supplied text: ...
/espresso rtk-on
/espresso rtk-off
```

The worker launches the same CLI on the session model, with no tools or
recursive extensions. It works only on the supplied text. State is per session:
concise policy starts on, RTK starts off. `off` stops new policy injection and RTK
rewriting; it cannot erase messages already sent to the model.

### OMP automatic research mode

`/espresso auto` enables standing authorization for substantial independent
read-only research. `/espresso manual` returns to explicit delegation;
`/espresso off` also clears automatic mode. These commands change session state.
The default is manual. A personal OMP wrapper can opt in on every startup by
calling the extension factory with `{auto: true}` as its second argument.
The installer refuses to overwrite such a customized wrapper.

The lead decides whether delegation is worthwhile after initial inspection.
Instructions limit it to two workers on the session model, no nested delegation, no edits,
and no trivial tasks. These are model instructions, not an enforced scheduler
or read-only sandbox. Explicit choices and stricter skill instructions win;
skills that require fresh consent may still ask. No workers run while idle.

[Anthropic’s research system](https://www.anthropic.com/engineering/multi-agent-research-system)
supports the usefulness of parallel independent research, not a token-saving
guarantee for Espresso. Espresso’s automatic policy still needs
task-level evaluation; command and policy-transition checks are not proof of
reliable delegation decisions.

### Arsenal and Ship compatibility

Arsenal owns skill selection and transitions. The selected skill owns approval
gates, solo flags, specialized agents, model assignments, output schemas,
artifact states, verification and commits. These take precedence over Espresso
recommendations. Espresso must not create a competing team or extra reviewer,
or use an external worker CLI to bypass a controlled runtime.

Ship currently asks before each delegation: automatic Espresso mode does not
remove that requirement. Likewise, `--no-agents` and solo mode remain solo.
Existing workflows do not require Espresso and are not rewritten by it.
This is instruction-level coexistence, not a verified end-to-end compatibility
claim for every Arsenal skill or harness.

## Verification scope

Local checks for 2.2.0: `claude plugin validate`, every Claude hook run
directly (per-project Ponytail modes, mode commands, visible status line,
silence on Codex), the OMP/Pi extension against a simulated host (string, array
and section prompts, same-model worker), selective RTK rewriting with RTK
0.51.0, and a Codex 0.160.1 install in an isolated configuration listing the
three bundled hooks. For 2.3.0: the scout agent passes `claude plugin
validate`, skips the Ponytail injection, and the agent status rows render from
sample input. How often Claude picks the scout on its own, and comparative
token/quality benchmarks, were not measured. For 2.4.1: the hooks inject the
web-only Haiku rule, the scout still skips Ponytail, and `claude plugin
validate` passes. The Haiku web-research timings come from two runs per model
on one brief, not a benchmark.

MIT License.

© Mirko Bozzetto · MIT · hashgraph-online/awesome-codex-plugins

Similar plugins

Plugins catalog →
espresso-skill TestMu AI Generate Espresso UI tests for Android apps written in Kotlin or Java. Use the skill to exercise screen interactions and check what the interface displays afterward. CX Codex +1 234installs ub-mode unclebob The ub-mode skill for Claude Code helps developers structure code changes. It guides the development process by following the principles of "First Make it Work, Then Make it Right, Then Follow Practice." CX Codex +1 930installs methodology-advisor FlorianBruniaux The methodology-advisor command for Claude Code and Codex reads the codebase and asks three questions to recommend an AI-development methodology stack. Run it at the start of a project, before choosing a workflow. CX Codex +1 ★ 6,529repo stars discernment-nudge official anthropics discernment-nudge — a plugin for Claude Code and Claude.ai that appends two or three short questions after a substantive answer. Helps check key facts, probe the reasoning, and spot missing context. ★ 198,522repo stars academy-guide official anthropics academy-guide is a Claude Code plugin that points users to Claude Academy courses, tutorials, and use cases. It responds to questions about using Claude. ★ 198,522repo stars claude-api official anthropics This plugin adds Claude API and SDK guidance for building LLM-powered applications. Install it when your project needs a Claude integration. ★ 198,522repo stars example-skills official anthropics example-skills — a plugin for Claude Code and Claude.ai with a set of sample skills. Demonstrates how to build skills, MCP servers, artifacts, web tests, and internal communication tools. ★ 198,522repo stars document-skills official anthropics Document processing suite for Excel, Word, PowerPoint, and PDF files. Equips the assistant to inspect and generate common document formats. ★ 198,522repo stars

From the same set391

The whole set →

Project sponsors

Companies that keep this analytics open