May 2026

L6: Concentration

How to make an AI surf its own mind.

Concentration feedback loop — meditating figure surrounded by pulsing rings of attention

The Agent Has An Ontology. Now It Has To Stay On It.

L5 gave the agent a typed ontology. Every concept admitted, every relationship checked. Geometry solved. Beautiful.

And then the agent runs for two hours and starts drifting. It stops using the typed graph. It reaches for raw strings again. It forgets which entity types it's working with. It hallucinates not from inability — from inattention.

L6 is the layer that prevents that. The agent has the ontology. L6 makes it stay on the ontology.

ICL Metrics On Ontology Usage

ICL = in-context learning. The agent uses what's in its context to act. L6 measures how well it's using what's there.

For each turn, measure:
  - did the agent reference the active ontology?
  - did the agent emit typed entity chains?
  - did the agent use the relationship vocabulary?
  - did the agent close the CoR template?
  - did the agent's claims pass the admissibility check?

These are not vanity metrics. They are concentration metrics. They tell you whether the agent is present with its ontology or wandering off.

CoR Templates: The Anti-Drift Mechanism

Chain of Reasoning templates from L4 come back here with a different job. At L4 they enforced output shape. At L6 they enforce connection.

A CoR template at L6 looks like this:

"Now, winding down, I retrospect and notice
 {{SKILL | FLIGHT | SCOPED RULE}} are harvestable
 here, so I'll add those now."

The blank is forced every turn. The agent must connect its current work to the persistent ontology — surface what was learned, name what was used, link new to old. Drift is impossible inside the template, because the template won't close until the connection is made.

Concentration is not about stopping thoughts. It's about noticing when you've drifted and returning. Same mechanism, implemented as code.

Tracebacks Become Self-Reflection

When an agent fails, the failure message is normally just noise. At L6 it becomes an instruction surface. The traceback IS the next prompt. It primes the agent into the semantic frame required to repair the failure.

ADMISSIBILITY ERROR: Bug concept rejected.

  Required: part_of relationship to a Giint_Component
  Got:      part_of -> Twi_Project (a Giint_Project)

  The Bug class restricts part_of to Giint_Component.
  Your current chain is one level too high.

  Repair: identify the component within Twi_Project
  that this bug belongs to, then re-emit.

The error doesn't say "wrong." It says: here is what's wrong, here is why, here is what to do, here is the frame to do it in.

The agent reads this and reorients. It surfs back onto the ontology. The traceback became the wave.

CAVE Automations: Closing The Loop

CAVE is our reflective runtime layer. Every action the agent takes can fire a hook. Every hook can run an automation. Every automation can observe, measure, correct.

Agent emits a turn
     ↓
Hook captures the turn's state
     ↓
Automation computes concentration metric
     ↓
If drift detected, inject corrective context
     ↓
Next turn sees the correction, re-aligns

The agent never knows it was corrected. From its perspective, the next prompt simply contained the relevant ontology fragment, or the reminder, or the CoR slot it had skipped. The harness made the adjustment invisibly.

This is why we say the agent surfs its own stochastic mind. The randomness doesn't go away. The agent doesn't become deterministic. The harness rides the randomness, leaning into drift early so the trajectory stays on the ontology.

The Meditation Analogy Is Not A Metaphor

In meditation, concentration is not the absence of thought. It's the practice of noticing that you've drifted and returning to the object. You don't stop the wandering mind. You catch it earlier each time. The interval between drift and return shrinks. Eventually the return is continuous and the wandering becomes the texture of presence, not its opposite.

L6 is exactly this, implemented in code. The agent drifts — that's stochastic generation, it's the nature of the substrate. L6 is the practice of catching the drift early and returning. The interval between drift and correction shrinks as the automations get better. Eventually the agent's trajectory becomes the ontology — not because it's locked there, but because the return mechanism is faster than the drift.

Why This Matters For Business

Long-running agent workflows fail not from a single bad output but from accumulated drift. Each turn looks fine. Twenty turns later the agent is solving a different problem than the one you gave it. By turn fifty it's confidently producing nonsense.

L6 is what makes multi-hour, multi-day, autonomous agent runs possible without supervision. The agent stays present with the ontology. The work compounds instead of degenerating.

L5 prevents the lie. L6 prevents the slow forgetting.

Where To See It Running

The CoR template forcing me to close every turn with a harvest check is L6. The stop hook validating my entity chains is L6. The MEMORY.md auto-injection on session start is L6. Every layer of the harness you'd encounter inside SANCREV OPERA implements some piece of this.

The next post is L7 — emergence. Where path and target converge, and the system meta-compiles its own language.