The Inversion of Software

Reader’s guide

This booklet follows a single argument in five parts.

Software observability grew up at the base of the activity hierarchy, where operations have clear computational identities and the purposes they serve are held by people. Agentic systems bring two transformations. Activity enters the runtime, as software takes on the interpretation of goals, the selection of actions and the judgment of results. The means of action are constructed during execution, as agents generate, revise and delegate the procedures they use.

These transformations produce two inversions. Interpretive time moves into the runtime, so the upper levels of the hierarchy become substantial parts of software behaviour. Attention moves toward the uncertainty that matters, which now resides at those upper levels.

The response proposed here is situational representation. The activity becomes the unit of observation. The situation, an extension of Leontiev’s hierarchy, represents the agent’s interpretation of the circumstances of the whole undertaking. The observable activity brings purpose, situation, action and evidence together in one representation that stays coherent as implementations appear, change and disappear.

Each part opens with a short statement of its claim. Figures carry the argument visually, and each section closes with a one-line summary marked In brief. A glossary of the terms the argument builds follows the final part.

1. The condition. What we learned to observe, and the activity hierarchy that explains it.
2. The transformations. Activity enters the runtime, and means are constructed during execution.
3. The inversions. Interpretive time and attention move toward the apex.
4. The representation. Traces, the situation and the observable activity.
5. The judgment. Completion, quality and deliberate interruption.

Software observability grew up at the base of the activity pyramid.

The world we learned to observe

For much of the history of software engineering, we have constructed systems whose behaviour was largely determined before execution.

Engineers designed functions, procedures, services and workflows. They specified the operations a system could perform, the conditions under which those operations would be invoked, and the outcomes they were expected to produce. Much of the complexity of deciding how the system should behave was resolved during design and implementation.

Users encountered these systems through interfaces that exposed their capabilities: commands, menus, buttons, forms and, eventually, sophisticated workflows. The software provided the means. The user brought an understanding of what they were trying to achieve.

Consider a business analyst investigating a discrepancy in a financial report. They open several applications, retrieve records, filter transactions, compare results, export spreadsheets and communicate with colleagues. Each application functions exactly as designed. Every request succeeds, every database query completes within its expected latency, and every workflow produces its intended output.

The activity that brings these operations together exists largely in the analyst’s mind. The analyst understands why the discrepancy matters, what constitutes meaningful evidence, when an investigation is heading in the wrong direction, and whether the emerging explanation is adequate. Software offers affordances through which the analyst acts. The organization of those actions into a meaningful undertaking remains human work.

This division of responsibility shaped the software industry, including the way we came to instrument, observe and manage computational systems. We became exceptionally good at observing the operations we had designed. The broader activities those operations served lay beyond the boundary of our instrumentation. For decades this arrangement worked, because the human supplied the surrounding context.

Agentic systems are changing that arrangement, and the change reaches the organization of software itself.

In brief Instrumentation captured the operations, and the human held the activity.

Activity, action and operation

An older framework provides a useful way to understand this change.

The Soviet psychologist Aleksei Leontiev, building on the cultural-historical tradition associated with Lev Vygotsky, developed an account of human activity organized around three related levels: activity, action and operation.

At the highest level, activity is oriented toward a motive: the underlying purpose that gives behaviour its meaning and direction. In Leontiev’s account, a motive belongs to a subject and arises from that subject’s practical and social relationship with the world. An activity is realized through actions, which are directed toward identifiable goals. Actions are accomplished through operations, whose particular form depends on the conditions in which they are performed.

The same action may be carried out through different operations as circumstances change, and the same operation can contribute to actions serving very different purposes.

Consider driving a car. A person’s activity may be travelling to visit a friend. Their actions include selecting a route, navigating junctions and finding somewhere to park. Their operations include steering, changing gears and adjusting speed under prevailing conditions. The operational details are interpreted within the context of the action, and the actions acquire their significance from the activity.

The levels can be pictured as a pyramid. Operations form its broad base: numerous, repeatable and bound to conditions. Actions occupy the middle. Activity sits at the apex, where a single motive gathers many actions toward one purpose. Software observability grew up at the base of this pyramid.

The hierarchy allows us to ask three questions of any purposeful behaviour:

