The Coding Agent That Would Rather Fail Than Quietly Forget

Every coding agent harness makes a quiet trade on your behalf. The context window fills up, so something gets summarized. The command output is enormous, so it gets capped. The model hits its output limit mid-answer, so the harness hands you the first half and calls it a day. None of this is announced. It is engineered amnesia, and it is the default behavior of most agent tooling you have used.

UNCUT, a tiny Go project by Balanov, is a refusal to make that trade. It is a headless coding-agent harness — no TUI, no telemetry, no plugins, no background agents, no automatic retries, no context compaction — built around one contract: the entire conversation is sent on every model call, file contents and command output are never truncated, and if the provider cuts a response at its output limit, UNCUT exits with an error instead of presenting a partial answer as success. The whole thing ships as a single statically linked binary around 7 MB, implements four tools, speaks one provider protocol, and fits in 837 lines of implementation Go.

That is the entire project. Whether that is a feature or a limitation is the interesting question, and the honest answer is: both, deliberately.

The contract, not the feature list

It helps to start with the name. The dictionary sense of “uncut” that matters here is “not abridged, curtailed, or expurgated” — the uncut version of the film, the one the studio didn’t trim for runtime (Merriam-Webster). The project applies that aesthetic to agent plumbing. It does not summarize, prune, slide a window over, or cap valid UTF-8 prompts, stored messages, file contents, or command output. Binary files and invalid UTF-8 are rejected explicitly rather than silently mangled — on Windows, where utilities sometimes emit UTF-16 or code-page output, UNCUT refuses to guess a conversion and errors out instead.

The most telling design decision is the exit code. When a provider returns a finish reason indicating the response was cut at the output limit, UNCUT exits with a dedicated error code rather than displaying the truncated text. In an ecosystem where a half-finished refactor presented as a completed one is a routine hazard, treating truncation as a failure state — as information, loudly surfaced — is a small act of engineering hygiene. The README is careful about what this does not mean: UNCUT does not extend the model’s context window and cannot control provider-side processing. It is lossless in transport, not magic in capacity.

The project also publishes a proof. A test script drives the real binary against a deterministic local provider — no API key or model required — and checks complete large-file and command-output transport, exact session resume, edits, explicit truncation failures, step limits, and invalid UTF-8 handling, with recorded results in the repository. The README is refreshingly blunt about the scope: these are transport tests, not model-quality benchmarks. A project that distinguishes between proving its contract and proving its competence is already ahead of most of its genre.

Why this argument lands right now

UNCUT’s timing is not accidental. The industry conversation has shifted from models to harnesses — the scaffolding around the model that manages context, tools, prompts, state, and control flow. LangChain’s framing is blunt: an agent is the model plus the harness, and “if you’re not the model, you’re the harness” (LangChain). Sebastian Raschka makes the same point from the practitioner side: recent progress in practical LLM systems comes as much from how models are used as from the models themselves, which is why Claude Code and Codex feel far more capable than the same model in a plain chat box (Raschka). A 42-author arXiv survey has now formalized “code as agent harness” as a research lens, covering everything from planning and memory to verification and multi-agent coordination (arXiv).

Once you accept that the harness is a first-class engineering artifact, you start auditing it. And when you audit a harness, the first thing you find is that it has been quietly deciding things for you: what to forget, what to elide, when to retry, when a partial answer counts as done. Birgitta Böckeler’s work on harness engineering frames the goal as building trust through guides and sensors — feedforward and feedback controls that raise the probability the agent gets it right and lets it self-correct before a human sees the mess (martinfowler.com). UNCUT sits at a stranger, more radical position on that spectrum: it builds trust by refusing to intervene at all. Its only sensor is the error code.

The second tailwind is the headless wave. Claude Code’s print mode turned an interactive assistant into a programmable command-line utility that fits Unix pipelines, CI jobs, and batch operations (dev.to), and practitioners running agents unattended in CI/CD have mapped the concentrated risks: permissions, cost, and audit — because in a headless run, only captured output, logs, and diffs exist as records (hidekazu-konishi.com). An entire meta-layer has emerged on top, like headless-cli, which normalizes eight different agent CLIs behind one interface (GitHub). UNCUT is native to this world: it reads stdin, writes final text to stdout, optionally emits structured NDJSON events, and treats Unix pipelines as its primary habitat. A diff piped in for review, a failing-test log piped in for diagnosis — these are the canonical uses, and the design serves them directly.

