Bringing Caveman and Ponytail to the GreenPT API

If you’ve been using AI coding agents this year, you’ve probably noticed something strange: the more advanced these models get, the more they talk. Every question triggers three paragraphs of explanation. Every code fix comes with a preamble, a walkthrough, and a summary. The model wants to be helpful. It’s helpful by being verbose. And you pay for every word.

Two open-source projects have quietly changed how developers think about this. Today we’re bringing both of them into the GreenPT API itself.

The problem: agents that overexplain, overengineer, and overcharge

Anyone running AI coding tools at scale knows the math is broken. GPT-5 class models generate output in the region of $10 to $15 per million tokens. A single senior dev running a coding agent all day can burn through millions of tokens in a week, most of them narration, boilerplate and defensively-generated code.

There’s a second cost that gets less attention: energy. Every output token is a forward pass through a large model. Fewer output tokens means less compute, less electricity, less CO2. For AI providers, output verbosity is essentially a hidden environmental tax, invisibly passed on to customers who can’t do much about it except upgrade to smaller (and worse) models.

Two builders in the open-source community decided this was solvable at the language level, not the model level.

Caveman: same answer, way fewer words

Julius Brussee started with a simple observation: most of what an AI coding agent generates is prose, not code. If you can compress the prose without touching the code, you get a huge chunk of the total saving.

His answer was Caveman, a ruleset that instructs the agent to write like, well, a caveman. Instead of “You should probably wrap the object in useMemo, since a new reference is created on every render and that defeats React’s referential-equality bail-out,” you get “New object ref each render. Wrap in useMemo.”

Same answer. About one-ninth the reading time. And critically: code blocks, error messages, tool calls and diffs are preserved byte-for-byte. Caveman compresses the wrapper, not the meaning.

The measured average is a 65% reduction in output tokens across chat-style prompts (range 22 to 87%). A March 2026 paper Brussee cites found that brevity in AI responses actually improved accuracy on some benchmarks by roughly 26 points. Less noise makes it easier to see the signal.

Caveman ships as a skill for Claude Code, Codex, Cursor, Windsurf, Cline, Copilot, and about 40 other agents. It’s MIT-licensed, has no telemetry, and now has over 95k stars on GitHub. Brussee is also refreshingly honest about the trade-offs: Caveman only compresses output tokens, not input or reasoning tokens, and adds roughly 1 to 1.5k tokens per turn as overhead. On mostly-code workflows, the savings shrink. On mostly-prose workflows, they’re huge.

Ponytail: the code you don’t write

Dietrich Gebert took a different angle. Where Caveman targets how the agent talks, Ponytail targets what the agent builds. Its core insight: senior developers are lazy. Not in a bad way. In the sense that they know the best code is the code you don’t write.

Ponytail enforces a decision ladder before the agent writes anything:

1. Does this need to exist? (YAGNI first)
2. Does it already exist in this codebase? (Reuse it)
3. Does the standard library cover it? (Use stdlib)
4. Does a native platform feature cover it? (Use it)
5. Does an installed dependency solve it? (Use it)
6. Can this be one line? (Make it one line)

Only if the answer is no to all six does the agent write new code. And even then, minimum viable.

The result is roughly 54% less generated code on average, up to 94% on aggressive over-engineering scenarios. Ponytail preserves 100% of security and validation logic, which is often the first thing over-eager agents try to “simplify”. Gebert launched it in June 2026 and it’s grown to over 95k stars, one of the fastest-growing coding tools of the year.

Like Caveman, it works across 13+ agents via plugins, hooks and rule files, and it’s MIT-licensed.

Why we brought both into the API layer

Here’s the thing about skills, plugins and rule files: someone has to install them. Configure them. Keep them updated across a team. Make sure new hires know they exist. That’s friction, and friction kills adoption.

We asked ourselves a simple question: what if the compression happened at the API endpoint itself, so there was nothing to install?

That’s what we shipped today. GreenPT now offers three new endpoints built on GLM-5.2:

• glm-5.2-caveman applies Brussee’s ruleset natively (-22% to -87% output tokens)
• glm-5.2-ponytail applies Gebert’s ruleset natively (-22% to -94% output tokens)
• glm-5.2-honey combines both, the same balance as our Honey skill, for mixed prose-and-code workloads (-6% to -77%)

Each comes in -lite, default and -ultra intensities. There are no extra parameters, no headers, no SDK gymnastics. You swap the model id in your existing OpenAI-compatible request and it just happens:

{
  "model": "glm-5.2-ponytail",
  "messages": [{ "role": "user", "content": "Add retry with backoff to this fetch call." }]
}

Because the endpoint is OpenAI-compatible, it drops straight into OpenCode, Cursor, Claude Code, and every coding tool that speaks the OpenAI API. The compression is baked in.

Why this matters beyond the token bill

For us at GreenPT, this is the whole mission compressed into one release: same answer, less energy.

The pricing model doesn’t change. You still pay per token, at the same CO2 per token as regular GLM-5.2. But because there are fewer output tokens, your total bill drops. Your response time drops. Your energy consumption drops. And we pass all of the saving through, because the saving is real, not a rebate we’re offering to move volume.

We publish CO2 metrics per API call as standard on GreenPT. With these endpoints, the number gets meaningfully lower, and it’s measurable in your dashboard from day one.

Partnering with the builders

We’re the first listed sponsor of Ponytail, and both rulesets ship natively on our endpoints with full credit to their creators. Julius Brussee and Dietrich Gebert built these tools in the open, MIT-licensed them, and made them available to anyone. That deserves recognition, not just adoption.

If you want to use their tools directly with your own agent setup, we’d encourage that too. What we’ve done is make the same principles available to anyone who already uses our API, without adding installation steps. It’s the same idea, delivered differently.

The bigger picture

There’s a strand of thinking in the AI industry that assumes efficiency will come from bigger models, better hardware, or clever inference tricks. And sometimes it does. But some of the biggest wins available right now aren’t in the model, they’re in the output. Every unnecessary word an agent generates costs money and energy that didn’t have to be spent.

Caveman and Ponytail proved this at the developer-tool level. We’re bringing it to the infrastructure level.

If you’re using GreenPT’s API, changing one string in your request could cut your output tokens by up to 70%. That’s not a rebate. That’s just what happens when the model stops overexplaining.

Try it

• Compression models documentation
• Caveman on GitHub
• Ponytail on GitHub