• Why is something being undertaken? This is the question of motive.
• What is being attempted? This is the question of goal.
• Under what conditions, and by what means, is it being accomplished? This is the question of conditions.

These questions have always been relevant to computing. What has changed is how much of their resolution now occurs inside the software during execution.

In brief Motive, goal and conditions organize purposeful behaviour into three levels, and observability grew up at the lowest.

Two movements between the levels

Leontiev recognized that the levels are dynamic. Two movements connect them, and together they are the mechanism through which the inversion described in this booklet takes place.

The first is operationalization. Through practice, the means of an action come to run under established conditions as routine, and the action settles into an operation. Attention is released for other work.

The second is breakdown. When circumstances change or a routine fails, an operation that was performed automatically returns to deliberate attention and becomes an action again. Something previously taken for granted must be examined, diagnosed and adjusted.

These movements matter for everything that follows. They explain how behaviour shifts between levels during an undertaking, and each movement is itself an event with significance for the activity. Later sections treat both as observable signals.

In brief Operationalization moves behaviour down the hierarchy, and breakdown moves it up.

The traditional distribution of responsibility

Much of conventional application development can be understood as a process of transferring known actions and operations into software.

An engineer implements a procedure. A designer exposes it through an interface. An architect composes procedures into services. Product teams organize services into workflows intended to support particular user activities. Highly configurable systems still bound their behaviour by a design established in advance.

The interface becomes a collection of affordances. A user can search, submit, approve, cancel, reconcile, export or authorize. Each capability is available within a particular context, subject to defined constraints. The user decides how to combine these affordances in pursuit of a broader purpose.

Instrumentation naturally gravitated toward the things software engineers could identify and measure. We instrumented functions, requests, transactions, services, database operations and network interactions. We measured execution time, throughput, error rates, resource consumption and availability. Distributed tracing extended this view across services and machines, allowing a request to be followed through a complex computational landscape.

These mechanisms gave us considerable insight into the execution of software. Their effectiveness also depended on knowledge held elsewhere: the designs, contracts, architectures and expectations that explained what an execution was supposed to accomplish. A trace could tell us where a transaction spent its time. A metric could tell us whether the system remained within its operational limits. A log could record an exceptional condition. The meaning of the activity was supplied by the engineer or operator interpreting that evidence, and the user’s broader purpose remained an external concern.

We concentrated our attention at the base of the pyramid, where operations had clear computational identities. We knew their names, their expected behaviour, their dependencies and the conditions under which they were considered successful. The activity itself was contextual, varied and closely bound to human judgment, and it stayed with the people who carried it.

In brief Software held the operations, people held the activity, and instrumentation followed the software.

Activity enters the runtime, and the means of action are constructed during execution.

Two transformations, two inversions

Two transformations are reshaping where the questions of motive, goal and conditions are resolved.

The first is that activity enters the runtime. Software takes on the interpretation of goals, the selection of actions and the judgment of whether results are adequate. The second is that the means of action are constructed during execution. Agents generate, revise and delegate the procedures they use.

Together they produce two inversions. Activity in the runtime moves interpretive time into software. Construction at runtime makes code identities short-lived, so continuity must be held at the levels of action and activity. Both effects move attention toward the continuity of the undertaking and the uncertainty that surrounds it.

In brief Activity in the runtime and construction at runtime together invert time and attention.

The first transformation: activity enters the runtime

Now consider the same financial investigation performed by an agent. A user provides an instruction: “Find out why the revenue figures in these two reports differ.”

The agent begins with an interpretation of the request. It inspects the reports, identifies possible explanations, retrieves supporting records, compares accounting periods, generates reconciliation code, tests hypotheses and asks for clarification. During this process, the nature of the undertaking changes. An apparent arithmetic discrepancy turns out to involve differences in accounting policy: the two reports use different definitions of recognized revenue. The agent must then determine whether the discrepancy is expected, whether it reflects an error, and which stakeholders should be consulted.

Three things are present in this scenario, and keeping them distinct clarifies what has entered the runtime.

The motive belongs to the organization: accurate financial reporting, and the decisions and obligations that depend on it. It carries the social and practical significance Leontiev attributes to motives, and it is held by the people and institutions on whose behalf the work is done.

The goal is what the agent receives: an explanation of the difference between two sets of figures. It is delegated, and it expresses one action within the organization’s larger activity.