For unattended runs, the lossless contract has a specific payoff: audit. If your only record of what an agent did is its session log, a harness that silently prunes that log is quietly corrupting your evidence. UNCUT’s sessions are append-only JSONL files that preserve every message and tool result, resume exactly, and error on invalid or partial records rather than discarding them to force a load. That is the behavior you want from an audit trail, and it is rarer than it should be.

The limits are the point — until they aren’t

Now the honest part. UNCUT’s core virtue is also a hard ceiling. No compaction means long tasks will eventually exceed the context window, at which point the provider rejects or mangles the request and UNCUT surfaces the failure. That is correct behavior under the contract, but it means the tool is best suited to bounded jobs — review this diff, diagnose this log, fix this test — rather than the multi-hour autonomous refactors that the big harnesses are engineered for. The big harnesses compaction because they must; UNCUT declines to because it can, given the jobs it targets. Both are defensible. Neither is free.

The feature list is short by conviction: four tools (whole-file read, whole-file write, single-occurrence replace, and command execution with complete combined output), one provider protocol (OpenAI-compatible Chat Completions, including local servers — the README notes a smoke test with a small local tool-capable model), text and tool calls only, no images, no streaming. There are no approval popups, no automatic commits, no hidden recovery loops. The README is admirably direct about the safety posture: UNCUT is not a sandbox. The model executes shell commands with your operating-system user’s permissions, and the workspace checks on file tools do not constrain what a shell command can touch. Run untrusted tasks in a disposable container. This is stated in bold, which is more than many larger projects manage.

There are rough edges visible in the source material. The release binaries are not code-signed, so macOS Gatekeeper and Windows SmartScreen will complain, and users are directed to verify checksums manually. The step limit defaults to 32 model calls before a dedicated exit code — a sensible guardrail, but one that will surprise anyone expecting marathon sessions. And the project is young: version 0.1.1, with no visible adoption, community, or ecosystem in the provided material. This is a single-author statement of intent, not an infrastructure play. The README’s own framing — “fork it, modify it, ship it” — acknowledges as much; at 837 lines with zero third-party Go dependencies, forking is a realistic strategy in a way it never is for a hundred-thousand-line harness.

There is also a naming collision, and it is a real one: “UNCUT” is a long-running British music magazine whose tagline calls it “the spiritual home of great music” (uncut.co.uk, Wikipedia). Searchability is a genuine cost for a small open-source project. One suspects the author considered the word’s meaning worth the collision, and it is hard to argue the word choice is wrong — no other adjective states the contract so economically.

A control group for the harness gold rush

The most useful way to read UNCUT is not as a competitor to Claude Code or Codex but as a control condition. The major harnesses are accumulating features at a furious pace — subagents, model routing, bundled sandboxes, middleware hooks, the whole apparatus LangChain catalogs (LangChain). Every one of those features is a hypothesis that intervening in the agent loop improves outcomes. UNCUT is the null hypothesis, held up in 837 readable lines: what if the harness just transported bytes faithfully, told the truth about failures, and got out of the way?

That question has research value beyond the tool itself. If a lossless minimal harness performs comparably to a feature-laden one on bounded tasks, the elaborate machinery is doing less than advertised. If it performs worse, you have isolated exactly what the machinery buys. Either result is informative, and almost nobody in the current gold rush is running that experiment. The arXiv survey’s open challenges — evaluation beyond final task success, verification under incomplete feedback, regression-free harness improvement (arXiv) — all become easier to study when a minimal, verifiable harness exists as a baseline.

Where it goes from here is an open question the sources do not answer. The obvious tensions are unresolved: someone will want compaction and ask for it; someone will want streaming; someone will want more tools. Each request tests whether the project’s discipline holds or whether it becomes the thing it was written against. The README’s answer is pre-loaded — fork it — and at this size, that answer might actually suffice.

In the meantime, UNCUT occupies a specific and useful niche: the honest pipe. For CI jobs, log triage, diff review, and agent experiments where you need to know exactly what the model saw and exactly where it failed, a harness that refuses to lie — even by omission — is not a limitation. It is the whole product.