<?xml version="1.0" encoding="utf-8"?> <feed xmlns="http://www.w3.org/2005/Atom" xml:lang="en"> <title>Essays · Anthony Kougkas</title> <subtitle>Essays by Anthony Kougkas.</subtitle> <id>https://akougkas.io/feed/essay.xml</id> <link rel="self" type="application/atom+xml" href="https://akougkas.io/feed/essay.xml"/> <link rel="alternate" type="text/html" href="https://akougkas.io/journal/?kind=essay"/> <updated>2026-11-13T00:00:00-06:00</updated> <author> <name>Anthony Kougkas</name> <uri>https://akougkas.io/about/</uri> </author> <entry> <title type="html">Reliable work from unreliable agents</title> <link rel="alternate" type="text/html" href="https://akougkas.io/journal/2026/reliable-work-from-unreliable-agents/"/> <id>https://akougkas.io/journal/2026/reliable-work-from-unreliable-agents/</id> <published>2026-11-13T00:00:00-06:00</published> <updated>2026-11-13T00:00:00-06:00</updated> <summary type="html">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.</summary> <content type="html" xml:base="https://akougkas.io/journal/2026/reliable-work-from-unreliable-agents/">&lt;p&gt;On Monday, November 9, I gave a guest lecture on agentic engineering in Xian-He Sun’s CS 595, Scalable Computing for AI, at Illinois Tech, and I opened with a show of hands. Who uses a chat window and pastes the answers? Autocomplete in the editor? An agent in the terminal that asks before each step? Agents that keep working overnight? Then the last rung: who has submitted a paper with a figure produced by agent-written code? Keep your hand up if you could regenerate that figure tomorrow. The gap between what we can now produce and what we can stand behind was the subject of the hour, and this is the argument for people who were not in the room.&lt;/p&gt; &lt;p class=&quot;btn-row&quot;&gt;&lt;a class=&quot;btn&quot; href=&quot;/assets/pdf/kougkas-reliable-work-from-unreliable-agents-2026-11.pdf&quot;&gt;Download the slides (PDF)&lt;/a&gt;&lt;/p&gt; &lt;aside class=&quot;entry-glance&quot; aria-label=&quot;At a glance&quot;&gt; &lt;p class=&quot;entry-glance__kicker&quot;&gt;At a glance&lt;/p&gt; &lt;dl&gt; &lt;div&gt;&lt;dt&gt;Anchor&lt;/dt&gt;&lt;dd&gt;Lecture, Agentic Engineering, November 9, 2026&lt;/dd&gt;&lt;/div&gt; &lt;div&gt;&lt;dt&gt;Instrument&lt;/dt&gt;&lt;dd&gt;&lt;a href=&quot;/work/clio-coder/&quot;&gt;CLIO Coder&lt;/a&gt;, part of &lt;a href=&quot;/work/clio/&quot;&gt;CLIO&lt;/a&gt;&lt;/dd&gt;&lt;/div&gt; &lt;div&gt;&lt;dt&gt;The claim&lt;/dt&gt;&lt;dd&gt;A coding agent is a system built around one brilliant, persuasive, unreliable component. Everything we call engineering lives in what we build around it.&lt;/dd&gt;&lt;/div&gt; &lt;div&gt;&lt;dt&gt;Slides&lt;/dt&gt;&lt;dd&gt;&lt;a href=&quot;/assets/pdf/kougkas-reliable-work-from-unreliable-agents-2026-11.pdf&quot;&gt;72 pages, PDF, with sources&lt;/a&gt;&lt;/dd&gt;&lt;/div&gt; &lt;/dl&gt; &lt;/aside&gt; &lt;h2 id=&quot;von-neumann-did-not-wait-for-better-tubes&quot;&gt;Von Neumann did not wait for better tubes&lt;/h2&gt; &lt;p&gt;My favorite paper title in computing is John von Neumann’s &lt;em&gt;Probabilistic Logics and the Synthesis of Reliable Organisms from Unreliable Components&lt;/em&gt;, from lectures he gave at Caltech in 1952 and published in &lt;em&gt;Automata Studies&lt;/em&gt; in 1956. He accepted that he would never get a perfect part and asked what organization makes the whole reliable anyway. He also named the weak point. Redundancy works when parts fail independently, and he called statistically dependent failures a good deal more realistic. Thirty years later Knight and Leveson tested that assumption on software: 27 independently written versions, a million tests, and independence rejected.&lt;/p&gt; &lt;p&gt;We are back in von Neumann’s position with a stranger component. Our tube does not burn out. It answers confidently, it is persuasive, and it is sometimes wrong. A coding agent is a system built around that component, and the people who know how to get reliable behavior out of unreliable parts at scale are the ones who already do checkpointing, distributed consensus, and numerical verification for a living.&lt;/p&gt; &lt;p&gt;The history also explains why this is harder than the last time programmers met a machine that wrote code for them. FORTRAN’s team asked for faith first and then made trust the engineering goal. A compiler is a function: same input, same output, defined semantics, and nobody reviews the assembly. An agent is a translation step with no semantics guarantee. We keep the productivity jump only if we rebuild around it what the compiler used to give us for free.&lt;/p&gt; &lt;h2 id=&quot;why-the-problem-cannot-wait&quot;&gt;Why the problem cannot wait&lt;/h2&gt; &lt;p&gt;METR’s time-horizon data show the longest task a frontier agent could finish growing from about 4 minutes in March 2023 to about 17 hours in April 2026, doubling roughly every 129 days. The axis is how long the task takes a human expert, the bar is success at least half the time, and the newest points are the least certain. Capability is also not reliability: a peer-reviewed study of 15 models at ICML this year calls reliability an industry-wide plateau. I told the room not to bet a group on this curve and not to ignore it either.&lt;/p&gt; &lt;p&gt;The chart I care about more comes from a &lt;a href=&quot;https://arxiv.org/abs/2507.09089&quot;&gt;randomized trial by METR&lt;/a&gt;: 16 experienced open-source developers on 246 real issues in their own repositories, using early-2025 tools. They forecast that AI would make them 24 percent faster. Afterward they believed it had made them 20 percent faster. The stopwatch said 19 percent slower. METR now considers the speed result dated, and that is fine, because the interesting finding is the instrument. We are the instrument, and it reads high. Lisanne Bainbridge saw the same thing in 1983 in &lt;em&gt;Ironies of Automation&lt;/em&gt;: automate the routine work and you ask a person to watch for the rare failure while the skill to catch it decays.&lt;/p&gt; &lt;p&gt;The organization around the model changes its behavior more than most people expect. &lt;a href=&quot;https://arxiv.org/abs/2510.20270&quot;&gt;ImpossibleBench&lt;/a&gt; builds tasks whose tests contradict the specification, so any pass is cheating. On its conflicting variant, letting GPT-5 say “I cannot do this” took its cheating rate from 54 percent to 9. Same model, different organization. Give your agent a dignified way to fail.&lt;/p&gt; &lt;p&gt;Scientific software raises the stakes. A web service that breaks throws an exception. A climate kernel that breaks returns a number. The wrong answer compiles, runs, scales, and looks plausible. The National Academies wrote in 2025 that methods for verification, validation, and uncertainty quantification “do not exist for, or map directly onto, foundation models.”&lt;/p&gt; &lt;h2 id=&quot;an-agent-is-a-while-loop&quot;&gt;An agent is a while loop&lt;/h2&gt; &lt;p&gt;Strip away the excitement and an agent is a loop. Call the model on the context. If it asks for no tools, return its text. Otherwise check whether each call is allowed, run it, append the result, and fit the context back into the window.&lt;/p&gt; &lt;div class=&quot;language-python highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;k&quot;&gt;while&lt;/span&gt; &lt;span class=&quot;bp&quot;&gt;True&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;reply&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;model&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;context&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;if&lt;/span&gt; &lt;span class=&quot;ow&quot;&gt;not&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;reply&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;tool_calls&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;return&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;reply&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;text&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;for&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;call&lt;/span&gt; &lt;span class=&quot;ow&quot;&gt;in&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;reply&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;tool_calls&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;if&lt;/span&gt; &lt;span class=&quot;ow&quot;&gt;not&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;allowed&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;call&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;):&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;result&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;refusal&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;call&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;else&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;result&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;run&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;call&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;context&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;append&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;call&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;result&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;context&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;fit&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;context&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt; &lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt; &lt;p&gt;All the intelligence is in the model. All the reliability is in three questions the loop leaves open: who decides what is allowed, what &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;fit&lt;/code&gt; throws away, and how anyone knows the answer is right. Nothing in the loop checks the answer before handing it back. In &lt;a href=&quot;/work/clio-coder/&quot;&gt;CLIO Coder&lt;/a&gt;, the open-source agent I build and used as the instrument for the lecture, the loop is still about this long. Nearly everything else answers those three questions.&lt;/p&gt; &lt;p&gt;Karpathy popularized the picture of the model as a CPU, the context window as RAM, and tools as devices. I would push it further: the harness is the kernel, and we are writing it the way people wrote kernels in the 1960s, without a textbook. My career has followed the machine’s bottleneck from compute to data, and it has moved again, to context: the right facts in front of the right reasoner at the right moment. The first lesson from building CLIO Coder is short. A prompt is a request. A checker is a law. “Please do not import across this boundary” in an instructions file works most of the time, and the architecture erodes in the remainder. A boundary checker that fails the build is something the agent reads, repairs against, and cannot negotiate with.&lt;/p&gt; &lt;h2 id=&quot;five-ideas&quot;&gt;Five ideas&lt;/h2&gt; &lt;h3 id=&quot;context-is-a-memory-hierarchy&quot;&gt;Context is a memory hierarchy&lt;/h3&gt; &lt;p&gt;The stable prompt prefix the provider caches behaves like a CPU cache. The live working set is DRAM. Evicted tool results that can be recalled by reference are a burst buffer, the full append-only session ledger is the parallel file system, and durable lessons and code maps are the archive. Locality, replacement policy, prefetching, and the cost of a cold start all apply, with one wrinkle: the processor gets worse as the top tier fills, and where the relevant text sits matters as much as whether it is there.&lt;/p&gt; &lt;p&gt;Locality is worth money. With a 20,000-token prefix over 50 requests and published multipliers of 1.25 for a cache write and 0.1 for a cache read, churning the prefix costs 2.7 times as much as keeping it stable. That is arithmetic, not a measurement. The measurement came from one session of our own, logged as issue #423 in CLIO Coder: 41 percent of main-loop spend went to re-prefilling tokens the server had already seen, because a background memory approval grew one prompt section from 163 to 275 tokens.&lt;/p&gt; &lt;p&gt;The open wound is compression. When we compress simulation output with SZ we state the error we can tolerate and the compressor guarantees it. When a model rewrites its own history into a checkpoint, the summary can be small, valid, and missing the one constraint that matters, and nothing would notice. There is still no accepted fidelity benchmark for real sessions. I have written about the lifetimes of &lt;a href=&quot;/journal/2026/context-needs-a-lifecycle/&quot;&gt;working context, handoffs, and memory&lt;/a&gt; and about &lt;a href=&quot;/journal/2026/agent-memory-is-a-storage-problem/&quot;&gt;memory as a storage problem&lt;/a&gt;; this is the piece neither of those essays solves.&lt;/p&gt; &lt;h3 id=&quot;contain-first-ask-last&quot;&gt;Contain first, ask last&lt;/h3&gt; &lt;p&gt;Simon Willison’s &lt;a href=&quot;https://simonwillison.net/2025/Jun/16/the-lethal-trifecta/&quot;&gt;lethal trifecta&lt;/a&gt; is private data, untrusted content, and a way out. Any two are survivable. A coding agent on your account, on a lab machine, with a README it just fetched, has all three by default. A dependency, a web page, a paper PDF, or a closed issue can carry instructions the model cannot reliably tell apart from yours.&lt;/p&gt; &lt;p&gt;Asking the human does not scale. Anthropic reports that users approve 93 percent of permission prompts and that sandboxing removed 84 percent of them. The better question is what the process can possibly touch. If the answer is the workspace on a read-only root with credentials masked, let it run, and save human attention for the decisions that deserve it.&lt;/p&gt; &lt;p&gt;The safety judge in CLIO Coder is reasoning-blind: it sees what the person said and the proposed call, never what the agent read. That removes the persuasion channel, and it is still not enough. In a probe this month, a trojan &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;AGENTS.md&lt;/code&gt; told the agent to run &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;npm test&lt;/code&gt; outside the sandbox. The judge never read the file, saw a clean-looking test command, and allowed it. The first fix let an escape through only when the operator had named it, and the judge then cited that permission when the operator had only asked it to fix the tests. Now the host checks the citation. Authority should flow downhill: nothing the agent reads can raise its authority, and only a person can loosen a rule. I made the longer case in &lt;a href=&quot;/journal/2026/an-agents-authority-should-travel-with-the-task/&quot;&gt;An agent’s authority should travel with the task&lt;/a&gt;.&lt;/p&gt; &lt;h3 id=&quot;many-minds-give-opinions-checks-give-verdicts&quot;&gt;Many minds give opinions, checks give verdicts&lt;/h3&gt; &lt;p&gt;Running several agents sometimes pays. Kim and colleagues measured a gain of 81 percent on decomposable financial reasoning and a loss of 70 percent on sequential planning, and CooperBench found two agents splitting work did 30 percent worse than one doing both. The vendors disagree with each other, and none of these studies covers scientific code. This field needs its Amdahl and its Gustafson: what is the serial fraction of a software task, and what does it cost agents to share what they decided?&lt;/p&gt; &lt;p&gt;Treating workers as ranks helps the design. Each gets its own context as its address space, a watchdog, and a budget, and different models can fill different roles the way we place GPU work on GPU nodes. The trap is agreement. In the VeriHarness preprint, a third of the answers that all ten attempts of one model agreed on were wrong. Voting barely moved the score. Going back to the data and checking did. This is von Neumann’s assumption failing in front of us: copies of one model do not fail independently.&lt;/p&gt; &lt;h3 id=&quot;evidence-comes-from-outside-the-model&quot;&gt;Evidence comes from outside the model&lt;/h3&gt; &lt;p&gt;Feynman’s first principle was that you must not fool yourself, and you are the easiest person to fool. Now there is a second party that writes the code, writes the test, and reports in lovely prose that the test passed. In CLIO Coder every check carries three separate judgments: whether the command executed, whether it passed validation, and a field whose only possible value is “not established by this check” for scientific validity. Ran, passed, and true are three different questions.&lt;/p&gt; &lt;p&gt;A tiny example made the point. A temperature-conversion test asserted that &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;celsiusToFahrenheit(-273.15)&lt;/code&gt; equals &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;-459.67&lt;/code&gt; and failed by one unit in the last place. The code was right and the test was wrong. The correct fix is a tolerance, which is exactly what an agent told to get to green will do to every test. The shipped tolerance is 1e-10. Is that right for calibration, for a climate model, for a Monte Carlo tally? A local open-weight model handed the same failing check left the source alone and, asked about the tolerance, called it a convention. That is the right answer from a tool, and the decision is still ours.&lt;/p&gt; &lt;p&gt;For every claim an agent makes, ask who could have faked it. “All tests pass” is a guess. A pasted log is a hint, because the agent chose what to show. The harness running the check on these exact files is evidence. Matching a known answer is the step only a scientist can supply. The evaluator is an unreliable component too: CORE-Bench scores for one model went from 42 to 95 percent after grader and scaffold fixes, and CLIO Coder’s own check runner once ran outside the sandbox, where a trojan test helper could read secrets through the tool meant to produce evidence. CLIO Coder is named for Clio, the muse of history, because a run should leave a record someone else can examine. A sealed run shows what ran, on which model, at what cost, and catches tampering. It does not show that the work was correct, that it would come out the same again, or who produced it. Knowing what a record does not prove is what separates a lab notebook from a marketing deck.&lt;/p&gt; &lt;h3 id=&quot;own-your-intelligence&quot;&gt;Own your intelligence&lt;/h3&gt; &lt;p&gt;Science cannot depend on one company’s pricing page. If the agent becomes as important as the compiler, the scientific community should insist on what it insisted on for compilers: multiple implementations, open source, and something that runs on our own machines. The harness should treat the model as a replaceable part chosen per task by sensitivity, capability, and cost. CLIO Coder supports local servers, institutional services, and the major cloud providers, and the tolerance report above came from an open-weight model on a machine in my lab. Where each local model breaks is still an open measurement. I wrote about the pairing of model and harness in &lt;a href=&quot;/journal/2026/a-capable-model-in-a-capable-harness/&quot;&gt;A capable model in a capable harness&lt;/a&gt;.&lt;/p&gt; &lt;h2 id=&quot;what-science-could-look-like&quot;&gt;What science could look like&lt;/h2&gt; &lt;p&gt;Assume we get the engineering right. For a whole career the gating question for a scientist who wanted to automate their work was whether they knew a programmer. That barrier is starting to fall, unevenly: in Anthropic’s own data, computer science is 4.3 percent of researchers and 32.7 percent of Claude Code research sessions.&lt;/p&gt; &lt;p&gt;Every lab has a code that produces results nobody disputes, in a dialect only two people still read. Port it in stages, and require every stage to reproduce the reference output before the next one starts, so the old code becomes the oracle for the new one. Its correctness is an asset to spend, though its bugs get ported too. A lab’s craft could live in agent skills the way wet-lab practice lives in protocols: written down, reviewed, improved when it fails, and someday cited in a methods section at a version. Every result could carry its own history, because an agent that is watching anyway can keep the notebook as a byproduct of the work instead of a chore at the end, and thresholds and verdict rules can be locked before any measurement.&lt;/p&gt; &lt;p&gt;Physics still bounds this. Anthropic’s own illustrative scenarios project 15 to 16 times the output for purely computational fields and 3 to 4 times for lab and field sciences, because those spend 38 to 41 percent of researcher time on physical steps. Those are scenarios from a vendor model, not measurements, and they make the right point: closing the loop on the computation does not close the loop on the beamline.&lt;/p&gt; &lt;p&gt;The slide I lingered on was fiction, on purpose: a Tuesday in 2030. Overnight, a group’s fleet ran 40 variants of a closure model, three diverged, and it could not explain a fourth. A student walks any figure back to its run, and the hour goes to the physics. A retired author signs off on the tolerance for the last ported module of a 1994 solver. Nobody in that story writes less science. They write less of everything else.&lt;/p&gt; &lt;h2 id=&quot;what-stands-between-us&quot;&gt;What stands between us&lt;/h2&gt; &lt;p&gt;Every part of that picture has an unsolved problem under it. Eight seemed ready to take this year: what a summary loses in a real session; the serial fraction and coordination cost of scientific tasks; whether memory changes the next task in a real repository; whether an oracle catches seeded bugs in a kernel or the agent talks around it; what numerical changes scientists accept with and without evidence; how much ten repeats of one scientific task vary, which sets the sample size for every other study; what agents do to a batch allocation; and where each model on one workstation breaks. Most of the agent literature measures models. Almost nobody measures harnesses.&lt;/p&gt; &lt;p&gt;Negative results belong in public too. CLIO Coder once shipped a small, fast decision model inside the agent loop. Across 12 real sessions the agents called it zero times, and the 0.6.8 release cut it back to what an agent or the safety judge asks for. Watching that number come back zero was instructive.&lt;/p&gt; &lt;p&gt;The strongest objection is that the model will absorb the harness. Part of it will. Context management can move into the weights: a preprint on context language models reports beating hand-built compaction, 11.4 percent more accurate on BrowseComp-Plus with 21.5 percent fewer FLOPs. Containment, verification, and provenance cannot, because they are valuable only from outside the thing they check.&lt;/p&gt; &lt;p&gt;Von Neumann did not wait for better tubes, and neither should we. Everything in this lecture can be automated eventually except deciding what counts as right and putting a name on it. That is what a scientist is.&lt;/p&gt; </content> </entry> <entry> <title type="html">One destination, N tiers</title> <link rel="alternate" type="text/html" href="https://akougkas.io/journal/2026/one-destination-n-tiers/"/> <id>https://akougkas.io/journal/2026/one-destination-n-tiers/</id> <published>2026-11-13T00:00:00-06:00</published> <updated>2026-11-13T00:00:00-06:00</updated> <summary type="html">Every tier supplies the application at once, and the application sees one destination. The thesis from a November 2026 talk to my group at the Gnosis Research Center, the six lines of I/O work behind it since 2016, and my bet that they are the foundation agents need for context.</summary> <content type="html" xml:base="https://akougkas.io/journal/2026/one-destination-n-tiers/">&lt;p&gt;On Wednesday, November 11, I gave a talk to my group at the &lt;a href=&quot;https://grc.iit.edu/&quot;&gt;Gnosis Research Center&lt;/a&gt; about what happens after the data leaves memory. Most of the room builds I/O systems, and many of them are building the newest pieces of the line I describe here. The talk had one thesis, and I put it on a slide by itself: every tier supplies the application at once. The application sees one destination.&lt;/p&gt; &lt;p class=&quot;btn-row&quot;&gt;&lt;a class=&quot;btn&quot; href=&quot;/assets/pdf/kougkas-one-destination-n-tiers-2026-11.pdf&quot;&gt;Download the slides (PDF)&lt;/a&gt;&lt;/p&gt; &lt;aside class=&quot;entry-glance&quot; aria-label=&quot;At a glance&quot;&gt; &lt;p class=&quot;entry-glance__kicker&quot;&gt;At a glance&lt;/p&gt; &lt;dl&gt; &lt;div&gt;&lt;dt&gt;Anchor&lt;/dt&gt;&lt;dd&gt;GRC group meeting, November 11, 2026&lt;/dd&gt;&lt;/div&gt; &lt;div&gt;&lt;dt&gt;Systems&lt;/dt&gt;&lt;dd&gt;&lt;a href=&quot;/work/hermes/&quot;&gt;Hermes&lt;/a&gt;, &lt;a href=&quot;/work/labios/&quot;&gt;LABIOS&lt;/a&gt;, &lt;a href=&quot;/work/dtio/&quot;&gt;DTIO&lt;/a&gt;, &lt;a href=&quot;/work/chronolog/&quot;&gt;ChronoLog&lt;/a&gt;, &lt;a href=&quot;/work/iowarp/&quot;&gt;IOWarp&lt;/a&gt;, &lt;a href=&quot;/work/clio/&quot;&gt;CLIO&lt;/a&gt;&lt;/dd&gt;&lt;/div&gt; &lt;div&gt;&lt;dt&gt;The claim&lt;/dt&gt;&lt;dd&gt;Six lines of I/O work converge on context, and agents are the client they were waiting for.&lt;/dd&gt;&lt;/div&gt; &lt;div&gt;&lt;dt&gt;Slides&lt;/dt&gt;&lt;dd&gt;&lt;a href=&quot;/assets/pdf/kougkas-one-destination-n-tiers-2026-11.pdf&quot;&gt;28 pages, PDF&lt;/a&gt;&lt;/dd&gt;&lt;/div&gt; &lt;/dl&gt; &lt;/aside&gt; &lt;h2 id=&quot;the-hierarchy-nobody-chooses&quot;&gt;The hierarchy nobody chooses&lt;/h2&gt; &lt;p&gt;None of us has ever chosen which cache level a variable lives in. That invisibility is forty years of architecture work, some of it done in our own lab, and it holds because one architect designs every level of one machine.&lt;/p&gt; &lt;p&gt;Below DRAM there is no such invisibility. From IBM’s first disk drive in 1956 until flash reached the data center, there was disk and then tape. Then four families of hardware arrived: flash, NVMe, and burst buffers; byte-addressable persistent memory such as Optane; disaggregated memory and storage over CXL, RDMA, and NVMe over Fabrics; and storage attached directly to accelerators through HBM and GPUDirect Storage. Software support arrived one device at a time. Intel wound Optane down in 2022, and software written against Optane went with it. Software written against the hierarchy kept running.&lt;/p&gt; &lt;p&gt;An I/O tier is not another cache level. It is shared by many jobs and many owners, it fails on its own, it is persistent and carries durability semantics, and it answers in microseconds to seconds instead of nanoseconds. The principle is the one the lab’s memory-systems work states for the inside of the machine: match the rate of requests to the rate of supply at every layer. Same principle, different problem, different machinery.&lt;/p&gt; &lt;h2 id=&quot;where-the-line-started&quot;&gt;Where the line started&lt;/h2&gt; &lt;p&gt;In 2015 and 2016, Cray’s DataWarp burst buffers arrived on Cori and Trinity. A new tier showed up on leadership machines and the first question was who manages it. Jobs interfered with each other on the shared tier, and &lt;a href=&quot;/publications/bbio/&quot;&gt;BBIO&lt;/a&gt;, my eScience 2016 paper with Matthieu Dorier, Rob Latham, and Rob Ross at Argonne, coordinated burst buffers to prevent that interference and improved performance by up to 2x. &lt;a href=&quot;/publications/kougkas2018harmonia/&quot;&gt;Harmonia&lt;/a&gt; followed as an interference-aware scheduler for shared burst buffers, and &lt;a href=&quot;/publications/kougkas2018iris/&quot;&gt;IRIS&lt;/a&gt; put files and objects behind one interface, which &lt;a href=&quot;https://grc.iit.edu/center/team/kun-feng/&quot;&gt;Kun Feng&lt;/a&gt; carried into &lt;a href=&quot;/publications/feng2019niobe/&quot;&gt;NIOBE&lt;/a&gt;.&lt;/p&gt; &lt;p&gt;Single tiers had managers: DataWarp for the burst buffer, Data Elevator between burst buffer and file system, hierarchical storage management for tape. Each of our early papers also tamed one tier or one interface. The machines already had five tiers, and nothing managed the hierarchy as one.&lt;/p&gt; &lt;h2 id=&quot;six-lines&quot;&gt;Six lines&lt;/h2&gt; &lt;p&gt;The thesis rests on six ideas. Each one has a name, a system, and people who built it.&lt;/p&gt; &lt;table&gt; &lt;thead&gt; &lt;tr&gt; &lt;th&gt;Line&lt;/th&gt; &lt;th&gt;The question&lt;/th&gt; &lt;th&gt;Systems&lt;/th&gt; &lt;th&gt;Built by&lt;/th&gt; &lt;/tr&gt; &lt;/thead&gt; &lt;tbody&gt; &lt;tr&gt; &lt;td&gt;Placement&lt;/td&gt; &lt;td&gt;Which tier holds the data now?&lt;/td&gt; &lt;td&gt;Hermes, then the CLIO Context Transfer Engine&lt;/td&gt; &lt;td&gt;Hari Devarajan and I; runtime by Luke Logan&lt;/td&gt; &lt;/tr&gt; &lt;tr&gt; &lt;td&gt;Intent&lt;/td&gt; &lt;td&gt;What does the application want?&lt;/td&gt; &lt;td&gt;LABIOS&lt;/td&gt; &lt;td&gt;Hari and I, with Jay Lofstead and Kathryn Mohror&lt;/td&gt; &lt;/tr&gt; &lt;tr&gt; &lt;td&gt;Task&lt;/td&gt; &lt;td&gt;What work travels with the data?&lt;/td&gt; &lt;td&gt;DTIO, now in CLIO Core&lt;/td&gt; &lt;td&gt;Keith Bateman, with Bogdan Nicolae and Franck Cappello&lt;/td&gt; &lt;/tr&gt; &lt;tr&gt; &lt;td&gt;Order&lt;/td&gt; &lt;td&gt;What happened first?&lt;/td&gt; &lt;td&gt;ChronoLog&lt;/td&gt; &lt;td&gt;Hari and I first; Kun Feng and Eneko Gonzalez wrote most of today’s code&lt;/td&gt; &lt;/tr&gt; &lt;tr&gt; &lt;td&gt;Runtime&lt;/td&gt; &lt;td&gt;What executes the decision?&lt;/td&gt; &lt;td&gt;The Hermes runtime, LabStor, Chimaera, the CLIO Runtime&lt;/td&gt; &lt;td&gt;Luke Logan&lt;/td&gt; &lt;/tr&gt; &lt;tr&gt; &lt;td&gt;Measurement&lt;/td&gt; &lt;td&gt;What is actually happening?&lt;/td&gt; &lt;td&gt;DLIO, DFTracer, WisIO&lt;/td&gt; &lt;td&gt;Hari, with Argonne and Livermore; Izzet Yildirim&lt;/td&gt; &lt;/tr&gt; &lt;/tbody&gt; &lt;/table&gt; &lt;p&gt;&lt;strong&gt;Placement.&lt;/strong&gt; &lt;a href=&quot;/work/hermes/&quot;&gt;Hermes&lt;/a&gt;, the multi-tier I/O buffering system in our &lt;a href=&quot;/publications/kougkas2018hermes/&quot;&gt;HPDC 2018 paper&lt;/a&gt;, treats RAM, NVMe, burst buffers, and the parallel file system as one buffer. Placement is solved per request, not fixed per device: if a request fits in a layer, place it; otherwise skip to the next layer, split it, or flush and recurse on what remains. Hermes was 8x faster than no buffering and more than 2x faster than Data Elevator and DataWarp, and it needed no application changes. Once tiers exist, every classic optimization gains a new variable, which tier, and &lt;a href=&quot;https://grc.iit.edu/center/team/hariharan-devarajan/&quot;&gt;Hariharan Devarajan&lt;/a&gt;’s &lt;a href=&quot;/publications/devarajan2020hfetch/&quot;&gt;HFetch&lt;/a&gt;, &lt;a href=&quot;/publications/devarajan2020hcompress/&quot;&gt;HCompress&lt;/a&gt;, and &lt;a href=&quot;/publications/devarajan2020hreplica/&quot;&gt;HReplica&lt;/a&gt; answered it for prefetching, compression, and replication.&lt;/p&gt; &lt;p&gt;&lt;strong&gt;Intent.&lt;/strong&gt; Every one of those algorithms inferred what the application wanted from its I/O calls. POSIX throws that away. &lt;a href=&quot;/work/labios/&quot;&gt;LABIOS&lt;/a&gt;, our label-based I/O system (&lt;a href=&quot;/publications/kougkas2019labios/&quot;&gt;HPDC 2019&lt;/a&gt;, with &lt;a href=&quot;https://www.lofstead.org/&quot;&gt;Jay Lofstead&lt;/a&gt; and &lt;a href=&quot;https://people.llnl.gov/people/mohror1&quot;&gt;Kathryn Mohror&lt;/a&gt;), puts it back. A label is an operation, a data pointer, and flags, and once I/O is labels, storage becomes a scheduling problem. I used to call labels an optimization. I now see them as intent preserved across a system boundary.&lt;/p&gt; &lt;p&gt;&lt;strong&gt;Task.&lt;/strong&gt; &lt;a href=&quot;/work/dtio/&quot;&gt;DTIO&lt;/a&gt;, &lt;a href=&quot;https://grc.iit.edu/center/team/keith-bateman/&quot;&gt;Keith Bateman&lt;/a&gt;’s task-based I/O system with &lt;a href=&quot;https://www.bnicolae.net/&quot;&gt;Bogdan Nicolae&lt;/a&gt; and &lt;a href=&quot;https://franckcappello.github.io/&quot;&gt;Franck Cappello&lt;/a&gt; at Argonne, turns the label into a DataTask that carries formats, ordering, and dependencies, so translation runs online and producer and consumer overlap. On PtychoNN it cut time by 49.6 percent against offline translation (&lt;a href=&quot;/publications/bateman2025dtio/&quot;&gt;SSDBM 2025&lt;/a&gt;). Its mechanisms now live in CLIO Core.&lt;/p&gt; &lt;p&gt;&lt;strong&gt;Order.&lt;/strong&gt; &lt;a href=&quot;/work/chronolog/&quot;&gt;ChronoLog&lt;/a&gt;, a distributed shared log ordered by physical time (&lt;a href=&quot;/publications/kougkas2020chronolog/&quot;&gt;MSST 2020&lt;/a&gt;), asks what happens if the data carries its own placement key. Physical time is the log sequence number, so a writer knows where its entry goes without asking a sequencer. The prototype sustained over a million tail operations per second. The log’s age order matches the hierarchy’s speed order, newest in RAM and oldest in the archive, and version 3.0 added SQL, publish and subscribe, and an MCP server in May 2026.&lt;/p&gt; &lt;p&gt;&lt;strong&gt;Runtime.&lt;/strong&gt; Every system kept rebuilding the same runtime. &lt;a href=&quot;https://grc.iit.edu/center/team/luke-logan/&quot;&gt;Luke Logan&lt;/a&gt; built it once and kept rebuilding it better: the Hermes runtime, then &lt;a href=&quot;/publications/logan2022labstor/&quot;&gt;LabStor&lt;/a&gt;, modular I/O stacks in user space, then Chimaera, where every module is a pool of tasks on shared-memory queues, and now the CLIO Runtime. His &lt;a href=&quot;/publications/logan2024megammap/&quot;&gt;MegaMmap&lt;/a&gt; put the same tiers behind a memory interface. Build the runtime once, and every system after it is a module.&lt;/p&gt; &lt;p&gt;&lt;strong&gt;Measurement.&lt;/strong&gt; You cannot place what you cannot see. DLIO is Hari’s benchmark of how scientific deep learning does I/O, built with Huihuo Zheng and Venkat Vishwanath at Argonne. Its later development and its place as the workload engine of MLPerf Storage are Argonne’s work, mostly Hari’s, and I was part of the Illinois Tech team that co-advised him. At Livermore, Hari built DFTracer, and &lt;a href=&quot;https://grc.iit.edu/center/team/izzet-yildirim/&quot;&gt;Izzet Yildirim&lt;/a&gt;’s &lt;a href=&quot;/publications/yildirim_wisio_2025/&quot;&gt;WisIO&lt;/a&gt; reads one trace from many views to classify bottlenecks from metrics rather than fixed rules.&lt;/p&gt; &lt;p&gt;None of this was one person’s work, and the line passes through five dissertations. Mine, on data labels, gave Harmonia, Hermes, and LABIOS. Kun’s integrated files and objects. Hari’s made storage tier-aware and measurable. Luke’s built the runtime. &lt;a href=&quot;https://grc.iit.edu/center/team/jaime-cernuda/&quot;&gt;Jaime Cernuda&lt;/a&gt;’s built the data flows and pipelines that now carry CLIO Agent and Relay. Each handed its ideas to the next, and all five continue in &lt;a href=&quot;/work/iowarp/&quot;&gt;IOWarp&lt;/a&gt;.&lt;/p&gt; &lt;h2 id=&quot;the-same-pyramid-different-hot-data&quot;&gt;The same pyramid, different hot data&lt;/h2&gt; &lt;p&gt;In 2018 the hot data in our pyramid was a checkpoint: RAM, NVMe, burst buffer, parallel file system. In 2025 the hot data is a KV-cache, the attention state a language model keeps per token, and the pyramid is GPU HBM, host DRAM, local SSD, and networked object storage. NVIDIA Dynamo, LMCache, and Mooncake all tier KV-cache blocks down that hierarchy. Industry arrived at the same pyramid independently, and that is the best evidence I know that the problem is real. &lt;a href=&quot;https://grc.iit.edu/center/team/jie-ye/&quot;&gt;Jie Ye&lt;/a&gt;’s measurements of &lt;a href=&quot;/publications/ye2025unboxkv-io/&quot;&gt;KV-cache I/O under concurrency&lt;/a&gt; are part of how our group came to see it.&lt;/p&gt; &lt;p&gt;The next hot data is the context an agent needs for one decision. I made the argument that the client changed at an &lt;a href=&quot;/journal/2025/from-storage-optimization-to-context-orchestration/&quot;&gt;Argonne seminar last year&lt;/a&gt;: a program’s unit of work is the byte and its access is periodic and knowable, while an agent’s unit of work is the decision and its requests are semantic and produced by reasoning. Context is the slice of data, metadata, provenance, system state, tool capability, and history that one decision needs. Assembling that slice on time, from every tier, is an I/O problem.&lt;/p&gt; &lt;h2 id=&quot;the-bet&quot;&gt;The bet&lt;/h2&gt; &lt;p&gt;My bet is that the line we have built since 2016 is the right foundation for agent context. Not because the systems were designed for agents, since none of them was, but because context is assembled from every tier at once and handed to a client that should see one destination. That is the thesis, with a new client.&lt;/p&gt; &lt;p&gt;Each line already has a home in the &lt;a href=&quot;/work/clio/&quot;&gt;CLIO&lt;/a&gt; stack, the context layer for scientific AI agents that I created for IOWarp. Placement lives in CLIO Core’s Context Transfer Engine, which is Hermes grown up: its policies became a chain of interposers on one task interface, cache, then compressor, then replication, then core. Intent and task live in CLIO Core. Order is ChronoLog as an agent’s history. Runtime is the CLIO Runtime. Luke leads Core engineering, and the &lt;a href=&quot;/journal/2026/clio-core-2-3-and-2-4-when-a-tier-fills-or-a-node-dies/&quot;&gt;2.3 and 2.4 releases&lt;/a&gt; taught it to evict from a full tier, lose no data when a tier goes offline, and run on Aurora’s Intel GPUs. Jaime leads CLIO Agent and Relay. Isa Muradli, Shazzadul Islam, Soham Sonar, and Aum Sathwara build CLIO Kit, the MCP servers for scientific formats and tools. I build &lt;a href=&quot;/work/clio-coder/&quot;&gt;CLIO Coder&lt;/a&gt;. Two DOE Genesis Mission projects, SPOTTER-AI led by Argonne and PORTUS led by PNNL, build on CLIO, and the full stack launches at SC26 in Chicago, November 15 to 20.&lt;/p&gt; &lt;p&gt;The measurement line is the youngest. For agents it means characterizing agents as an I/O workload, and several students in the group are now doing exactly that. Agents read, write, and revisit context in patterns that our storage stacks were never tuned for, and nobody has measured them carefully yet. If agent context turns out to be a first-class I/O workload, every tier in the hierarchy has a new tenant to serve. The other five lines tell us where context should live and how it should move. Measurement is how we will learn whether agents need it the way I think they do.&lt;/p&gt; &lt;h2 id=&quot;what-the-line-taught-me&quot;&gt;What the line taught me&lt;/h2&gt; &lt;p&gt;None of these lessons is about I/O. The system existed before the project did: Hermes was a paper and a prototype before it was funded. One line of work compounds: one runtime, from Hermes to LabStor to Chimaera, now sits under everything we ship. Software makes an idea negotiate, with compilers, failures, other people’s workloads, and the cost of being understood. And the abstraction outlives the code. &lt;a href=&quot;/journal/2024/hermes-is-complete/&quot;&gt;Hermes’s final release&lt;/a&gt; was in 2024, and its placement model runs inside CLIO today.&lt;/p&gt; &lt;p&gt;None of these systems started because someone asked for them. Each started because someone in the lab saw a thing that should exist and began building it well. Pursuing excellence does not need justification.&lt;/p&gt; </content> </entry> <entry> <title type="html">CLIO as the entry point</title> <link rel="alternate" type="text/html" href="https://akougkas.io/journal/2026/clio-as-the-entry-point/"/> <id>https://akougkas.io/journal/2026/clio-as-the-entry-point/</id> <published>2026-11-07T00:00:00-06:00</published> <updated>2026-11-07T00:00:00-06:00</updated> <summary type="html">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.</summary> <content type="html" xml:base="https://akougkas.io/journal/2026/clio-as-the-entry-point/">&lt;p&gt;&lt;a href=&quot;/work/clio/&quot;&gt;CLIO&lt;/a&gt;, the context layer I created and lead across &lt;a href=&quot;/work/iowarp/&quot;&gt;IOWarp&lt;/a&gt;, should become the one place a developer starts. The way there is an application SDK with deployment profiles, not an umbrella package that pulls the whole ecosystem into every caller and not a gateway service that every call has to pass through.&lt;/p&gt; &lt;h2 id=&quot;where-a-developer-starts-in-november-2026&quot;&gt;Where a developer starts in November 2026&lt;/h2&gt; &lt;p&gt;The parts work and they install separately. &lt;a href=&quot;https://github.com/iowarp/clio-core&quot;&gt;CLIO Core&lt;/a&gt;, the tiered context and data runtime, was at v2.4.0 in November 2026 and arrives as a pip wheel, a &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;.deb&lt;/code&gt;, &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;.rpm&lt;/code&gt;, or AppImage, or a Windows installer. &lt;a href=&quot;https://github.com/iowarp/clio-kit&quot;&gt;CLIO Kit&lt;/a&gt;, the MCP servers for HDF5, Slurm, ParaView, and the rest of the scientific stack, was at v2.11.1 and installs from PyPI as a tool that places selected servers into several agent clients. &lt;a href=&quot;https://github.com/iowarp/clio-agent&quot;&gt;CLIO Agent&lt;/a&gt;, the science agent, was at v0.9.5.1 with one installer per operating system that brings its own Python and uv runtimes. &lt;a href=&quot;/work/clio-coder/&quot;&gt;CLIO Coder&lt;/a&gt;, the coding agent, was at v0.6.9 with an installer that brings its own Node.js, or an npm package for anyone who already has one. Four install stories, four lifecycles, four ways to be wrong about what is running.&lt;/p&gt; &lt;p&gt;The platform site at iowarp.ai lists a separate first command for each component, and the components carry different licenses: BSD-3-Clause for Core, Kit, and Agent, Apache-2.0 for Coder, MIT for Relay. There is no single thing to install. Two names are already taken as well: the &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;clio&lt;/code&gt; executable belongs to Agent’s launcher, and the PyPI name &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;clio&lt;/code&gt; belongs to an unrelated project.&lt;/p&gt; &lt;h2 id=&quot;the-decision&quot;&gt;The decision&lt;/h2&gt; &lt;p&gt;My answer is an application SDK with component construction and deployment profiles. A small library supplies composition. A CLI resolves and installs qualified component artifacts and hands deployment to the component that already owns it. Local native calls, subprocess transports, and remote connections stay visible to the caller rather than hidden behind one abstraction.&lt;/p&gt; &lt;p&gt;Three profiles carry the installation story. The first connects to an existing deployment with no local components: a laptop talking to a cluster someone else runs. The second manages local components: a workstation where the SDK installs and starts what it needs. The third deploys into an HPC allocation: it accepts an existing allocation or requests one, resolves artifacts and topology into a reviewable plan, starts Core and verifies its entry pool, then attaches the Agent and the selected tools. A profile records only the components and connections it actually qualifies, which is what keeps it from becoming another aspirational install command.&lt;/p&gt; &lt;p&gt;Two alternatives were on the table and both lost. An umbrella dependency package looks simple from outside and exposes every caller to incompatible dependency graphs, native initialization, and application lifecycles; one package name would inherit every conflict between component pins without resolving any. A universal gateway service would simplify remote access at the cost of another mandatory deployment, would make native data access indirect for no reason on the machine where the data sits, and would risk becoming a second control plane next to the runtime Core already is.&lt;/p&gt; &lt;h2 id=&quot;what-changes-for-each-layer&quot;&gt;What changes for each layer&lt;/h2&gt; &lt;p&gt;Core stays the runtime and grows a public boundary worth depending on. Its Context Exploration Engine already defines bundle, query, retrieve, and destroy over assimilation and transfer. What it owes the SDK is structured ingestion outcomes that separate accepted from scheduled from completed, query results that keep tag and object identity along with score and method, and an effective deployment descriptor naming the build, the installed modules, the entry pool, and the transport. It also needs an attach-only mode, so a client that attaches to a running daemon never takes ownership of it.&lt;/p&gt; &lt;p&gt;Kit stays the tools, and its conformance bar rises from schemas to behavior. Every server should report failure the same typed way and keep no hidden process-wide state between sessions. A managed connection cannot promise independent sessions or a successful call because an MCP response arrived.&lt;/p&gt; &lt;p&gt;Agent and Coder stay the two agents, aimed at different work. Agent’s 0.9.5.1 release replaced its blueprints with plugins that assemble tools, skills, agents, and hooks, an agent-class model, and an SDK; what the entry point still needs is a supported factory that injects context, model, policy, and lifecycle without importing internals. Coder is controllable through its ACP server; a reusable TypeScript construction API is component work that has not happened, and no aliasing trick lets a Python library embed a Node runtime.&lt;/p&gt; &lt;p&gt;CLIO Researcher and CLIO Bench are the loop that measures the rest. Researcher runs experiment campaigns where a model never grades: the grader is code over raw measurements and the directive, and a promotion has to hold on a holdout split the planner never sees. Bench is the record and the display, drawing runs from every producer in the ecosystem. Neither is released yet, and releases are coming. Until they are, an SDK profile cannot depend on them.&lt;/p&gt; &lt;h2 id=&quot;what-2027-looks-like&quot;&gt;What 2027 looks like&lt;/h2&gt; &lt;p&gt;The test is a scientist who has never cloned an IOWarp repository. She installs one thing, picks the profile that matches her machine, resolves a dataset by reference, inspects it with Kit, asks Coder for an analysis program, runs that program through the execution owner she already has, and gets back the program, the result, and a provenance record that names the artifacts and the component versions that produced them. The application code owns the sequence. Nothing in that path asks her to guess who started a daemon or who will stop it.&lt;/p&gt; &lt;p&gt;Falsification is specific. If an outside developer still has to import component internals, copy artifacts by hand, guess lifecycle ownership, or interpret an ambiguous success, the SDK has not done its job, and API aliases and installation manifests do not count as evidence that it has. One case makes the point sharp: a relay invocation that returns successfully may mean only that it submitted an inner job. If 2027 arrives and the SDK still reports that as a finished scientific workload, the thesis is wrong in the place it matters.&lt;/p&gt; &lt;p&gt;What is decided is the shape. One entry point, an SDK rather than an umbrella or a gateway, profiles that record what they qualify, components that stay independently usable and independently released. What is not decided is almost everything a user would type. Nothing here establishes an accepted API, an implementation scope, a component assignment, or a qualified release, and the package name, the import path, and the license are open. This is the direction. The boundaries get written with the component leads, in public, and I would rather publish the direction now than publish an install command before the thing it installs exists.&lt;/p&gt; </content> </entry> <entry> <title type="html">A capable model in a capable harness</title> <link rel="alternate" type="text/html" href="https://akougkas.io/journal/2026/a-capable-model-in-a-capable-harness/"/> <id>https://akougkas.io/journal/2026/a-capable-model-in-a-capable-harness/</id> <published>2026-11-07T00:00:00-06:00</published> <updated>2026-11-07T00:00:00-06:00</updated> <summary type="html">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.</summary> <content type="html" xml:base="https://akougkas.io/journal/2026/a-capable-model-in-a-capable-harness/">&lt;p&gt;Claude 3.5 Sonnet is the model that brought me back to engineering. I had been away from writing code for a long time, and it was the first tool that made returning feel like work I could do rather than a course I had to retake. It explained the parts I had forgotten, let me try things quickly, and left the decisions with me.&lt;/p&gt; &lt;p&gt;The model is the part everyone names. The harness around it is what I have built since, and &lt;a href=&quot;/work/clio-coder/&quot;&gt;CLIO Coder&lt;/a&gt; is where that work landed. The model and the harness belong in the same sentence.&lt;/p&gt; &lt;h2 id=&quot;the-road-here&quot;&gt;The road here&lt;/h2&gt; &lt;p&gt;The &lt;a href=&quot;/journal/2026/the-repository-is-younger-than-the-idea/&quot;&gt;repository is younger than the idea&lt;/a&gt;. I started the exploration in December 2023, then built wrappers around Claude Code, Warpio, AWOC, and PanCode. The CLIO Coder repository began in April 2026. The public launch was v0.5.0 on September 20, &lt;a href=&quot;https://github.com/iowarp/clio-coder/releases/tag/v0.5.7&quot;&gt;v0.5.7&lt;/a&gt; followed in late September, and the 0.6 line has shipped since October 3, most recently &lt;a href=&quot;https://github.com/iowarp/clio-coder/releases/tag/v0.6.9&quot;&gt;v0.6.9&lt;/a&gt; on November 6.&lt;/p&gt; &lt;p&gt;Every one of those stages taught me something about the space around the model. None of them changed what the model could do. That belongs to Anthropic and the other labs, and I have benefited from it without contributing to it.&lt;/p&gt; &lt;h2 id=&quot;where-affordable-comes-from&quot;&gt;Where affordable comes from&lt;/h2&gt; &lt;p&gt;The most capable models are out of reach for most people. Access is limited, the price is high, or both. A tool that only feels good on the best available model is a tool for the few people who can run it all day.&lt;/p&gt; &lt;p&gt;Each generation of mid-priced models, Claude Sonnet 5.5 among them, moves that line: capable enough to hold a real task together, and priced so that a student, a research engineer, or a small lab can leave it running. I have not measured where the line sits inside Clio, and I am not going to put a number on it here. Prices are the labs’ to publish, and how each model behaves inside Clio is something I will find out in public with everyone else.&lt;/p&gt; &lt;p&gt;I do expect the pairing to matter more than either half. A capable model with no harness leaves the person to remember what it touched, what it ran, and why they should believe it. A capable harness around a weak model records the failure carefully and still fails. The combination I want is a model good enough to make progress and a harness that makes the progress checkable.&lt;/p&gt; &lt;h2 id=&quot;what-the-harness-is&quot;&gt;What the harness is&lt;/h2&gt; &lt;p&gt;CLIO Coder connects a model to repository tools, project context, verification, and worker delegation. She reads and edits a repository, runs the checks a project declares, and writes a sealed record of what happened: tool activity, changes, checks, and a run receipt you can read afterward. I made the case for those choices in the &lt;a href=&quot;/journal/2026/why-clio-coder-1-your-models-your-machines/&quot;&gt;Why CLIO Coder series&lt;/a&gt;, and I will not repeat it here.&lt;/p&gt; &lt;p&gt;Two properties matter here. First, the model is a setting. Chat and workers can use different models, and Anthropic is one of the supported cloud APIs. A Claude Pro or Max subscription can sign in through &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;anthropic-max&lt;/code&gt;. Second, cost is visible. &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;/usage&lt;/code&gt; shows session token and cost totals per model, and &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;safety.limits.sessionCostUsd&lt;/code&gt; defaults to &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;5&lt;/code&gt;, so a session has a dollar ceiling unless you change it. A local model is listed at &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;$0.00&lt;/code&gt;.&lt;/p&gt; &lt;p&gt;That is the practical meaning of affordable for me. You can see what a session costs while it runs, you can cap it, and you can move the same workflow to a cheaper or local model without rebuilding anything.&lt;/p&gt; &lt;h2 id=&quot;try-her&quot;&gt;Try her&lt;/h2&gt; &lt;p&gt;CLIO Coder requires Node.js 22.19 or newer and a model with tool calling. Linux and macOS are the primary platforms; Windows support is best effort.&lt;/p&gt; &lt;div class=&quot;language-bash highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;npm &lt;span class=&quot;nb&quot;&gt;install&lt;/span&gt; &lt;span class=&quot;nt&quot;&gt;-g&lt;/span&gt; @iowarp/clio-coder &lt;span class=&quot;nb&quot;&gt;cd&lt;/span&gt; /path/to/your/project clio-coder configure clio-coder &lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt; &lt;p&gt;Choose Guided setup, pick the kind of connection you have, and select a model from the list. Then give her a request that changes nothing:&lt;/p&gt; &lt;blockquote&gt; &lt;p&gt;Explain how this repository builds and runs its tests. Identify the main entry points and suggest one verification task. Do not change files yet.&lt;/p&gt; &lt;/blockquote&gt; &lt;p&gt;When she finishes, open &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;/usage&lt;/code&gt; to see what the session cost, and run &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;clio-coder evidence list&lt;/code&gt; to read the record of how the answer was produced.&lt;/p&gt; &lt;h2 id=&quot;what-is-still-true&quot;&gt;What is still true&lt;/h2&gt; &lt;p&gt;CLIO Coder is pre-1.0. Interfaces change between minor versions. Linux has had the broadest exercise. The desktop app, added in v0.6.0, is in alpha. The benchmark campaigns I have named are plans, not results, so I cannot tell you which model does best in Clio. I can tell you what I am going to look at: whether a task finishes, whether the checks pass, what it cost, and whether the receipt lets someone else trust the result.&lt;/p&gt; &lt;p&gt;I am proud of where this arrived. A model got me back to the keyboard, and it took years of building around models to make a harness I am willing to hand to other people. Now I get to hand it over. Bring a repository, point her at a model, and tell me where she fails.&lt;/p&gt; </content> </entry> <entry> <title type="html">An accountable agent says what it is waiting on</title> <link rel="alternate" type="text/html" href="https://akougkas.io/journal/2026/an-accountable-agent-says-what-it-is-waiting-on/"/> <id>https://akougkas.io/journal/2026/an-accountable-agent-says-what-it-is-waiting-on/</id> <published>2026-11-06T00:00:00-06:00</published> <updated>2026-11-06T00:00:00-06:00</updated> <summary type="html">Across the CLIO Coder 0.6 line, from v0.6.0 on October 3 to v0.6.9 on November 6, accountability narrowed to two statements an agent should be able to make at any moment: under whose authority it acts, and what it is waiting on.</summary> <content type="html" xml:base="https://akougkas.io/journal/2026/an-accountable-agent-says-what-it-is-waiting-on/">&lt;p&gt;A coding agent spends much of a session waiting. It waits on a model that has not sent its first byte, on a worker in another process, on a server loading weights, and on me. A spinner draws all of those the same way, and the same animation tells me nothing about whom to ask or what to stop.&lt;/p&gt; &lt;p&gt;The 0.6 line of &lt;a href=&quot;/work/clio-coder/&quot;&gt;CLIO Coder&lt;/a&gt;, the coding agent I create inside &lt;a href=&quot;/work/clio/&quot;&gt;CLIO&lt;/a&gt;, ran from v0.6.0 on October 3 to v0.6.9 on November 6, 2026. Over those five weeks my working definition of accountability got narrower. An accountable agent can say two things at any moment: under whose authority it is acting, and what it is waiting on.&lt;/p&gt; &lt;h2 id=&quot;authority-fixed-at-the-handoff&quot;&gt;Authority fixed at the handoff&lt;/h2&gt; &lt;p&gt;Since v0.6.0, every attempt by a dispatched worker runs under an immutable permit that fixes its asks, its tools and its Git allowance. The operator sets what workers may hold with &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;--delegate-tools&lt;/code&gt;, separately from the main agent’s &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;--allow-tools&lt;/code&gt;, so the coordinator’s privileges are not the worker’s by default.&lt;/p&gt; &lt;p&gt;The permit is backed by the operating system. A worker’s own commands (&lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;bash&lt;/code&gt;, &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;run_script&lt;/code&gt; and verification) run inside an OS sandbox when a backend exists: bubblewrap on Linux and Seatbelt on macOS. Writes land only in the worker’s roots, &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;.git&lt;/code&gt; and &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;.clio-coder&lt;/code&gt; stay read-only, and the network is off unless the run holds &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;web_fetch&lt;/code&gt; or &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;safety.sandboxNetwork&lt;/code&gt; is set.&lt;/p&gt; &lt;p&gt;The part I use most is the refusal. Since v0.6.0, a denial names the tool, the command (clipped, with secrets redacted) and the rule that refused it. Under the v0.6.0 default the refusal returns to the model, and a third refusal ends the run as &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;permission_required&lt;/code&gt; with every refused command listed. A refusal that names its rule is something I can change or argue with. A refusal that only says no leaves me guessing which boundary I hit.&lt;/p&gt; &lt;h2 id=&quot;a-wait-has-a-subject&quot;&gt;A wait has a subject&lt;/h2&gt; &lt;p&gt;v0.6.9 applies the same discipline to time. Its status rail names one subject per session: the model, worker, server or person a turn waits on, with a clock and the key that stops it. A silence is stated with its evidence. A silent model wait reads &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;no bytes yet&lt;/code&gt; at 10 seconds, names Esc at 30 and says &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;may be loading or stuck&lt;/code&gt; at 90, and after 60 seconds a transcript row names the last evidence and its age. Cold loads name the lock holder, the unload and load, or another Clio loading the same model. The spinner moves only beside live model, tool or harness work, and a wait on me shows a still mark.&lt;/p&gt; &lt;p&gt;Two small lines from v0.6.9 carry both halves of the idea at once. A call the safety judge holds reads &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;Waiting for the safety judge&lt;/code&gt; instead of reading as running. A call denied because nobody answered reads &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;no answer in N s, so Clio denied it&lt;/code&gt;. Each line names the party the decision belonged to and what happened when that party was silent.&lt;/p&gt; &lt;h2 id=&quot;one-way-to-count&quot;&gt;One way to count&lt;/h2&gt; &lt;p&gt;Accounting is the third place an agent can claim more than it knows. Since v0.6.9, receipts, &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;/usage&lt;/code&gt;, the exit summary and Fleet Runs count calls and tokens one way. They count model calls, worker runs included, and not attempts or calls that were never sent. An unknown figure reads &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;not measured&lt;/code&gt;, and the footer marks Clio’s own estimates with &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;~&lt;/code&gt;. A guessed number is a statement the agent makes on my behalf, and I would rather see the gap.&lt;/p&gt; &lt;h2 id=&quot;the-other-half-of-the-handoff&quot;&gt;The other half of the handoff&lt;/h2&gt; &lt;p&gt;In September I argued that &lt;a href=&quot;/journal/2026/an-agents-authority-should-travel-with-the-task/&quot;&gt;an agent’s authority should travel with the task&lt;/a&gt;. That essay was about the moment of delegation. The 0.6 line is about the hours after it: the permit has to be legible when something is refused, and the wait has to be legible when nothing appears to happen. A bounded assignment that fails silently is still hard to supervise.&lt;/p&gt; &lt;h2 id=&quot;limits&quot;&gt;Limits&lt;/h2&gt; &lt;p&gt;In v0.6.0 the sandbox covered dispatched workers only, and main-agent commands were not sandboxed. v0.6.4 moved the main session’s &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;bash&lt;/code&gt; and &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;run_script&lt;/code&gt; into the sandbox at the &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;default&lt;/code&gt; autonomy level, with three caveats its notes state: at &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;yolo&lt;/code&gt; under &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;safety.sandbox: auto&lt;/code&gt; they run unsandboxed with the operator’s credentials, Windows has no backend so nothing is contained there, and the macOS Seatbelt profile for the main session had not been verified on a real macOS build. Since v0.6.0, a worker confined to narrow write roots loses &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;bash&lt;/code&gt; and &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;verify&lt;/code&gt; when no sandbox is active.&lt;/p&gt; &lt;p&gt;The refusal story also ends at the edge of other agents. In v0.6.0 the Claude SDK runtime still ended at its first refusal instead of returning it to the model. External agents that run their own tool loop cannot be mediated per call, so they are refused write-capable work unless the target sets &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;trustedUnmediated: true&lt;/code&gt;, which moves the trust decision back to me.&lt;/p&gt; &lt;p&gt;Naming a wait does not shorten it, and &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;not measured&lt;/code&gt; is an absence, not a figure. Both are still better than a confident animation.&lt;/p&gt; &lt;p&gt;The &lt;a href=&quot;https://coder.iowarp.ai/&quot;&gt;CLIO Coder guide&lt;/a&gt; covers setup and the current settings, and the &lt;a href=&quot;https://github.com/iowarp/clio-coder/releases/tag/v0.6.0&quot;&gt;v0.6.0&lt;/a&gt; and &lt;a href=&quot;https://github.com/iowarp/clio-coder/releases/tag/v0.6.9&quot;&gt;v0.6.9&lt;/a&gt; release notes record each behavior described here.&lt;/p&gt; </content> </entry> <entry> <title type="html">A study that keeps its evidence</title> <link rel="alternate" type="text/html" href="https://akougkas.io/journal/2026/a-study-that-keeps-its-evidence/"/> <id>https://akougkas.io/journal/2026/a-study-that-keeps-its-evidence/</id> <published>2026-10-30T00:00:00-05:00</published> <updated>2026-10-30T00:00:00-05:00</updated> <summary type="html">CLIO Agent 0.9.5.1 links a study&apos;s questions, hypotheses, experiments, observations, and conclusions to the tool calls that produced them, so a scientific conclusion stays attached to its evidence the way a CLIO Coder receipt stays attached to its run.</summary> <content type="html" xml:base="https://akougkas.io/journal/2026/a-study-that-keeps-its-evidence/">&lt;p&gt;A conclusion that has lost its evidence is an anecdote. &lt;a href=&quot;https://github.com/iowarp/clio-agent&quot;&gt;CLIO Agent&lt;/a&gt;, the science agent in &lt;a href=&quot;/work/clio/&quot;&gt;CLIO&lt;/a&gt;, now keeps the two together. Version &lt;a href=&quot;https://github.com/iowarp/clio-agent/releases/tag/v0.9.5.1&quot;&gt;0.9.5.1&lt;/a&gt;, released on October 29, adds a Science log that links questions, hypotheses, experiments, observations, and conclusions to the recorded calls behind them.&lt;/p&gt; &lt;h2 id=&quot;the-receipt-applied-to-a-study&quot;&gt;The receipt, applied to a study&lt;/h2&gt; &lt;p&gt;In &lt;a href=&quot;/work/clio-coder/&quot;&gt;CLIO Coder&lt;/a&gt; a managed run ends with a receipt: the context it selected, the policy that applied, the tool calls, and what they returned, assessed against fingerprints of the source and the declared checks. A later edit can make an earlier pass stale, and the receipt shows it. I built it that way because “the tests pass” is worthless once nobody can say which code it was about.&lt;/p&gt; &lt;p&gt;A study has the same problem with higher stakes. In an agent conversation, a conclusion is a sentence. Whether it holds depends on which dataset was read, which filter was applied, which run produced the number, and whether the inputs changed since. In most agent tools that chain lives only in a scrolling transcript, and the conclusion floats free of it.&lt;/p&gt; &lt;p&gt;The Science log gives the chain a structure. A question leads to a hypothesis, the hypothesis to an experiment, the experiment to observations, the observations to a conclusion, and each entry points to the calls that recorded it. Study views that the agent builds read live measurements and selected records, with linked viewers and CSV or Parquet exports, so the numbers on screen come from the measurements the view reads, and they leave with them.&lt;/p&gt; &lt;h2 id=&quot;one-question-followed-to-a-package&quot;&gt;One question, followed to a package&lt;/h2&gt; &lt;p&gt;The &lt;a href=&quot;https://github.com/iowarp/clio-agent/releases/tag/v0.9.5-beta.8&quot;&gt;0.9.5-beta.8 notes&lt;/a&gt; of October 21 describe the Agent’s connection to the National Data Platform (NDP) and its shareable conversations, saved as portable HTML. The &lt;a href=&quot;https://clio.iowarp.ai/docs/examples/ndp-science/&quot;&gt;NDP examples&lt;/a&gt; published with them show the shape I mean.&lt;/p&gt; &lt;p&gt;One starts from a question about snowfall at Alta-Collins: how unusual was the 2023–24 total compared with the historical winters available through NDP? The answer on the page is 635.5 inches for October through April, sixth among 18 winters with complete coverage, with seven earlier winters left out because they lack October observations. The second question finds January through March elevated and the other months below baseline. The third asks whether a colleague can reproduce the comparison outside CLIO. The package holds the original measurements and READMEs, a standard-library Python script, derived tables, methods, and checksums, and an independent clean extraction reproduced all three result CSVs byte for byte.&lt;/p&gt; &lt;p&gt;The same page says that one station and one winter do not establish a climate trend. That sentence belongs to the evidence as much as the checksums do. The measurements also keep their publisher: NDP provided the access, and the citations still point to the &lt;a href=&quot;https://www.utah.edu/&quot;&gt;University of Utah&lt;/a&gt;’s Hive.&lt;/p&gt; &lt;aside class=&quot;entry-pull&quot;&gt; &lt;p&gt;A study that keeps its evidence also keeps its coverage limits in view.&lt;/p&gt; &lt;/aside&gt; &lt;p&gt;Each archived conversation carries its saved charts, figures, and recorded tool activity, corrections included, and opening one does not run the agent. A reader can check the work without an account or a running Endpoint.&lt;/p&gt; &lt;h2 id=&quot;limits&quot;&gt;Limits&lt;/h2&gt; &lt;p&gt;&lt;a href=&quot;https://clio.iowarp.ai/&quot;&gt;CLIO Agent&lt;/a&gt; is in beta. NDP operations depend on the Endpoint you connect and on your account’s permissions, and the default sign-in uses NDP’s test identity service; the beta.8 notes say both. The 0.9.5.1 notes list open Windows findings in &lt;a href=&quot;https://github.com/iowarp/clio-agent/issues/1887&quot;&gt;#1887&lt;/a&gt;. A linked record shows where a conclusion came from. It does not show that the conclusion is right, and the Science log does not replace a scientist reading the analysis.&lt;/p&gt; &lt;h2 id=&quot;who-built-it&quot;&gt;Who built it&lt;/h2&gt; &lt;p&gt;Day-to-day development of CLIO Agent is led by &lt;a href=&quot;https://grc.iit.edu/center/team/jaime-cernuda/&quot;&gt;Jaime Cernuda&lt;/a&gt;, and this release line is his team’s work: the NDP connection and stream reads, the shareable conversations, the plugins and flows, and the Science log. Making the receipt a first-class object across CLIO is one of the questions I keep pushing on. In the Agent it now has a form built for science: a study that can be handed to a colleague with its evidence still attached.&lt;/p&gt; </content> </entry> <entry> <title type="html">The repository is younger than the idea</title> <link rel="alternate" type="text/html" href="https://akougkas.io/journal/2026/the-repository-is-younger-than-the-idea/"/> <id>https://akougkas.io/journal/2026/the-repository-is-younger-than-the-idea/</id> <published>2026-09-27T00:00:00-05:00</published> <updated>2026-09-27T00:00:00-05:00</updated> <summary type="html">A repository can appear suddenly while carrying years of design work. CLIO Coder grew out of experiments with context, tools, and distributed agents that I began in December 2023.</summary> <content type="html" xml:base="https://akougkas.io/journal/2026/the-repository-is-younger-than-the-idea/">&lt;p&gt;The first commit is a useful date. It is a poor measure of when an idea began.&lt;/p&gt; &lt;p&gt;I started the exploration that became &lt;a href=&quot;/work/clio-coder/&quot;&gt;CLIO Coder&lt;/a&gt; in December 2023. Its current repository began in April 2026. Between those dates were several attempts to answer a question from my work on scientific data systems: what must a runtime provide before an AI agent can take part in work that other people have to inspect, repeat, and maintain?&lt;/p&gt; &lt;h2 id=&quot;what-survived-the-earlier-systems&quot;&gt;What survived the earlier systems&lt;/h2&gt; &lt;section class=&quot;entry-timeline&quot; aria-label=&quot;Timeline&quot;&gt; &lt;ol&gt; &lt;li&gt; &lt;time datetime=&quot;2023-12&quot;&gt;Dec 2023&lt;/time&gt; &lt;p&gt;&lt;strong&gt;The exploration begins.&lt;/strong&gt;A question from scientific data systems. What must a runtime provide before an agent&apos;s work can be inspected, repeated, and maintained by other people? &lt;/p&gt; &lt;/li&gt; &lt;li&gt; &lt;span class=&quot;entry-timeline__undated&quot; aria-hidden=&quot;true&quot;&gt;&lt;/span&gt; &lt;p&gt;&lt;strong&gt;Wrappers around Claude Code.&lt;/strong&gt;A quick way to study the workflow, which also meant inheriting another agent&apos;s assumptions. &lt;/p&gt; &lt;/li&gt; &lt;li&gt; &lt;span class=&quot;entry-timeline__undated&quot; aria-hidden=&quot;true&quot;&gt;&lt;/span&gt; &lt;p&gt;&lt;strong&gt;Warpio.&lt;/strong&gt;A fork of Gemini CLI with room for scientific personas and context handover. &lt;/p&gt; &lt;/li&gt; &lt;li&gt; &lt;span class=&quot;entry-timeline__undated&quot; aria-hidden=&quot;true&quot;&gt;&lt;/span&gt; &lt;p&gt;&lt;strong&gt;AWOC.&lt;/strong&gt;A language for directing agents and coordinating shared memory. &lt;/p&gt; &lt;/li&gt; &lt;li&gt; &lt;span class=&quot;entry-timeline__undated&quot; aria-hidden=&quot;true&quot;&gt;&lt;/span&gt; &lt;p&gt;&lt;strong&gt;PanCode.&lt;/strong&gt;An explicit control loop and a worker pool, closer to a runtime. &lt;/p&gt; &lt;/li&gt; &lt;li&gt; &lt;time datetime=&quot;2026-04&quot;&gt;Apr 2026&lt;/time&gt; &lt;p&gt;&lt;strong&gt;The CLIO Coder repository.&lt;/strong&gt;The lessons consolidated into one codebase. &lt;/p&gt; &lt;/li&gt; &lt;li&gt; &lt;time datetime=&quot;2026-09-27&quot;&gt;Sep 27, 2026&lt;/time&gt; &lt;p&gt;&lt;strong&gt;CLIO Coder v0.5.7.&lt;/strong&gt;Public and pre-1.0; interfaces still change. &lt;/p&gt; &lt;/li&gt; &lt;/ol&gt; &lt;/section&gt; &lt;p&gt;The early experiments were wrappers around Claude Code. They let me study the workflow quickly, but inheriting an agent also meant inheriting its assumptions. Warpio, a fork of Gemini CLI, gave me room to explore scientific personas and context handover. AWOC explored a language for directing agents and coordinating shared memory. PanCode brought the work closer to a runtime, with an explicit control loop and a worker pool.&lt;/p&gt; &lt;figure class=&quot;entry-figure entry-wide&quot; id=&quot;figure-warpio&quot;&gt; &lt;div class=&quot;entry-figure__frame&quot;&gt;&lt;img src=&quot;/assets/img/warpio-screenshot.webp&quot; alt=&quot;Warpio CLI start screen with an active scientific persona, tips that mention a WARPIO.md project file and IOWarp tools, two MCP servers, and the Gemini model with its remaining context.&quot; width=&quot;1772&quot; height=&quot;567&quot; loading=&quot;lazy&quot; decoding=&quot;async&quot; /&gt; &lt;svg class=&quot;entry-figure__marks&quot; aria-hidden=&quot;true&quot; focusable=&quot;false&quot;&gt; &lt;g&gt; &lt;circle cx=&quot;27%&quot; cy=&quot;26%&quot; r=&quot;14&quot;&gt;&lt;/circle&gt; &lt;text x=&quot;27%&quot; y=&quot;26%&quot; text-anchor=&quot;middle&quot; dominant-baseline=&quot;central&quot;&gt;1&lt;/text&gt; &lt;/g&gt; &lt;g&gt; &lt;circle cx=&quot;45%&quot; cy=&quot;57.5%&quot; r=&quot;14&quot;&gt;&lt;/circle&gt; &lt;text x=&quot;45%&quot; y=&quot;57.5%&quot; text-anchor=&quot;middle&quot; dominant-baseline=&quot;central&quot;&gt;2&lt;/text&gt; &lt;/g&gt; &lt;g&gt; &lt;circle cx=&quot;21.5%&quot; cy=&quot;76.5%&quot; r=&quot;14&quot;&gt;&lt;/circle&gt; &lt;text x=&quot;21.5%&quot; y=&quot;76.5%&quot; text-anchor=&quot;middle&quot; dominant-baseline=&quot;central&quot;&gt;3&lt;/text&gt; &lt;/g&gt; &lt;g&gt; &lt;circle cx=&quot;97.5%&quot; cy=&quot;93%&quot; r=&quot;14&quot;&gt;&lt;/circle&gt; &lt;text x=&quot;97.5%&quot; y=&quot;93%&quot; text-anchor=&quot;middle&quot; dominant-baseline=&quot;central&quot;&gt;4&lt;/text&gt; &lt;/g&gt; &lt;/svg&gt; &lt;/div&gt; &lt;figcaption&gt; &lt;p&gt;Warpio CLI at start, showing its scientific persona, a project metadata file, and the model&apos;s remaining context.&lt;/p&gt; &lt;ol class=&quot;entry-figure__notes&quot; aria-label=&quot;Marked on the image&quot;&gt; &lt;li&gt;A persona set the agent&apos;s scientific role.&lt;/li&gt; &lt;li&gt;A project file, WARPIO.md, carried instructions into each session.&lt;/li&gt; &lt;li&gt;IOWarp&apos;s scientific tools arrived through MCP servers.&lt;/li&gt; &lt;li&gt;The status line reported the model and its remaining context.&lt;/li&gt; &lt;/ol&gt; &lt;p class=&quot;entry-figure__credit&quot;&gt;Warpio CLI, a fork of Google&apos;s Gemini CLI (Apache 2.0). Screenshot from the Warpio project, akougkas/warpio-cli.&lt;/p&gt; &lt;/figcaption&gt; &lt;/figure&gt; &lt;p&gt;Each stage was useful because it exposed a different failure. A longer conversation did not necessarily preserve the right decision. Another worker did not necessarily reduce the coordinator’s burden. A confident result did not say which checks ran. A good local interaction did not explain what would happen when the worker moved to another machine.&lt;/p&gt; &lt;p&gt;CLIO Coder consolidates those lessons. Its young repository holds decisions whose earlier forms lived elsewhere. That does not make the software mature by declaration: it is pre-1.0, its interfaces change, and there are things it cannot establish. The history explains the direction. The present implementation has to earn its use.&lt;/p&gt; &lt;h2 id=&quot;the-model-and-the-system-around-it&quot;&gt;The model and the system around it&lt;/h2&gt; &lt;p&gt;Model development and harness design are different engineering problems. The model supplies reasoning and generation. The harness decides how that reasoning meets a repository, tools, permissions, memory, and other workers.&lt;/p&gt; &lt;p&gt;I want those choices to stay separable. A researcher may need inference on institutional hardware. A developer may prefer a cloud model for one task and a local model for another. A closed decision with a small answer set may need a different kind of model from the one writing code. None of those choices should require rebuilding the workflow.&lt;/p&gt; &lt;p&gt;Separation also gives a community somewhere to contribute. A better project handbook, a useful verification policy, or a carefully scoped worker recipe improves the work around a model. A contribution does not have to be another model release.&lt;/p&gt; &lt;h2 id=&quot;what-it-means-to-grow&quot;&gt;What it means to grow&lt;/h2&gt; &lt;p&gt;When I say that an AI system grows, I mean the accumulation of context, tested procedures, feedback, and useful boundaries around it. I do not mean that a coding session silently trains the underlying model’s weights.&lt;/p&gt; &lt;p&gt;Growth of this kind is familiar territory for a systems researcher. In &lt;a href=&quot;/work/hermes/&quot;&gt;Hermes&lt;/a&gt;, the question was where data should live in a storage hierarchy. In &lt;a href=&quot;/work/chronolog/&quot;&gt;ChronoLog&lt;/a&gt;, it was how to keep an inspectable record of activity. In &lt;a href=&quot;/work/clio/&quot;&gt;CLIO&lt;/a&gt;, the context architecture I lead across &lt;a href=&quot;/work/iowarp/&quot;&gt;IOWarp&lt;/a&gt;, those questions become part of how an agent works across data, tools, and machines.&lt;/p&gt; &lt;p&gt;I am proud to have brought this line into a tool people can try. The useful next step is specific: bring a repository, choose a model, give the agent a bounded task, and inspect what happens. The &lt;a href=&quot;https://coder.iowarp.ai/tutorials/first-session.html&quot;&gt;first-session guide&lt;/a&gt; starts there. The larger research question remains how to carry context and control across work that no single conversation can contain.&lt;/p&gt; </content> </entry> <entry> <title type="html">Intelligent software needs a runtime</title> <link rel="alternate" type="text/html" href="https://akougkas.io/journal/2026/intelligent-software-needs-a-runtime/"/> <id>https://akougkas.io/journal/2026/intelligent-software-needs-a-runtime/</id> <published>2026-09-27T00:00:00-05:00</published> <updated>2026-09-27T00:00:00-05:00</updated> <summary type="html">A model can be a useful execution component without being the whole application. The CPU and operating-system analogy helps explain why context, tools, authority, and continuity belong in the runtime around it.</summary> <content type="html" xml:base="https://akougkas.io/journal/2026/intelligent-software-needs-a-runtime/">&lt;p&gt;Imagine asking a program to inspect a folder of measurements, explain an unexpected result, prepare a correction, and stop before changing the original data. You have described an objective, a resource, and a boundary. You have not specified every operation needed to reach the result.&lt;/p&gt; &lt;p&gt;That is a useful way to understand intelligent software. A model can help interpret the objective and choose a sequence of actions. The application still needs somewhere to get its data, tools that do the work, and rules about what it may change.&lt;/p&gt; &lt;h2 id=&quot;a-computer-inside-the-software&quot;&gt;A computer inside the software&lt;/h2&gt; &lt;p&gt;In &lt;a href=&quot;https://www.ycombinator.com/library/MW-andrej-karpathy-software-is-changing-again&quot;&gt;Software Is Changing (Again)&lt;/a&gt;, Andrej Karpathy describes Software 3.0: software whose programming interface includes natural language. He also explores a computer analogy, with the model in a CPU-like role and context in a memory-like role, alongside an operating-system analogy for the surrounding ecosystem.&lt;/p&gt; &lt;p&gt;The analogy helps because most people already understand that a processor is not a complete application. A processor needs memory, devices, an execution environment, and software that gives its work a purpose.&lt;/p&gt; &lt;p&gt;A language model has learned knowledge that matters, and it can be directed toward many tasks through instructions, examples, supplied data, and feedback. That combination makes it a useful component in an application. It does not make the model the application.&lt;/p&gt; &lt;p&gt;Ordinary software has always needed the user’s data, and intelligent software does too. Knowing about spreadsheets is different from reading the spreadsheet on your desk, applying the right procedure, and preserving the original when you asked it to.&lt;/p&gt; &lt;h2 id=&quot;what-the-runtime-owns&quot;&gt;What the runtime owns&lt;/h2&gt; &lt;p&gt;The runtime decides how the model encounters the world. It assembles context, exposes tools, admits actions, places work, records results, and manages continuation when a task outlives one request.&lt;/p&gt; &lt;figure class=&quot;diagram diagram--stack entry-wide&quot; id=&quot;diagram-runtime-stack&quot; data-stepper=&quot;&quot; data-step-label=&quot;Step&quot; data-of-label=&quot;of&quot; data-previous-label=&quot;Previous step&quot; data-next-label=&quot;Next step&quot;&gt; &lt;div class=&quot;diagram__head&quot;&gt; &lt;p class=&quot;diagram__title&quot;&gt;One request through three layers&lt;/p&gt; &lt;/div&gt;&lt;div class=&quot;diagram__body-grid&quot;&gt; &lt;ol class=&quot;diagram__stages&quot;&gt; &lt;li class=&quot;diagram__stage&quot;&gt; &lt;p class=&quot;diagram__label&quot;&gt;Application&lt;/p&gt; &lt;p class=&quot;diagram__body&quot;&gt;The person&apos;s objective, their data, and the domain&apos;s rules.&lt;/p&gt; &lt;ul class=&quot;diagram__chips&quot;&gt; &lt;li&gt;Objective&lt;/li&gt; &lt;li&gt;Data&lt;/li&gt; &lt;li&gt;Domain rules&lt;/li&gt; &lt;/ul&gt; &lt;/li&gt; &lt;li class=&quot;diagram__stage&quot;&gt; &lt;p class=&quot;diagram__label&quot;&gt;Runtime&lt;/p&gt; &lt;p class=&quot;diagram__body&quot;&gt;Decides how the model encounters the world.&lt;/p&gt; &lt;ul class=&quot;diagram__chips&quot;&gt; &lt;li&gt;Context&lt;/li&gt; &lt;li&gt;Tools&lt;/li&gt; &lt;li&gt;Authority&lt;/li&gt; &lt;li&gt;Placement&lt;/li&gt; &lt;li&gt;Records&lt;/li&gt; &lt;li&gt;Continuation&lt;/li&gt; &lt;/ul&gt; &lt;/li&gt; &lt;li class=&quot;diagram__stage&quot;&gt; &lt;p class=&quot;diagram__label&quot;&gt;Model&lt;/p&gt; &lt;p class=&quot;diagram__body&quot;&gt;Interprets the task and proposes actions; its outputs are probabilistic.&lt;/p&gt; &lt;ul class=&quot;diagram__chips&quot;&gt; &lt;li&gt;Interpretation&lt;/li&gt; &lt;li&gt;Proposals&lt;/li&gt; &lt;/ul&gt; &lt;/li&gt; &lt;/ol&gt; &lt;ol class=&quot;diagram__notes&quot;&gt; &lt;li data-stage=&quot;1&quot;&gt; &lt;p&gt;A person asks for an explanation of an unexpected measurement and a correction, without changing the original data.&lt;/p&gt; &lt;/li&gt; &lt;li data-stage=&quot;2&quot;&gt; &lt;p&gt;The runtime assembles context for the request, including the objective, the relevant files, and the boundary.&lt;/p&gt; &lt;/li&gt; &lt;li data-stage=&quot;3&quot;&gt; &lt;p&gt;The model interprets the objective and proposes a sequence of actions, one of them a command.&lt;/p&gt; &lt;/li&gt; &lt;li data-stage=&quot;2&quot;&gt; &lt;p&gt;The runtime decides whether this task may run the command, and where the work runs.&lt;/p&gt; &lt;/li&gt; &lt;li data-stage=&quot;2&quot;&gt; &lt;p&gt;A tool runs. The runtime records the observed result and the inputs it ran against.&lt;/p&gt; &lt;/li&gt; &lt;li data-stage=&quot;1&quot;&gt; &lt;p&gt;The application presents the explanation and the proposed correction; the original data is unchanged.&lt;/p&gt; &lt;/li&gt; &lt;/ol&gt;&lt;/div&gt; &lt;figcaption&gt;The application, runtime, and model layers of an intelligent application, beside the path one request takes through them.&lt;/figcaption&gt; &lt;/figure&gt; &lt;!-- prettier-ignore-start --&gt; &lt;table class=&quot;entry-compare&quot;&gt; &lt;thead&gt; &lt;tr&gt; &lt;th&gt;Familiar computer role&lt;/th&gt; &lt;th&gt;Intelligent-software role&lt;/th&gt; &lt;th&gt;Important difference&lt;/th&gt; &lt;/tr&gt; &lt;/thead&gt; &lt;tbody&gt; &lt;tr&gt; &lt;td&gt;Processor&lt;/td&gt; &lt;td&gt;Model interpreting a task and proposing actions&lt;/td&gt; &lt;td&gt;Its outputs are probabilistic&lt;/td&gt; &lt;/tr&gt; &lt;tr&gt; &lt;td&gt;Memory&lt;/td&gt; &lt;td&gt;Context assembled for the current work&lt;/td&gt; &lt;td&gt;More history is not always more useful context&lt;/td&gt; &lt;/tr&gt; &lt;tr&gt; &lt;td&gt;Operating environment&lt;/td&gt; &lt;td&gt;Runtime managing tools, authority, and continuation&lt;/td&gt; &lt;td&gt;A harness is not an OS sandbox&lt;/td&gt; &lt;/tr&gt; &lt;tr&gt; &lt;td&gt;Application&lt;/td&gt; &lt;td&gt;A workflow with the user’s data and domain rules&lt;/td&gt; &lt;td&gt;The model does not supply those rules by itself&lt;/td&gt; &lt;/tr&gt; &lt;/tbody&gt; &lt;/table&gt; &lt;!-- prettier-ignore-end --&gt; &lt;p&gt;That is the operating-system role I want to emphasize. The model may propose a command; the runtime decides whether the task may execute it. The model may request another worker; the runtime resolves where it runs and what authority it receives. The model may say a check passed; the runtime needs the observed result and the inputs it ran against.&lt;/p&gt; &lt;p&gt;In &lt;a href=&quot;/work/clio/&quot;&gt;CLIO&lt;/a&gt;, the context architecture I created and lead across &lt;a href=&quot;/work/iowarp/&quot;&gt;IOWarp&lt;/a&gt;, I think of this broader direction as a ContextOS. I use that name for an architectural idea: context and execution services that intelligent applications can share. It is not a claim that a new operating-system kernel or a finished universal application SDK has shipped.&lt;/p&gt; &lt;h2 id=&quot;the-analogy-has-limits&quot;&gt;The analogy has limits&lt;/h2&gt; &lt;p&gt;A conventional CPU executes specified instructions. A model produces probabilistic outputs and can misunderstand an instruction or invent a fact. A prompt is not a permission boundary, and tool admission is a different protection from operating-system isolation.&lt;/p&gt; &lt;p&gt;Likewise, giving a model context is not the same as training its weights. In-context adaptation, retrieving a stored lesson, and fine-tuning change a system in different ways. An application can improve its procedures and accumulated context without the underlying model learning during every session.&lt;/p&gt; &lt;p&gt;These distinctions are useful to someone building a product. They tell you which failure needs a better model, which needs better data, and which needs an execution rule the model cannot rewrite.&lt;/p&gt; &lt;h2 id=&quot;an-application-that-also-supplies-a-runtime&quot;&gt;An application that also supplies a runtime&lt;/h2&gt; &lt;p&gt;&lt;a href=&quot;/work/clio-coder/&quot;&gt;CLIO Coder&lt;/a&gt; is itself intelligent software: a person brings a repository and asks for help with a task. It also has runtime machinery that another application could use, including model connections, tool execution, context management, delegated work, and recorded results.&lt;/p&gt; &lt;p&gt;Its current integration paths are headless CLI runs and the Agent Client Protocol. Its Library supplies reusable skills, prompts, agents, fleets, and plugins, so a specialized writing or scientific workflow can bring its own procedures instead of rebuilding a coding loop from nothing.&lt;/p&gt; &lt;p&gt;A general application platform needs more than those ingredients. Stable interfaces, lifecycle ownership, deployment boundaries, and an explicit security contract still have to be designed and maintained. That is work to do, not something the operating-system metaphor grants.&lt;/p&gt; &lt;p&gt;The opportunity is to make those services reusable while the application defines the user’s task. A student building a data-analysis assistant should spend effort on the analysis, its checks, and its interaction with the person, rather than rediscovering every lesson about interrupted runs and stale context.&lt;/p&gt; &lt;p&gt;Software that understands a request still needs software that takes responsibility for its execution. That is where I see room for systems research, and where I want CLIO to grow.&lt;/p&gt; </content> </entry> <entry> <title type="html">Context needs a lifecycle</title> <link rel="alternate" type="text/html" href="https://akougkas.io/journal/2026/context-needs-a-lifecycle/"/> <id>https://akougkas.io/journal/2026/context-needs-a-lifecycle/</id> <published>2026-09-27T00:00:00-05:00</published> <updated>2026-09-27T00:00:00-05:00</updated> <summary type="html">An agent needs more than a larger prompt. Working context, handoffs, and durable memory have different lifetimes, and treating them separately is a useful systems technique.</summary> <content type="html" xml:base="https://akougkas.io/journal/2026/context-needs-a-lifecycle/">&lt;p&gt;A test passed. Then a file changed. A branch forked. The session ended and another began. Which of those facts should the next model request carry, and which are already out of date?&lt;/p&gt; &lt;p&gt;That question is more useful to me than asking how much conversation fits into a context window. In &lt;a href=&quot;/work/clio/&quot;&gt;CLIO&lt;/a&gt;, the context architecture I lead across &lt;a href=&quot;/work/iowarp/&quot;&gt;IOWarp&lt;/a&gt;, context is part of the system. &lt;a href=&quot;/work/clio-coder/&quot;&gt;CLIO Coder&lt;/a&gt; is one place where I can work through the consequences against an actual repository.&lt;/p&gt; &lt;figure class=&quot;diagram diagram--lifecycle entry-wide&quot; id=&quot;diagram-context-lifecycle&quot; data-stepper=&quot;&quot; data-step-label=&quot;Step&quot; data-of-label=&quot;of&quot; data-previous-label=&quot;Previous step&quot; data-next-label=&quot;Next step&quot;&gt; &lt;div class=&quot;diagram__head&quot;&gt; &lt;p class=&quot;diagram__title&quot;&gt;Four kinds of information across one task&lt;/p&gt; &lt;/div&gt; &lt;div class=&quot;diagram__scroll&quot; role=&quot;region&quot; aria-label=&quot;Four kinds of information across one task&quot; tabindex=&quot;0&quot;&gt; &lt;table class=&quot;diagram__matrix&quot;&gt; &lt;thead&gt; &lt;tr&gt; &lt;td&gt;&lt;/td&gt; &lt;th scope=&quot;col&quot;&gt;Test passes&lt;/th&gt; &lt;th scope=&quot;col&quot;&gt;File changes&lt;/th&gt; &lt;th scope=&quot;col&quot;&gt;Branch forks&lt;/th&gt; &lt;th scope=&quot;col&quot;&gt;Session ends&lt;/th&gt; &lt;th scope=&quot;col&quot;&gt;Next session&lt;/th&gt; &lt;/tr&gt; &lt;/thead&gt; &lt;tbody&gt; &lt;tr&gt; &lt;th scope=&quot;row&quot;&gt; &lt;span class=&quot;diagram__label&quot;&gt;The test result&lt;/span&gt;&lt;span class=&quot;diagram__body&quot;&gt;One fact in the working context&lt;/span&gt; &lt;/th&gt; &lt;td data-state=&quot;live&quot;&gt;In use&lt;/td&gt; &lt;td data-state=&quot;stale&quot;&gt;Stale&lt;/td&gt; &lt;td data-state=&quot;stale&quot;&gt;Stale&lt;/td&gt; &lt;td data-state=&quot;none&quot;&gt;&lt;/td&gt; &lt;td data-state=&quot;none&quot;&gt;&lt;/td&gt; &lt;/tr&gt; &lt;tr&gt; &lt;th scope=&quot;row&quot;&gt; &lt;span class=&quot;diagram__label&quot;&gt;Working context&lt;/span&gt;&lt;span class=&quot;diagram__body&quot;&gt;Objective, relevant code, current decisions&lt;/span&gt; &lt;/th&gt; &lt;td data-state=&quot;live&quot;&gt;In use&lt;/td&gt; &lt;td data-state=&quot;live&quot;&gt;In use&lt;/td&gt; &lt;td data-state=&quot;live&quot;&gt;In use&lt;/td&gt; &lt;td data-state=&quot;none&quot;&gt;&lt;/td&gt; &lt;td data-state=&quot;live&quot;&gt;In use&lt;/td&gt; &lt;/tr&gt; &lt;tr&gt; &lt;th scope=&quot;row&quot;&gt; &lt;span class=&quot;diagram__label&quot;&gt;Handoff&lt;/span&gt;&lt;span class=&quot;diagram__body&quot;&gt;What remains, why, and where to look&lt;/span&gt; &lt;/th&gt; &lt;td data-state=&quot;none&quot;&gt;&lt;/td&gt; &lt;td data-state=&quot;none&quot;&gt;&lt;/td&gt; &lt;td data-state=&quot;none&quot;&gt;&lt;/td&gt; &lt;td data-state=&quot;carried&quot;&gt;Kept&lt;/td&gt; &lt;td data-state=&quot;live&quot;&gt;In use&lt;/td&gt; &lt;/tr&gt; &lt;tr&gt; &lt;th scope=&quot;row&quot;&gt; &lt;span class=&quot;diagram__label&quot;&gt;Memory&lt;/span&gt;&lt;span class=&quot;diagram__body&quot;&gt;A lesson worth retrieving later&lt;/span&gt; &lt;/th&gt; &lt;td data-state=&quot;none&quot;&gt;&lt;/td&gt; &lt;td data-state=&quot;none&quot;&gt;&lt;/td&gt; &lt;td data-state=&quot;none&quot;&gt;&lt;/td&gt; &lt;td data-state=&quot;review&quot;&gt;For review&lt;/td&gt; &lt;td data-state=&quot;live&quot;&gt;In use&lt;/td&gt; &lt;/tr&gt; &lt;/tbody&gt; &lt;/table&gt; &lt;/div&gt; &lt;ol class=&quot;diagram__notes&quot;&gt; &lt;li&gt; &lt;p&gt;A test passes. The result belongs in the working context because it describes the files as they are now.&lt;/p&gt; &lt;/li&gt; &lt;li&gt; &lt;p&gt;A file changes. The earlier pass no longer describes the code; it remains history, not current evidence.&lt;/p&gt; &lt;/li&gt; &lt;li&gt; &lt;p&gt;A branch forks. Each branch keeps its own working context. A fork can recall earlier notes without inheriting permission to resume its parent&apos;s pending handoff.&lt;/p&gt; &lt;/li&gt; &lt;li&gt; &lt;p&gt;The session ends. What must continue goes into a handoff bound to its branch and decisions; a lesson worth keeping becomes a memory proposal for review.&lt;/p&gt; &lt;/li&gt; &lt;li&gt; &lt;p&gt;The next session resumes from the handoff, retrieves reviewed memory, and rebuilds a working context for the task at hand.&lt;/p&gt; &lt;/li&gt; &lt;/ol&gt; &lt;figcaption&gt;Lifetimes of a test result, the working context, a handoff, and a memory across five events in one coding task. Illustration.&lt;/figcaption&gt; &lt;/figure&gt; &lt;h2 id=&quot;different-information-needs-different-lifetimes&quot;&gt;Different information needs different lifetimes&lt;/h2&gt; &lt;p&gt;The active task needs a small working set: the objective, the relevant code, current decisions, and the checks still to run. A handoff needs enough to continue that task after a transition. Durable memory needs a lesson worth retrieving in another session.&lt;/p&gt; &lt;p&gt;Those are different objects. Saving all of them as one long transcript makes later retrieval expensive and leaves the receiving agent to infer which statements are still authoritative. Compressing all of them into one summary can discard the detail that makes a result inspectable.&lt;/p&gt; &lt;p&gt;The systems technique is to give each object a lifecycle. Working context shrinks as the task moves. A handoff is bound to the branch and decisions that produced it. A memory proposal is reviewed before it becomes a recurring influence. An old note can remain useful history without becoming a current instruction.&lt;/p&gt; &lt;h2 id=&quot;finding-a-capability-without-carrying-the-whole-library&quot;&gt;Finding a capability without carrying the whole library&lt;/h2&gt; &lt;p&gt;Tools and skills have the same problem. A repository may need one specialized procedure from a large collection. Putting every procedure and tool description into every request spends context before the agent knows what matters.&lt;/p&gt; &lt;p&gt;CLIO Coder’s recent releases make discovery explicit. The coordinator starts with a small attached toolkit and discovers secondary capabilities when a task needs them. The Library groups skills, agents, prompts, fleets, and plugins in user and project scopes, and a project can select or suppress resources instead of silently inheriting everything available to one developer.&lt;/p&gt; &lt;p&gt;This is more than a shorter prompt. It is a decision about what the agent can discover, what it has already loaded, and which actions still require admission. Removing a resource from discovery cannot erase instructions an earlier turn has already read, and that limit matters when designing controls for a running system.&lt;/p&gt; &lt;h2 id=&quot;a-handoff-is-a-continuation-contract&quot;&gt;A handoff is a continuation contract&lt;/h2&gt; &lt;p&gt;A useful handoff says what remains, why a choice was made, and where to inspect the work. It should not ask the next agent to trust the previous agent’s confidence.&lt;/p&gt; &lt;p&gt;Branch-bound handoffs in CLIO Coder make this concrete. A note belongs to the branch and decisions under which it was prepared. A fork can recall earlier notes, but it does not inherit permission to continue its parent’s pending transition. Recovery takes an explicit command, not an encouraging paragraph saying that everything is ready.&lt;/p&gt; &lt;p&gt;There is a practical lesson here for students building agents. Start by naming the information that must survive, the event that makes it stale, and the person or process allowed to promote it. Those choices are an architecture before any storage engine enters the picture.&lt;/p&gt; &lt;p&gt;A larger context window is still useful. It gives us room. Lifecycles give that room structure. The &lt;a href=&quot;https://coder.iowarp.ai/docs/guide/context-continuity.html&quot;&gt;context continuity guide&lt;/a&gt; explains the current controls; the research direction is to make these boundaries work across the much larger scientific workflows that CLIO serves.&lt;/p&gt; </content> </entry> <entry> <title type="html">An agent&apos;s authority should travel with the task</title> <link rel="alternate" type="text/html" href="https://akougkas.io/journal/2026/an-agents-authority-should-travel-with-the-task/"/> <id>https://akougkas.io/journal/2026/an-agents-authority-should-travel-with-the-task/</id> <published>2026-09-27T00:00:00-05:00</published> <updated>2026-09-27T00:00:00-05:00</updated> <summary type="html">Distributed agents need explicit work, bounded authority, and results people can inspect. The useful scale is not the number of workers; it is the work that can be checked and carried forward.</summary> <content type="html" xml:base="https://akougkas.io/journal/2026/an-agents-authority-should-travel-with-the-task/">&lt;p&gt;A laptop can be the place where I decide what work should happen. It does not have to be the place where every worker runs.&lt;/p&gt; &lt;p&gt;That is the attraction of distributed agents for scientific software. A project may depend on machines at a university, an institutional inference service, or a remote server with the right environment. The difficulty is carrying the task, its authority, and its results across those boundaries without replacing them with assumptions.&lt;/p&gt; &lt;p&gt;&lt;a href=&quot;/work/clio-coder/&quot;&gt;CLIO Coder&lt;/a&gt;, the coding agent I create inside &lt;a href=&quot;/work/clio/&quot;&gt;CLIO&lt;/a&gt;, is where I explore that problem most directly.&lt;/p&gt; &lt;figure class=&quot;diagram diagram--flow entry-wide&quot; id=&quot;diagram-authority-path&quot; data-stepper=&quot;&quot; data-step-label=&quot;Step&quot; data-of-label=&quot;of&quot; data-previous-label=&quot;Previous step&quot; data-next-label=&quot;Next step&quot;&gt; &lt;div class=&quot;diagram__head&quot;&gt; &lt;p class=&quot;diagram__title&quot;&gt;One delegated task&lt;/p&gt; &lt;/div&gt; &lt;ol class=&quot;diagram__stages&quot;&gt; &lt;li class=&quot;diagram__stage&quot;&gt; &lt;p class=&quot;diagram__label&quot;&gt;Session&lt;/p&gt; &lt;p class=&quot;diagram__body&quot;&gt;Holds the conversation with you.&lt;/p&gt; &lt;p class=&quot;diagram__detail&quot;&gt;The main session may run at yolo; that level governs only the main agent.&lt;/p&gt; &lt;/li&gt; &lt;li class=&quot;diagram__stage&quot;&gt; &lt;p class=&quot;diagram__label&quot;&gt;Dispatch&lt;/p&gt; &lt;p class=&quot;diagram__body&quot;&gt;Admits one bounded assignment.&lt;/p&gt; &lt;p class=&quot;diagram__detail&quot;&gt;Every worker and peer runs at default. Read-only is a separate restriction on the dispatch.&lt;/p&gt; &lt;/li&gt; &lt;li class=&quot;diagram__stage&quot;&gt; &lt;p class=&quot;diagram__label&quot;&gt;Worker&lt;/p&gt; &lt;p class=&quot;diagram__body&quot;&gt;Runs where it is placed.&lt;/p&gt; &lt;p class=&quot;diagram__detail&quot;&gt;On this machine, or on an SSH node with a matching runtime and the project at the same absolute path.&lt;/p&gt; &lt;/li&gt; &lt;li class=&quot;diagram__stage&quot;&gt; &lt;p class=&quot;diagram__label&quot;&gt;Checks&lt;/p&gt; &lt;p class=&quot;diagram__body&quot;&gt;Declared checks run through verify.&lt;/p&gt; &lt;p class=&quot;diagram__detail&quot;&gt;Results are recorded against source, check-declaration, and policy fingerprints.&lt;/p&gt; &lt;/li&gt; &lt;li class=&quot;diagram__stage&quot;&gt; &lt;p class=&quot;diagram__label&quot;&gt;Review&lt;/p&gt; &lt;p class=&quot;diagram__body&quot;&gt;A person decides.&lt;/p&gt; &lt;p class=&quot;diagram__detail&quot;&gt;An edit after a passing run makes the result stale; missing evidence stays unverified.&lt;/p&gt; &lt;/li&gt; &lt;/ol&gt; &lt;figcaption&gt;The path of one delegated task in CLIO Coder v0.5.7, from the coordinating session to review, with the authority and evidence that travel with it.&lt;/figcaption&gt; &lt;/figure&gt; &lt;h2 id=&quot;delegation-needs-an-explicit-boundary&quot;&gt;Delegation needs an explicit boundary&lt;/h2&gt; &lt;p&gt;A main session and a worker have different jobs. The session holds the conversation with the operator; the worker receives a bounded assignment. Passing every session privilege to every worker would make delegation an expansion of authority as well as of capacity.&lt;/p&gt; &lt;p&gt;The current runtime keeps that distinction visible. Workers and external peers run at &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;default&lt;/code&gt;, even when the main session uses &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;yolo&lt;/code&gt;, and a read-only dispatch is a separate restriction. The names of the settings matter less than the principle: the receiving task gets an explicit execution boundary instead of inheriting whatever the coordinator happened to be allowed to do.&lt;/p&gt; &lt;p&gt;External agents also expose different controls. A managed run and an interactive handoff are not interchangeable, and some connectors cannot mediate every action inside a peer’s own loop. Those limits belong in the operator’s choice, not behind one successful-looking dashboard.&lt;/p&gt; &lt;h2 id=&quot;completion-is-something-to-inspect&quot;&gt;Completion is something to inspect&lt;/h2&gt; &lt;p&gt;A worker saying “the tests pass” leaves several questions open. Which tests? Against which files? Did the command run, was it denied, or did the model merely name it?&lt;/p&gt; &lt;p&gt;CLIO Coder discovers checks from a repository’s declared build and test setup, and a quality policy can require particular checks for particular changes. Recorded results are assessed against source, check-declaration, and policy fingerprints, so changing an input after a passing run makes that evidence stale.&lt;/p&gt; &lt;figure class=&quot;entry-figure entry-wide&quot; id=&quot;figure-results&quot;&gt; &lt;div class=&quot;entry-figure__frame&quot;&gt;&lt;a href=&quot;/assets/img/clio-coder-results-v057.webp&quot;&gt;&lt;img src=&quot;/assets/img/clio-coder-results-v057.webp&quot; alt=&quot;CLIO Coder browser alpha. The conversation reports that all seven calibration tests pass; beside it, the Artifacts panel shows the recorded verify run with exit status 0 and output listing seven tests, seven passes, and no failures.&quot; width=&quot;1600&quot; height=&quot;1000&quot; loading=&quot;lazy&quot; decoding=&quot;async&quot; /&gt;&lt;/a&gt; &lt;svg class=&quot;entry-figure__marks&quot; aria-hidden=&quot;true&quot; focusable=&quot;false&quot;&gt; &lt;g&gt; &lt;circle cx=&quot;40%&quot; cy=&quot;50.8%&quot; r=&quot;14&quot;&gt;&lt;/circle&gt; &lt;text x=&quot;40%&quot; y=&quot;50.8%&quot; text-anchor=&quot;middle&quot; dominant-baseline=&quot;central&quot;&gt;1&lt;/text&gt; &lt;/g&gt; &lt;g&gt; &lt;circle cx=&quot;90%&quot; cy=&quot;48.5%&quot; r=&quot;14&quot;&gt;&lt;/circle&gt; &lt;text x=&quot;90%&quot; y=&quot;48.5%&quot; text-anchor=&quot;middle&quot; dominant-baseline=&quot;central&quot;&gt;2&lt;/text&gt; &lt;/g&gt; &lt;g&gt; &lt;circle cx=&quot;92%&quot; cy=&quot;80%&quot; r=&quot;14&quot;&gt;&lt;/circle&gt; &lt;text x=&quot;92%&quot; y=&quot;80%&quot; text-anchor=&quot;middle&quot; dominant-baseline=&quot;central&quot;&gt;3&lt;/text&gt; &lt;/g&gt; &lt;/svg&gt; &lt;/div&gt; &lt;figcaption&gt; &lt;p&gt;A model&apos;s summary beside the recorded run it describes, in the browser alpha&apos;s Artifacts panel.&lt;/p&gt; &lt;ol class=&quot;entry-figure__notes&quot; aria-label=&quot;Marked on the image&quot;&gt; &lt;li&gt;The model&apos;s answer says all seven tests pass.&lt;/li&gt; &lt;li&gt;The recorded call ran verify and exited with status 0.&lt;/li&gt; &lt;li&gt;The observed output counts seven tests, seven passes, and no failures.&lt;/li&gt; &lt;/ol&gt; &lt;p class=&quot;entry-figure__credit&quot;&gt;CLIO Coder v0.5.7 browser alpha, captured September 26, 2026 from a model-created temperature-calibration session. From the CLIO Coder repository&apos;s release captures.&lt;/p&gt; &lt;/figcaption&gt; &lt;/figure&gt; &lt;p&gt;This does not prove the software correct. A test suite can miss a scientific error, and a fingerprint cannot account for every external dataset or service. It does give review a better starting point: which declared checks were observed against which work, and what remains unverified.&lt;/p&gt; &lt;p&gt;That is a lesson from data systems applied to agents. Preserve the event and its inputs while they exist; do not try to reconstruct them from the final prose.&lt;/p&gt; &lt;p&gt;The record on disk also creates an attachment point for observers. A dashboard can read what happened without becoming the agent, and I want guardian agents to use the same separation to notice drift and ask for intervention. That is a direction for the system, not a claim that an independent guardian already supervises every run.&lt;/p&gt; &lt;h2 id=&quot;distance-adds-requirements&quot;&gt;Distance adds requirements&lt;/h2&gt; &lt;p&gt;Native remote workers use SSH, with preflight checks and a matching runtime, and the current fleet expects the project at the same absolute path on each node. That is a deployment requirement, not a detail to omit when showing a laptop directing remote work.&lt;/p&gt; &lt;p&gt;Clio does not submit arbitrary jobs to every national-laboratory scheduler or move a repository onto an unrelated server automatically. It offers a concrete mechanism that fits an environment when its access rules and filesystem layout permit, and institutional policy still governs where work and data may go.&lt;/p&gt; &lt;p&gt;The browser alpha is a local place to follow conversations and results; the terminal remains the primary interface for the full workflow. Either interface is worth what it shows a person about the work and how easily that person can intervene.&lt;/p&gt; &lt;p&gt;For my students, the transferable technique is to design the task boundary and the evidence boundary together. More workers are useful when their outputs can be reviewed, combined, and corrected. The &lt;a href=&quot;https://coder.iowarp.ai/docs/guide/fleet-dispatch.html&quot;&gt;fleet guide&lt;/a&gt; describes the current deployment requirements, and the &lt;a href=&quot;https://coder.iowarp.ai/tutorials/temperature-calibration.html&quot;&gt;calibration example&lt;/a&gt; shows recorded checks on a small numerical change.&lt;/p&gt; </content> </entry> <entry> <title type="html">Why CLIO Coder, part 5 of 5: decisions without prose</title> <link rel="alternate" type="text/html" href="https://akougkas.io/journal/2026/why-clio-coder-5-decisions-without-prose/"/> <id>https://akougkas.io/journal/2026/why-clio-coder-5-decisions-without-prose/</id> <published>2026-09-22T00:00:00-05:00</published> <updated>2026-09-22T00:00:00-05:00</updated> <summary type="html">A coding harness makes hundreds of small decisions per turn, and a chat model is the wrong instrument for them. CLIO Coder v0.5.3 binds four decision sites to a System One model that returns a calibrated distribution over a closed answer shape, and adds a diffusion runtime for the latency-sensitive slot beside it.</summary> <content type="html" xml:base="https://akougkas.io/journal/2026/why-clio-coder-5-decisions-without-prose/">&lt;p&gt;&lt;strong&gt;September 27, 2026:&lt;/strong&gt; v0.5.4 expanded decision-model sites, retired legacy routing, and removed the old evaluation engine and baselines. This essay describes the v0.5.3 design. See the &lt;a href=&quot;https://coder.iowarp.ai/docs.html&quot;&gt;current product guides&lt;/a&gt; and &lt;a href=&quot;https://github.com/iowarp/clio-coder/releases&quot;&gt;release history&lt;/a&gt;.&lt;/p&gt; &lt;p&gt;A coding turn produces one visible answer and a few hundred invisible decisions. Which worker takes this dispatch. Which installed skills the listing surfaces first. Which memory records are worth the prompt budget. How much a parked command could destroy. Every one is a closed question with a small answer set, and the only instrument on hand was a model trained to write English: slow, unparseable, unable to state how sure it is. v0.5.3 of &lt;a href=&quot;/work/clio-coder/&quot;&gt;CLIO Coder&lt;/a&gt; gives the harness a second kind of model for them.&lt;/p&gt; &lt;h2 id=&quot;a-closed-question-deserves-a-closed-answer&quot;&gt;A closed question deserves a closed answer&lt;/h2&gt; &lt;p&gt;A System One model does not generate prose. Every question names its answer shape up front and the model returns a calibrated distribution over that shape in one round trip. &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;decide()&lt;/code&gt; on the runtime descriptor answers a batch of independent typed questions against one body of evidence. Three primitives: &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;noul&lt;/code&gt; returns a truth probability, &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;choice&lt;/code&gt; returns one option from a declared set with the distribution over the whole set, and &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;score&lt;/code&gt; returns a position on a criteria ladder. The question’s &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;criteria&lt;/code&gt; says what each rung means, so the caller defines the scale instead of hoping a prompt implies it.&lt;/p&gt; &lt;p&gt;Confidence is a separate axis from the answer, because they are different questions. A &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;noul&lt;/code&gt; of 0.5 at high confidence is a decided coin-flip; at low confidence it is an abstention, and a caller gating on the result has to tell them apart. The readers in &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;decisions.ts&lt;/code&gt; return &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;null&lt;/code&gt; rather than &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;false&lt;/code&gt; below a confidence floor. A missing or unrecognised answer throws instead: callers index by the ids they submitted, so a dropped answer is a contract break, and a caller gating dispatch must never receive a decision the model did not make.&lt;/p&gt; &lt;h2 id=&quot;four-sites-off-until-you-bind-them&quot;&gt;Four sites, off until you bind them&lt;/h2&gt; &lt;p&gt;The runtime is &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;typesafe-jev&lt;/code&gt;, hidden and declaring &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;chat: false&lt;/code&gt;, so it never appears as a conversational target and the configure wizard does not offer it. It binds through &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;fleet.decisionProfiles&lt;/code&gt;, a map from a decision site to an existing &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;fleet.profiles&lt;/code&gt; entry, because a decision model is a provider rather than an agent and the profile machinery already validates a target and a model. Four sites name moments in a turn: &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;routing&lt;/code&gt; picks a worker at dispatch, &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;skills&lt;/code&gt; and &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;memory&lt;/code&gt; narrow what the prompt carries, &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;toolRisk&lt;/code&gt; rates a parked command’s blast radius at the approval prompt.&lt;/p&gt; &lt;figure class=&quot;figure--diagram&quot;&gt; &lt;svg viewBox=&quot;0 0 640 360&quot; role=&quot;img&quot; aria-labelledby=&quot;fig-decision-sites&quot;&gt; &lt;title id=&quot;fig-decision-sites&quot;&gt;A turn begins and fans out to four decision sites: routing, skills, memory, and toolRisk. The four sites converge into one decide call carrying their questions together, which returns typed answers with their own confidence, and those answers return to the sites that asked.&lt;/title&gt; &lt;rect class=&quot;d-soft&quot; x=&quot;200&quot; y=&quot;10&quot; width=&quot;240&quot; height=&quot;36&quot; rx=&quot;4&quot; /&gt; &lt;text class=&quot;d-text&quot; x=&quot;320&quot; y=&quot;34&quot; text-anchor=&quot;middle&quot;&gt;turn begins&lt;/text&gt; &lt;path class=&quot;d-line&quot; d=&quot;M320 46 V58&quot; /&gt; &lt;path class=&quot;d-line&quot; d=&quot;M108 58 H546&quot; /&gt; &lt;path class=&quot;d-line&quot; d=&quot;M108 58 V66&quot; /&gt; &lt;polygon class=&quot;d-accent-fill&quot; points=&quot;102,66 114,66 108,76&quot; /&gt; &lt;path class=&quot;d-line&quot; d=&quot;M254 58 V66&quot; /&gt; &lt;polygon class=&quot;d-accent-fill&quot; points=&quot;248,66 260,66 254,76&quot; /&gt; &lt;path class=&quot;d-line&quot; d=&quot;M400 58 V66&quot; /&gt; &lt;polygon class=&quot;d-accent-fill&quot; points=&quot;394,66 406,66 400,76&quot; /&gt; &lt;path class=&quot;d-line&quot; d=&quot;M546 58 V66&quot; /&gt; &lt;polygon class=&quot;d-accent-fill&quot; points=&quot;540,66 552,66 546,76&quot; /&gt; &lt;rect class=&quot;d-box&quot; x=&quot;40&quot; y=&quot;76&quot; width=&quot;136&quot; height=&quot;36&quot; rx=&quot;4&quot; /&gt; &lt;text class=&quot;d-text&quot; x=&quot;108&quot; y=&quot;100&quot; text-anchor=&quot;middle&quot;&gt;routing&lt;/text&gt; &lt;rect class=&quot;d-box&quot; x=&quot;186&quot; y=&quot;76&quot; width=&quot;136&quot; height=&quot;36&quot; rx=&quot;4&quot; /&gt; &lt;text class=&quot;d-text&quot; x=&quot;254&quot; y=&quot;100&quot; text-anchor=&quot;middle&quot;&gt;skills&lt;/text&gt; &lt;rect class=&quot;d-box&quot; x=&quot;332&quot; y=&quot;76&quot; width=&quot;136&quot; height=&quot;36&quot; rx=&quot;4&quot; /&gt; &lt;text class=&quot;d-text&quot; x=&quot;400&quot; y=&quot;100&quot; text-anchor=&quot;middle&quot;&gt;memory&lt;/text&gt; &lt;rect class=&quot;d-box&quot; x=&quot;478&quot; y=&quot;76&quot; width=&quot;136&quot; height=&quot;36&quot; rx=&quot;4&quot; /&gt; &lt;text class=&quot;d-text&quot; x=&quot;546&quot; y=&quot;100&quot; text-anchor=&quot;middle&quot;&gt;toolRisk&lt;/text&gt; &lt;path class=&quot;d-line&quot; d=&quot;M108 112 V124&quot; /&gt; &lt;path class=&quot;d-line&quot; d=&quot;M254 112 V124&quot; /&gt; &lt;path class=&quot;d-line&quot; d=&quot;M400 112 V124&quot; /&gt; &lt;path class=&quot;d-line&quot; d=&quot;M546 112 V124&quot; /&gt; &lt;path class=&quot;d-line&quot; d=&quot;M108 124 H546&quot; /&gt; &lt;path class=&quot;d-line&quot; d=&quot;M320 124 V132&quot; /&gt; &lt;polygon class=&quot;d-accent-fill&quot; points=&quot;314,132 326,132 320,142&quot; /&gt; &lt;rect class=&quot;d-box&quot; x=&quot;200&quot; y=&quot;142&quot; width=&quot;240&quot; height=&quot;36&quot; rx=&quot;4&quot; /&gt; &lt;text class=&quot;d-text&quot; x=&quot;320&quot; y=&quot;166&quot; text-anchor=&quot;middle&quot;&gt;one decide call&lt;/text&gt; &lt;path class=&quot;d-line&quot; d=&quot;M320 178 V188&quot; /&gt; &lt;polygon class=&quot;d-accent-fill&quot; points=&quot;314,188 326,188 320,198&quot; /&gt; &lt;rect class=&quot;d-soft&quot; x=&quot;210&quot; y=&quot;198&quot; width=&quot;220&quot; height=&quot;36&quot; rx=&quot;4&quot; /&gt; &lt;text class=&quot;d-text&quot; x=&quot;320&quot; y=&quot;222&quot; text-anchor=&quot;middle&quot;&gt;typed answers&lt;/text&gt; &lt;path class=&quot;d-accent&quot; d=&quot;M210 216 H22 V94 H28&quot; /&gt; &lt;polygon class=&quot;d-accent-fill&quot; points=&quot;28,88 28,100 40,94&quot; /&gt; &lt;/svg&gt; &lt;figcaption&gt;A turn fanning out to its four decision sites, the sites batching their questions into one decide call, and the typed answers returning to the sites that asked.&lt;/figcaption&gt; &lt;/figure&gt; &lt;p&gt;A site with no entry resolves to nothing and its caller keeps the behavior it had before the site existed. It is opt-in by absence, and a misbehaving site can be unbound without giving up the other three. Abstention below the confidence floor and provider failure take that same path, so an unbound site, an outage, and an uncertain answer are indistinguishable from each other and from the behavior that preceded the site.&lt;/p&gt; &lt;p&gt;That matters most at &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;routing&lt;/code&gt;. Unbound, &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;classifyAgentTask&lt;/code&gt; reads a task with an ordered regex list and reports a confidence of 0.3 or 0.7 depending only on whether any task-type rule matched. On “Review the auth middleware for timing attacks, then fix anything you find and add regression tests”, the word-count ladder returns &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;simple&lt;/code&gt; and the conjunction rule returns indivisible. Both are wrong. The live provider returns complexity 1.86 of 3 and decomposable 0.81 for that task, using 718 input and 188 output tokens in 249 ms, pinned in a contract test. Bound, the site asks four independent questions in one call, and each field falls back to the regex value on its own. &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;routeValidationProjection&lt;/code&gt; strips task features on the same terms as the reservation, so a model cannot author the features its own routing reads.&lt;/p&gt; &lt;p&gt;The other three carry rules of their own. The skills listing is ranked and never filtered, because a skill the model cannot see is a capability it has no way to know was withheld, and a row that abstains keeps its position, since an unscored skill is not a low-scored one. &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;toolRisk&lt;/code&gt; is advisory and never changes what is permitted, so a decision model can neither widen nor narrow what an operator approves. Memory scores resolve once at the turn boundary and ride into the prompt-cache key, because reusing the previous turn’s cached section after a new pass would be a correctness bug. A four-candidate fan-out cost 593 input and 81 output tokens in 274 ms, and swapping the text behind an id moved that id’s score from 0.25 to 0.07, confirming that the model resolves an id against the state rather than reading the id.&lt;/p&gt; &lt;h2 id=&quot;a-runtime-that-denoises-instead-of-predicting&quot;&gt;A runtime that denoises instead of predicting&lt;/h2&gt; &lt;p&gt;&lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;inception&lt;/code&gt; serves Inception’s Mercury models, which denoise whole blocks of tokens in parallel instead of emitting them left to right, and that is what makes them fast enough for a latency-sensitive slot a frontier model cannot fill. Chat runs through the ordinary transport with tool calling and &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;json-schema&lt;/code&gt; structured outputs. Fill-in-the-middle runs through the existing &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;infill()&lt;/code&gt; verb, so callers reach Mercury as they reach llama.cpp’s, and a target naming no &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;defaultModel&lt;/code&gt; infills with the edit-tuned &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;mercury-edit-2&lt;/code&gt;.&lt;/p&gt; &lt;p&gt;&lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;reasoning_effort&lt;/code&gt; is pinned to &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;instant&lt;/code&gt; and reasoning is declared false. Above &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;instant&lt;/code&gt; the response carries &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;content: null&lt;/code&gt; with &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;reasoning_summary: null&lt;/code&gt;, so there is nothing to show an operator. Omitting the field is worse: Mercury then reasons by default and returns an empty completion with &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;finish_reason: &quot;length&quot;&lt;/code&gt;. &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;/v1/edit/completions&lt;/code&gt; is left out on purpose, because its next-edit prediction needs a contract verb of its own and its context-tag request format is not covered by the published reference.&lt;/p&gt; &lt;p&gt;One quirk earned a general mechanism. Inception rejects the &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;developer&lt;/code&gt; role outright, so every request carrying a system prompt in it is a 400. Catalog-backed model synthesis gained &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;compat&lt;/code&gt; and &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;samplingParams&lt;/code&gt; passthrough, so a runtime can declare the wire quirks it knows about its own endpoint over whatever the shared catalog says. A provider can be OpenAI-compatible in shape without being compatible in vocabulary, and a descriptor can now say so.&lt;/p&gt; &lt;h2 id=&quot;the-discipline-that-lets-any-of-this-be-judged&quot;&gt;The discipline that lets any of this be judged&lt;/h2&gt; &lt;p&gt;Two new surfaces in one release is when a harness starts moving underneath you, so v0.5.3’s third piece is measurement. A suite now declares &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;baseline: {file, pin}&lt;/code&gt;, and &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;eval baseline record|check&lt;/code&gt; writes and verifies a committed per-task reference. A threshold bounds a metric across a matrix; a baseline says one named scenario reproduces one exact value. &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;eval run&lt;/code&gt; runs the check inline, because a reference only a later command consults leaves the run that broke it exiting zero.&lt;/p&gt; &lt;p&gt;Recording refuses an unstable value. A pinned metric absent from a task or disagreeing across repeats is not a baseline, and recording one makes the next check fail for a reason nobody can act on. Pins stay limited to properties of the harness, so wall time, memory, and CPU are excluded. The file is sorted by task and by metric with one value per line, which makes its &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;git diff&lt;/code&gt; the behavioral changelog: a change that moves one tool’s result shape appears as that scenario’s &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;custom.digest.behavior&lt;/code&gt; line changing, and the review question becomes whether it was intended. The corpus is 261 pinned scenarios: 230 across the tool bench’s six tools and two splits, 31 across five offline model-free suites for dispatch admission, prompt layering, context budgets, memory selection, and continuity handoff.&lt;/p&gt; &lt;p&gt;Discovery got cheaper too. &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;gateway(op=&quot;find&quot;)&lt;/code&gt; and &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;describe&lt;/code&gt; answer from a recorded catalog instead of launching every trusted MCP server first; only &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;call&lt;/code&gt; and an explicit &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;refresh&lt;/code&gt; connect.&lt;/p&gt; &lt;h2 id=&quot;try-it&quot;&gt;Try it&lt;/h2&gt; &lt;p&gt;CLIO Coder is pre-1.0 and the System One surface is alpha within it. A site answers only once a credential, a target, a profile, and a binding all exist. The configure wizard does not offer a hidden runtime, so the target goes into &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;settings.yaml&lt;/code&gt; by hand.&lt;/p&gt; &lt;div class=&quot;language-yaml highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;na&quot;&gt;targets&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;pi&quot;&gt;-&lt;/span&gt; &lt;span class=&quot;na&quot;&gt;id&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;jev&lt;/span&gt; &lt;span class=&quot;na&quot;&gt;runtime&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;typesafe-jev&lt;/span&gt; &lt;span class=&quot;na&quot;&gt;defaultModel&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;jev-latest&lt;/span&gt; &lt;span class=&quot;na&quot;&gt;auth&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;na&quot;&gt;apiKeyEnvVar&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;TYPESAFE_API_KEY&lt;/span&gt; &lt;span class=&quot;na&quot;&gt;fleet&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;na&quot;&gt;profiles&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;na&quot;&gt;system-one&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;na&quot;&gt;target&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;jev&lt;/span&gt; &lt;span class=&quot;na&quot;&gt;model&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;jev-latest&lt;/span&gt; &lt;span class=&quot;na&quot;&gt;decisionProfiles&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;na&quot;&gt;routing&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;system-one&lt;/span&gt; &lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt; &lt;div class=&quot;language-bash highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;nb&quot;&gt;export &lt;/span&gt;&lt;span class=&quot;nv&quot;&gt;TYPESAFE_API_KEY&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;=&lt;/span&gt;&lt;span class=&quot;s1&quot;&gt;&apos;...&apos;&lt;/span&gt; clio-coder auth status jev clio-coder targets &lt;span class=&quot;nt&quot;&gt;--probe&lt;/span&gt; clio-coder models &lt;span class=&quot;nt&quot;&gt;--target&lt;/span&gt; jev &lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt; &lt;p&gt;A listing returning &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;jev-latest&lt;/code&gt; and &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;jev-preview&lt;/code&gt; proves the key, the URL, and the model id together. The binding itself has no verification command yet. &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;inspectDecisionSite&lt;/code&gt; answers that question and no CLI surface calls it, so what you rely on is settings validation rejecting an unknown site name and an undefined profile. A Mercury target for fill-in-the-middle is four lines.&lt;/p&gt; &lt;div class=&quot;language-yaml highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;na&quot;&gt;targets&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;pi&quot;&gt;-&lt;/span&gt; &lt;span class=&quot;na&quot;&gt;id&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;mercury&lt;/span&gt; &lt;span class=&quot;na&quot;&gt;runtime&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;inception&lt;/span&gt; &lt;span class=&quot;na&quot;&gt;auth&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;na&quot;&gt;apiKeyEnvVar&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;INCEPTION_API_KEY&lt;/span&gt; &lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt; &lt;div class=&quot;language-bash highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;clio-coder doctor clio-coder &lt;span class=&quot;nb&quot;&gt;eval &lt;/span&gt;baseline check &lt;span class=&quot;nt&quot;&gt;--suite&lt;/span&gt; evals/machinery/dispatch-admission.yaml &lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt; &lt;p&gt;The machinery suite needs no model: it runs the pinned dispatch-admission scenarios and names every value that moved, disappeared, or became unstable.&lt;/p&gt; &lt;h2 id=&quot;what-is-left-for-you&quot;&gt;What is left for you&lt;/h2&gt; &lt;p&gt;Nobody knows how a decision model’s calibration drifts as a repository’s tasks move away from the distribution it was measured on, and a site that slowly becomes overconfident degrades quietly. Nobody knows which other moments in a turn deserve a closed question: context eviction, verifier selection, and continuity checkpoint placement are candidates, each an experiment rather than a plan. A non-autoregressive runtime raises the same question from the other side, which is where in an agent loop a fast model belongs when it is not the one holding the conversation.&lt;/p&gt; &lt;p&gt;Four surfaces accept contributions without a pull request against the harness. An extension declares command tools in a &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;clio-coder-extension.yaml&lt;/code&gt; Clio validates without importing package code. A verifier turns a scientific claim into an exact argv vector with a declared tolerance, and a domain whose tolerance Clio cannot express yet is the most useful bug report here. An eval turns an opinion into a row. A provider runtime adds a model, and institutional gateways, national-laboratory endpoints, and inference servers nobody upstream has heard of are what a research group can contribute and nobody else can.&lt;/p&gt; &lt;p&gt;Five parts, one argument: a coding agent you can trust with a repository is one whose every decision you can name, bound, measure, and turn off. The rest is prose. &lt;a href=&quot;https://github.com/iowarp/clio-coder&quot;&gt;The repository&lt;/a&gt; is where a field report changes what happens next. The install path is in the &lt;a href=&quot;/journal/2026/clio-coder-on-your-own-gpu/&quot;&gt;GPU tutorial&lt;/a&gt;; the &lt;a href=&quot;/journal/2026/shipping-a-coding-agent-in-public/&quot;&gt;launch essay&lt;/a&gt; covers what “shipped” had to mean first.&lt;/p&gt; </content> </entry> <entry> <title type="html">Why CLIO Coder, part 4 of 5: bounded workers, sealed receipts</title> <link rel="alternate" type="text/html" href="https://akougkas.io/journal/2026/why-clio-coder-4-bounded-workers-sealed-receipts/"/> <id>https://akougkas.io/journal/2026/why-clio-coder-4-bounded-workers-sealed-receipts/</id> <published>2026-09-22T00:00:00-05:00</published> <updated>2026-09-22T00:00:00-05:00</updated> <summary type="html">CLIO Coder sends work to bounded worker agents that declare their read and write scope before they run, verifies the result on the host, and seals a receipt every time. Delegation you can watch and audit, tested at v0.5.2.</summary> <content type="html" xml:base="https://akougkas.io/journal/2026/why-clio-coder-4-bounded-workers-sealed-receipts/">&lt;p&gt;&lt;strong&gt;September 27, 2026:&lt;/strong&gt; Later releases changed worker authority and simplified new receipts, including removal of the receipt attestation field. Older receipts still verify. See the &lt;a href=&quot;https://coder.iowarp.ai/docs.html&quot;&gt;current product guides&lt;/a&gt; and &lt;a href=&quot;https://github.com/iowarp/clio-coder/releases&quot;&gt;release history&lt;/a&gt;.&lt;/p&gt; &lt;p&gt;A spinner is not accountability. When an agent farms work out to a second agent, the interesting question is not whether the second one finished but what it was allowed to touch, what was checked afterwards, and who can read that back a week later. &lt;a href=&quot;/work/clio-coder/&quot;&gt;CLIO Coder&lt;/a&gt;, the terminal coding agent I create and maintain inside &lt;a href=&quot;/work/clio/&quot;&gt;CLIO&lt;/a&gt;, answers all three with the same mechanism: a dispatch declares its scope before it runs, the orchestrator verifies the result itself, and every run seals a receipt. CLIO Coder v0.5.2, released September 21, 2026, is the reference here.&lt;/p&gt; &lt;h2 id=&quot;a-dispatch-declares-its-scope-before-it-runs&quot;&gt;A dispatch declares its scope before it runs&lt;/h2&gt; &lt;p&gt;Delegation in CLIO Coder is a typed call, not a paragraph of instructions. A request carries an &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;intent&lt;/code&gt; object with &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;read_roots&lt;/code&gt;, &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;write_roots&lt;/code&gt;, &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;relevant_paths&lt;/code&gt;, &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;expected_outputs&lt;/code&gt;, and a list of &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;verification&lt;/code&gt; checks. Paths are normalized into sorted, duplicate-free repository-relative POSIX entries under entry and byte caps; an absolute, escaping, or malformed entry fails before the approval step, not halfway through the work.&lt;/p&gt; &lt;p&gt;The declaration is authoritative. Five containment checks share one path grammar, where a trailing slash means a subtree and its absence means an exact file, so admission reasons about the same scope the worker will be held to. A declared write scope is the scope; a path that prose inference would have contributed but the declaration omits is reported to the operator by name rather than quietly added.&lt;/p&gt; &lt;p&gt;A &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;verification&lt;/code&gt; entry names a check id, never a command. Admission resolves it through the same declared-check projection the &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;verify&lt;/code&gt; tool reads, which is your package scripts and &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;.clio-coder/verifiers.yaml&lt;/code&gt;, so model text never becomes argv. The resolved argv, working directory, and timeout are frozen into the execution snapshot and into the plan hash the approval renders. When the worker reports success, the orchestrator runs each check itself through the code-step runner, with no shell and a closed environment allowlist, and seals the result. A rejected check turns the run into &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;host_verification_rejected&lt;/code&gt;, an outcome that suppresses automatic retry, because the tree is what failed, not the worker’s luck.&lt;/p&gt; &lt;h2 id=&quot;the-same-worker-one-ssh-hop-away&quot;&gt;The same worker, one SSH hop away&lt;/h2&gt; &lt;p&gt;A worker is a process that reads one JSON specification on stdin and writes newline-delimited events to stdout. A remote worker is that exact protocol tunneled through &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;ssh -T&lt;/code&gt;, so distance changes nothing about prompts, safety, receipts, or telemetry. Fleet nodes are declared under &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;fleet.nodes&lt;/code&gt; with a host, labels, and a per-node worker cap; the implicit &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;local&lt;/code&gt; node always exists.&lt;/p&gt; &lt;p&gt;Before its first model call, every native worker announces itself on a structured control lane and attests its protocol version, process group, host, settings fingerprint, its own computed digest of the specification it received, runtime and target ids, endpoint identity hash, wire model id, tool signature, and bounded node facts. Drift from the approved identity kills the whole process group. Placement and admission stay separate: pins restrict the eligible node set and fail closed rather than falling back, unpinned placement prefers the node with lower durable lease usage, and one cross-process lock over a shared lease file is the final capacity authority. A run records the node its worker process ran on, which is not the node serving the model.&lt;/p&gt; &lt;figure class=&quot;figure--diagram&quot;&gt; &lt;svg viewBox=&quot;0 0 640 360&quot; role=&quot;img&quot; aria-labelledby=&quot;fig-dispatch-loop&quot;&gt; &lt;title id=&quot;fig-dispatch-loop&quot;&gt;The dispatch loop: a session sends typed intent, a worker runs on a fleet node, the orchestrator runs host verification, the run seals a receipt, an evidence bundle is written to disk, and the command clio-coder evidence list reads it back.&lt;/title&gt; &lt;rect class=&quot;d-soft&quot; x=&quot;24&quot; y=&quot;36&quot; width=&quot;184&quot; height=&quot;48&quot; rx=&quot;4&quot; /&gt; &lt;text class=&quot;d-text&quot; x=&quot;116&quot; y=&quot;66&quot; text-anchor=&quot;middle&quot;&gt;session&lt;/text&gt; &lt;path class=&quot;d-line&quot; d=&quot;M212 60 H216&quot; /&gt; &lt;polygon class=&quot;d-accent-fill&quot; points=&quot;216,54 224,60 216,66&quot; /&gt; &lt;rect class=&quot;d-soft&quot; x=&quot;228&quot; y=&quot;36&quot; width=&quot;184&quot; height=&quot;48&quot; rx=&quot;4&quot; /&gt; &lt;text class=&quot;d-text&quot; x=&quot;320&quot; y=&quot;66&quot; text-anchor=&quot;middle&quot;&gt;typed intent&lt;/text&gt; &lt;path class=&quot;d-line&quot; d=&quot;M416 60 H420&quot; /&gt; &lt;polygon class=&quot;d-accent-fill&quot; points=&quot;420,54 428,60 420,66&quot; /&gt; &lt;rect class=&quot;d-box&quot; x=&quot;432&quot; y=&quot;36&quot; width=&quot;184&quot; height=&quot;48&quot; rx=&quot;4&quot; /&gt; &lt;text class=&quot;d-text&quot; x=&quot;524&quot; y=&quot;66&quot; text-anchor=&quot;middle&quot;&gt;fleet worker&lt;/text&gt; &lt;path class=&quot;d-line&quot; d=&quot;M524 88 V144&quot; /&gt; &lt;polygon class=&quot;d-accent-fill&quot; points=&quot;518,144 530,144 524,156&quot; /&gt; &lt;rect class=&quot;d-box&quot; x=&quot;432&quot; y=&quot;156&quot; width=&quot;184&quot; height=&quot;48&quot; rx=&quot;4&quot; /&gt; &lt;text class=&quot;d-text&quot; x=&quot;524&quot; y=&quot;186&quot; text-anchor=&quot;middle&quot;&gt;host checks&lt;/text&gt; &lt;path class=&quot;d-line&quot; d=&quot;M428 180 H424&quot; /&gt; &lt;polygon class=&quot;d-accent-fill&quot; points=&quot;424,174 424,186 416,180&quot; /&gt; &lt;rect class=&quot;d-box&quot; x=&quot;228&quot; y=&quot;156&quot; width=&quot;184&quot; height=&quot;48&quot; rx=&quot;4&quot; /&gt; &lt;text class=&quot;d-text&quot; x=&quot;320&quot; y=&quot;186&quot; text-anchor=&quot;middle&quot;&gt;sealed receipt&lt;/text&gt; &lt;path class=&quot;d-line&quot; d=&quot;M224 180 H220&quot; /&gt; &lt;polygon class=&quot;d-accent-fill&quot; points=&quot;220,174 220,186 212,180&quot; /&gt; &lt;rect class=&quot;d-box&quot; x=&quot;24&quot; y=&quot;156&quot; width=&quot;184&quot; height=&quot;48&quot; rx=&quot;4&quot; /&gt; &lt;text class=&quot;d-text&quot; x=&quot;116&quot; y=&quot;186&quot; text-anchor=&quot;middle&quot;&gt;evidence&lt;/text&gt; &lt;path class=&quot;d-line&quot; d=&quot;M116 208 V264&quot; /&gt; &lt;polygon class=&quot;d-accent-fill&quot; points=&quot;110,264 122,264 116,276&quot; /&gt; &lt;rect class=&quot;d-box&quot; x=&quot;24&quot; y=&quot;276&quot; width=&quot;592&quot; height=&quot;48&quot; rx=&quot;4&quot; /&gt; &lt;text class=&quot;d-text&quot; x=&quot;320&quot; y=&quot;306&quot; text-anchor=&quot;middle&quot;&gt;clio-coder evidence list&lt;/text&gt; &lt;/svg&gt; &lt;figcaption&gt;The path a dispatched run takes, from the session&apos;s typed intent through a worker on a fleet node, host verification, the sealed receipt, and the evidence bundle a later command reads back.&lt;/figcaption&gt; &lt;/figure&gt; &lt;h2 id=&quot;every-run-seals-a-receipt&quot;&gt;Every run seals a receipt&lt;/h2&gt; &lt;p&gt;The receipt is the unit of accountability. It carries one current integrity version, 20, which authenticates the complete receipt against reconstructed ledger provenance; a receipt sealed under a lower version is reported as retired, is never migrated, and is never read as evidence. Under that digest sit the node the worker ran on, failover hops, the plan hash and cost ceiling, the byte count and hash of the briefing without the briefing prose, the normalized intent, the host-verification evidence with argv, exit codes, and a bounded output tail, and the terminal outcome code.&lt;/p&gt; &lt;p&gt;When a dispatched run finalizes, an evidence bundle is compiled under the data directory and a compact row lands in a sidecar index. The bundle holds an overview, a readable transcript, raw and cleaned trace rows, tool events, linked audit rows, the receipt, gate decisions, a per-run trust projection, protected-artifact state, and findings in both machine and human form. Attribution is recorded rather than guessed: an entry stamped with a run id at write time is marked exact, and an entry falling inside more than one concurrent run’s window appears in every candidate bundle with a null run id and the candidate list, never dropped and never claimed as exact.&lt;/p&gt; &lt;p&gt;v0.4.4 closed the gap this all exists to close, which is a turn that talks its way past its own finish contract. A turn that could not verify something now records that through a &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;limitation&lt;/code&gt; tool call whose receipt has to land inside the same window as the mutation scan; the seven prose patterns that used to satisfy the gate are gone, so wording alone no longer passes it. The &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;decide&lt;/code&gt; tool records a design choice with the alternatives the model rejected, and dispatch seals every active decision reference onto the request, the envelope, and the receipt. Verifier catalogs gained two executable check kinds beside a plain command, one judging JSON numbers against a reference file under named tolerances and one judging wall time against a budget or a recorded baseline, and host verification runs and seals those judgements too.&lt;/p&gt; &lt;p&gt;None of it is worth much if only the terminal can see it. Behavioral results carry an execution envelope binding prompt fragment ids, versions, content hashes, and a composition hash to the recipe, route, tool surface, autonomy, and policy hashes, so a comparison across releases marks a row incomparable instead of averaging over a prompt that moved underneath it. Hosts speaking the Agent Client Protocol can opt into an &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;accountability.evidenceReady&lt;/code&gt; event carrying the run id, evidence id, first-pass success, finding count, and tags, once per run whose bundle and index row landed; bundle prose never crosses the wire, and a failed build sends nothing. In the terminal, &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;/tree&lt;/code&gt; walks the session tree and &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;/fork&lt;/code&gt; branches from an assistant turn, so the history a receipt is filed against stays navigable. CLIO Coder is experimental by design and pre-1.0; the receipt chain is the part I would defend hardest.&lt;/p&gt; &lt;h2 id=&quot;try-it&quot;&gt;Try it&lt;/h2&gt; &lt;p&gt;Dispatch one worker explicitly and let it come back with an answer and a receipt:&lt;/p&gt; &lt;div class=&quot;language-bash highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;clio-coder run &lt;span class=&quot;nt&quot;&gt;--agent&lt;/span&gt; coder &lt;span class=&quot;s2&quot;&gt;&quot;Find the main build, test, and lint commands.&quot;&lt;/span&gt; &lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt; &lt;p&gt;The same harness runs headless, streaming newline-delimited JSON events instead of prose:&lt;/p&gt; &lt;div class=&quot;language-bash highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;clio-coder run &lt;span class=&quot;nt&quot;&gt;--json&lt;/span&gt; &lt;span class=&quot;s2&quot;&gt;&quot;Investigate the failing parser test and report the evidence.&quot;&lt;/span&gt; &lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt; &lt;p&gt;Then read what happened, without asking the agent to characterize its own work:&lt;/p&gt; &lt;div class=&quot;language-bash highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;clio-coder trace runs &lt;span class=&quot;nt&quot;&gt;--limit&lt;/span&gt; 10 clio-coder evidence list clio-coder evidence inspect run-&amp;lt;runId&amp;gt; &lt;span class=&quot;nt&quot;&gt;--json&lt;/span&gt; &lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt; &lt;p&gt;You will see the bundle for each finished run, and inside it the sealed receipt with the node, the frozen check argv, the exit codes, and the trust projection for that run. In the interactive session the equivalent is &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;/run coder &amp;lt;task&amp;gt;&lt;/code&gt; for the dispatch and &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;/view verify &amp;lt;runId&amp;gt;&lt;/code&gt; for the receipt.&lt;/p&gt; &lt;h2 id=&quot;what-is-left-for-you&quot;&gt;What is left for you&lt;/h2&gt; &lt;p&gt;The mechanism is in place; the vocabulary of what counts as proof is not finished. Two tags in the evidence taxonomy keep me up: &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;proxy-validation&lt;/code&gt;, a check that only confirmed a file exists, and &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;no-validation&lt;/code&gt;, a run that succeeded and ran nothing. Both are honest labels for a weak result, and the interesting work is in how a project declares what a strong one would have been. The verifier catalog is where that declaration lives, and a numeric tolerance or a performance budget from your own domain is a more useful contribution than another opinion about agents. The source, the changelog, and the architecture documents behind every claim here are at &lt;a href=&quot;https://github.com/iowarp/clio-coder&quot;&gt;github.com/iowarp/clio-coder&lt;/a&gt;; the &lt;a href=&quot;/journal/2026/clio-coder-on-your-own-gpu/&quot;&gt;GPU tutorial&lt;/a&gt; has the install depth.&lt;/p&gt; </content> </entry> <entry> <title type="html">Why CLIO Coder, part 3 of 5: the agent writes its own handoff</title> <link rel="alternate" type="text/html" href="https://akougkas.io/journal/2026/why-clio-coder-3-the-agent-writes-its-own-handoff/"/> <id>https://akougkas.io/journal/2026/why-clio-coder-3-the-agent-writes-its-own-handoff/</id> <published>2026-09-22T00:00:00-05:00</published> <updated>2026-09-22T00:00:00-05:00</updated> <summary type="html">CLIO Coder v0.5.2 turns compaction into a recoverable transaction: the agent writes its own handoff note with self_compact, the reduction leaves durable checkpoints, and an interrupted transition is resumed by an explicit operator command rather than guessed at.</summary> <content type="html" xml:base="https://akougkas.io/journal/2026/why-clio-coder-3-the-agent-writes-its-own-handoff/">&lt;p&gt;A long session ends the same way in most coding agents: the window fills, something summarizes the history, and the work resumes a little dumber than it was. The summary is written by a process that was not doing the task, it is not addressed to anyone, and nothing records whether it survived. In &lt;a href=&quot;/work/clio-coder/&quot;&gt;CLIO Coder&lt;/a&gt; v0.5.2, released September 21, 2026, the agent doing the work writes the note, the reduction is a transaction with checkpoints, and an interruption in the middle of it is something an operator resolves by name.&lt;/p&gt; &lt;h2 id=&quot;compaction-as-a-transaction&quot;&gt;Compaction as a transaction&lt;/h2&gt; &lt;p&gt;The native orchestrator gets one tool for this, &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;self_compact({&quot;note_to_self&quot;: &quot;…&quot;})&lt;/code&gt;, and it must call it alone. A batch that pairs it with another tool, or asks for two compactions, is rejected before any valid sibling in that batch executes. The note is bounded at 8,192 UTF-8 bytes, must be nonblank, and is preserved exactly as written. Clio labels it assistant-authored recall, never an operator instruction, which matters because the text is about to be read back by a model that will otherwise treat anything at the top of its window as authority.&lt;/p&gt; &lt;p&gt;What the tool returns first is not a completed compaction. The first receipt means the note was prepared and flushed to the session ledger. Reduction happens after that receipt is persisted: the attempt is recorded before the summarizer is invoked, the outcome is checkpointed, and delivery intent is recorded before another foreground request is allowed. Acknowledgement is tied to a final, nonempty, successful assistant response. Intermediate tool calls, empty responses, errors, cancellation, and a generic end-of-run event do not acknowledge anything. Continuation preserves the original operator turn instead of appending a new one.&lt;/p&gt; &lt;p&gt;The whole transaction is bounded. Each handoff allows at most two reduction attempts, at most two summary stream invocations per attempt, and a fifteen-minute automatic window. A new operator recovery request can renew that window; it does not refund spent attempts or mint a replacement handoff identity. Summarizer calls, including failed ones with known usage, stay attributable to the session that made them.&lt;/p&gt; &lt;figure class=&quot;figure--diagram&quot;&gt; &lt;svg viewBox=&quot;0 0 640 360&quot; role=&quot;img&quot; aria-labelledby=&quot;fig-handoff-cycle&quot;&gt; &lt;title id=&quot;fig-handoff-cycle&quot;&gt;The handoff cycle in CLIO Coder: an operator turn is admitted against a budget of estimated input plus reserved output, the agent writes a note with self_compact, the reduction records summary and eviction checkpoints, and the handoff either delivers the continuation, which returns to the same operator turn, or pauses for explicit recovery through the context recover command.&lt;/title&gt; &lt;rect class=&quot;d-box&quot; x=&quot;190&quot; y=&quot;16&quot; width=&quot;260&quot; height=&quot;40&quot; rx=&quot;4&quot; /&gt; &lt;text class=&quot;d-text&quot; x=&quot;320&quot; y=&quot;41&quot; text-anchor=&quot;middle&quot;&gt;operator turn&lt;/text&gt; &lt;path class=&quot;d-line&quot; d=&quot;M320 56 V76&quot; /&gt; &lt;polygon class=&quot;d-accent-fill&quot; points=&quot;314,76 320,88 326,76&quot; /&gt; &lt;rect class=&quot;d-box&quot; x=&quot;190&quot; y=&quot;88&quot; width=&quot;260&quot; height=&quot;40&quot; rx=&quot;4&quot; /&gt; &lt;text class=&quot;d-text&quot; x=&quot;320&quot; y=&quot;113&quot; text-anchor=&quot;middle&quot;&gt;budget check&lt;/text&gt; &lt;path class=&quot;d-line&quot; d=&quot;M320 128 V148&quot; /&gt; &lt;polygon class=&quot;d-accent-fill&quot; points=&quot;314,148 320,160 326,148&quot; /&gt; &lt;rect class=&quot;d-box&quot; x=&quot;190&quot; y=&quot;160&quot; width=&quot;260&quot; height=&quot;40&quot; rx=&quot;4&quot; /&gt; &lt;text class=&quot;d-text&quot; x=&quot;320&quot; y=&quot;185&quot; text-anchor=&quot;middle&quot;&gt;self_compact note&lt;/text&gt; &lt;path class=&quot;d-line&quot; d=&quot;M320 200 V220&quot; /&gt; &lt;polygon class=&quot;d-accent-fill&quot; points=&quot;314,220 320,232 326,220&quot; /&gt; &lt;rect class=&quot;d-box&quot; x=&quot;190&quot; y=&quot;232&quot; width=&quot;260&quot; height=&quot;40&quot; rx=&quot;4&quot; /&gt; &lt;text class=&quot;d-text&quot; x=&quot;320&quot; y=&quot;257&quot; text-anchor=&quot;middle&quot;&gt;summary checkpoint&lt;/text&gt; &lt;path class=&quot;d-line&quot; d=&quot;M320 272 V286 H150 V288&quot; /&gt; &lt;polygon class=&quot;d-accent-fill&quot; points=&quot;144,288 150,300 156,288&quot; /&gt; &lt;path class=&quot;d-line&quot; d=&quot;M320 272 V286 H490 V288&quot; /&gt; &lt;polygon class=&quot;d-accent-fill&quot; points=&quot;484,288 490,300 496,288&quot; /&gt; &lt;rect class=&quot;d-soft&quot; x=&quot;20&quot; y=&quot;300&quot; width=&quot;260&quot; height=&quot;44&quot; rx=&quot;4&quot; /&gt; &lt;text class=&quot;d-text&quot; x=&quot;150&quot; y=&quot;327&quot; text-anchor=&quot;middle&quot;&gt;continuation&lt;/text&gt; &lt;rect class=&quot;d-soft&quot; x=&quot;360&quot; y=&quot;300&quot; width=&quot;260&quot; height=&quot;44&quot; rx=&quot;4&quot; /&gt; &lt;text class=&quot;d-text&quot; x=&quot;490&quot; y=&quot;327&quot; text-anchor=&quot;middle&quot;&gt;/context recover&lt;/text&gt; &lt;path class=&quot;d-accent&quot; d=&quot;M20 322 H12 V36 H178&quot; /&gt; &lt;polygon class=&quot;d-cyan-fill&quot; points=&quot;178,30 190,36 178,42&quot; /&gt; &lt;/svg&gt; &lt;figcaption&gt;The handoff cycle: an admitted turn, a note the agent writes for itself, a checkpointed reduction, and either a delivered continuation of the same turn or a paused handoff awaiting an operator command.&lt;/figcaption&gt; &lt;/figure&gt; &lt;h2 id=&quot;recovery-is-a-command-not-a-guess&quot;&gt;Recovery is a command, not a guess&lt;/h2&gt; &lt;p&gt;A process that restarts in the middle of a reduction records the interrupted state as paused. It does not repeat an uncertain delivery. The &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;/context&lt;/code&gt; overlay shows the pending handoff identifier and its phase, and the operator resolves it with the exact identifier:&lt;/p&gt; &lt;div class=&quot;language-bash highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;/context recover &amp;lt;handoffId&amp;gt; reduce /context recover &amp;lt;handoffId&amp;gt; deliver &lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt; &lt;p&gt;&lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;reduce&lt;/code&gt; is available when the handoff has not committed and an attempt remains; &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;deliver&lt;/code&gt; is available when a validated commit exists. Authority to do either comes from the operator command and its durable control record, and it is bound to the branch that owns the handoff. It never comes from a tool argument or from text found inside a note, which closes the obvious path by which a model could write itself permission to resume. Missing or conflicting storage evidence prevents recovery rather than starting a fresh transaction under a new identity; a missing commit is reconstructed only from a validated summary carry, under its original reserved identity and an exact storage check.&lt;/p&gt; &lt;p&gt;Session format v5 keeps continuity records through replay, forks, export, and later summaries. A fork inherits the note as recall and does not inherit permission to resume the parent’s handoff. Ordinary summaries live in the session ledger and replay after &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;/resume&lt;/code&gt;, so the continuity is a property of the recorded session rather than of a process that happened to stay alive.&lt;/p&gt; &lt;h2 id=&quot;the-budget-both-sides-can-read&quot;&gt;The budget both sides can read&lt;/h2&gt; &lt;p&gt;None of this works if the window is a surprise. Admission requires estimated input plus the resolved output reservation to fit the effective window, and it is checked at submission, at settled tool continuation, and again at the final provider boundary after steering has been drained. Pending user-message framing and images are priced. Disabling automatic compaction is a preference about routine pressure; it cannot authorize an oversized request. The operator reads the same accounting in &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;/context&lt;/code&gt; that the model reads through &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;context(scope=&quot;budget&quot;)&lt;/code&gt;, which removes the usual asymmetry where the agent negotiates against a limit only the harness can see.&lt;/p&gt; &lt;p&gt;Durable memory is frozen the same way. Approved selection is fixed for a prepared turn and its continuations, and a change in session, repository, runtime, model, or memory configuration invalidates that authority. Selection uses bounded content hashes, so a same-size rewrite of a record cannot hide behind a file-size cache key. The defaults stay five records and 400 estimated tokens, and lexical relevance ranking remains experimental and off. The roadmap names the reason these are separate mechanisms at all: three memory lifetimes, the active working set, session continuity, and reviewed durable lessons, each with explicit provenance and scope. CLIO Coder is experimental and pre-1.0, and token counts remain estimates unless a provider has attested the relevant prefix. This is the same argument I made about &lt;a href=&quot;/journal/2026/agent-memory-is-a-storage-problem/&quot;&gt;agent memory as a storage problem&lt;/a&gt;: lifetime and provenance are properties of the store, not of the prompt.&lt;/p&gt; &lt;h2 id=&quot;try-it&quot;&gt;Try it&lt;/h2&gt; &lt;p&gt;Install and start a session, then work until the window is under real pressure.&lt;/p&gt; &lt;div class=&quot;language-bash highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;npm &lt;span class=&quot;nb&quot;&gt;install&lt;/span&gt; &lt;span class=&quot;nt&quot;&gt;-g&lt;/span&gt; @iowarp/clio-coder clio-coder configure clio-coder &lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt; &lt;p&gt;Open the context ledger before and after a reduction. With no arguments it shows the window, the working-set policy, evicted items and tokens, and any pending handoff with its phase.&lt;/p&gt; &lt;div class=&quot;language-bash highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;/context /context compact &lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt; &lt;p&gt;If a reduction is interrupted, the overlay names the handoff. Use the identifier it prints:&lt;/p&gt; &lt;div class=&quot;language-bash highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;/context recover &amp;lt;handoffId&amp;gt; deliver &lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt; &lt;p&gt;You will see the note the agent wrote to itself replayed as assistant-authored recall, and the original task continue without a second operator turn.&lt;/p&gt; &lt;h2 id=&quot;what-is-left-for-you&quot;&gt;What is left for you&lt;/h2&gt; &lt;p&gt;The open question is which reductions are worth what they cost. The roadmap is explicit that threshold changes and wider memory automation still depend on comparative evaluation across task completion, context cost, cache effects, and recovery latency together, and that evaluation is easier to do with sessions that are not mine. Long-running work on an unfamiliar repository, a slow local model, a provider that rate-limits mid-reduction: each of those stresses a different part of the transaction. Session ledgers and evidence bundles record enough to argue about, and issues at &lt;a href=&quot;https://github.com/iowarp/clio-coder&quot;&gt;github.com/iowarp/clio-coder&lt;/a&gt; are where that argument belongs. The &lt;a href=&quot;/journal/2026/shipping-a-coding-agent-in-public/&quot;&gt;launch essay&lt;/a&gt; covers what “public” currently means for this project, and the &lt;a href=&quot;/journal/2026/clio-coder-on-your-own-gpu/&quot;&gt;GPU tutorial&lt;/a&gt; covers install depth.&lt;/p&gt; </content> </entry> <entry> <title type="html">Shipping a coding agent in public</title> <link rel="alternate" type="text/html" href="https://akougkas.io/journal/2026/shipping-a-coding-agent-in-public/"/> <id>https://akougkas.io/journal/2026/shipping-a-coding-agent-in-public/</id> <published>2026-09-22T00:00:00-05:00</published> <updated>2026-09-22T00:00:00-05:00</updated> <summary type="html">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.</summary> <content type="html" xml:base="https://akougkas.io/journal/2026/shipping-a-coding-agent-in-public/">&lt;p&gt;In August I wrote down what &lt;a href=&quot;/journal/2026/when-is-research-software-shipped/&quot;&gt;shipped&lt;/a&gt; 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 &lt;a href=&quot;/work/clio-coder/&quot;&gt;CLIO Coder&lt;/a&gt;, the terminal coding agent I create and maintain inside &lt;a href=&quot;/work/clio/&quot;&gt;CLIO&lt;/a&gt;, reached v0.5.0 on September 20, 2026 and I had to decide whether the word “public” was earned.&lt;/p&gt; &lt;p&gt;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.&lt;/p&gt; &lt;h2 id=&quot;what-changed-at-the-launch-boundary&quot;&gt;What changed at the launch boundary&lt;/h2&gt; &lt;p&gt;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.&lt;/p&gt; &lt;p&gt;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.&lt;/p&gt; &lt;h2 id=&quot;the-browser-app-is-subordinate-and-says-so&quot;&gt;The browser app is subordinate, and says so&lt;/h2&gt; &lt;p&gt;The same release bundled a local graphical application. &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;clio-coder gui&lt;/code&gt; 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.&lt;/p&gt; &lt;p&gt;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.&lt;/p&gt; &lt;h2 id=&quot;plans-and-shipped-behavior-live-in-separate-files&quot;&gt;Plans and shipped behavior live in separate files&lt;/h2&gt; &lt;p&gt;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.”&lt;/p&gt; &lt;p&gt;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.&lt;/p&gt; &lt;p&gt;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 &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;/context recover &amp;lt;handoffId&amp;gt;&lt;/code&gt;, 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 &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;/context&lt;/code&gt;. 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.&lt;/p&gt; &lt;h2 id=&quot;what-is-still-not-true&quot;&gt;What is still not true&lt;/h2&gt; &lt;p&gt;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.&lt;/p&gt; &lt;p&gt;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.&lt;/p&gt; &lt;p&gt;If you want to try it, you need Node.js 22.19 or newer and a model service, local or remote:&lt;/p&gt; &lt;div class=&quot;language-bash highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;npm &lt;span class=&quot;nb&quot;&gt;install&lt;/span&gt; &lt;span class=&quot;nt&quot;&gt;-g&lt;/span&gt; @iowarp/clio-coder &lt;span class=&quot;nb&quot;&gt;cd&lt;/span&gt; /path/to/your/project clio-coder configure clio-coder &lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt; &lt;p&gt;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 &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;clio-coder evidence list&lt;/code&gt; 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.&lt;/p&gt; </content> </entry> <entry> <title type="html">Why CLIO Coder, part 2 of 5: typed tools, never a raw shell</title> <link rel="alternate" type="text/html" href="https://akougkas.io/journal/2026/why-clio-coder-2-typed-tools-never-a-raw-shell/"/> <id>https://akougkas.io/journal/2026/why-clio-coder-2-typed-tools-never-a-raw-shell/</id> <published>2026-09-21T00:00:00-05:00</published> <updated>2026-09-21T00:00:00-05:00</updated> <summary type="html">CLIO Coder hands the model a catalog of typed tools with declared action classes instead of a shell prompt. Bounded reads, an enforced autonomy dial, per-workspace consent, and, since v0.5.1, a quota reading you can see before a provider refuses you.</summary> <content type="html" xml:base="https://akougkas.io/journal/2026/why-clio-coder-2-typed-tools-never-a-raw-shell/">&lt;p&gt;An agent that can type anything into a shell is an agent you have to watch. &lt;a href=&quot;/work/clio-coder/&quot;&gt;CLIO Coder&lt;/a&gt;, the terminal coding agent I create and maintain inside &lt;a href=&quot;/work/clio/&quot;&gt;CLIO&lt;/a&gt;, gives the model a catalog of 30 typed tools instead, each carrying an action class that &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;src/tools/policy.ts&lt;/code&gt; asserts at bootstrap so the classifier and the registered schemas cannot drift apart. A shell is in that catalog. It is the most heavily governed entry in it.&lt;/p&gt; &lt;h2 id=&quot;the-catalog-is-the-surface&quot;&gt;The catalog is the surface&lt;/h2&gt; &lt;p&gt;The 30 tools sit in eight planes. OBSERVE holds &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;read&lt;/code&gt;, &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;grep&lt;/code&gt;, &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;find&lt;/code&gt;, &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;ls&lt;/code&gt;, &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;code_nav&lt;/code&gt;, and the rest of the inspection set, all read class. MUTATE holds &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;write&lt;/code&gt; and &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;edit&lt;/code&gt;. EXECUTE holds &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;bash&lt;/code&gt;, &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;verify&lt;/code&gt;, and &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;run_script&lt;/code&gt;, plus &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;git&lt;/code&gt;, which carries the read class because its operations are fixed command vectors on the safe-exec spine. A tool that a target’s capabilities hide is never shown to the model; a tool that is shown still passes every gate below before it runs.&lt;/p&gt; &lt;p&gt;A typed tool means a contract you can read before you run it. Take &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;read&lt;/code&gt;. Each call is capped at 2000 lines or &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;safety.limits.readBytesPerCall&lt;/code&gt;, whichever hits first, and the per-turn observation budget can shrink that further. Text files of any size are read through bounded windows, so size is a paging problem rather than a refusal. Exact line counting stops at a 32 MiB file-size budget and larger files report an unknown total as &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;N+&lt;/code&gt;. Images keep a separate 20 MB ceiling. NUL bytes and invalid UTF-8 in the inspected bytes are refused with zero-based byte offsets rather than decoded into plausible-looking garbage, and a truncated result carries &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;next: offset=&amp;lt;first unshown line&amp;gt;&lt;/code&gt; so the model continues from a stated position instead of guessing one. Those bounds shipped in v0.4.9 on September 17, 2026, and the documentation states the matching limit: a bounded read does not validate the regions it did not read.&lt;/p&gt; &lt;p&gt;&lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;bash&lt;/code&gt; is where the difference is sharpest. Commands spawn as &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;/bin/bash -o pipefail -c&lt;/code&gt;, so a failure upstream of a filter such as &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;tail&lt;/code&gt; survives into the result and a verification receipt cannot report success because the filter succeeded; a caller that wants the old behavior writes &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;set +o pipefail&lt;/code&gt; and says so. The policy engine then tags the command recognized or unrecognized. Recognized covers a narrow built-in set (&lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;pwd&lt;/code&gt;, simple &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;ls&lt;/code&gt;, &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;git status&lt;/code&gt;, bounded &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;git diff&lt;/code&gt; and &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;git log&lt;/code&gt;, the repository test runners) plus whatever a reviewed project policy declares. Everything else parks at the default &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;auto-edit&lt;/code&gt; level for one operator decision. Command substitution is a confirm rail at every level, &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;full-auto&lt;/code&gt; included, because the net cannot scan what it will execute until runtime.&lt;/p&gt; &lt;h2 id=&quot;two-axes-and-neither-is-a-warning&quot;&gt;Two axes, and neither is a warning&lt;/h2&gt; &lt;p&gt;Permission in Clio is a dial and a net, and they are independent. The &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;safety.autonomy&lt;/code&gt; dial takes &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;read-only&lt;/code&gt;, &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;suggest&lt;/code&gt;, &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;auto-edit&lt;/code&gt;, or &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;full-auto&lt;/code&gt;, and it decides one thing: which action classes run immediately, which park for approval, and which are denied outright. The safety net is the damage-control rule packs, path policy, protected artifacts, the loop guard, and dispatch scope admission. It is identical at every level. A net &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;block&lt;/code&gt; is final and is never downgraded, so zero-access paths such as &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;.git/config&lt;/code&gt; and &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;credentials.yaml&lt;/code&gt; stay blocked at &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;full-auto&lt;/code&gt;, and a malformed project policy cannot disable the built-in path protection.&lt;/p&gt; &lt;p&gt;Operator approval is one-shot by construction. Approving a command or a write authorizes that single presented call, keyed to its request id; it does not loosen the level, and it cannot promote anything the net blocked. Project configuration is consented to rather than trusted by proximity: since v0.4.5 on September 7, 2026, project safety, hooks, and settings are ignored until an operator reviews them with &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;clio-coder config trust safety|hooks|settings&lt;/code&gt;, which prints the exact source bytes and a full SHA-256 digest, and approves that digest with &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;--hash&lt;/code&gt;. Consent binds one canonical workspace and one surface, so approving a repository’s safety policy never quietly extends to its hooks or to another checkout. &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;--revoke&lt;/code&gt; withdraws it.&lt;/p&gt; &lt;p&gt;Repetition is handled without weakening any of that. v0.5.0 scoped worker approval reuse to the same run, the exact arguments, the approval axis, the action class, and the policy identity. An identical call under identical conditions reuses the operator’s prior decision; a changed argument or a different asking rail earns a fresh card. Worker approvals are human-only by construction, because a model approving its own fleet’s asks would collapse the audit trail the receipts exist to carry.&lt;/p&gt; &lt;p&gt;The honest limit belongs in the same paragraph as the claim. These policies classify and admit tool calls. They are not an OS sandbox, and child tools run with the host user’s filesystem and process access, so untrusted execution still belongs in a separate account, container, or machine.&lt;/p&gt; &lt;figure class=&quot;figure--diagram&quot;&gt; &lt;svg viewBox=&quot;0 0 640 360&quot; role=&quot;img&quot; aria-labelledby=&quot;fig-typed-tool-path&quot;&gt; &lt;title id=&quot;fig-typed-tool-path&quot;&gt;A tool request passes through seven stages in order: the model asks for a tool, the request becomes a typed call with a fixed schema, the safety net returns a verdict, the autonomy mapping allows or parks or denies it, an operator consent decision resolves anything parked, execution runs under declared bounds, and a receipt with an audit row records what happened.&lt;/title&gt; &lt;rect class=&quot;d-soft&quot; x=&quot;140&quot; y=&quot;10&quot; width=&quot;360&quot; height=&quot;36&quot; rx=&quot;4&quot; /&gt; &lt;text class=&quot;d-text&quot; x=&quot;320&quot; y=&quot;34&quot; text-anchor=&quot;middle&quot;&gt;model asks for a tool&lt;/text&gt; &lt;path class=&quot;d-line&quot; d=&quot;M320 46 V56&quot; /&gt; &lt;polygon class=&quot;d-accent-fill&quot; points=&quot;314,56 326,56 320,66&quot; /&gt; &lt;rect class=&quot;d-box&quot; x=&quot;140&quot; y=&quot;58&quot; width=&quot;360&quot; height=&quot;36&quot; rx=&quot;4&quot; /&gt; &lt;text class=&quot;d-text&quot; x=&quot;320&quot; y=&quot;82&quot; text-anchor=&quot;middle&quot;&gt;typed call, fixed schema&lt;/text&gt; &lt;path class=&quot;d-line&quot; d=&quot;M320 94 V104&quot; /&gt; &lt;polygon class=&quot;d-accent-fill&quot; points=&quot;314,104 326,104 320,114&quot; /&gt; &lt;rect class=&quot;d-box&quot; x=&quot;140&quot; y=&quot;106&quot; width=&quot;360&quot; height=&quot;36&quot; rx=&quot;4&quot; /&gt; &lt;text class=&quot;d-text&quot; x=&quot;320&quot; y=&quot;130&quot; text-anchor=&quot;middle&quot;&gt;safety net verdict&lt;/text&gt; &lt;path class=&quot;d-line&quot; d=&quot;M320 142 V152&quot; /&gt; &lt;polygon class=&quot;d-accent-fill&quot; points=&quot;314,152 326,152 320,162&quot; /&gt; &lt;rect class=&quot;d-box&quot; x=&quot;140&quot; y=&quot;154&quot; width=&quot;360&quot; height=&quot;36&quot; rx=&quot;4&quot; /&gt; &lt;text class=&quot;d-text&quot; x=&quot;320&quot; y=&quot;178&quot; text-anchor=&quot;middle&quot;&gt;autonomy mapping&lt;/text&gt; &lt;path class=&quot;d-line&quot; d=&quot;M320 190 V200&quot; /&gt; &lt;polygon class=&quot;d-accent-fill&quot; points=&quot;314,200 326,200 320,210&quot; /&gt; &lt;rect class=&quot;d-box&quot; x=&quot;140&quot; y=&quot;202&quot; width=&quot;360&quot; height=&quot;36&quot; rx=&quot;4&quot; /&gt; &lt;text class=&quot;d-text&quot; x=&quot;320&quot; y=&quot;226&quot; text-anchor=&quot;middle&quot;&gt;operator consent&lt;/text&gt; &lt;path class=&quot;d-line&quot; d=&quot;M320 238 V248&quot; /&gt; &lt;polygon class=&quot;d-accent-fill&quot; points=&quot;314,248 326,248 320,258&quot; /&gt; &lt;rect class=&quot;d-box&quot; x=&quot;140&quot; y=&quot;250&quot; width=&quot;360&quot; height=&quot;36&quot; rx=&quot;4&quot; /&gt; &lt;text class=&quot;d-text&quot; x=&quot;320&quot; y=&quot;274&quot; text-anchor=&quot;middle&quot;&gt;bounded execution&lt;/text&gt; &lt;path class=&quot;d-accent&quot; d=&quot;M320 286 V296&quot; /&gt; &lt;polygon class=&quot;d-accent-fill&quot; points=&quot;314,296 326,296 320,306&quot; /&gt; &lt;rect class=&quot;d-soft&quot; x=&quot;140&quot; y=&quot;298&quot; width=&quot;360&quot; height=&quot;36&quot; rx=&quot;4&quot; /&gt; &lt;text class=&quot;d-text&quot; x=&quot;320&quot; y=&quot;322&quot; text-anchor=&quot;middle&quot;&gt;receipt and audit row&lt;/text&gt; &lt;/svg&gt; &lt;figcaption&gt;The path a tool request takes from model intent to a recorded receipt, with the safety net, the autonomy mapping, and operator consent in the order they evaluate.&lt;/figcaption&gt; &lt;/figure&gt; &lt;h2 id=&quot;knowing-the-budget-before-it-refuses-you&quot;&gt;Knowing the budget before it refuses you&lt;/h2&gt; &lt;p&gt;The same stance applies to the quota that ends a session early. v0.5.1, on September 21, 2026, added adapters that read the stored credentials of Claude Code, &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;anthropic-max&lt;/code&gt;, the Codex CLI, and Antigravity and normalize every reported window into one model of consumed percentage, so one provider’s percentages and another’s remaining fractions are never read interchangeably. The reads are strictly read-only: no token refresh, no credential write, no sign-in flow. Readings cache for about five minutes and refresh lazily when a surface that shows them renders, never on a background timer, and a failed refresh keeps the last good reading and marks it stale instead of blanking the account. Two credentials on one Anthropic subscription fold into a single account so the apparent budget is not doubled.&lt;/p&gt; &lt;p&gt;&lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;/usage&lt;/code&gt; replaces &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;/cost&lt;/code&gt;, with no alias. It keeps the session token and cost accounting and adds four views: Accounts for the subscription and credit meters with reset countdowns in an explicit time zone, Session for the token, cost, cache, reasoning, and background-call breakdown, Models for each model’s share of recorded processed tokens, and Workers for tokens, cost, and context per run beside the shared account limit. Every percentage carries a direction in its own label, so a weekly window at 9% used and a footer badge reading &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;weekly 91% left&lt;/code&gt; are the same number. Worker quota is presented as shared account headroom rather than a measured per-worker share, because per-target token attribution does not exist yet.&lt;/p&gt; &lt;p&gt;A tool whose contract you can read is a tool you can trust with one GPU and a twenty-minute build. That is the whole argument for typing the surface instead of opening a shell.&lt;/p&gt; &lt;h2 id=&quot;try-it&quot;&gt;Try it&lt;/h2&gt; &lt;p&gt;Install the agent and check the installation:&lt;/p&gt; &lt;div class=&quot;language-bash highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;npm &lt;span class=&quot;nb&quot;&gt;install&lt;/span&gt; &lt;span class=&quot;nt&quot;&gt;-g&lt;/span&gt; @iowarp/clio-coder clio-coder doctor &lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt; &lt;p&gt;Review a repository’s project safety policy before anything in it can apply, then approve the exact digest the review prints:&lt;/p&gt; &lt;div class=&quot;language-bash highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;clio-coder config trust safety clio-coder config inspect &lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt; &lt;p&gt;Watch a bounded read and a refusal in the same posture, where every mutating call is denied by the dial rather than by a prompt:&lt;/p&gt; &lt;div class=&quot;language-bash highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;clio-coder run &lt;span class=&quot;nt&quot;&gt;--autonomy&lt;/span&gt; read-only &lt;span class=&quot;s2&quot;&gt;&quot;Read the first 40 lines of package.json, then read .git/index and report exactly what the read tool returned.&quot;&lt;/span&gt; &lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt; &lt;p&gt;The text file comes back as a bounded window with a continuation offset; the binary comes back as a refusal naming a zero-based byte offset, not as decoded text. Inside an interactive session, &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;/settings&lt;/code&gt; opens the Permissions &amp;amp; Limits section that owns the autonomy dial, and &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;/usage&lt;/code&gt; opens the four views above. &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;clio-coder usage report&lt;/code&gt; is the cross-session command and is unaffected by the overlay.&lt;/p&gt; &lt;h2 id=&quot;what-is-left-for-you&quot;&gt;What is left for you&lt;/h2&gt; &lt;p&gt;The part of this model that is still open is the boundary the documentation admits: admission is not isolation, and detect-and-rollback on write boundaries is not a read-only mount. CLIO Coder is experimental by design and pre-1.0, and closing that gap honestly means OS-level isolation with receipts that say which guarantee actually held for a given run, per platform, without overclaiming on any of them. On a cluster, where the host user’s access is a far larger blast radius than on a laptop, the design of that boundary is worth arguing about in the open. The tool catalog, the policy engine, and the safety documentation are all at &lt;a href=&quot;https://github.com/iowarp/clio-coder&quot;&gt;github.com/iowarp/clio-coder&lt;/a&gt;, and the install path for your own hardware is in the &lt;a href=&quot;/journal/2026/clio-coder-on-your-own-gpu/&quot;&gt;GPU tutorial&lt;/a&gt;.&lt;/p&gt; </content> </entry> <entry> <title type="html">Why CLIO Coder, part 1 of 5: your models, your machines</title> <link rel="alternate" type="text/html" href="https://akougkas.io/journal/2026/why-clio-coder-1-your-models-your-machines/"/> <id>https://akougkas.io/journal/2026/why-clio-coder-1-your-models-your-machines/</id> <published>2026-09-20T00:00:00-05:00</published> <updated>2026-09-20T00:00:00-05:00</updated> <summary type="html">CLIO Coder resolves every turn through a target you configured: a local server, an institutional gateway, a cloud API, or a subscription sign-in. With no target there is no session, because the harness has no hosted model of its own to fall back on.</summary> <content type="html" xml:base="https://akougkas.io/journal/2026/why-clio-coder-1-your-models-your-machines/">&lt;p&gt;Most coding agents answer the question of where your code goes before you have asked it. &lt;a href=&quot;/work/clio-coder/&quot;&gt;CLIO Coder&lt;/a&gt;, the terminal coding agent I create and maintain inside &lt;a href=&quot;/work/clio/&quot;&gt;CLIO&lt;/a&gt;, answers it the other way: every turn resolves through a model service you named, and there is no hosted model underneath it waiting to take over. With nothing configured the resolver returns &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;no targets configured; add one with clio-coder configure or clio-coder targets add&lt;/code&gt; and the session does not start.&lt;/p&gt; &lt;p&gt;That refusal is the design, not a rough edge. A scientist with code under an export restriction, a lab with a gateway allocation, and an engineer with one GPU under the desk all need the same guarantee, and a silent failover to somebody’s API would void it for all three.&lt;/p&gt; &lt;h2 id=&quot;one-harness-many-runtimes&quot;&gt;One harness, many runtimes&lt;/h2&gt; &lt;p&gt;A saved model service is a &lt;strong&gt;target&lt;/strong&gt;: a runtime id, an endpoint, a model id, and whatever credentials the endpoint wants. Chat, workers, and optional model-assisted memory each resolve through a target, and they need not resolve through the same one. Configuration is target-first, which means the harness has no provider-specific flags that route around &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;settings.yaml&lt;/code&gt;.&lt;/p&gt; &lt;p&gt;Four families of target ship in the tree. On your own workstation or server, the local runtimes cover llama.cpp, Ollama, LM Studio, vLLM, SGLang, and Lemonade. Through a gateway or a compatible API, LiteLLM and the generic OpenAI-compatible and Anthropic-compatible runtimes reach anything speaking those two protocols. As cloud APIs, OpenAI, Anthropic, Google, OpenRouter, Groq, Mistral, DeepSeek, and Amazon Bedrock each have a descriptor. By subscription sign-in, a ChatGPT plan connects through &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;openai-codex&lt;/code&gt; and a Claude plan through &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;anthropic-max&lt;/code&gt;, so an account you already pay for is a route rather than a second bill.&lt;/p&gt; &lt;p&gt;Institutional inference, reached through the gateway family, is the reason the list is not just a compatibility table. &lt;a href=&quot;https://www.anl.gov/&quot;&gt;Argonne&lt;/a&gt;’s &lt;a href=&quot;https://www.alcf.anl.gov/&quot;&gt;ALCF&lt;/a&gt; inference gateway is an OpenAI-compatible target backed by Globus OAuth, with &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;clio-coder auth login alcf&lt;/code&gt; opening an authorize URL and asking you to paste the displayed code back. That flow was chosen because it survives SSH: a researcher on a login node with no browser can still authenticate. Sophia and Metis are configured as separate cluster targets, and Clio sends the configured wire model id literally rather than rewriting it, because a gateway’s model names belong to the gateway.&lt;/p&gt; &lt;figure class=&quot;figure--diagram&quot;&gt; &lt;svg viewBox=&quot;0 0 640 360&quot; role=&quot;img&quot; aria-labelledby=&quot;fig-provider-fanin&quot;&gt; &lt;title id=&quot;fig-provider-fanin&quot;&gt;Four families of model service feed one saved target: local servers such as llama.cpp, Ollama and vLLM; the ALCF inference gateway reached through Globus; cloud APIs such as OpenAI, Anthropic and Groq; and a Claude or ChatGPT subscription plan. The target resolves into one Clio harness, which produces one receipt.&lt;/title&gt; &lt;rect class=&quot;d-soft&quot; x=&quot;24&quot; y=&quot;8&quot; width=&quot;260&quot; height=&quot;44&quot; rx=&quot;4&quot; /&gt; &lt;text class=&quot;d-text&quot; x=&quot;154&quot; y=&quot;37&quot; text-anchor=&quot;middle&quot;&gt;local servers&lt;/text&gt; &lt;path class=&quot;d-line&quot; d=&quot;M288 30 H310&quot; /&gt; &lt;polygon class=&quot;d-accent-fill&quot; points=&quot;310,24 322,30 310,36&quot; /&gt; &lt;rect class=&quot;d-soft&quot; x=&quot;24&quot; y=&quot;58&quot; width=&quot;260&quot; height=&quot;44&quot; rx=&quot;4&quot; /&gt; &lt;text class=&quot;d-text&quot; x=&quot;154&quot; y=&quot;87&quot; text-anchor=&quot;middle&quot;&gt;ALCF gateway&lt;/text&gt; &lt;path class=&quot;d-line&quot; d=&quot;M288 80 H310&quot; /&gt; &lt;polygon class=&quot;d-accent-fill&quot; points=&quot;310,74 322,80 310,86&quot; /&gt; &lt;rect class=&quot;d-soft&quot; x=&quot;24&quot; y=&quot;108&quot; width=&quot;260&quot; height=&quot;44&quot; rx=&quot;4&quot; /&gt; &lt;text class=&quot;d-text&quot; x=&quot;154&quot; y=&quot;137&quot; text-anchor=&quot;middle&quot;&gt;cloud APIs&lt;/text&gt; &lt;path class=&quot;d-line&quot; d=&quot;M288 130 H310&quot; /&gt; &lt;polygon class=&quot;d-accent-fill&quot; points=&quot;310,124 322,130 310,136&quot; /&gt; &lt;rect class=&quot;d-soft&quot; x=&quot;24&quot; y=&quot;158&quot; width=&quot;260&quot; height=&quot;44&quot; rx=&quot;4&quot; /&gt; &lt;text class=&quot;d-text&quot; x=&quot;154&quot; y=&quot;187&quot; text-anchor=&quot;middle&quot;&gt;subscription plan&lt;/text&gt; &lt;path class=&quot;d-line&quot; d=&quot;M288 180 H310&quot; /&gt; &lt;polygon class=&quot;d-accent-fill&quot; points=&quot;310,174 322,180 310,186&quot; /&gt; &lt;rect class=&quot;d-box&quot; x=&quot;328&quot; y=&quot;8&quot; width=&quot;288&quot; height=&quot;194&quot; rx=&quot;4&quot; /&gt; &lt;text class=&quot;d-text&quot; x=&quot;472&quot; y=&quot;112&quot; text-anchor=&quot;middle&quot;&gt;saved target&lt;/text&gt; &lt;path class=&quot;d-accent&quot; d=&quot;M472 202 V226&quot; /&gt; &lt;rect class=&quot;d-box&quot; x=&quot;200&quot; y=&quot;230&quot; width=&quot;416&quot; height=&quot;44&quot; rx=&quot;4&quot; /&gt; &lt;text class=&quot;d-text&quot; x=&quot;408&quot; y=&quot;259&quot; text-anchor=&quot;middle&quot;&gt;one Clio harness&lt;/text&gt; &lt;path class=&quot;d-accent&quot; d=&quot;M408 274 V298&quot; /&gt; &lt;rect class=&quot;d-box&quot; x=&quot;200&quot; y=&quot;302&quot; width=&quot;416&quot; height=&quot;44&quot; rx=&quot;4&quot; /&gt; &lt;text class=&quot;d-text&quot; x=&quot;408&quot; y=&quot;331&quot; text-anchor=&quot;middle&quot;&gt;one receipt&lt;/text&gt; &lt;/svg&gt; &lt;figcaption&gt;Four families of model service feeding one saved target, which resolves into one harness and one receipt.&lt;/figcaption&gt; &lt;/figure&gt; &lt;h2 id=&quot;why-a-small-model-is-worth-pointing-at&quot;&gt;Why a small model is worth pointing at&lt;/h2&gt; &lt;p&gt;Choice of model is worth little if only a frontier model can drive the agent. Three properties of the harness are what let a model small enough to fit on a single workstation GPU do useful work, and each gets a part of this series to itself.&lt;/p&gt; &lt;p&gt;The agent never receives a raw shell as its general-purpose escape hatch. Tools are typed, and a turn’s constraints are shared between admission and prompt guidance so that ordinary English is not treated as an authorization parser. A weaker model produces malformed calls more often, and a typed boundary turns those into rejections instead of damage. Part 2 takes that apart.&lt;/p&gt; &lt;p&gt;Context is accounted for rather than hoped about. Since v0.5.2, input plus reserved output is enforced at submission, at settled tool continuation, and at the final provider boundary, and the live budget is inspectable through &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;/context&lt;/code&gt;. When a handoff is needed the agent writes its own note, preserved exactly as it authored it. Part 3 follows that mechanism.&lt;/p&gt; &lt;p&gt;Every run seals a receipt. Tool activity, usage, traces, decisions, evidence, and worker results are recorded, which is what converts a cheap second opinion from a claim into a lead you can check. Part 4 covers bounded workers and what their receipts do and do not establish.&lt;/p&gt; &lt;p&gt;None of that makes a small model correct. It bounds what a wrong answer can cost and leaves a record of what was attempted, which is a different and more achievable promise.&lt;/p&gt; &lt;h2 id=&quot;what-v050-put-in-public&quot;&gt;What v0.5.0 put in public&lt;/h2&gt; &lt;p&gt;CLIO Coder reached v0.5.0 on September 20, 2026, and I wrote separately about &lt;a href=&quot;/journal/2026/shipping-a-coding-agent-in-public/&quot;&gt;what made “public” the right word&lt;/a&gt;. For the provider layer the launch changed two things a newcomer meets first. The README was rewritten for a first-time reader and reviewed against the implementation, so the commands on the front page describe the build that ships. And &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;clio-coder configure&lt;/code&gt; opens a launcher whose &lt;strong&gt;Quick Connect&lt;/strong&gt; path takes an endpoint, credentials if the endpoint needs them, and a model selection, then shows you the connection before saving it. LM Studio commonly listens at &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;localhost:1234&lt;/code&gt; and Ollama at &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;localhost:11434&lt;/code&gt;; subscription sign-in lives under Settings → Connections.&lt;/p&gt; &lt;p&gt;The same release bundled a local browser application. &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;clio-coder gui&lt;/code&gt; starts a server bound to 127.0.0.1 and prints a private launch link, and &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;clio-coder docs&lt;/code&gt; opens the shipped documentation inside it and returns control to the terminal. Both read the same configuration, sessions, traces, and evidence as the command line. The documentation ships with the package, so asking Clio how to use Clio consults the version you are running instead of a guess. The launch notes call the terminal the primary coding interface and the wider application an early preview, and the GUI reference calls it a companion to the terminal agent. Clio is pre-1.0 and experimental by design; interfaces can move between minor versions.&lt;/p&gt; &lt;p&gt;The provider layer has kept moving since. On September 22, 2026 an &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;inception&lt;/code&gt; runtime landed for Inception’s Mercury diffusion language models, authenticated from &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;INCEPTION_API_KEY&lt;/code&gt;, with &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;mercury-2.5&lt;/code&gt;, &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;mercury-2&lt;/code&gt;, and &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;mercury-edit-2&lt;/code&gt; as its known wire models. A diffusion model denoises whole blocks of tokens in parallel instead of emitting them left to right, which is what makes it fast enough for a latency-sensitive slot a frontier model cannot fill. Two surfaces are wired: chat at &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;/v1/chat/completions&lt;/code&gt; with tool calling and JSON-schema structured outputs, and fill-in-the-middle at &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;/v1/fim/completions&lt;/code&gt; through the same &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;infill()&lt;/code&gt; verb that reaches llama.cpp’s. Mercury Edit 2’s next-edit prediction is deliberately left out, because it needs a contract verb of its own and its request format is not covered by the published reference. The runtime shipped in v0.5.3; no rates ship with it, and cost accounting reads the target’s own pricing block as it does for any other target.&lt;/p&gt; &lt;p&gt;Three model families with three different physics, one socket. That is the shape the provider layer is built to hold.&lt;/p&gt; &lt;h2 id=&quot;try-it&quot;&gt;Try it&lt;/h2&gt; &lt;p&gt;You need Node.js 22.19 or newer and a model service. Install the package and configure a first target:&lt;/p&gt; &lt;div class=&quot;language-bash highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;npm &lt;span class=&quot;nb&quot;&gt;install&lt;/span&gt; &lt;span class=&quot;nt&quot;&gt;-g&lt;/span&gt; @iowarp/clio-coder &lt;span class=&quot;nb&quot;&gt;cd&lt;/span&gt; /path/to/your/project clio-coder configure &lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt; &lt;p&gt;Choose &lt;strong&gt;Quick Connect&lt;/strong&gt;, paste your endpoint, select a model, and review the connection. Then start a session, or check the installation first:&lt;/p&gt; &lt;div class=&quot;language-bash highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;clio-coder doctor clio-coder &lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt; &lt;p&gt;Ask for something bounded on the first turn, such as an explanation of how the repository builds and tests itself. When you want the same view in a browser, open the companion:&lt;/p&gt; &lt;div class=&quot;language-bash highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;clio-coder gui &lt;span class=&quot;nt&quot;&gt;--open&lt;/span&gt; clio-coder docs safety &lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt; &lt;p&gt;You will see the terminal conversation, tool activity, and diffs in one place, and the browser application serving the same configuration, sessions, traces, and evidence from 127.0.0.1. For a longer walk through a local server, the &lt;a href=&quot;/journal/2026/clio-coder-on-your-own-gpu/&quot;&gt;GPU tutorial&lt;/a&gt; covers runtime ids, quantization, and reading the receipt.&lt;/p&gt; &lt;h2 id=&quot;what-is-left-for-you&quot;&gt;What is left for you&lt;/h2&gt; &lt;p&gt;The provider list is long and the tested list is shorter. A model family counts as sanctioned only when the exact artifact, quantization, runtime surface, hardware, context window, and observed quirks are written down, and most of what people actually run has never been through that. If you connect Clio to a local server, a gateway, or a model nobody here has exercised, the useful artifact is that record: what you ran, where it was served, what the tool calls did, and where it failed. A difficult build, an unreliable connection, or a workflow that needs too much babysitting is equally worth reporting. Bring it to &lt;a href=&quot;https://github.com/iowarp/clio-coder&quot;&gt;the repository&lt;/a&gt;, with your Clio and Node versions and &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;clio-coder doctor&lt;/code&gt; output, credentials removed.&lt;/p&gt; </content> </entry> <entry> <title type="html">When is research software shipped?</title> <link rel="alternate" type="text/html" href="https://akougkas.io/journal/2026/when-is-research-software-shipped/"/> <id>https://akougkas.io/journal/2026/when-is-research-software-shipped/</id> <published>2026-08-27T09:00:00-05:00</published> <updated>2026-08-27T09:00:00-05:00</updated> <summary type="html">A working definition of &quot;shipped&quot; for research software, built around a named state someone else can run, evidence tied to that state, explicit limits, and a continuity signal, with Hermes and DLIO as the worked examples.</summary> <content type="html" xml:base="https://akougkas.io/journal/2026/when-is-research-software-shipped/">&lt;p&gt;A paper acceptance is not a software release. I have blurred that line myself, more than once.&lt;/p&gt; &lt;p&gt;In research we say a system “exists” when what we mean is that our team ran a particular commit, on a particular machine, with enough local knowledge to produce the evaluation in a paper. That is a real achievement. It is also a long way from giving a stranger a fair chance to use the software. I needed a more useful word for the far side of that boundary, and the word I settled on is &lt;strong&gt;shipped&lt;/strong&gt;.&lt;/p&gt; &lt;p&gt;Research software is shipped when someone outside the room where it was built can identify a named state, reach it, run at least one intended behavior, understand the evidence and its boundary, and report what happened without reconstructing the project from our private memory.&lt;/p&gt; &lt;p&gt;That definition is deliberately smaller than “production ready.” It is also more demanding than “the code is on GitHub.”&lt;/p&gt; &lt;h2 id=&quot;the-states-are-different&quot;&gt;The states are different&lt;/h2&gt; &lt;p&gt;I find it useful to separate five states that usually get collapsed into one announcement:&lt;/p&gt; &lt;ol&gt; &lt;li&gt;&lt;strong&gt;Experiment.&lt;/strong&gt; The code answers a research question for the people running it.&lt;/li&gt; &lt;li&gt;&lt;strong&gt;Prototype.&lt;/strong&gt; The important mechanism is implemented well enough to inspect and evaluate.&lt;/li&gt; &lt;li&gt;&lt;strong&gt;Paper artifact.&lt;/strong&gt; The software, inputs, and method support a published argument within a stated environment.&lt;/li&gt; &lt;li&gt;&lt;strong&gt;Release.&lt;/strong&gt; A named version has an installation path, an intended behavior, and public notes about what changed.&lt;/li&gt; &lt;li&gt;&lt;strong&gt;Maintained software.&lt;/strong&gt; Ownership, issue handling, compatibility decisions, and another release are all plausible after the paper deadline has passed.&lt;/li&gt; &lt;/ol&gt; &lt;p&gt;Each state is valuable. The trouble starts when I describe one as another. A prototype is not diminished by calling it a prototype. A paper artifact is not a failed product. The label tells a reader what kind of promise we are making, and I would rather make a small promise I can keep.&lt;/p&gt; &lt;p&gt;“Shipped” usually begins at the release boundary, but a tag alone is not enough. The tag has to point at a usable contract.&lt;/p&gt; &lt;h2 id=&quot;the-smallest-release-i-trust&quot;&gt;The smallest release I trust&lt;/h2&gt; &lt;p&gt;Before I call one of our systems shipped, I look for a short list of receipts.&lt;/p&gt; &lt;p&gt;&lt;strong&gt;A named, recoverable state.&lt;/strong&gt; A version, release, image digest, or immutable commit that two people can identify without asking which branch was current that afternoon. “Use main” is a moving target, not a release coordinate.&lt;/p&gt; &lt;p&gt;&lt;strong&gt;A path from zero.&lt;/strong&gt; Installation instructions that begin before the maintainer’s shell history: dependencies, supported environments, build or package commands, and the first expected result. A container helps, but a container with no description of its assumptions only freezes the mystery.&lt;/p&gt; &lt;p&gt;&lt;strong&gt;One behavior another person can exercise.&lt;/strong&gt; A minimal example persuades more than a broad capability list. The question is not whether every scientific workflow has been packaged. It is whether a newcomer can make one intended path work and recognize the output.&lt;/p&gt; &lt;p&gt;&lt;strong&gt;Evidence connected to the version.&lt;/strong&gt; A benchmark number needs the version, configuration, input, machine boundary, baseline, and measurement method that make it interpretable. The paper carries the argument; the release should say which part of that argument the current code reproduces.&lt;/p&gt; &lt;p&gt;&lt;strong&gt;Explicit limits.&lt;/strong&gt; Supported platforms, incomplete components, scaling boundaries, known failures, data restrictions, and security assumptions belong next to the instructions. Hiding them does not make the software stronger. It makes the first external user rediscover the same boundary, expensively.&lt;/p&gt; &lt;p&gt;&lt;strong&gt;A continuity signal.&lt;/strong&gt; Where issues go, who decides whether a change belongs, and whether the project is active, complete, or archived. That is not a promise of support forever. It stops a public repository from impersonating a maintained service.&lt;/p&gt; &lt;h2 id=&quot;two-systems-i-hold-to-this&quot;&gt;Two systems I hold to this&lt;/h2&gt; &lt;p&gt;&lt;a href=&quot;/work/hermes/&quot;&gt;Hermes&lt;/a&gt; is the cleanest example I have. It started as the center of my PhD, became five years of NSF-funded work with The HDF Group, and closed in August 2024 with &lt;a href=&quot;https://github.com/HDFGroup/hermes/releases/tag/v1.2.1&quot;&gt;v1.2.1&lt;/a&gt;: a named state, under an organization that outlives the grant, with adapters, packaging, and documentation that other people used on Theta and Summit. It is complete, and I say so. Its ideas kept moving into &lt;a href=&quot;/work/iowarp/&quot;&gt;IOWarp&lt;/a&gt;, but the software itself has a last release, and that is a legitimate ending.&lt;/p&gt; &lt;p&gt;&lt;a href=&quot;/work/deepio/&quot;&gt;DLIO&lt;/a&gt; shipped differently. &lt;a href=&quot;https://grc.iit.edu/center/team/hariharan-devarajan/&quot;&gt;Hariharan Devarajan&lt;/a&gt; built it with &lt;a href=&quot;https://www.anl.gov/&quot;&gt;Argonne&lt;/a&gt; to reproduce the I/O of scientific deep-learning jobs, and I was part of the &lt;a href=&quot;https://www.iit.edu/&quot;&gt;Illinois Tech&lt;/a&gt; team that co-advised him; the &lt;a href=&quot;/publications/devarajan2021dlio/&quot;&gt;CCGrid 2021 paper&lt;/a&gt; carried the argument. What made it shipped was everything after, and that is Argonne’s work, mostly Hari’s: &lt;a href=&quot;https://github.com/mlcommons/storage&quot;&gt;MLPerf Storage&lt;/a&gt; adopted it as the workload generator, the Argonne team and the community kept releasing it, and &lt;a href=&quot;https://github.com/argonne-lcf/dlio_benchmark/releases/tag/v2.0.1&quot;&gt;v2.0.1&lt;/a&gt; is a state that storage vendors install without ever talking to its authors. Integration sharpened the interfaces, because assumptions that felt harmless in one lab became bugs across submitters’ platforms.&lt;/p&gt; &lt;p&gt;Neither release proves portability, performance, or adoption by itself. What each one does is give those questions a concrete object.&lt;/p&gt; &lt;h2 id=&quot;where-i-am-being-careful&quot;&gt;Where I am being careful&lt;/h2&gt; &lt;p&gt;&lt;a href=&quot;/work/iowarp/&quot;&gt;IOWarp&lt;/a&gt; is at a different point, and I want the language to say so. The &lt;a href=&quot;https://github.com/iowarp&quot;&gt;public organization&lt;/a&gt; makes active implementation visible, but the visibility of a repository must not turn every design target into a shipped claim. Inside &lt;a href=&quot;/work/clio/&quot;&gt;CLIO&lt;/a&gt;, Core and Kit are released and maintained, Agent is beta, and &lt;a href=&quot;/work/clio-coder/&quot;&gt;CLIO Coder&lt;/a&gt; is experimental and ships quickly. Each component earns “shipped” through its own releases, instructions, tests, and stated limits. &lt;a href=&quot;/work/chronolog/&quot;&gt;ChronoLog 3.0&lt;/a&gt; earned it in May with a changelog; the &lt;a href=&quot;/work/labios/&quot;&gt;LABIOS 2.0&lt;/a&gt; branch has not yet, and its story says exactly that.&lt;/p&gt; &lt;h2 id=&quot;shipping-changes-the-research&quot;&gt;Shipping changes the research&lt;/h2&gt; &lt;p&gt;Release work is sometimes treated as cleanup after the interesting systems work. In my experience it exposes systems questions that the paper path lets you avoid. What is the actual interface? Which configuration is part of the scientific method? Which behavior is stable, and which was incidental to one machine? Which dependency is essential? Which failure should stop a run instead of silently changing it? Who owns the next decision?&lt;/p&gt; &lt;p&gt;Those questions improve the architecture. They also change the relationship with readers. A paper asks someone to evaluate an argument. Shipped software lets them inspect the mechanism, try it in a different setting, and return evidence we did not control. The most useful feedback I have received on any of these systems arrived after the software left the environment that made all of its assumptions feel obvious.&lt;/p&gt; &lt;h2 id=&quot;software-is-collective-work&quot;&gt;Software is collective work&lt;/h2&gt; &lt;p&gt;The release is never just the person who tells the story about it. &lt;a href=&quot;/work/hermes/&quot;&gt;Hermes&lt;/a&gt; was built by a team spanning the &lt;a href=&quot;https://grc.iit.edu/&quot;&gt;Gnosis Research Center&lt;/a&gt;, &lt;a href=&quot;https://www.hdfgroup.org/&quot;&gt;The HDF Group&lt;/a&gt;, and research partners. &lt;a href=&quot;/work/deepio/&quot;&gt;DLIO&lt;/a&gt; grew through the Argonne team and collaborators who designed, implemented, evaluated, documented, and maintained it. Students and research software engineers do most of the work that turns a paper prototype into something another person can run.&lt;/p&gt; &lt;p&gt;Credit should follow those contributions into the release notes, the paper, the repository history, and the project story. “I shipped it” is only honest when “I” names my role and “we” stays visible.&lt;/p&gt; &lt;h2 id=&quot;what-shipped-does-not-mean&quot;&gt;What shipped does not mean&lt;/h2&gt; &lt;p&gt;It does not mean the software works on every system, is secure in every setting, or will be supported indefinitely. Some artifacts require scarce hardware or licensed data. Some cannot be released immediately because of an embargo, a security concern, a partner agreement, or a privacy obligation. Some research code should be preserved as an artifact and then deliberately archived rather than maintained badly.&lt;/p&gt; &lt;p&gt;It also does not mean finished. Shipped software can be narrow, early, and unfinished. The promise is smaller: here is the state, here is what it does, here is how we know, here is what we do not know, and here is where the next result belongs.&lt;/p&gt; &lt;p&gt;That is enough to move research software from a claim about our past into an object someone else can question, use, and carry forward. It is the standard I am trying to hold &lt;a href=&quot;/work/iowarp/&quot;&gt;IOWarp&lt;/a&gt; and &lt;a href=&quot;/work/clio/&quot;&gt;CLIO&lt;/a&gt; to, one component at a time.&lt;/p&gt; </content> </entry> <entry> <title type="html">Context is part of the system</title> <link rel="alternate" type="text/html" href="https://akougkas.io/journal/2026/context-is-part-of-the-system/"/> <id>https://akougkas.io/journal/2026/context-is-part-of-the-system/</id> <published>2026-08-26T18:25:00-05:00</published> <updated>2026-08-27T00:00:00-05:00</updated> <summary type="html">A capable model still fails when the system hands it the wrong slice of reality. CLIO&apos;s answer is to treat context the way a database treats state, and to seal a receipt for every action.</summary> <content type="html" xml:base="https://akougkas.io/journal/2026/context-is-part-of-the-system/">&lt;p&gt;Here is a failure I have watched more than once. An agent has a strong model behind it, a clear question in front of it, and it still makes a bad call. The calibration file changed yesterday. The dataset belongs to a different experiment. The derived quantity has no provenance. The tool named &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;compare&lt;/code&gt; deletes. The action it wants to take exceeds the authority of the person who asked.&lt;/p&gt; &lt;p&gt;None of those are prompt-writing failures. They are systems failures. The model acted inside a reality that the surrounding system assembled badly, and I have spent the last two years building around that observation.&lt;/p&gt; &lt;h2 id=&quot;the-thesis&quot;&gt;The thesis&lt;/h2&gt; &lt;p&gt;&lt;a href=&quot;/work/clio/&quot;&gt;CLIO&lt;/a&gt; gives agents what databases give applications: structured, reliable, queryable state. A model on its own has a context window. A scientist has terabytes on a parallel file system, a Slurm queue, instrument metadata, a decade of provenance, and tools with side effects. Something has to select from that world, shape it for one decision, and write down what it chose. When that something is invisible, the agent’s answer is unauditable no matter how good the model is.&lt;/p&gt; &lt;p&gt;So “context” in CLIO is not a paragraph pasted above a question. It is a runtime product: content, metadata, current state, provenance, tool contracts, policy, and the boundary of human approval, assembled for a particular action and recorded.&lt;/p&gt; &lt;p&gt;That is a data-systems claim, and it comes from a data-systems lineage. &lt;a href=&quot;/work/hermes/&quot;&gt;Hermes&lt;/a&gt; taught me that placement decisions are only trustworthy when you can see why they happened. &lt;a href=&quot;/work/labios/&quot;&gt;LABIOS&lt;/a&gt; taught me that a request should carry its intent instead of forcing the system to guess. &lt;a href=&quot;/work/chronolog/&quot;&gt;ChronoLog&lt;/a&gt; taught me to order activity at write time so it can be replayed later. &lt;a href=&quot;/work/dtio/&quot;&gt;DTIO&lt;/a&gt; taught me that a task is a better unit than a request once a pipeline has more than one stage. CLIO is what happens when you apply those lessons to an agent instead of an I/O request.&lt;/p&gt; &lt;h2 id=&quot;what-that-looks-like-in-code&quot;&gt;What that looks like in code&lt;/h2&gt; &lt;p&gt;&lt;a href=&quot;/work/clio-coder/&quot;&gt;CLIO Coder&lt;/a&gt; is the component where I test these contracts most directly, because I write it myself and a coding agent exposes every shortcut immediately.&lt;/p&gt; &lt;p&gt;&lt;strong&gt;Selection is bounded.&lt;/strong&gt; Every observation tool returns through a truncation envelope with offload paths and next hints, so a large result is bounded rather than silently cut. One &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;grep&lt;/code&gt; cannot blow the window. The compiled prompt and tool schemas stay byte-stable across turns so a local model’s prefix cache stays hot, and the ledger records a cache verdict for every call.&lt;/p&gt; &lt;p&gt;&lt;strong&gt;Authority is typed.&lt;/strong&gt; Twenty tools sit in seven policy planes. Bash is default-deny. The autonomy dial decides what runs immediately and what parks for approval; it never widens the tool surface. A worker can only narrow the orchestrator’s authority, never exceed it. Reviewers and judges run read-only. Since v0.3.7 a dispatch carries typed intent: read roots, write roots, expected outputs, and the verification checks the host runs afterwards with no shell. That is a &lt;a href=&quot;/work/labios/&quot;&gt;LABIOS&lt;/a&gt; label applied to an agent.&lt;/p&gt; &lt;p&gt;&lt;strong&gt;Everything leaves a receipt.&lt;/strong&gt; A run seals tokens, priced cost, tool activity, safety decisions, routing, worker attestation, and result conformance. &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;clio-coder evidence inspect&lt;/code&gt; reads it back. Nothing in the audit trail is reconstructed from prose, because prose is exactly the thing you cannot trust an agent about. That is &lt;a href=&quot;/work/chronolog/&quot;&gt;ChronoLog&lt;/a&gt;’s lesson, applied to a coding session.&lt;/p&gt; &lt;p&gt;That is the shape I want across the whole of CLIO, not only in the coder: selection, rejection, authority, and action, with a receipt another person can check. &lt;a href=&quot;/work/iowarp/&quot;&gt;IOWarp&lt;/a&gt; is where the rest of the team and I are carrying it into the context store, the scientific tools, and the science agent.&lt;/p&gt; &lt;h2 id=&quot;more-context-is-not-the-goal&quot;&gt;More context is not the goal&lt;/h2&gt; &lt;p&gt;Context windows invite an easy metric: fit more tokens. Scientific context does not become correct when it becomes large. A smaller, well-scoped package with provenance beats a giant retrieval dump. A refusal caused by missing authority beats a plausible action. An explicit conflict between two measurements beats a smooth synthesis that hides the disagreement.&lt;/p&gt; &lt;p&gt;The objective is the smallest sufficient context for a bounded action, with enough provenance and state to make the result inspectable.&lt;/p&gt; &lt;h2 id=&quot;context-is-a-data-movement-problem&quot;&gt;Context is a data-movement problem&lt;/h2&gt; &lt;p&gt;At scientific scale the right evidence lives in object storage, a parallel file system, an instrument buffer, or another site entirely. Moving all of it toward a model wastes bandwidth; summarizing too early erases the feature the agent needs. Where filtering happens, which representation moves, what gets cached, when a derived object is safer than the source: these are the questions &lt;a href=&quot;/work/hermes/&quot;&gt;Hermes&lt;/a&gt; and &lt;a href=&quot;/work/labios/&quot;&gt;LABIOS&lt;/a&gt; asked about I/O, and &lt;a href=&quot;/work/iowarp/&quot;&gt;IOWarp&lt;/a&gt;’s transfer and assimilation engines ask them again with an agent on the other end.&lt;/p&gt; &lt;h2 id=&quot;what-is-unresolved&quot;&gt;What is unresolved&lt;/h2&gt; &lt;p&gt;I do not have a universal schema for context, and I doubt one exists across instruments, simulations, and organizations. Provenance describes a chain without proving its inputs were right. A perfect receipt does not repair a biased selection policy. Retrieval quality, adversarial content in retrieved text, changing permissions, and the cost of keeping history are all open. And context can expose the very thing a system is meant to protect, so minimization and redaction have to happen before data reaches a model, not after generation.&lt;/p&gt; &lt;p&gt;The model matters. But the model acts inside the reality the surrounding system constructs. Design, test, and audit that layer like any other component. If you want to see one concrete version of it, &lt;a href=&quot;/journal/2026/clio-coder-on-your-own-gpu/&quot;&gt;run CLIO Coder against a model on your own GPU&lt;/a&gt; and read the receipt it seals.&lt;/p&gt; </content> </entry> <entry> <title type="html">We need an Agent500</title> <link rel="alternate" type="text/html" href="https://akougkas.io/journal/2026/we-need-an-agent500/"/> <id>https://akougkas.io/journal/2026/we-need-an-agent500/</id> <published>2026-06-16T00:00:00-05:00</published> <updated>2026-06-16T00:00:00-05:00</updated> <summary type="html">Agent leaderboards score answers. Science needs a ranking that runs an agent through a real workflow with real tools and data and measures correctness, cost, I/O efficiency, and provenance together.</summary> <content type="html" xml:base="https://akougkas.io/journal/2026/we-need-an-agent500/">&lt;p&gt;A new agent benchmark arrived in my reading pile this week. &lt;a href=&quot;https://arxiv.org/abs/2602.11685&quot;&gt;DRACO&lt;/a&gt; takes deep-research tasks sampled from real usage, spanning ten domains, and grades the output against rubrics for accuracy, completeness, objectivity, and citation quality. It is careful work and I am glad it exists. It also measures none of the things that decide whether an agent can do science.&lt;/p&gt; &lt;p&gt;It scores the answer. It does not score the system.&lt;/p&gt; &lt;aside class=&quot;entry-glance&quot; aria-label=&quot;At a glance&quot;&gt; &lt;p class=&quot;entry-glance__kicker&quot;&gt;At a glance&lt;/p&gt; &lt;dl&gt; &lt;div&gt;&lt;dt&gt;Anchor&lt;/dt&gt;&lt;dd&gt;DRACO on arXiv, read June 16, 2026&lt;/dd&gt;&lt;/div&gt; &lt;div&gt;&lt;dt&gt;Systems&lt;/dt&gt;&lt;dd&gt;&lt;a href=&quot;/work/deepio/&quot;&gt;DeepIO&lt;/a&gt;, &lt;a href=&quot;/work/clio/&quot;&gt;CLIO&lt;/a&gt;, &lt;a href=&quot;/work/iowarp/&quot;&gt;IOWarp&lt;/a&gt;&lt;/dd&gt;&lt;/div&gt; &lt;div&gt;&lt;dt&gt;The claim&lt;/dt&gt;&lt;dd&gt;A ranking of agent systems on a fixed scientific workflow, scored on five numbers together, would make “the agent got better” checkable.&lt;/dd&gt;&lt;/div&gt; &lt;div&gt;&lt;dt&gt;Paper&lt;/dt&gt;&lt;dd&gt;&lt;a href=&quot;/publications/yildirim2026ioefficient/&quot;&gt;Correct Is Not I/O Efficient, GCASR 2026&lt;/a&gt;&lt;/dd&gt;&lt;/div&gt; &lt;/dl&gt; &lt;/aside&gt; &lt;h2 id=&quot;what-the-leaderboards-measure&quot;&gt;What the leaderboards measure&lt;/h2&gt; &lt;p&gt;Almost every agent evaluation I have read this year follows the same shape. Pose a task, let the agent run, grade the text it produces. The grader is a rubric or another model. The result is a number that says how good the answer was. I read these the way I once read storage benchmarks, looking for the row that says what it cost, and the row is not there.&lt;/p&gt; &lt;p&gt;For a research assistant that is the right question. For an agent working inside a scientific workflow it leaves out everything that costs money and everything that goes wrong. How many bytes did it read to answer? How many times did it read the same file? Did it submit a job it did not need? Can anyone reconstruct which version of the dataset produced the figure? What did the run cost, in tokens and in node hours, and how much of that was the agent repeating a failed action?&lt;/p&gt; &lt;p&gt;Two papers from our group in May put a name on this. The title of the first is the finding: &lt;a href=&quot;/publications/yildirim2026ioefficient/&quot;&gt;Correct Is Not I/O Efficient&lt;/a&gt;, characterizing the I/O behavior of LLM agents on scientific data. A correct answer and an efficient one are different properties, and a leaderboard that grades the paragraph cannot tell them apart. &lt;a href=&quot;/publications/islam2026agenticsearch/&quot;&gt;Agentic Search Efficiency for Scientific Data Discovery&lt;/a&gt; asks the same question of discovery.&lt;/p&gt; &lt;h2 id=&quot;the-precedent&quot;&gt;The precedent&lt;/h2&gt; &lt;p&gt;The high-performance computing community solved a version of this problem in 1993. &lt;a href=&quot;https://top500.org/&quot;&gt;TOP500&lt;/a&gt; ranks supercomputers twice a year on one number from one benchmark, and &lt;a href=&quot;https://www.top500.org/lists/top500/&quot;&gt;every list since 1993&lt;/a&gt; is still online. The number is crude. It is also public, reproducible, dated, and comparable across two decades, and it changed what people built. I am not romantic about TOP500. It has been gamed, and it has rewarded machines nobody could program. It is still the most useful number the field ever agreed on. When it became clear that FLOPS no longer described the bottleneck, the storage community answered with &lt;a href=&quot;https://io500.org/&quot;&gt;IO500&lt;/a&gt;, which ranks systems on bandwidth and metadata rates together so that a system cannot win by being good at only one. The &lt;a href=&quot;https://io500.org/list/isc25/io500&quot;&gt;ISC 2025 list&lt;/a&gt; is a good place to see what that looks like in practice.&lt;/p&gt; &lt;p&gt;I have watched what happens when a benchmark leaves the room where it was written. &lt;a href=&quot;/work/deepio/&quot;&gt;DLIO&lt;/a&gt;, which &lt;a href=&quot;https://grc.iit.edu/center/team/hariharan-devarajan/&quot;&gt;Hariharan Devarajan&lt;/a&gt; built with &lt;a href=&quot;https://www.anl.gov/&quot;&gt;Argonne&lt;/a&gt; to reproduce the I/O of deep-learning training while I was part of the team co-advising him, is &lt;a href=&quot;https://github.com/argonne-lcf/dlio_benchmark&quot;&gt;maintained in the open&lt;/a&gt;; &lt;a href=&quot;https://mlcommons.org/benchmarks/storage/&quot;&gt;MLPerf Storage&lt;/a&gt; adopted it as the workload generator, and submitters I have never met now run it against systems I have never seen. A benchmark becomes real when a second community uses it to compare things they built. That is the outcome I want here.&lt;/p&gt; &lt;aside class=&quot;entry-pull&quot;&gt; &lt;p&gt;A benchmark becomes real when a second community uses it to compare things they built.&lt;/p&gt; &lt;/aside&gt; &lt;h2 id=&quot;what-an-agent500-would-measure&quot;&gt;What an Agent500 would measure&lt;/h2&gt; &lt;p&gt;Here is the idea I have been carrying in a notes file since March, and I would rather have it argued with in public.&lt;/p&gt; &lt;p&gt;An organization, modeled on TOP500 and IO500, that publishes a ranked list of agent systems on a cadence. Not models. Systems: the model, the tools, the context layer, the storage underneath, and the policy that governs them, run as one unit through a fixed scientific workflow.&lt;/p&gt; &lt;p&gt;The workflow is the benchmark. It has real tools, a scheduler, a parallel file system, and datasets in real formats, and it asks the agent to do something a scientist would do: find the relevant runs, extract a derived quantity, compare against a baseline, and produce a figure with provenance. The list would rank on five numbers, published together so that a system cannot win on one.&lt;/p&gt; &lt;ul&gt; &lt;li&gt;&lt;strong&gt;Correctness&lt;/strong&gt;, against a held-out answer, the way every leaderboard already does it.&lt;/li&gt; &lt;li&gt;&lt;strong&gt;Cost&lt;/strong&gt;, in tokens and in node hours, so that a system that spends a hundred times more to be right is visibly different from one that does not.&lt;/li&gt; &lt;li&gt;&lt;strong&gt;I/O efficiency&lt;/strong&gt;, bytes moved per unit of correct output, and redundant reads counted separately. This is the number nobody publishes.&lt;/li&gt; &lt;li&gt;&lt;strong&gt;Provenance&lt;/strong&gt;, whether an auditor can reconstruct the inputs, versions, and tool calls behind the result from the run’s own record, without the agent’s prose.&lt;/li&gt; &lt;li&gt;&lt;strong&gt;Time to answer&lt;/strong&gt;, wall clock, because a workflow that is right in a week is a different thing from one that is right in an hour.&lt;/li&gt; &lt;/ul&gt; &lt;p&gt;If I had to keep one of the five, it would be provenance, because it is the only one that tells you whether the other four can be trusted.&lt;/p&gt; &lt;figure class=&quot;figure--diagram&quot;&gt; &lt;svg viewBox=&quot;0 0 640 240&quot; role=&quot;img&quot; aria-labelledby=&quot;fig-agent500-numbers&quot;&gt; &lt;title id=&quot;fig-agent500-numbers&quot;&gt;Five numbers published together for one run: correctness, cost, I/O efficiency, provenance, and time to answer. Provenance is the one that validates the rest.&lt;/title&gt; &lt;text class=&quot;d-kicker&quot; x=&quot;24&quot; y=&quot;40&quot;&gt;five numbers, published together&lt;/text&gt; &lt;rect class=&quot;d-box&quot; x=&quot;24&quot; y=&quot;72&quot; width=&quot;110&quot; height=&quot;80&quot; rx=&quot;4&quot; /&gt; &lt;text class=&quot;d-label&quot; x=&quot;79&quot; y=&quot;118&quot; text-anchor=&quot;middle&quot;&gt;correctness&lt;/text&gt; &lt;rect class=&quot;d-box&quot; x=&quot;144&quot; y=&quot;72&quot; width=&quot;110&quot; height=&quot;80&quot; rx=&quot;4&quot; /&gt; &lt;text class=&quot;d-label&quot; x=&quot;199&quot; y=&quot;118&quot; text-anchor=&quot;middle&quot;&gt;cost&lt;/text&gt; &lt;rect class=&quot;d-box&quot; x=&quot;264&quot; y=&quot;72&quot; width=&quot;110&quot; height=&quot;80&quot; rx=&quot;4&quot; /&gt; &lt;text class=&quot;d-label&quot; x=&quot;319&quot; y=&quot;106&quot; text-anchor=&quot;middle&quot;&gt;I/O&lt;/text&gt; &lt;text class=&quot;d-label&quot; x=&quot;319&quot; y=&quot;130&quot; text-anchor=&quot;middle&quot;&gt;efficiency&lt;/text&gt; &lt;rect class=&quot;d-accent&quot; x=&quot;385&quot; y=&quot;72&quot; width=&quot;110&quot; height=&quot;80&quot; rx=&quot;4&quot; /&gt; &lt;text class=&quot;d-label&quot; x=&quot;440&quot; y=&quot;118&quot; text-anchor=&quot;middle&quot;&gt;provenance&lt;/text&gt; &lt;rect class=&quot;d-box&quot; x=&quot;506&quot; y=&quot;72&quot; width=&quot;110&quot; height=&quot;80&quot; rx=&quot;4&quot; /&gt; &lt;text class=&quot;d-label&quot; x=&quot;561&quot; y=&quot;106&quot; text-anchor=&quot;middle&quot;&gt;time to&lt;/text&gt; &lt;text class=&quot;d-label&quot; x=&quot;561&quot; y=&quot;130&quot; text-anchor=&quot;middle&quot;&gt;answer&lt;/text&gt; &lt;path class=&quot;d-accent&quot; d=&quot;M440 152 V184&quot; /&gt; &lt;path class=&quot;d-accent&quot; d=&quot;M24 184 H616&quot; /&gt; &lt;text class=&quot;d-kicker&quot; x=&quot;24&quot; y=&quot;216&quot;&gt;provenance validates the rest&lt;/text&gt; &lt;/svg&gt; &lt;figcaption&gt;Five boxes in a row, correctness, cost, I/O efficiency, provenance, and time to answer, with provenance highlighted and a line running from it under the other four.&lt;/figcaption&gt; &lt;/figure&gt; &lt;p&gt;Submissions would carry the full configuration: model, quantization, tool set, context policy, and the storage tiers the run touched. Runs would be reproducible by a second party, on the same hardware class, before they count.&lt;/p&gt; &lt;h2 id=&quot;what-would-go-wrong&quot;&gt;What would go wrong&lt;/h2&gt; &lt;p&gt;I have run enough benchmarks to know what happens next.&lt;/p&gt; &lt;ul&gt; &lt;li&gt;&lt;strong&gt;Gaming.&lt;/strong&gt; The moment the workflow is public, systems will be tuned to it, and the tuning will look like progress. TOP500 has lived with this for thirty years; the defense is a workflow suite that rotates and a rule that the reference data changes between lists. I do not think gaming is avoidable. I think it should be visible.&lt;/li&gt; &lt;li&gt;&lt;strong&gt;Cost.&lt;/strong&gt; A run on real hardware with real data is expensive, and a list that only well-funded groups can enter measures funding. The answer is a small tier that runs on one node with one GPU and a public dataset, so that a lab with a workstation can appear on the same list as a national facility, in a different bracket.&lt;/li&gt; &lt;li&gt;&lt;strong&gt;Reproducibility.&lt;/strong&gt; Models drift under the same name, tools change, and a run from June may not be repeatable in December. The list has to pin everything, including the model weights, and refuse a submission that cannot be re-run. That will exclude most commercial APIs at first. I think that is correct.&lt;/li&gt; &lt;li&gt;&lt;strong&gt;The grader.&lt;/strong&gt; A rubric graded by another model is a benchmark of two models. For science tasks the answer key has to be data, computed independently, and a human has to sign off on the first list.&lt;/li&gt; &lt;/ul&gt; &lt;h2 id=&quot;what-i-would-do-first&quot;&gt;What I would do first&lt;/h2&gt; &lt;p&gt;Not an organization. One workflow, one dataset, one node, and a script that emits the five numbers. Run &lt;a href=&quot;/work/clio/&quot;&gt;CLIO Agent&lt;/a&gt; (&lt;a href=&quot;https://github.com/iowarp/clio-agent&quot;&gt;iowarp/clio-agent&lt;/a&gt;, on &lt;a href=&quot;https://pypi.org/project/clio-agent/&quot;&gt;PyPI&lt;/a&gt;) through it, then run two other agent systems through it, and publish all three results with the configurations, including the ones where we lose. I expect to lose at least one. That is the point of running it. If the numbers are interesting to anyone else, the second edition can have a committee.&lt;/p&gt; &lt;p&gt;The naming of a list is not the point. The point is that “the agent got better” is a claim I cannot currently check, on my own systems or anyone else’s, and science runs on claims that can be checked.&lt;/p&gt; &lt;p&gt;If you maintain an agent system for scientific work and would run it through a workflow like this, I want to know what you would refuse to measure and why.&lt;/p&gt; </content> </entry> <entry> <title type="html">High-performance agentic computing</title> <link rel="alternate" type="text/html" href="https://akougkas.io/journal/2026/high-performance-agentic-computing/"/> <id>https://akougkas.io/journal/2026/high-performance-agentic-computing/</id> <published>2026-03-22T00:00:00-05:00</published> <updated>2026-03-22T00:00:00-05:00</updated> <summary type="html">The case for naming a discipline at the meeting point of HPC, autonomous AI, and domain science, with the multiplicative axiom behind it and my own doubt about whether it is a field or a decade-long transition.</summary> <content type="html" xml:base="https://akougkas.io/journal/2026/high-performance-agentic-computing/">&lt;p&gt;I have been carrying a document around since February. It is called a constitution, a grand word for a working paper. I am Greek, so I know what the word implies, and I chose it to make myself accountable to it. It argues that a discipline is forming at the meeting point of high-performance computing, autonomous AI, and domain science. I call it high-performance agentic computing, HPAC for short. Version 0.3 is dated this month, and I still doubt part of it.&lt;/p&gt; &lt;aside class=&quot;entry-glance&quot; aria-label=&quot;At a glance&quot;&gt; &lt;p class=&quot;entry-glance__kicker&quot;&gt;At a glance&lt;/p&gt; &lt;dl&gt; &lt;div&gt;&lt;dt&gt;Anchor&lt;/dt&gt;&lt;dd&gt;HPAC Constitution v0.3, March 2026&lt;/dd&gt;&lt;/div&gt; &lt;div&gt;&lt;dt&gt;Systems&lt;/dt&gt;&lt;dd&gt;&lt;a href=&quot;/work/clio/&quot;&gt;CLIO&lt;/a&gt;, &lt;a href=&quot;/work/iowarp/&quot;&gt;IOWarp&lt;/a&gt;, &lt;a href=&quot;/work/building-grc/&quot;&gt;Building GRC&lt;/a&gt;&lt;/dd&gt;&lt;/div&gt; &lt;div&gt;&lt;dt&gt;The claim&lt;/dt&gt;&lt;dd&gt;Agentic fluency, domain intuition, and agent-aware infrastructure multiply, and a discipline is forming where they meet.&lt;/dd&gt;&lt;/div&gt; &lt;div&gt;&lt;dt&gt;Paper&lt;/dt&gt;&lt;dd&gt;&lt;a href=&quot;/publications/ye2025unboxkv-io/&quot;&gt;UnboxKV, IPDPS 2025&lt;/a&gt;&lt;/dd&gt;&lt;/div&gt; &lt;/dl&gt; &lt;/aside&gt; &lt;h2 id=&quot;why-a-name&quot;&gt;Why a name&lt;/h2&gt; &lt;p&gt;Fields do not get named because their content is new. They get named when three separate communities keep colliding with the same problem, and none of them can claim it. The precedents I keep returning to are three.&lt;/p&gt; &lt;p&gt;The word bioinformatics was coined in 1970 by Paulien Hogeweg and Ben Hesper. For two decades it described a service function inside biology. The &lt;a href=&quot;https://en.wikipedia.org/wiki/Human_Genome_Project&quot;&gt;Human Genome Project&lt;/a&gt;, launched in 1990, produced sequence data at a volume no existing group could absorb, and by 1993 the field had its own conference in &lt;a href=&quot;https://en.wikipedia.org/wiki/Intelligent_Systems_for_Molecular_Biology&quot;&gt;ISMB&lt;/a&gt;. The catalyst was a data flood, not a theory.&lt;/p&gt; &lt;p&gt;&lt;a href=&quot;https://en.wikipedia.org/wiki/Data_science&quot;&gt;Data science&lt;/a&gt; circulated as a term from the 1970s, when Peter Naur proposed it as a replacement for “computer science.” The field crystallized only around 2012, when web-scale data outran what statistics departments and computer science departments could each handle alone. It then spent a decade fighting turf wars between those two parents over who owned the curriculum.&lt;/p&gt; &lt;p&gt;Cybersecurity is the third pattern. The &lt;a href=&quot;https://en.wikipedia.org/wiki/Morris_worm&quot;&gt;Morris worm&lt;/a&gt; of November 1988 took down a meaningful fraction of the early internet, DARPA funded the CERT Coordination Center in response, and a subfield of systems administration became a field that now needs law, policy, and psychology as much as it needs protocols. The federal government later built a dedicated workforce pipeline, the &lt;a href=&quot;https://www.nsf.gov/funding/opportunities/cyberai-sfs-cyberaicorps-scholarship-service&quot;&gt;CyberCorps Scholarship for Service&lt;/a&gt;, because the market alone was not producing people fast enough.&lt;/p&gt; &lt;p&gt;Each of those fields was doing its work before it had a name. I find that reassuring rather than discouraging. The name came when practitioners needed a shared vocabulary, a venue, and a way to be hired and promoted for work that fit no home department.&lt;/p&gt; &lt;h2 id=&quot;the-collision-i-see-from-the-storage-side&quot;&gt;The collision I see from the storage side&lt;/h2&gt; &lt;p&gt;I build storage and I/O systems for supercomputers at the &lt;a href=&quot;https://grc.iit.edu/&quot;&gt;Gnosis Research Center&lt;/a&gt;. For most of my career that meant simulations: bulk-synchronous, compute-bound, predictable. In the last two years the workloads arriving at our systems changed shape. Agents generate intermediate state continuously, retrieve against large corpora with thousands of small semantic reads, and need to persist and replay what they did. The KV cache alone turns attention into a memory-hierarchy problem, and &lt;a href=&quot;/publications/ye2025unboxkv-io/&quot;&gt;our group’s measurements of it under concurrency&lt;/a&gt; are the reason I started thinking about attention as an I/O signature rather than a model detail.&lt;/p&gt; &lt;p&gt;The AI community is meeting these problems for the first time and largely solving them from scratch. Message passing, collective operations, parallel I/O, hierarchical storage management: the HPC community has decades of results on exactly these coordination problems, and I watch them get reinvented at lower quality in agent frameworks every month. It is not that the people reinventing them are careless. They have never been in the room where the original was built, and nobody offered to bring them. That is what happens when two communities have no shared room to meet in.&lt;/p&gt; &lt;p&gt;At the same time, the people who most need these systems are not computer scientists at all. A physicist, a physician, an economist has the judgment to evaluate an agent’s output and the domain sense to know what is worth asking. What they lack is the fluency to direct a system of agents and the infrastructure to run one beyond a laptop.&lt;/p&gt; &lt;h2 id=&quot;the-axiom&quot;&gt;The axiom&lt;/h2&gt; &lt;p&gt;The constitution reduces to one equation, and I would rather defend the equation than the document. I am also suspicious of equations in position papers, mine included, so read it as a claim about structure rather than a model.&lt;/p&gt; &lt;p&gt;Agentic engineering fluency, times domain-specific intuition, times scalable agent-aware infrastructure, equals the rate of discovery.&lt;/p&gt; &lt;figure class=&quot;figure--diagram&quot;&gt; &lt;svg viewBox=&quot;0 0 640 240&quot; role=&quot;img&quot; aria-labelledby=&quot;fig-hpac-axiom&quot;&gt; &lt;title id=&quot;fig-hpac-axiom&quot;&gt;Agentic fluency times domain intuition times agent-aware infrastructure equals the rate of discovery.&lt;/title&gt; &lt;rect class=&quot;d-box&quot; x=&quot;24&quot; y=&quot;56&quot; width=&quot;170&quot; height=&quot;72&quot; rx=&quot;4&quot; /&gt; &lt;text class=&quot;d-label&quot; x=&quot;109&quot; y=&quot;86&quot; text-anchor=&quot;middle&quot;&gt;agentic&lt;/text&gt; &lt;text class=&quot;d-label&quot; x=&quot;109&quot; y=&quot;110&quot; text-anchor=&quot;middle&quot;&gt;fluency&lt;/text&gt; &lt;text class=&quot;d-text&quot; x=&quot;214&quot; y=&quot;99&quot; text-anchor=&quot;middle&quot;&gt;×&lt;/text&gt; &lt;rect class=&quot;d-box&quot; x=&quot;235&quot; y=&quot;56&quot; width=&quot;170&quot; height=&quot;72&quot; rx=&quot;4&quot; /&gt; &lt;text class=&quot;d-label&quot; x=&quot;320&quot; y=&quot;86&quot; text-anchor=&quot;middle&quot;&gt;domain&lt;/text&gt; &lt;text class=&quot;d-label&quot; x=&quot;320&quot; y=&quot;110&quot; text-anchor=&quot;middle&quot;&gt;intuition&lt;/text&gt; &lt;text class=&quot;d-text&quot; x=&quot;425&quot; y=&quot;99&quot; text-anchor=&quot;middle&quot;&gt;×&lt;/text&gt; &lt;rect class=&quot;d-box&quot; x=&quot;446&quot; y=&quot;56&quot; width=&quot;170&quot; height=&quot;72&quot; rx=&quot;4&quot; /&gt; &lt;text class=&quot;d-label&quot; x=&quot;531&quot; y=&quot;86&quot; text-anchor=&quot;middle&quot;&gt;agent-aware&lt;/text&gt; &lt;text class=&quot;d-label&quot; x=&quot;531&quot; y=&quot;110&quot; text-anchor=&quot;middle&quot;&gt;infrastructure&lt;/text&gt; &lt;path class=&quot;d-accent&quot; d=&quot;M24 160 H616&quot; /&gt; &lt;text class=&quot;d-text&quot; x=&quot;320&quot; y=&quot;200&quot; text-anchor=&quot;middle&quot;&gt;= rate of discovery&lt;/text&gt; &lt;text class=&quot;d-kicker&quot; x=&quot;24&quot; y=&quot;226&quot;&gt;a product, not a sum&lt;/text&gt; &lt;/svg&gt; &lt;figcaption&gt;Domain expertise, AI fluency, and scalable infrastructure drawn as three factors of one product, with a zero in any factor taking the product to zero.&lt;/figcaption&gt; &lt;/figure&gt; &lt;p&gt;The multiplication is the whole point. A domain expert without fluency stays bottlenecked on manual work. A fluent AI engineer without domain intuition produces technically competent and scientifically empty results. Both are stuck at the scale of one machine without infrastructure that can deliver context, persist state, and orchestrate agents at the size of the problem. If any factor is zero, the product is zero. That is not true of a sum, and most of the “AI literacy” conversation treats the factors as a sum.&lt;/p&gt; &lt;p&gt;Fluency here is not programming. It is the ability to specify goals, structure workflows, manage context, evaluate outputs, and hold safety constraints across agents that run for hours without you. Intuition is the thing no model has: the physician’s clinical eye, the physicist’s feel for a symmetry, the sense that a result is wrong before you can say why. Infrastructure is my part of the equation, and it is the factor I think the field is under-investing in relative to models. &lt;a href=&quot;/work/clio/&quot;&gt;CLIO&lt;/a&gt; and &lt;a href=&quot;/work/iowarp/&quot;&gt;IOWarp&lt;/a&gt; are my concrete attempt at it: a context layer that treats what an agent knows, retrieves, and records as system state with placement, provenance, and a receipt, rather than as a prompt. The code is public under the &lt;a href=&quot;https://github.com/iowarp&quot;&gt;IOWarp organization&lt;/a&gt;, and the program’s record is on the &lt;a href=&quot;https://grc.iit.edu/research/projects/iowarp/&quot;&gt;center’s site&lt;/a&gt;.&lt;/p&gt; &lt;p&gt;The person who commands all three factors does not have a job title yet. In the document I call that person a director of intelligence. The title matters less than the claim that the role exists and that no current curriculum produces it. None produced me either. I came to this through an army career and then a storage lab, and the combination was an accident that I now think should be a design.&lt;/p&gt; &lt;aside class=&quot;entry-pull&quot;&gt; &lt;p&gt;If any factor is zero, the product is zero.&lt;/p&gt; &lt;/aside&gt; &lt;h2 id=&quot;what-a-program-would-contain&quot;&gt;What a program would contain&lt;/h2&gt; &lt;p&gt;If HPAC is real, it needs a curriculum, an infrastructure agenda, and a venue. The constitution sketches all three, and here is the short version.&lt;/p&gt; &lt;p&gt;The curriculum has four layers.&lt;/p&gt; &lt;ul&gt; &lt;li&gt;&lt;strong&gt;A foundation&lt;/strong&gt; in computational fluency: the terminal, version control, and the practice of directing agents with tool use, context management, and evaluation.&lt;/li&gt; &lt;li&gt;&lt;strong&gt;A systems layer&lt;/strong&gt; that teaches infrastructure literacy without demanding that students build storage systems: enough about memory hierarchies, parallel I/O, and scheduling to make good decisions when directing agents that depend on them.&lt;/li&gt; &lt;li&gt;&lt;strong&gt;A domain layer&lt;/strong&gt; that stays the student’s own field, at full depth.&lt;/li&gt; &lt;li&gt;&lt;strong&gt;A capstone&lt;/strong&gt; where students attack a real problem in their domain with agents at scale and evaluate both the system and the science.&lt;/li&gt; &lt;/ul&gt; &lt;p&gt;I have been running a small version of the first layer for graduate researchers at &lt;a href=&quot;/work/building-grc/&quot;&gt;GRC&lt;/a&gt; since last summer, and the thing I learned is that the domain layer does most of the work. Students with a real problem learn the tools in weeks. Students without one learn the tools and then wait for a problem, which is the failure mode of most computing curricula I have seen.&lt;/p&gt; &lt;p&gt;The infrastructure agenda is the research program I already run. Context-aware storage, distributed agent memory, orchestration that negotiates with goal-directed processes rather than scheduling static binaries, and provenance that survives a session. The line I hold to is that when a problem was solved by the HPC, distributed systems, or database communities, the job is to adapt the solution, not to build a worse one. I call the alternative the reinvention tax.&lt;/p&gt; &lt;p&gt;The venue is the part I can least do alone. A workshop co-located with &lt;a href=&quot;https://supercomputing.org/&quot;&gt;SC&lt;/a&gt;, HPDC, or &lt;a href=&quot;https://pearc.acm.org/&quot;&gt;PEARC&lt;/a&gt;. A shared benchmark. A way for someone at another institution to say “this is HPAC work” and have a review committee know what that means.&lt;/p&gt; &lt;h2 id=&quot;where-i-am-not-sure&quot;&gt;Where I am not sure&lt;/h2&gt; &lt;p&gt;Here is the doubt I promised. It is possible that none of this is a discipline. It might be a ten-year transition after which “computing” simply means this, the way “computing” absorbed networking without a separate department for it. Data science may be the cautionary tale rather than the model: a name that produced degree programs faster than it produced a coherent body of theory.&lt;/p&gt; &lt;p&gt;Two things push me toward naming it anyway. The first is that the three precedents all show the same lag: the work was happening for years before the name, and the name is what let people be hired, funded, and promoted for it. The second is the diffusion problem. Frontier models and national supercomputers are the Formula One cars of computing, and the value of Formula One is what trickles down to the road. If a name helps build the abstractions and the courses that get a topographer or an econometrician directing agents at scale, the name earns its keep even if it fades later.&lt;/p&gt; &lt;p&gt;The constitution is a living document. I am refining it in the open, first inside GRC, then with collaborators at the national laboratories and partner institutions, and a public version is coming. When it exists, I will link it from here.&lt;/p&gt; &lt;p&gt;If you are working on agent memory, context orchestration, or teaching domain scientists to direct agents, and you have felt that your work has no natural home, I would like to hear which parts of this argument you would cross out.&lt;/p&gt; </content> </entry> </feed>