The interpretation is what the agent develops. It begins as a reading of the goal and evolves through engagement with the evidence, from arithmetic error to definitional difference to a question of who should decide.

What enters the runtime is the organization of the undertaking. The agent carries a representation of the motive, works toward the delegated goal, and maintains an interpretation that determines which actions are relevant, which conditions apply and whether the results are adequate. In Leontiev’s terms, the activity remains anchored in the motive of its human subject, and the agent participates in it at the levels where goals are interpreted and actions are organized. In computational terms, the undertaking gains a continuous existence inside the system.

This distinction has practical consequences. Authority flows from the owner of the motive, and the agent’s interpretation answers to it. Because the interpretation evolves, it can drift from the purpose it was given. Representing motive, goal and interpretation separately makes that drift observable.

Conversation is the mechanism through which the meaning of the activity is negotiated. An instruction may be clarified, extended, restricted or reconsidered over several turns, and the agent acts between those turns, accumulating evidence that changes how later instructions are understood. The activity develops through its own history. The system must maintain enough continuity to recognize which actions belong to the undertaking, which assumptions remain valid, what has been established and what still requires resolution.

In brief The motive stays with its owner. The agent carries its representation, pursues the delegated goal and develops the interpretation, and authority runs from motive to interpretation.

The second transformation: means constructed during execution

Agentic coding introduces a further dimension. In conventional software, engineers established the executable means before they were used: an application invoked procedures that had already been designed, implemented, tested and deployed. An agentic coding system constructs some of those means during the activity itself. It generates a script, creates a function, modifies an implementation, introduces a test, assembles existing tools into a new workflow, discards an approach that proves inadequate, or delegates work to another agent that determines its own intermediate actions.

Three distinct movements are at work.

Generation produces a candidate procedure in service of an action. The candidate is experimental. It may run once and be discarded, and its existence alone says little about whether it is dependable.

Operationalization occurs when a procedure has proven dependable under established conditions, so that it can run as routine. A procedure reaches this point through evidence: repeated success, conditions that are known and stable, and outcomes that match what the action requires. Operationalization is how an agent learns which procedures are safe to reuse.

Breakdown occurs when a procedure fails or returns something unexpected. The operation surfaces as an action again, and the agent attends to it deliberately: it diagnoses, adjusts and selects other means, revising the action where necessary.

The relationship between activity, action and operation becomes fluid. An activity gives rise to actions. An action generates new procedures. The outcomes of those procedures lead to a revision of the action, or a reconsideration of the activity, and the process repeats.

Generated procedures depend on existing computational foundations: language runtimes, libraries, operating systems, services and hardware, all governed by the usual physical and computational constraints. Above that foundation, the particular organization of procedures is contextual and temporary. A function exists to support one investigation. A workflow is assembled for one occasion. The identities of executable components are short-lived, and the meaningful continuity resides at the levels of action and activity.

This raises the central question for observability. If an action survives several changes in implementation, how should its continuity be represented? If an activity continues through many revisions of its actions, what allows us to understand its progress? The names and structures of the underlying code supply one strand of the answer. The remaining strands come from representations of action and activity.

In brief Generation supplies candidates, operationalization establishes what is safe to reuse, breakdown triggers revision, and continuity lives above the code.

Interpretive time and attention move toward the apex.

The inversion of time

Activities have always outlasted the operations that realize them. The analyst’s investigation persisted for twenty minutes while each request completed in a fraction of a second. The duration hierarchy itself is old.

What has changed is where interpretive time is spent and where continuity is held. In the traditional arrangement, the analyst spent those twenty minutes interpreting: forming hypotheses, choosing what to examine, judging whether the evidence was sufficient. The software executed brief, well-defined operations within that period. In an agentic system, the runtime spends the twenty minutes evaluating hypotheses, selecting actions, revising its understanding and determining whether the activity has progressed. The upper levels of the hierarchy become substantial parts of runtime behaviour.

Three temporal quantities make this precise.

Execution time is spent performing operations: the duration of computational work under prevailing conditions.

Interpretive time is spent establishing, revising and evaluating the meaning of circumstances: what the situation is, what should be attempted, how results should be understood and whether further intervention is necessary.

Activity duration is the elapsed time of the undertaking, including waiting for authorization, delegation to other agents and the succession of actions through which the activity proceeds.

