Modern software has learned to see itself through traces. A request comes in. It picks up an identity. That identity travels from service to service, call to call, span to span, until someone can lay the whole path out afterward and say: this happened, then this happened, then this, and somewhere along this line the system did something strange.
To the software industry, this approach feels natural. Systems are complex, so we trace them. Services are numerous, so we correlate them. Events are dispersed, so we collect them into a path we can inspect. The trace appears to be the obvious starting point for comprehending a system. However, it is an unusual thing to construct. Surprisingly, most systems in the world comprehend flow and function far more effectively without the need for a trace.
A body does not tag each molecule of blood with an identifier and follow it through the heart, lungs, liver, and brain to work out whether it is alive, stressed, poisoned, or recovering. It has receptors, pressures, rhythms, chemical signals, thresholds, and organs that already know what a given change means for the job they do.
A flock of birds keeps no record of the flock. Each bird responds to the spacing, speed, and movement around it. The shape of the flock is not pieced together later from everyone’s flight path. It comes from each bird reading what matters from where it sits.
A conversation does not trace every sentence as a span through the minds of the people talking. Meaning comes through timing, tone, turn-taking, repair, hesitation, the pause before an answer. People remember things, but they do not need a full replay of the talk to follow it. They read it as it happens.
A factory line does not need each item to carry the memory of the whole system. Each station knows what arrives, what it is meant to do, what is good enough, what gets rejected, what gets held back, what gets flagged, and what to tell the next station. The intelligence is spread along the line.
These systems are not less complex than software because they avoid traces. They are readable because their parts are situated. Each part has a boundary, a role, a local expectation, and a way of responding when that expectation is strained. Meaning is not reconstructed globally after the fact. It is produced locally as the flow moves.
In all of these, understanding is not detective work after the fact. It happens in the moment, as part of the work.
Two ways of knowing
A trace is built for the investigator. It exists because the system did not notice anything meaningful at the time, so someone has to come along afterward and rebuild the story from the leftovers. The knowing sits outside the system, after the event. The system runs blind, and gets read later.
A trace is built for the detective. A sign is built for the participant. It exists because the part doing the work is already telling things apart: this is normal, this is strained, this is blocked, this is late, this is dangerous, this is a handoff, this is a promise I just broke. These are not raw events waiting to be explained. They are calls made by the component close enough to the action to know what it meant. The knowing sits inside the system. The system runs with its eyes open and says what it sees.
The detective model treats the system as a machine that spits out raw events, and treats understanding as a layer bolted on afterward, over stored data. The other model treats understanding as part of doing the work: telling things apart at the point of action and putting out signs that carry what they meant. One hands the thinking to the observer. The other keeps the thinking at the site. This is why the trace is an odd foundation. It does not start with meaning.
Tracing starts with being able to recover things. It asks the system to leave enough behind that something else, or someone else, can later guess what mattered. The trace is a memory aid. It makes up for the fact that the system never learned to describe its own condition while it was working.
Tracing is a tell-tale sign that meaning has not yet been operationalized at the point of action.
Useful, but not natural
None of this makes traces useless. Traces do have use: for debugging, audit, recovery, comparison, accountability. Traces keep a history you can go back and inspect. They show how a failure spread from one service to the next. But being useful is not the same as being natural, and a record is not the same as a meaning. The mistake is treating traces as the ground floor of understanding, when they are really one artifact produced by systems that are not understood.
A trace says: something passed through here, then here, then here.
A sign says: something mattered here, and this is how.
The trace keeps the sequence.
The sign keeps the significance.
One belongs to the observer after the fact; the other belongs to the participant in the moment.
That gap is why so much of observability today stays stuck at the level of representation. We keep building better recordings of execution and skip the harder question of what the system can actually tell apart on its own. More spans, more logs, more attributes, more correlation, more history retained, and we call the pile observability. But observability is not how much you have stored. It is whether the behavior makes sense. And making sense needs meaning.
Meaning does not show up just because the path is complete. A full trace of broken behavior is still just a full trace of broken behavior. It cannot tell you which expectation was violated unless that expectation lives somewhere. It cannot tell you which promise was broken unless that promise is written down somewhere. It cannot tell you whether the behavior was fine, strained, adaptive, reckless, or impossible unless someone, or some part, can draw that line.
The missing middle
The industry has built the lower floor: instrumentation, telemetry, traces, logs, metrics, storage, query. Lately it has added a talking layer on top: agents that read the data, summarize the incident, guess at causes, and narrate what may have happened. But between the raw recording and the fluent story there is still a hole, and the hole is meaning.
The trace-heavy view tries to cover the hole by saying: keep everything first, figure out what it meant later.
Living systems tend to do the reverse. They figure out what matters first, and that decides what to keep, amplify, ignore, or act on. Memory does not come before meaning. Meaning decides what is worth remembering.
The body does not store every sensation evenly. It attends to pain, pressure, hunger, fever, threat, balance. The immune system does not log every encounter neutrally; it sorts self from other, harmless from dangerous. The nervous system does not record the world in full; it filters, predicts, reacts, updates. It is always quietly asking: what matters here?
That is the part most software still cannot do. It puts out data but not judgment. It records what happened but not what was at stake. It shows execution but not situation. So you get a strange inversion. The system acts without understanding, then leans on an outside observer to understand the act afterward. It runs blind and only becomes readable in hindsight. Trace-centered observability is the architecture of that blindness.
What a sighted system would say
Again, this is not a case for ripping out traces. It is a case for putting them in their place. A trace should be a history of meaningful signals, not a stand-in for meaning. It should keep the signs that participants put out as they worked, rather than collecting leftovers that signs have to be guessed from later.
In a system that could see itself, each part would put out more than mechanical facts. It would say things like:
I am starting. I am calling. I am waiting. I am retrying. I am redirecting. I am overloaded. I am degraded. I am rejecting this input. I am keeping this promise. I am breaking this promise. I am compensating. I am recovering. I am no longer sure of my own condition.
These are not just events. They are signs, small acts of a system describing its own situation. They let a system say not only what it did, but what kind of thing it thought was happening.
That changes the whole shape of observability. Instead of asking an outsider to rebuild meaning from trace leftovers, the system starts taking part in its own readability. It tells you what it is telling apart, at the place where that matters. It gives an observer not just a path through the system, but an account of the calls the system was making about itself.
Trace is still useful, but no longer the main way of knowing. It becomes the kept memory of signs, signals, judgments, handoffs, and promises: the history of a system that was already trying to understand itself as it worked.
Flow is meaningful while it flows
This is closer to how flow systems actually work. They are not made readable by tagging everything with an identifier and rebuilding every path afterward. They are made readable by local expectations, boundaries, transformations, handoffs, feedback, and response. At each point, something receives, reads, acts, and signals onward.
The sense of the system is not only in the global path. It is in how each part conducts itself.
A river needs no trace ID for the water to show obstruction, pressure, turbulence, overflow, drought, or force. The signs are right there in how it moves. A city needs no full path for every person to show congestion, panic, routine, or evacuation; you read it in the density, the delay, the movement, the blockage. A supply chain does not become readable because every object carries its full history. It becomes readable when each queue and handoff can say its condition: late, early, blocked, starved, saturated, damaged, rerouted, done. The trace is strange because it asks flow to turn into history before it is allowed to mean anything. But flow means something while it is still flowing.
That is the deeper problem with trace-centered observability. It has mistaken the recoverable path for the understandable system. It assumed that because software can record execution, that recording must be the natural unit of understanding. It confused the archive of behavior with the understanding of behavior.
The next step is not better tracing, and it is not draping language models over traces so the leftovers can be narrated more smoothly. The next step is to build systems that put out meaning at the point of action. Traces answer one question: where did this go? Signs answer another: what did this mean here? Only signs start from understanding.
Appendix: Commentary
A trace is useful memory. It preserves path, sequence, and causal adjacency. It can help an investigator reconstruct what moved through a system when the system itself did not know how to describe the significance of that movement. The problem begins when trace becomes the primary model of understanding. Then the system is allowed to remain blind because blindness has been made operationally tolerable. Every component may act, call, wait, retry, degrade, and fail, while the meaning of those actions is deferred to a later reader. The trace becomes a prosthetic for a missing faculty: the capacity of the participant to say what distinction mattered at the moment it acted.
A sighted system does not eliminate traces. It demotes them. The trace keeps the path. The sign keeps the significance. A system needs memory, but memory is not perception, and reconstruction is not understanding.
The conceptual gap between a trace and situational intelligence is enormous. They are not adjacent things on the same ladder. A trace is a record of traversal. Situational intelligence is a judgment about what is happening, why it matters, what it threatens, what it enables, and what might happen next. Those are not one abstraction apart. They are worlds apart. The hidden assumption in trace-centered observability is that, with enough recorded paths, enough correlation, enough storage, enough query, and now enough LLM narration, situational understanding will somehow emerge. But there is no natural staircase from “this call went here, then here, then here” to “this system is entering a strained coordination pattern because one participant is no longer keeping a timing commitment that downstream actors rely on, and if this continues the next likely situation is degraded fulfillment rather than outright failure.”
There is no direct path from trace to situational intelligence because a trace records movement, while a situation is a judgment about meaning under conditions of expectation, consequence, and possible action.
The missing layer is not more data, better correlation, or more fluent narration. The missing layer is the system’s own capacity to express the distinctions it is already making as it acts.