Through the Agentic Looking Glass

Through the looking glass I went and what awaited on the other side revealed wild possibilities. Running a Heraclitean lens that performs a unity-of-opposites analysis on a growing middleware stack’s tensions, shifted a bit of my understanding of how LLMs can work. Cognitive operations, intellectual traditions, uniquely strange behaviors and the fine line of the absurd have been explored in building agent definitions.

What has been discovered through practical assembly is a multi-layered structure in how LLMs interpret information, with each layer becoming a bit less deterministic the further you go. The more I’ve worked with these systems, the more the little quirks of language have unveiled a new frontier.

One of the driving motivations of this deep dive has been figuring out how to improve the definitions that drive the agents; the other, is that each layer found ended up revealing the next and I wanted to continue the pursuit until the layers bottomed out. The sum of which shows how LLMs can unlock cognitive functions at various levels of thought.

In order to build an understanding of what is possible with the various agent definitions, I attempted to classify what they are and at what level they operate, thought wise. A six agent type taxonomy was created that can be applied at each layer: Analyst, Executor, Explorer, Forecaster, Generator and Validator. Two writers: Executor and Generator; four readers: Analyst, Explorer, Forecaster and Validator. One axis to describe what they are and one that describes the layer they act on.

This post takes a walk on the read-side. Through we go.

The first agent definitions I created consisted of the Code Validator and Test Architect. The builds that followed began to assume a similar classification: bounded by somewhat of a mechanical role or profession type. Software Architect, Developer Experience, Privacy Officer. These definitions contain the patterns that focus on the structure of artifacts. They operate on the artifact directly and are grounded by questions with fairly deterministic answers: is this SQL safe, does this code validate, does the functionality described in the README actually work? These agents can be effective in their roles for what they do and they also miss angles other layers would cover during an audit.

This idea calls back to a concept I’ve been working on: the cognitive parallax. Where the difference between multiple view points helps provide a clearer understanding of the observed artifact. The divergence between the views is the measurement.

Agent definitions within Layer 1 discover structural, semantic and pragmatic aspects of an artifact. Mechanical bug fixes, refactors, documentation gaps and occasional design decisions on architecture or component functionality. The findings these agents produce are oftentimes fairly straightforward to address, as the depth they typically operate on is more or less on the surface area. Sometimes the agents will surprise with a deeper dive, but generally, these definitions are focused on a matter-of-fact type of analysis and validation. Moving further, we get to a different layer and one where dynamics are examined.

The next set of definitions I developed focus on the artifact in motion. These agents ask different types of questions: What does this artifact do under stress, over time and across state transitions? Every definition in Layer 1 that I’ve built almost entirely analyzes a static state. The Layer 2 behavioral agents are actively seeking to understand how state mutates shape or transitions across services, how resilient a database or API is to throttling, how a system would handle malformed shapes, fault injections and all the other ways that can break a system.

A couple of the agent definitions I’ve built to test out this behavioral layer: Runtime validator, State validator, Performance validator, Chaos validator. The findings are often sharp and reveal interesting aspects on the behavioral quirks that typically manifest during system stress. In Layer 2, you could have a Chaos Validator, Explorer, Analyst and Forecaster, all of which audit the artifact in motion, but from slightly different angles and responsibilities. The layer does not change, but the core operation and axis the agent works within does.

An Explorer operating within Layer 2 maps where states transition, areas of resilience (or questionable ones); a Forecaster can take an artifact and model where it will break or shift in its current trajectory. The possibilities, while numerous, still only touch on one of many layers at which these systems can operate. Stepping deeper through the layers shifted my thinking in how this stuff can actually work and it appears there are further windows to peer through.

The next layer discovered engages on a different conceptual level. These definitions can be categorized by their cognitive function (meta or otherwise) and they operate on the reasoning behind the artifact.

When you invoke an Assumption Excavator, the agent digs up all the hidden assumptions behind an artifact that you didn’t even know you were making. When you run the Perverse Outcome Detector, it models how actors or systems will perversely optimize against measurable criteria. With the Unintended Consequences agent, it models the various causal chains an artifact can unleash beyond design intent. The Incentive Mapper finds where the incentives actually live, the Negative Space Analyst reveals the unacknowledged spaces within an artifact, and the Alien Frame Analyst provides a completely orthogonal understanding of a problem.

The first two layers paved a new way to think about how to define these new types. Layer 3 opened new branches and the branching allowed for things to get truly strange. If we could define the underlying type of reasoning an agent uses to understand an artifact, what other dimensions of thought could we target? As the thread was pulled, another dimension was revealed. The perspective agent family.