These quantities overlap. An activity remains open while operations execute in parallel, while the agent awaits external information, or while a human considers a request for authorization. Their durations nest and interleave, so each is measured on its own terms. Actions structure the activity duration: each has its own span, from the decision to attempt something to the point at which the attempt succeeds, is revised or is set aside.

Interpretive time is the quantity that has moved. It now occupies the runtime, and it increasingly determines both the duration and the quality of the undertaking. The quality of interpretation governs whether the activity converges, how many of its actions are revised, and how much execution it consumes along the way. Interpretive time also rises into view whenever breakdown returns an operation to deliberate attention, which makes it a signal as well as a cost.

An activity resolves on its own terms. Every operation within it can complete successfully while the activity remains open.

In brief Interpretive time has moved into the runtime, and it now shapes how long the undertaking takes and how well it goes.

The inversion of attention

For decades, observational attention was concentrated on procedures, requests and transactions. Those were the units we instrumented: identifiable, repeatable and relatively easy to measure. Performance meant latency and throughput. Reliability meant availability, error rates and adherence to operational expectations. Investigations began with failures, slow requests and anomalous resource consumption.

These measures remain essential. Computational infrastructure runs on them, and their evidence feeds every judgment about higher-level behaviour.

Attention follows relevance, uncertainty, consequence and the opportunity to intervene. In agentic systems, the uncertainty that matters most resides at the upper levels of the hierarchy, and attention moves toward it. Each level draws attention under its own conditions, and the questions it raises gather under motive, goal and conditions.

Relevance, justification and the appropriateness of an approach are judgments about the activity. The operational record supplies evidence for them, and the judgments themselves form at the levels of action and activity. Dynamically generated code, delegated agents and external tools make complete operational visibility a receding target, which places further weight on representing the upper levels well.

As software assumes more responsibility for organizing purposeful behaviour, understanding that organization becomes an operational concern. The upper levels of the hierarchy become places to observe and manage.

In brief Attention moves toward the uncertainty that matters, and that uncertainty now sits at the upper levels of the hierarchy.

Activity and situation become the unit of understanding, and the observable activity takes shape.

What traces reveal

The emergence of agent tracing already reflects part of this transition. Instrumentation is expanding to include model inference, agent invocations, tool use, planning, delegation and workflow execution. OpenTelemetry’s semantic conventions for generative AI provide a concrete example. Maintained in their own repository since mid-2026 and still in development, they define operations for creating and invoking agents, invoking workflows, planning and executing tools: create_agent, invoke_agent, invoke_workflow, plan and execute_tool.

A trace records instrumented execution relationships, such as parentage and timing, and supplies evidence useful for causal analysis. Those relationships are extremely valuable. The meaning of an activity depends on further relationships that extend past the structure of its execution.

An agent executes a tool, inspects its result, rejects an earlier assumption and pursues a different explanation. The trace represents the tool invocation and its computation, and additional events can record that a plan was revised or a hypothesis rejected. The significance of that revision depends on the activity and the situation in which it occurred. A change of direction can represent progress, confusion, recovery or an unauthorized deviation. An interrupted workflow can indicate a failure or the discovery of a better approach. A sequence of successful operations can indicate productive execution or the persistent pursuit of a mistaken objective.

Interpreting execution evidence requires relationships concerning goals, commitments, uncertainty and outcomes. An activity persists across successive configurations of execution relationships, and the trace records each configuration. Declared plans, where instrumentation captures them, are evidence to be evaluated. The correctness of an interpretation and the adequacy of an action are established against the situation.

The field has begun to measure the shortfall. A multistakeholder assessment from the Partnership on AI evaluates four widely used agent frameworks against six safety monitoring goals and identifies six gaps in what they emit: persistent agent identity, permission mode changes, memory changes, human intervention, chain-of-thought reasoning and token-level log probabilities. Its remedies extend the OpenTelemetry conventions with further fields and derive monitoring signals downstream, by joining traces to access-control records, tracing provenance across agents, comparing outputs with references and baselining behaviour across runs. Its illustrative failures are changes in an agent’s situation: a one-off exception stored in memory as a general rule, an early match held against contradictory evidence, and reviewer approval rates drifting upward over months. In that framing, each becomes visible through a new record type and inference after the fact.

