akougkas.io

Shipping a coding agent in public

CLIO Coder reached v0.5.0 on September 20, 2026. Measuring that launch against the definition of shipped I wrote in August: what had to be true before public was the right word, what was labelled an early preview, and what is still not true.

Published
Reading
6 min read
Topics
agents, building, research practice
  1. A tutorial note walks through CLIO Coder v0.3.7 on a local model.

  2. “When is research software shipped?” sets the bar: a named state, a path from zero, evidence, limits, and a continuity signal.

  3. CLIO Coder v0.5.0.The public launch, with a rewritten README, reviewed documentation, and a qualified release artifact.

  4. CLIO Coder v0.5.2.The agent writes its own handoff before compaction, and interrupted transitions recover by command.

In August I wrote down what shipped should mean for research software: a named state someone else can run, evidence tied to that state, explicit limits, and a continuity signal. Writing that definition against other people’s projects was the easy half. The harder half arrived three weeks later, when CLIO Coder, the terminal coding agent I create and maintain inside CLIO, reached v0.5.0 on September 20, 2026 and I had to decide whether the word “public” was earned.

The repository had been public for months. Releases went to npm every few days, a tutorial here walked through v0.3.7 in August, and anyone could read the source. By the August definition, none of that is shipping. Visibility is not a path from zero, and a package on a registry is not a promise about what the current documentation describes.

What changed at the launch boundary

Between v0.4.9 and v0.5.0 the code kept moving, but the part that made “public” the right word was mostly not new behavior. The README was rewritten shorter and aimed at a first-time reader rather than at me. Contributor and security guidance were brought current, so a stranger with a bug and a stranger with a vulnerability have different, named destinations. Package and repository metadata were made consistent, which is what turns a tag into a coordinate two people can agree on. The shipped Markdown was reviewed against the implementation instead of against the intentions of whichever week wrote it, and the browser documentation now renders from those same versioned files, so the two readings cannot drift apart between releases.

The release also qualified its own artifact. Package contents, the installed command-line and browser checks, and component notices are verified against the exact build that goes out, which is the difference between a version number and a state someone can reach. That list maps cleanly onto the August receipts: a named recoverable state, a path from zero, one behavior a newcomer can exercise, and a continuity signal that says where the next report belongs. The evidence receipt that seals every run had been there since long before the launch. What it lacked was a reader who could get to it without asking me first.

The browser app is subordinate, and says so

The same release bundled a local graphical application. clio-coder gui starts a server bound to 127.0.0.1, prints a private launch link, and reads the same configuration, sessions, traces, evidence, and documentation as the terminal. It covers conversation, sessions, traces, fleet and dispatch history, evidence, evals, usage, the library, settings and targets, toolchain, and system health. That is a lot of surface for a first version, and the temptation to call it the product was available. The launch notes call the terminal the primary coding interface and the wider graphical app an early preview, and the roadmap repeats the boundary rather than softening it.

One rule inside that application matters more than the rest of it. Every inspector states whose data it shows and what it may do to it, distinguishes a store that was never created from one that is empty, says what a bounded list dropped, and closes by naming what stays on the machine. An inspector that skips those four things is not neutral. It invites a reader to mistake an uninitialized store for an empty one, a truncated list for a complete one, and another agent’s history for Clio’s own. Opening a page never runs another coding agent’s executable either; a version probe is an explicit button, because reading a record should not be the act that starts a process.

Plans and shipped behavior live in separate files

The roadmap is where that separation is enforced. It opens by saying it describes priorities, not available features or delivery promises, and it sends readers to the documentation for implemented behavior and to the changelog for history. The section that governs the rest of it is short: “A future design is not a release claim, a benchmark proposal is not a measured result, and a successful command does not establish scientific validity.”

Keeping that line honest cost something immediately. The launch priorities are retained in the roadmap as the historical scope of the launch, with a note that a completed test campaign establishes its recorded coverage and not universal correctness across every model, platform, or scientific workload. The next section listed v0.5.2’s context and memory priorities as intended work before any of it existed.

Then v0.5.2 shipped on September 21, and the first item on that list became behavior. The agent can now write its own handoff before compaction: a note it authors, preserved as written, bound to two attempts and four summary invocations, with the original operator turn carried across the continuation. An interrupted transition is recoverable on purpose through /context recover <handoffId>, with no automatic redelivery after an uncertain interruption, because guessing whether a message arrived is how a session quietly duplicates work. The live budget is inspectable through /context. Placing that in the release after the launch rather than inside it was deliberate. It belongs to the next program, and calling it a launch feature would have made the launch sound larger than it was.

What is still not true

The benchmark names in the repository are plans. SWE-bench, Terminal-Bench, SciCode, and ScienceAgentBench appear in the roadmap as potential external campaigns, not as published scores or completed adapters. The eval engine is built; the campaigns are not run. Until a public regression corpus with variance gates exists, “better” is a claim I cannot support.

The software is pre-1.0. Interfaces can change between minor versions, so anything built on top of a command today may need adjusting. Coverage is uneven: Linux has the broadest live exercise, macOS and Windows less. And the quality of a session still depends on the model you point it at, its quantization, the context you can afford, and whether its tool calls parse cleanly. The harness bounds what a weak model can damage and records what it did. It does not make that model correct.

If you want to try it, you need Node.js 22.19 or newer and a model service, local or remote:

npm install -g @iowarp/clio-coder
cd /path/to/your/project
clio-coder configure
clio-coder

Then give it the task the README suggests: ask it to explain how your repository builds and tests itself, find the entry points, and propose one small verification before it changes anything. When it finishes, run clio-coder evidence list and inspect the receipt. The answer is worth reading. The record of how it was produced is the part that decides whether the answer can be trusted.

Sources, code, and records

  1. source

    CLIO Coder v0.5.0 release

    The public launch, September 20, 2026, with the reviewed documentation, contributor and security guidance, and the bundled browser application.

  2. source

    CLIO Coder v0.5.1 release

    Subscription quota readings and the unified /usage overlay, September 21, 2026.

  3. source

    CLIO Coder v0.5.2 release

    Durable self-compaction, explicit handoff recovery, and an inspectable context budget, September 21, 2026.

  • 2023–present
    active

    CLIO Coder

    A local-first coding agent with typed tools, bounded workers, and receipts

  • 2025–present
    active

    CLIO

    A context layer for scientific AI agents and workflows

More on CLIO Coder

  1. essay

    Reliable work from unreliable agents

    A coding agent is a system built around one brilliant, persuasive, unreliable component. The argument of my November 9, 2026 lecture on agentic engineering: five ideas for building trustworthy work around that component, what they could do for science, and the problems still open.

    14 min
  2. essay

    CLIO as the entry point

    CLIO should become the single place a developer starts with IOWarp, built as an application SDK with deployment profiles rather than an umbrella package or a gateway service. This is the direction for 2027; the API and the scope are still open.

    6 min
  3. essay

    A capable model in a capable harness

    Claude 3.5 Sonnet brought me back to writing code. A capable model still needs a harness that makes its progress checkable and its cost visible, and CLIO Coder is the one I built around models that many people can afford to use.

    4 min