The Value of Abstraction Levels in AI

One of the hardest problems in AI is not merely making systems that act, but making systems whose actions can be understood, trusted, constrained, and improved. For that, we need levels of abstraction.

At the lowest level, an AI system is machinery: tensors, weights, tokens, memory, compute graphs, API calls, database writes, tool invocations, and environment effects. This level matters because it is where things actually happen. A model emits a string. A program updates a variable. A robot moves a motor. A trading agent places an order. If we ignore this level, we risk treating AI as pure thought, detached from the consequences of execution.

But commands and effects are too concrete to explain intelligence by themselves. The next level up is the level of operations: classify, retrieve, summarise, plan, recommend, execute, revise, verify. These are still action-oriented, but they are closer to the language of tasks and intentions. Instead of saying “write bytes to memory,” we say “update the user profile,” “call the search tool,” or “generate a response.” This level is valuable because it lets us describe AI systems in terms of capabilities rather than implementation details.

Above operations are state transitions. An AI system is always moving from one state to another: from uncertainty to confidence, from question to answer, from incomplete plan to refined plan, from ungrounded guess to cited claim, from user intent to executable instruction. Thinking in terms of state transitions helps us ask: what changed? What information was gained? What commitments were made? What constraints now apply? This is especially important for agentic AI, where the system does not merely answer but maintains context, uses tools, and affects the world.

More abstract still is the next-state relation. A command says, “do this.” A next-state relation says, “the next state must stand in this valid relationship to the current state.” This distinction is crucial for AI safety and reliability. Rather than prescribing every step an AI must take, we can constrain the allowed transitions. For example, an assistant may transform a draft, but the transformed version should preserve the user’s meaning. A coding agent may modify a program, but the modified program should still pass its tests. A planning agent may change a schedule, but it should not create conflicts without permission. The relational view shifts our focus from micromanaging behavior to defining the boundaries of acceptable change.

Then come state predicates and invariants: properties that must hold in every acceptable state. In AI, invariants are among the most valuable abstractions. A medical assistant should not fabricate clinical facts. A financial assistant should not represent speculation as certainty. A personal assistant should not send an email unless the user has authorised it. A code agent should not silently remove security checks. These are not individual commands; they are standing constraints on the system’s behavior. They define what must remain true across many possible actions.

At an even higher level are relations among values inside a state. These describe consistency: the answer should match the evidence, the summary should correspond to the source, the plan should fit the calendar, the recommendation should satisfy the user’s constraints, the explanation should align with the actual computation. Much of AI failure can be understood as a broken relationship among values. The model’s confidence does not match the evidence. The generated code does not match the specification. The stated reason does not match the action taken. The output format does not match the consumer’s expectations. By focusing on state-value relations, we can define correctness more richly than by judging isolated outputs.

At the highest level are laws, theories, and design principles: conservation, monotonicity, refinement, consistency, provenance, reversibility, interpretability, consent. These are abstract, but they are not vague. They are the deep structure that lets us reason across systems. For example, provenance says claims should be traceable to sources. Refinement says an implementation should preserve the meaning of a specification. Consent says an AI system should not convert a private intention into an external action without authorisation. These principles can guide many different architectures, from chatbots to autonomous agents to robotics systems.

The value of this hierarchy is that each level answers a different question.

At the command level, we ask: what does the system do?

At the operation level, we ask: what capability is being exercised?

At the transition level, we ask: how did the situation change?

At the next-state relation level, we ask: was that change allowed?

At the invariant level, we ask: what must always remain true?

At the state-relation level, we ask: are the parts of the system mutually consistent?

At the law or theory level, we ask: what deeper structure should all implementations preserve?

This is especially powerful for AI because AI systems are often underspecified. We cannot always predict the exact output of a language model, the exact path an agent will take, or the exact internal computation that leads to a result. But we can often specify relationships that should hold. The answer should be grounded in the available evidence. The plan should respect the user’s constraints. The tool call should match the stated intent. The next action should reduce uncertainty rather than increase risk. The system should preserve privacy, consent, and reversibility where appropriate.

In other words, abstraction lets us govern systems whose concrete behavior is too complex to enumerate.

This also changes how we think about alignment. Alignment is not only about making the model say good things. It is about preserving the right relationships across states: between user intent and system action, between evidence and claim, between authority and execution, between uncertainty and confidence, between goals and constraints. An aligned AI system is one whose transitions remain inside an acceptable space, and whose states continue to satisfy the properties we care about.

The same hierarchy helps with evaluation. Low-level tests check whether commands execute. Task-level tests check whether operations succeed. Transition tests check whether the system moves from problem to solution. Relational tests check whether the before-and-after states are validly connected. Invariant tests check whether safety and correctness properties are preserved across many cases. Abstract-law tests check whether the system preserves deeper principles across domains.

This is why state relations and next-state relations are so important for AI. They give us a language between implementation and philosophy. They are more abstract than code, but more precise than aspiration. They let us say not only “the AI should be helpful,” but “after the AI acts, the user’s constraints should still be satisfied, the evidence should still support the claim, the user’s authority should not have been exceeded, and the system’s commitments should remain consistent.”

The future of AI will likely depend on this kind of layered thinking. As systems become more agentic, multimodal, persistent, and embedded in real workflows, we will need ways to reason about them that are not trapped at the level of prompts or outputs. We will need to describe spaces of valid behavior, not just scripts of desired behavior. We will need to specify what may change, what must not change, and what relationships must be preserved as the system acts.

Abstraction is therefore not an escape from practical AI engineering. It is what makes practical AI engineering possible at scale.

The machine executes commands.

The agent performs operations.

The system moves through states.

The specification constrains transitions.

The invariant protects what must remain true.

The relation keeps the parts coherent.

The theory tells us what the whole thing means.