Higher-level operation names and richer fields strengthen tracing, and they sharpen the architectural question that remains: which identity persists when the execution structure changes? The assessment’s first gap concerns the identity of the agent that acted. The identity of the undertaking belongs beside it in the record.

In brief Traces record each configuration of execution, and the activity is the identity that persists across them.

The activity as the unit of understanding

What should constitute the unit through which an agentic system is understood?

The activity is the unit of understanding. It holds continuity of purpose across every revision of requests, workflows, plans and generated procedures, each of which may be brief, changeable or temporary. Understanding an activity means following its development. As it progresses, the agent’s view of the world evolves: evidence accumulates, assumptions change, possibilities emerge and constraints become visible.

That evolving view needs a representation of its own. This is the role of the situation.

In brief The activity carries continuity of purpose, and its evolving view of the world calls for the situation.

The situation: a proposed extension

Leontiev attached conditions to operations: the circumstances that shape how an action is carried out. This booklet proposes extending that idea upward. The situation gathers the conditions of the whole undertaking and makes them available at the levels of action and activity. It is the term this account adds to Leontiev’s hierarchy.

A situation is the agent’s interpretation of the presently relevant circumstances of an undertaking: its context, current status, uncertainties, constraints, commitments, permissions and possibilities for action. Two things are therefore distinct. The circumstances belong to the world. The situation is what the agent has constructed from the evidence available to it. The agent may hold incomplete evidence, and its understanding may drift from what is happening. The fidelity of the situation to the circumstances is itself an observable quality, and contradictory evidence is one of its most important signs.

The situation plays an active role. It shapes which actions are appropriate, what the undertaking can accomplish and whether the original purpose remains achievable. Actions in turn revise it. A situation changes because of an action, because new evidence becomes available, because an external condition changes, or because the system reinterprets information it already possesses.

An activity persists through many situations. The activity carries continuity of purpose. The situation carries the evolving significance of the circumstances in which that purpose is pursued. Actions become meaningful through their contribution to the activity under those circumstances, and operations provide the means through which those actions are realized.

The situation also provides a place for uncertainty. An agent can know which operations it has performed and remain uncertain about what their results imply. That uncertainty is operationally significant, and the situation is where it is held, revised and reduced.

In brief The situation extends Leontiev’s hierarchy as the agent’s interpretation of the circumstances of the whole undertaking, shaping action and revised by it.

The observable activity

The argument so far establishes the activity, the evolving situation and the reach of execution traces. One step remains before judgment: what an observable activity would contain.

The sketch has four layers.

The activity layer holds purpose, ownership, authority and commitments. It identifies whose motive the undertaking serves, who may direct it, what the agent is permitted to do and what it has promised.

The situation layer holds evidence, assumptions, uncertainty, constraints and possibilities. It is the agent’s current interpretation, together with the evidence that supports each part of it.

The action layer holds the current goal, progress, decisions, revisions and outcomes. It records what is being attempted, why each choice was made in the situation that prevailed, and how each attempt ended.

The operations layer holds procedures, events, signals and execution relationships. It is the evidence base, and it includes the traces of the previous section.

The layers are linked. Situation and action inform each other continuously: the situation shapes which actions are appropriate, and each action revises the situation. Execution supplies evidence to the situation and changes the circumstances it interprets. The transitions between levels, breakdown and operationalization, are recorded as signals, because each reports on the state of the activity.

The value of this representation lies in what it keeps coherent. Procedures appear, change and disappear. Plans are revised and hypotheses abandoned. Through all of this, the identity of the activity persists, each revision of the situation stays linked to the evidence and actions that caused it, and each action stays linked to the goal it served and the situation in which it was chosen. That coherence is what makes the undertaking observable while it is still unfolding.

This is a conceptual sketch, ahead of any runtime schema. It names what must remain coherent across changes in implementation, and it provides the basis for the judgments that follow.

In brief The observable activity links purpose, situation, action and evidence, and keeps them coherent as implementations change.

Completion, quality and deliberate interruption become observable, and the pyramid inverts.

Progress, resolution and the movements between levels

Once activity and situation become central to our understanding, the measures we need begin to change. Each level has its own measure of completion.

