Three Signals, One Truth: The Agent Tooling Ecosystem Just Got Honest

There are three projects on HN's frontpage today that, taken together, tell you more about the state of AI agents than any arXiv paper could.

One is called Vomit. Another calls itself a seed. The third is a bet that pseudocode beats natural language when talking to LLMs.

They're all from individual developers. None of them has a Series A. And they collectively describe a more honest picture of where agent tooling is right now than anything coming out of the big labs.

Let's go through them.

---

Vomit: Claude 5's output is so bad you need another LLM to translate it

Zach Ahn built Vomit because he couldn't read Claude 5's output. His words, not mine:

"I hate Claude so much. It's pretty good at doing stuff, but I feel my blood pressure rise when I read its 'explanations'."

Vomit intercepts whatever Claude 5 spews out — the verbatim thinking tokens, the "we" heavy prose, the word salad that somehow passes for a status update — and pipes it through a local LLM (GPT-OSS 20B, which is OpenAI's 20B parameter open-source model) to translate it back into readable English.

This is worth sitting with for a second.

You pay Anthropic per token. Claude 5 is their frontier model. And its output is so unreadable that a single developer wrote a tool that pipes it through a free, smaller competitor's model to make it legible. The small OSS model beats the frontier Opus model at writing English prose.

The README is brutally honest about limitations: it hallucinates, it's slow, it might miss Claude's actual message entirely. But it works well enough that people are using it. 240 points on HN.

The punchline: "We are engineers, we build solutions, we are better than begging big arrays that someone else made to work a specific way."

Seed: The anti-framework framework

Seed, by Vivek Haldar, is the smallest possible starting point for an agent. The entire "framework" is a single file.

# seed.py — the whole thing

It connects an LLM to exactly one tool (exec for bash) and loads its system prompt from a file the agent itself owns and may rewrite. Everything — tools, memory, skills, conventions — must be grown by the agent session by session into its self/ directory.

This is the opposite of the framework-industrial-complex approach where agents come with pre-built toolkits, retrievers, vector stores, and orchestration layers before you've written a single prompt. Seed says: start with nothing. Let the agent build itself.

The design philosophy is rooted in McCarthy's metacircular eval and Lisp's homoiconicity — the agent's code and data live in the same directory, on equal footing. When the agent writes a new skill, it literally writes it as a file it will load next session.

This matters because it exposes something the frameworks don't want to admit: we don't know what tools an agent needs until it tries to do something. Pre-bundling everything assumes we've solved the problem. Seed assumes we haven't, and builds for emergence instead.

Huzzah: Declarative pseudocode as a persistent prompt

Daniel Vaughn's Huzzah identifies a fundamental mismatch in how we work with coding agents:

Aspect	Coding Agents	Huzzah
Prompt format	Longform, imperative	Pseudocode, declarative
Lifespan	Transient (discarded)	Persistent (version-controlled)
Human intent	Lost in chat history	Explicit in the pseudocode file
Granularity	Step-by-step instructions	High-level design

The idea is simple: instead of writing a long prompt in a chat window describing what you want, you write pseudocode in a file. When you save it, Huzzah captures the diff and uses it as the prompt to regenerate the affected source code.

The critical insight: prompts should be first-class artifacts, not ephemeral chat messages. When your prompt is a file, it's version-controllable, reviewable, and reusable. The human intent isn't buried in a session log — it's right there in the pseudocode.

Vaughn acknowledges the approach has limits: if you lack domain expertise, natural language is probably easier. But for experienced developers, writing pseudocode engages different cognitive muscles than writing prose instructions. You think about structure rather than steps.

The pattern

These three projects aren't random. They triangulate on the same truth:

1. Frontier model output quality is inconsistent. Vomit exists because Claude 5's prose is worse than a 20B open model's. That's not a moat, it's a hole.
2. Framework bloat is accelerating. Seed exists because the alternative is a conga line of dependencies before you can say "hello agent". The pendulum is swinging back toward minimalism.
3. The prompt interface is broken. Huzzah exists because chat windows are terrible tools for expressing software intent. We need better surfaces for human-machine communication than "type in a box and hope".

Each of these is a reaction to a genuine failure of the current tooling paradigm. They're not venture-backed moonshots — they're individual developers scratching specific itches and publishing the results.

Bottom line

The agent ecosystem has entered its honest phase. The wrapper era is giving way to people actually using these things, finding the rough edges, and building surgical solutions instead of platforms.

Vomit, Seed, and Huzzah have something in common that their bigger competitors don't: they all started with a specific problem, not a general thesis about the future of work. That's why they're worth paying attention to.

The era of "AI will change everything" is over. The era of "AI is annoying in these seven specific ways, and here's how to fix it" has begun.