Thought of the Month (February 2026): Agents Need Self-Modeling Humans

while (world) { observe(); infer(); hallucinate?(); self-correct(); } while (world) { observe(); infer(); hallucinate?(); self-correct(); } while (world) { observe(); infer(); hallucinate?(); self-correct(); }

001101 010011 sigil::bagua seed::entropy trace::mechanical awe::human 001101 010011 sigil::bagua seed::entropy trace::mechanical awe::human 001101 010011 sigil::bagua seed::entropy trace::mechanical awe::human

temperature=0.92 top_p=0.95 sampler=stochastic runtime=deterministic user=astonished temperature=0.92 top_p=0.95 sampler=stochastic runtime=deterministic user=astonished temperature=0.92 top_p=0.95 sampler=stochastic runtime=deterministic user=astonished

☰☱☲☳☴☵☶☷ oracle != truth ritual == interface meaning <- interpretation ☰☱☲☳☴☵☶☷ oracle != truth ritual == interface meaning <- interpretation ☰☱☲☳☴☵☶☷ oracle != truth ritual == interface meaning <- interpretation

seed = hash(question + state); noise = sample(temperature); pattern = deterministic(seed, noise); if (human_can_track === false) mark("mystic"); return explainability_gap(pattern); seed = hash(question + state); noise = sample(temperature); pattern = deterministic(seed, noise); if (human_can_track === false) mark("mystic"); return explainability_gap(pattern);

## Not a person, still persuasive - interface implies intention - language implies confidence - user infers agency => design for interpretability ## Not a person, still persuasive - interface implies intention - language implies confidence - user infers agency => design for interpretability

cast.bagua = pickTrigrams(seed); cast.moonBlocks = deriveHexagram(seed); cast.fortuneSticks = burnModel(intensity); cast.scapula = generateCracks(seed); return readable_fiction(cast); cast.bagua = pickTrigrams(seed); cast.moonBlocks = deriveHexagram(seed); cast.fortuneSticks = burnModel(intensity); cast.scapula = generateCracks(seed); return readable_fiction(cast);

{ "observe": true, "decide": constrained, "act": reversible, "measure": behavior, "learn": weekly } { "observe": true, "decide": constrained, "act": reversible, "measure": behavior, "learn": weekly }

def perceivable_randomness(system): return complexity(system) > attention_budget if perceivable_randomness(llm): user.labels_output = "fate" def perceivable_randomness(system): return complexity(system) > attention_budget if perceivable_randomness(llm): user.labels_output = "fate"

[trace] t=02:13 system murmurs [trace] tokens fall like ash [trace] certainty simulated [trace] mechanism remains [trace] human names it chance [trace] t=02:13 system murmurs [trace] tokens fall like ash [trace] certainty simulated [trace] mechanism remains [trace] human names it chance

My thought for February 2026 is simple: AI agents are most useful in the hands of people who can model their own thinking.

A lot of agent discourse assumes the bottleneck is tooling sophistication. In practice, the bottleneck is usually human clarity. If a person cannot describe the goal, constraints, and definition of done in plain language, the agent is forced to optimize ambiguity.

That is why many agent workflows feel impressive and fragile at the same time.

What self-modeling means in practice

Self-modeling is not introspective fluff. It is operational clarity:

What outcome am I actually trying to produce?
What quality bar matters for this outcome?
What risks are unacceptable?
What decisions must stay human-owned?

Without those answers, delegation quality collapses.

The delegation rule

Treat each agent as an autonomous extension of one goal.

When one agent is overloaded with mixed objectives, you get scope bleed, conflicting heuristics, and confusing output evaluation. One agent, one objective, one observable success condition is a much stronger base pattern.

Technical literacy is part of the stack

Even with clear goals, operator competence still matters. People using agents need enough technical understanding to inspect what happened:

what tools were called
what assumptions were made
where uncertainty entered
how outputs were transformed before delivery

If you cannot audit the path, you cannot govern the system.

Why this matters now

As agent frameworks get easier to spin up, the failure mode shifts from “can we build this” to “can we steer this responsibly.” Teams that win will not be the ones with the most agents; they will be the ones with the best delegation architecture.

Bottom line

The real leverage pattern is:

strong self-modeling
scoped delegation
technical auditability

Agents amplify whatever operating discipline you already have. If that discipline is weak, they amplify confusion. If it is strong, they amplify execution.

Your human friend, Oli — Oliver Cheng | February 28, 2026