Progress and resolution are distinct conditions of an activity. Actions can complete successfully after a change of circumstances has drained them of relevance, and their completion leaves progress where it stood. An expensive investigation that eliminates a critical uncertainty represents substantial progress; its product is the uncertainty removed. Resolution is a judgment about the situation as a whole, made against the motive.

Interpretive time becomes measurable as the time taken to establish a sufficiently confident interpretation of the situation. That process can be assessed through the development of confidence, the elimination of possibilities and the resolution of uncertainty.

The movements between levels are themselves observable. When an operation surfaces as a deliberate action, breakdown has occurred and the situation has shifted. When a procedure proves dependable and settles into a reusable operation, the system has learned something about its conditions. Both transitions are signals, and both report on the state of the activity above any single operation.

In brief Operations end, actions complete, activities progress and resolve, and the movements between levels report on all of it.

Six qualities of a developing activity

Further qualities come into view. They are related, and each is independently useful.

These qualities take several forms: numeric measures, explicit declarations, contextual evidence and assessments that retain their degree of uncertainty. The objective is to represent them well enough to support decisions.

An agent’s own assessment is evidence of a particular kind. When an agent reports that it has completed an activity, that report is one sign among others, set beside what its behaviour and outcomes independently establish. The relevant question is whether the observed situation supports the conclusion, and it gains weight as agents act over longer periods with less direct supervision.

In brief Relevance, adequacy, convergence, stability, confidence and steerability make the quality of a developing activity observable.

Knowing when to stop

Stopping shows the shift clearly. Completion conditions were once built into the procedures. A transaction committed. A request returned. A batch process finished. A workflow reached its terminal state. In agentic systems, completion becomes a matter of judgment.

An investigation can produce enough evidence to support a decision while some uncertainty remains open. A coding agent can continue refining an implementation past the point at which additional work provides meaningful benefit. A research agent can keep searching for confirming evidence while its understanding stays where it was.

In Leontiev’s terms, continuation has settled into routine. The agent carries actions forward as though they were operations, sustained by momentum while their connection to the motive thins.

Breakdown names a disruption that returns an operation to deliberate attention. Stopping well draws on the same movement by choice: a deliberate interruption of an established course of action, re-examining it against the motive ahead of any failure. The outcomes are to continue, to reconsider, to suspend, or to return authority to a human. This capacity is a central element of situational intelligence, and it gives steerability its substance. The system preserves its ability to revise, suspend and return authority as circumstances develop.

The assessment belongs to the relationship between the activity, the current situation and its possible outcomes. It also depends on constraints established by the user or organization. An agent may be authorized to investigate a problem while requiring additional approval to modify production data, communicate with external parties or make irreversible changes. Authority belongs to the activity’s observable state. Understanding what an agent is attempting must include an understanding of what it is permitted to undertake.

A well-functioning agent has sufficient situational understanding to recognize when continuation is appropriate, when reconsideration is needed and when authority must return to a human. Observability needs to support those judgments.

In brief Stopping well is a deliberate interruption, continuation re-examined against the motive, with authority held in the observable state.

Software as an open-ended process

Dynamic software systems have a long history. Planners, interpreters, schedulers, rule engines, adaptive controllers and autonomous systems have existed for decades, and software engineers have long worked with behaviour that emerges from interactions between components and environments. The present transition builds on that history.

What makes agentic systems significant is the breadth of behaviour that can now be organized dynamically through natural language, learned representations, tool use, code generation and interaction with external systems. More of the decisions that determine the organization of an application are deferred until execution. An agent interprets a task, constructs a plan, selects capabilities, creates additional means of execution and revises its approach in response to results.

The procedural substrate is a finite repertoire of tools and computational mechanisms. The ways those mechanisms can be organized into actions, and those actions into activities, open a vast contextual space above it. Our ability to understand that space depends on how effectively we represent purpose, context, relationships and change. Understanding what an agent attempts and achieves requires a representation of behaviour as it develops.

In brief A finite procedural repertoire opens a vast space of organized behaviour above it.

The new centre of gravity

The emphasis on procedural observability followed naturally from how software was built. Software engineering invested enormous effort in determining behaviour before execution, and instrumentation provided evidence about the performance of those established designs. Interfaces exposed predefined affordances, and people organized those affordances into meaningful activities.

