akougkas.io

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.

Published
Updated
Reading
5 min read
Topics
systems, data, scientific computing, agents, building

The boundary around one action

  1. Scientific state

    Data, metadata, provenance, and tools.

  2. Bounded context

    Select what the decision needs.

  3. Authorized action

    Apply tool contracts and human approval.

  4. Inspectable receipt

    Record selection, activity, and decisions.

Selection and authority shape one action, and a receipt records what happened.

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 compare deletes. The action it wants to take exceeds the authority of the person who asked.

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.

The thesis

CLIO 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.

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.

That is a data-systems claim, and it comes from a data-systems lineage. Hermes taught me that placement decisions are only trustworthy when you can see why they happened. LABIOS taught me that a request should carry its intent instead of forcing the system to guess. ChronoLog taught me to order activity at write time so it can be replayed later. DTIO 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.

What that looks like in code

CLIO Coder is the component where I test these contracts most directly, because I write it myself and a coding agent exposes every shortcut immediately.

Selection is bounded. 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 grep 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.

Authority is typed. 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 LABIOS label applied to an agent.

Everything leaves a receipt. A run seals tokens, priced cost, tool activity, safety decisions, routing, worker attestation, and result conformance. clio-coder evidence inspect 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 ChronoLog’s lesson, applied to a coding session.

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. IOWarp is where the rest of the team and I are carrying it into the context store, the scientific tools, and the science agent.

More context is not the goal

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.

The objective is the smallest sufficient context for a bounded action, with enough provenance and state to make the result inspectable.

Context is a data-movement problem

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 Hermes and LABIOS asked about I/O, and IOWarp’s transfer and assimilation engines ask them again with an agent on the other end.

What is unresolved

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.

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, run CLIO Coder against a model on your own GPU and read the receipt it seals.

Sources, code, and records

  1. source

    CLIO Coder safety model

    The autonomy matrix and the level-independent safety net, as implemented.

  2. source

    CLIO Coder observability

    How receipts and evidence bundles are built from the session ledger.

  3. source

    IOWarp documentation

    The runtime layers under CLIO.

  • 2025–present
    active

    CLIO

    A context layer for scientific AI agents and workflows

  • 2024–present
    active

    IOWarp

    Context management infrastructure for scientific AI

  • 2023–present
    active

    CLIO Coder

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

More on CLIO

  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. 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