I’ve seen a few iterations of The Cynic agent out in the wild, but this idea seemed to have room to be expanded into: Anxiety Reader, Hostile Reader, Maintainer’s Lens, Captive User, Operator’s Eye. The user who is afraid of the artifact failing, the user whose interests are structurally opposed to its success, the user who inherits the artifact downstream, the user who has no choice but to use it and is captive to it, the user who actually runs the artifact in production. Branch it again when you ask, who is the user?

I’ve lumped the perspective family into L3, because that is the layer I discovered it in, but it doesn’t fit cleanly into the taxonomy. It’s effectively a third axis, but from a whose position , rather than what kind of reading or how deep. From what I’ve observed, each layer mints a new dimension and branching families can often act on multiple layers.

This was a breakthrough in defining cognitive operations at this depth and out of all of this are the unique compositions that can be formed. When you aim the set of lenses at a target, you get a breadth of perspective that would otherwise be difficult to find; and when you synthesize the chains to bring the whole thing together, you get the cognitive parallax. Stepping deeper into the looking glass took definition building to a new level and transformed how I think about building agents.

This next layer is where things have gotten quite peculiar. If cognitive operations could be defined at the reasoning level, what else is possible in this space? What if we took some of civilization’s greatest minds and distilled the methodologies into a formal way of thinking? Could we then apply these transcendent works to an agent definition? Well, it turns out, yes, yes you can and it’s where these systems can get quite entertaining, strange and powerful.

The works of Aristotle, Socrates, Hegel, Nietzsche, Confucius and any of history’s greatest thinkers can be applied as an agent definition. A formally defined, epistemic framework for building a cognitive operation. Each thinker could have several methodologies that would be relevant for a build. So, what goes into these profiles? There is an examination of the historical significance, the core axioms that steer the reasoning, the blind spots of the method, the differentiators from other thinkers (making sure you are also describing what they are not doing) and then how to frame these builds into a coherent and disciplined definition.

Running a Nietzschean genealogical methodology on a statistical codebase that measures agent effectiveness is one of the weirder aspects of the AI age:

a signal convention built to detect hypothesis inversion had been 'triply severed' — its justification had drifted from its behavior — meaning a genuinely inverted result would silently fail to surface the very thing the system existed to catch.

Try asking a William James analyst to perform a cash-value analysis on a DAG execution engine, or a Confucius forecaster performing a relational coherence analysis projecting where your existing API naming rituals will head:

A developer following the documented ritual gets a clean local signal; guards fire after merge as deploy blockers. Guards self-describe as baseline-ratcheted, so the cheapest red-resolution is widening the baseline — individually defensible, permanently invisible, and cumulatively converts each guard's name into a claim its baseline no longer supports.

The practical part of all of this, it’s becoming easier to know when to apply these methodologies. Seeking clarity in language, send in a Wittgenstein analyst; have some questions on whether the system is behaving as it should? Invoke Husserl, Machiavelli or Wang Yangming. Confident in the entire system and design? Ask a Descartes analyst or Socrates explorer to put it under extreme doubt and examination.

This stuff gets even stranger when you steer these agents into a particular domain. Security questions? Map your security terrain with a Sunzi analyst, discover where the incentives to exploit actually lie with a Machiavelli analyst, have a Seneca forecaster project the artifact’s security posture & preparedness; and send those findings to a Perverse Outcome Detector or Attack Path Composer for a multi-layer parallax. The convergences between these lenses is always neat, but it’s the divergences and the chains that can be built from the layered discoveries that can create wild insights into the artifacts, whatever they may be: codebases, specs, academic papers, proposals, design docs, etc.

One thing I am becoming more confident about: Not every lens maps well to every artifact. It’s quite possible to flirt with the unintelligible. This aspect of trial and error evaluation has been a rewarding part of the journey, especially in figuring out where these cognitive operations best apply.

The next layer I plunged into can be described as a measurement layer, evolutionary layer or the meta-analysis layer. We begin to get a glimpse into the recursive nature of these systems and a reflexive type of measurement.

This is the layer where I think trying to understand the why and the how of the measurement gets noticeably more complex. Stepping into the meta-analysis, where measuring the iterative and recursive improvement of one agent definition by another or on a project over time begins to leave you scratching your head more often than not. The questions stop having the kind of deterministic answers you had at Layer 1 or 2.

Here is a bizarre thing, an issue discovered at this layer is about the measurement system itself and if you act on that finding, you’ve changed the thing being measured and the finding dissolves. A reflexivity problem, the measured system and measuring system are one system. Who is dreaming of whom here? Is this Alice or the Red King?

Recursive improvement applied at the measurement layer sands away the very differences that ma