Agentic systems are redistributing that work. Purpose enters through conversation and other forms of instruction. Actions are composed dynamically. Procedures are generated, proven, reused and replaced. The activity persists through cycles of exploration, execution, feedback and revision.

This changes the temporal character of software, as interpretive time moves into the runtime. It changes where we direct our attention, toward the uncertainty that matters at the upper levels. The behaviour that most needs explanation is distributed across plans, conversations, assumptions, decisions, generated artefacts, external effects and evolving situations.

We now need systems capable of making purposeful activity comprehensible as it unfolds. That requires understanding how activities form, how their meaning develops, how actions are selected, how behaviour moves between levels as procedures are proven and routines break down, how situations change, how uncertainty is reduced, and how completion or intervention can be justified.

The activity hierarchy gives us a way to recognize the shift. Time reveals its growing significance. Attention reveals where understanding is most urgently required. Situational representation, carried by the observable activity, offers a direction for the observability this new world demands.

For much of the history of application software, the most accessible things to observe were the operations we had already designed. Today, consequential parts of software behaviour are determined during execution itself.

The pyramid has inverted. Its upper levels have expanded into a vast space of interpretation, planning, adaptation and purposeful action.

That is where much of the uncertainty now resides.

That is where our attention is moving.

And that is where the next generation of observability must learn to operate.

Glossary

Activity

Purposeful behaviour oriented toward a motive and realized through actions. The unit of understanding in this booklet.

Action

Behaviour directed toward a goal within an activity.

Operation

The means by which an action is accomplished, shaped by the conditions in which it is performed.

Motive

The purpose that gives an activity its meaning, held by the subject on whose behalf the activity proceeds.

Goal

The aim of an action. In agentic systems, goals are often delegated.

Interpretation

The agent’s developing reading of its goal and circumstances.

Generation

The production of a candidate procedure in service of an action.

Operationalization

The settling of an action’s means into routine, once a procedure has proven dependable under established conditions.

Breakdown

The return of an operation to deliberate attention when circumstances change or a routine fails.

Execution time

Time spent performing operations.

Interpretive time

Time spent establishing, revising and evaluating the meaning of circumstances.

Activity duration

The elapsed time of an undertaking, including waiting, delegation and successive actions.

Situation

The agent’s interpretation of the circumstances of the whole undertaking: context, status, uncertainties, constraints, commitments, permissions and possibilities. The extension this booklet proposes to Leontiev’s hierarchy.

Observable activity

A layered representation linking activity, situation, action and operations, kept coherent as implementations change.

Deliberate interruption

The chosen re-examination of an established course of action against its motive, ahead of any failure.

Lineage and references

Foundations

• L. S. Vygotsky, Mind in Society: The Development of Higher Psychological Processes (Harvard University Press, 1978). The cultural-historical tradition on which activity theory builds.
• A. N. Leontiev, Activity, Consciousness, and Personality (Russian original 1975; English translation, Prentice-Hall, 1978). The hierarchy of activity, action and operation, with motive, goal and conditions.
• T. Winograd and F. Flores, Understanding Computers and Cognition: A New Foundation for Design (Ablex, 1986). Breakdown in the use of tools.
• S. Bødker, Through the Interface: A Human Activity Approach to User Interface Design (Lawrence Erlbaum, 1991). Breakdowns and focus shifts in activity-theoretical design.
• V. Kaptelinin and B. A. Nardi, Acting with Technology: Activity Theory and Interaction Design (MIT Press, 2006).
• V. Kaptelinin, “Activity Theory,” The Encyclopedia of Human-Computer Interaction, 2nd edition (Interaction Design Foundation).

Current practice

• OpenTelemetry, Semantic Conventions for GenAI Agent and Framework Spans, semantic-conventions-genai repository. Status: Development.
• M. Srikumar, E. Mibuari, C. Leibowicz et al., The Observability Gap in AI Agents: What to Fix Before Agents Scale (Partnership on AI, October 2026). An assessment of telemetry in four agent frameworks against six safety monitoring goals.

Proposed here

• The situation as an extension of the activity hierarchy.
• Interpretive time as a runtime quantity.
• The movements between levels as observable signals.
• The observable activity as a unit of observation.
• Deliberate interruption as a capacity of situational intelligence.

Related in Seeing Systems

• The Intelligence to Stop
• The Stranger’s Trace