akougkas.io

Notes

Technical notes, tutorials, field observations, updates, and personal writing from systems research, software, and teaching.

51 entries

Follow by RSS

2026

  1. essay

    Reliable work from unreliable agents

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

    14 min
  2. essay

    One destination, N tiers

    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.

    9 min
  3. field note

    SC26 in Chicago

    What the group brings to SC26 in Chicago, the pressure from GPUs and agent fleets that runs through all of it, and an invitation to Thursday's Birds of a Feather on HDF5 in the age of AI-driven science.

    4 min
  4. essay

    CLIO as the entry point

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

    6 min
  5. essay

    A capable model in a capable harness

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

    4 min
  6. essay

    An accountable agent says what it is waiting on

    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.

    5 min
  7. update

    CLIO Core 2.3 and 2.4: when a tier fills or a node dies

    Four CLIO Core releases between October 9 and November 2, 2026 added a device-paged GPU vector and Intel GPU support, then taught the context store to recover a full tier and keep data and directories readable when a node goes down.

    3 min
  8. essay

    A study that keeps its evidence

    CLIO Agent 0.9.5.1 links a study'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.

    4 min
  9. essay

    The repository is younger than the idea

    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.

    4 min
  10. essay

    Intelligent software needs a runtime

    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.

    5 min
  11. essay

    Context needs a lifecycle

    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.

    4 min
  12. essay

    An agent's authority should travel with the task

    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.

    5 min
  13. essay

    Why CLIO Coder, part 5 of 5: decisions without prose

    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.

    Series: Why CLIO Coder

    10 min
  14. essay

    Why CLIO Coder, part 4 of 5: bounded workers, sealed receipts

    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.

    Series: Why CLIO Coder

    8 min
  15. essay

    Why CLIO Coder, part 3 of 5: the agent writes its own handoff

    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.

    Series: Why CLIO Coder

    7 min
  16. essay

    Shipping a coding agent in public

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

    6 min
  17. essay

    Why CLIO Coder, part 2 of 5: typed tools, never a raw shell

    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.

    Series: Why CLIO Coder

    8 min
  18. essay

    Why CLIO Coder, part 1 of 5: your models, your machines

    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.

    Series: Why CLIO Coder

    8 min
  19. tutorial

    A closed loop for AI-assisted research writing

    Install CLIO Coder, WTF-P, and CiteNexus on Linux and run a first supervised writing session: the agent keeps the bookkeeping, every citation stays traceable to its source, and the author keeps the judgment.

    Tested with CLIO Coder 0.4.9

    12 min
  20. tutorial

    Serving Qwen3.8-27B on a Radeon AI PRO R9700 is not a one-liner

    The same Qwen3.8-27B GGUF on the same 32 GB Radeon decodes at 27 or 46 tokens per second, and the difference is speculative decoding. The backend is a prefill and decode trade, KV precision is a memory choice, and this is the llama.cpp preset I run under CLIO Coder.

    Tested with llama.cpp b10687

    19 min
  21. update

    Two years of IOWarp

    Two years after the NSF award, what IOWarp promised, what shipped as public releases, what changed course, and what is still a plan.

    4 min
  22. essay

    When is research software shipped?

    A working definition of "shipped" 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.

    7 min
  23. update

    CLIO in two Genesis Mission projects

    Two first-round DOE Genesis Mission projects, PORTUS with Pacific Northwest and SPOTTER-AI with Argonne, build on CLIO. What each asks of it, and why context and provenance matter when agents act on shared infrastructure.

    2 min
  24. tutorial

    Run CLIO Coder against a model on your own GPU

    Install CLIO Coder from npm, point it at a local llama.cpp or LM Studio server, run one headless turn, and read the receipt it seals.

    Tested with CLIO Coder 0.3.7

    6 min
  25. essay

    Context is part of the system

    A capable model still fails when the system hands it the wrong slice of reality. CLIO's answer is to treat context the way a database treats state, and to seal a receipt for every action.

    5 min
  26. essay

    We need an Agent500

    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.

    7 min
  27. update

    ChronoLog 3.0: SQL, pub/sub, and an MCP server

    ChronoLog 3.0.0 adds ChronoSQL, a pub/sub plugin, and an in-tree MCP server, so an agent can record and replay time-ordered activity through the same log a scientific workflow writes to.

    4 min
  28. essay

    High-performance agentic computing

    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.

    8 min
  29. essay

    Agent memory is a storage problem

    Memory for agents decomposes into tiers with different access patterns: episodic, semantic, procedural, working. Storage people already know how to build tiers, and a time-ordered shared log is the episodic one.

    8 min
  30. essay

    MCP for science: what sixteen servers taught us

    CLIO Kit ships sixteen MCP servers over scientific formats, schedulers, and a shared log. What they taught us about tool shapes, what a summarize tool must refuse, and where the protocol runs out.

    9 min
  31. essay

    Three pillars for a university in the AI era

    Faculty fluency first, a multi-vendor institutional strategy next, sovereign AI infrastructure as the destination. The case was made to the Illinois Tech faculty council and holds for any research university.

    7 min
  32. essay

    Why your AI infrastructure is already obsolete

    Obsolete means built on assumptions that no longer hold. Seven such assumptions behind current AI infrastructure, and the dissertation problem hiding in each, from a doctoral seminar at Illinois Tech.

    8 min

