Measuring the Agent Surface

A hard lesson from running agentic work daily: instructions that exist are not instructions that are followed. A cohesion rule sat in our governed policies while an agent built a god service that violated it. Adding more instructions in more places makes adherence worse, not better, because volume buries signal.

Token volume has become a spectator sport this year, with counters tracking who burns through a billion tokens first. That is not the metric here. The measurement matters as a proxy for attention: the more an agent is told, the less of it is followed.

The answer was not more governance text. It was to measure what an agent actually loads, and when.

1. Measure the surface first

Every agent session assembles its context from many surfaces: provider-global instruction files, repository instructions, project material, skills, and protocols. Nobody had ever totalled it. The first inventory found the boot surface alone, the material accumulated before a session has even started, ran to 283,293 characters.

You cannot streamline what you have not counted.

2. Classify by route role, not hierarchy

Surfaces are classified by the job they do for the task at hand: boot_contract (identity, rules, working relationship), operational_guidance (reusable procedures), or task_material (the specific work). Role is a routing decision, kept separate from authority, scope, and delivery. The same document can be boot material for one journey and task material for another.

3. Find duplication and conflict deterministically

Clone detection and structural analysis surface exact duplicates, partial overlaps, and contradictions across the instruction set, each with a severity and a linked source:

finding: duplicate_directive
rule: "no service owns responsibilities of separate primitives"
surfaces: [repo instructions, global policy, project protocol]
severity: medium
disposition: single canonical owner, pointers elsewhere

4. Supervised, never autonomous

Proposed changes to placement, precedence, or budget go through human disposition. Accepted changes are replayed against a representative journey before being retained. The system does not rewrite its own instructions; it recommends, a human decides, and evidence decides whether the change stays.

Every measurement is emitted as structured, graphable data, so baselines and candidates can be compared over time. The surface gets a trend line, not just a snapshot: is the boot load actually shrinking, and did the last accepted change help or hurt?

5. Provider-neutral by design

Adapters record what each host was declared to load versus what was observed. The analysis runs across Codex and Gemini today, with Kimi next. Cognition can move between providers; the authority and the instruction surface stay governed locally.

The same treatment applies to learned context: curated knowledge is routed into the pack as one bounded lane when relevant, not loaded wholesale. What an agent is told and what the operation has learned are both governed, both measured.