Independent developer Jonathan Chang built hip-agent, an open-source agent harness whose core loop runs to roughly 200 lines of Python, plus a separate module for the Codex API. The project is a personal write-up, not a benchmarked product launch, and Chang has not claimed it beats any existing coding harness.
The premise is that most agent frameworks are built for humans to operate, not for other agents to operate. Chang notes that when an agent is asked to run a tool like Codex CLI as a subagent, it often burns several turns just guessing the right command flags or digging through source code to understand what a harness actually does. His fix is to make the harness itself something an agent can read in full: the system prompt tells the model to go inspect the source rather than trust a black-box description of its own tools.
That readability is the actual argument, and it is easy to miss under the code. A harness small enough to fit inside a prompt is not a minimalist aesthetic choice. It changes what the agent can do with its own tooling. A model calling a large, opaque framework has to trust documentation or guess at behavior from error messages. A model that can open the harness’s source and read exactly how a shell command becomes an action, or how a subagent gets spawned, can reason about its own capabilities the way it reasons about any other code, which is a different kind of competence than simply having more tools available.
Chang gets there by leaning on machinery that already exists in most Unix environments rather than inventing a bespoke orchestration layer. Settings load through ordinary environment variables, so the entire configuration for a run fits in a few lines of a shell profile. Every action the model takes is a shell command, so there is no custom action schema to parse. And when the agent needs a subagent, hip-agent simply forks a child process, which inherits the parent’s environment and starts its own conversation, with its full session history readable from a file afterward. For plugins he adopts the Agent Plugins spec as it stands. For hooks he borrows the contract Claude Code already defines. The conversation log is written as a Codex CLI session file, which means codex resume opens it. Chang frames this as offloading complexity onto formats and protocols that already have implementations, instead of writing new abstractions for configuration, tool registries, and inter-process messaging that a fatter framework would otherwise need to build and document from scratch.
Chang also ran a small evaluation of his own. After iterating on the shell design, prompt, and a new image-viewing tool using Terminal-Bench 2, he tested the final version against a Codex CLI 0.147.0 baseline on 113 tasks from DeepSWE. hip-agent resolved 73 tasks (64.6 percent) against Codex CLI’s 72 (63.7 percent), using fewer model calls per task (187 versus 208) but more wall-clock time per task (58 minutes versus 52). Chang says plainly that each figure comes from a single run, carries no error bars, and was produced on two boxes that shared a CPU but differed elsewhere. He also skipped token comparisons, since hip-agent keeps no record of them. He is not presenting this as proof of superiority, only as evidence the approach is workable.
The larger point Chang raises is about evaluation, not performance. He argues that a benchmark score measures the model and its harness together, not the model alone, and cites OpenAI’s finding that two settings changes tripled ARC-AGI-3 scores without touching the underlying model, plus Anthropic’s own April postmortem describing how a harness change silently degraded output quality while the model stayed fixed. His conclusion is that user-facing harnesses change too often to be a stable measurement instrument, and that model builders would do labs and developers a favor by shipping something like hip-agent alongside each model: a minimal, legible reference implementation separate from the polished product, so anyone testing a new model can plug it in as a subagent without first reverse-engineering a proprietary CLI.
For teams building multi-agent systems, the practical takeaway is to separate the question of “does this model perform well” from “does this harness perform well,” and to treat a framework’s opacity as a real cost, not just a maintenance inconvenience, the next time a subagent burns unexplained turns discovering its own tools.
Jonathan Chang described hip-agent’s design and results in a blog post on his own site, jonathanc.net.