2025

  1. personal

    2025 reflections

    A personal record of 2025: a promotion, a keynote, two dissertations, a summer of teaching, a loss, and the argument I kept making all year about what a researcher is for now.

    7 min
  2. essay

    A researcher's guide to funding proposals

    What I look for on a review panel, and what I try to do when I am the one writing. The reviewer reads for the question first, the budget is a claim about the plan, and a team is an argument.

    8 min
  3. field note

    Two PhDs, one architecture

    Luke Logan and Jaime Cernuda defended in the same semester. Their dissertations are the two halves of the runtime and the agent layer we are building, and they got there by owning the problems, not by executing mine.

    4 min
  4. field note

    Reflecting on SC25

    What I noticed at SC25 in St. Louis, what the group brought, what a year of running the PDSW program committee taught me about how a workshop gets made, and a few notes for people attending their first SC.

    8 min
  5. essay

    AI coding agents for HPC researchers: what actually works

    Three workflows that hold up on real HPC code, the skill that decides whether an agent helps, and what kills adoption in three months. The talk was at the Innovative Computing Laboratory.

    9 min
  6. essay

    From storage optimization to context orchestration

    Twenty years of I/O research optimized bytes per second for programs. Agents are a different client, and each system in our lineage contributes one primitive to serving them, as argued in a seminar at Argonne.

    8 min
  7. field note

    Vibe Coding Fridays

    Twelve Fridays, three hours each, teaching a research group to work with coding agents: the frame that stuck, the bake-off at week five, the checklist, and what I would change.

    6 min
  8. essay

    Context is the new compute

    The scarce resource for scientific AI is not FLOPS or bytes but assembled, trustworthy context, and the storage we built as tanks has to become a refinery. From the AI4Sys keynote at HPDC 2025.

    8 min
  9. essay

    DTIO: turning labels into schedulable data tasks

    A data task is a label with a schedule. What DTIO adds to label-based I/O, what the SSDBM 2025 paper measured, and what a task runtime still has to prove.

    7 min

2024

  1. personal

    2024 Reflections: Year in Review

    The five-year NSF award for IOWarp, nine papers, a first organizing-committee role, the end of a two-year relationship, and what authenticity turned out to mean in 2024.

    5 min
  2. personal

    Change Hurts! Does it have to?

    Change hurts, but the pain is a symptom of how the loss is framed rather than a requirement of the loss itself. What military service and teaching showed about reframing an ending as an opening.

    6 min
  3. field note

    Reflecting on SC24

    What I noticed at SC24, what our group brought to Atlanta, and a few practical notes for first-time conference attendees.

    4 min
  4. update

    DLIO joins MLPerf Storage

    MLPerf Storage now uses DLIO, Hariharan Devarajan's deep-learning I/O benchmark maintained at Argonne, to generate its workloads. A research tool found a second life.

    2 min
  5. update

    NSF funds the next five years of IOWarp

    A five-year NSF award for IOWarp, the collaboration with The HDF Group and the University of Utah that grew out of Hermes.

    2 min
  6. update

    Hermes is complete

    Hermes v1.2.1 is the final release of a project that started as the center of my PhD and ran for five years with The HDF Group. What the multi-tier buffering bet proved, what it did not, and what moves into IOWarp.

    5 min
  7. essay

    Physical time as a sequencer

    ChronoLog 1.0.0 is out. A distributed log can order by synchronized physical clocks and drop the central sequencer. Why that trade fits activity data, what 1.0 delivers, and what worries me about clocks.

    7 min

2023

  1. essay

    Co-founding a research center

    The Scalable Computing Software lab at Illinois Tech is now the Gnosis Research Center. Why a lab with two decades of history became a center, what changes in practice, and what I am unsure about.

    6 min
  2. update

    DOE funds DTIO

    The Department of Energy has funded DTIO, a three-year project with Argonne to turn I/O requests into schedulable data tasks. It is what LABIOS labels become when a pipeline has more than one stage.

    4 min
  3. essay

    The label that became a patent

    US Patent 11,630,834 was granted today for label-based I/O. What a label is, how the idea went from a dissertation chapter to a best-paper award to a patent, and what a patent does not mean for research software.

    7 min

Follow one kind