The Semantic Browser

Take the twenty-page incident report from the first chapter. A database went down on a Tuesday. The report holds a timeline, excerpts of logs, five candidate causes, and a conclusion that two engineers dispute. It is the kind of document that has to be read by several people for quite different reasons, and the chapters of this part have been building, one piece at a time, toward handling it differently. This chapter puts the pieces together and follows that one report through them, to see what the system looks like when it works as a whole.

Here is the whole shape, before the walk-through:

SOURCE
   ↓
SEMANTIC RECORD
   ↓
PRESERVATION OBLIGATIONS
   ↓
CURRENT TASK
   ↓
REPRESENTATION CHOICE
   ↓
RENDERING
   ↓
OPTIONAL SIDECAR AND RELATIONS
   ↓
READER RECONSTRUCTION
   ↓
PRESERVATION CHECK

Call a system built this way a semantic browser: a renderer that treats documents as sources, builds a traceable interpretation of them, chooses a representation for the task in hand, and checks what survived before showing it. It is not a claim that the system understands the document. Each step is a modest operation with its own limits, and the point of the chapter is to see how they fit. It is not a separate product. It is the same layer the book has been describing, working on one kind of source.

From the report to a record

First the report is interpreted, and the interpretation is kept. The record holds the claims the report makes: the five candidate causes, the evidence cited for each, the timeline of events. It holds the relations between them, with direction: this log excerpt supports the second hypothesis, that one contradicts the third. It holds the qualifiers: the third hypothesis is ruled out only if the replication lag was under a second, and the report says the lag data has a gap. It holds the uncertainty: the root cause is disputed, and the report says which engineer holds which view. And every entry carries the passage it came from. The source stays exactly as it was. The record is the system’s reading of it, and a reading can be wrong.

Next, what has to survive is declared, in plain words, and it depends on who is asking. Suppose the first reader is a manager deciding whether to approve the proposed fix. For her the obligations might read:

must preserve:
- all five candidate causes and the evidence for each
- that the conclusion is disputed, and by whom
- the gap in the replication-lag data and what depends on it
- who proposed the fix and on what grounds

These are not a summary of the report. They are a statement of what a representation would have to keep for her purpose.

One source, several tasks

The same source, with the same record, now meets four readers. What changes is the task, and the representation follows it.

Deciding whether to open it. An engineer on another team sees the report in a list and wonders whether it affects her service. A preview serves: a few lines on what failed, what is disputed and which components are named. The obligation here is narrow. Do not let a false skip happen. If her service is named, the preview must say so.

Approving the fix. The manager needs the structure of the argument. The system draws the five hypotheses as a diagram with the evidence for each, marking the disputed conclusion and the data gap where they matter. The diagram is a re-expression: nothing in it is added, and every arrow can be traced back through the record to a passage. A table of what each hypothesis predicts against what the logs show may sit beside it, because comparison is the task.

Carrying out the remediation. An engineer has to follow a procedure, and here the report’s prose is already doing a good job. The right representation is the report itself, lightly annotated: the conditions on each step revealed, the exceptions marked. Changing its form would invite exactly the loss of qualifiers the earlier chapters warned about.

Looking up one fact. Someone wants the exact time of the failover. The best representation is the source, with the passage found and highlighted. A generated view would only add delay and risk. The system leaves the page alone.

same source
same semantic obligations
different task
different representation

Notice that leaving the source unchanged was one of the outputs, and not a failure to produce one. A system that always transforms is only a generator in search of work. For some tasks and some documents, the best a dynamic representation system can do is get out of the way, and the design treats that as a first-class result.

What sits beside the page

For the manager there is also something beside the main view. The system has retrieved an earlier postmortem from the same team. It shows the item in a margin, marked as external material, with the relation it claims: this earlier report contradicts the second hypothesis, on the evidence of these two passages, under these conditions; standing: possible, unconfirmed. A second margin item is derived from the record: a list of the assumptions the preferred explanation depends on. A third is waiting only if she asks, in answer to a question she types, and is marked as generated.

Each item says where it came from. She can tell which words are the report’s, which are the system’s reading of the report, which came from other documents, and which the model produced for her. Nothing in the margin looks like it was written by the author of the report. None of it interrupts: it is there if she wants it.

Checking before showing

Before anything reaches her, each generated representation is checked against the obligations. This is the step that gives the whole arrangement its character, so it is worth seeing it do something.

Suppose the system produces the comparison table, and the check finds that the row for the third hypothesis no longer carries the condition about the replication lag. The table is tidy and wrong: it now reads as though the third hypothesis is simply ruled out. The obligation about the data gap has not been met. The system does not display the table with a warning. It repairs the table, restoring the condition, and checks again. If it cannot do so with enough confidence, the fallback is the safe one: show the source, or the source with the relevant passage revealed. A transformation that cannot show it preserved what mattered does not ship.

The check is itself an instrument, and it can be wrong. It might pass something that has lost a qualifier it had no way to notice, or refuse something that was fine. That is why its refusals are worth watching: a gate that never refuses is either perfect or decorative, and perfect is unlikely.

What it costs, and where it can fail

It would be easy to present the whole thing as a triumph, so the costs deserve their own statement. Interpreting the document takes time. Checking takes time. The reader who only wants a single fact is better served by the plain page, and a system that makes her wait for a pipeline to run has made her worse off. A margin full of retrieved material can distract from a demanding diagram. A check that passes things for the wrong reasons gives false comfort.

The deeper point is that a component can work well alone and still fail in company. The sidecar that helped when someone was reading a paper may hurt when it sits next to a diagram that already demands attention. The check that improved fidelity may slow scanning to the point of uselessness. These are not reasons to abandon the design. They are the reason that the whole must be tested against the plain page it is supposed to improve, and that each part must earn its place, task by task. The architecture here has not been measured as a whole in this book. It is offered as a coherent design with its costs stated.

What the browser does not claim

The boundaries established along the way still hold when the pieces are assembled:

source ≠ semantic record
semantic record ≠ source of truth
rendering ≠ source
retrieval ≠ verification
preference ≠ benefit

The record is an interpretation, not the facts. A margin item that was retrieved has been found, not confirmed. A representation the reader prefers is not thereby one that helps her. And nothing in the system is allowed to quietly become the source: the unchanged document is always one step away.

What has changed

Before, the path from author to reader was simple and fixed:

AUTHOR → FIXED PAGE → READER

Now it looks like this:

SOURCE
   ↓
structured interpretation
   ↓
task and preservation constraints
   ↓
generated representation
   ↓
READER

That is a small example of intelligence entering the channel. The reader is no longer given a single form that someone chose in advance for no one in particular. Between the document and the person there is now something that reads, chooses, adds, declines, and checks, and that can be asked to show its working. The communication is still between an author and a reader. But the form it takes has become a decision made in the middle, for this reader and this purpose, with a record of what the decision was meant to keep.

Where this leaves us, and what it creates

Part I has taken one idea from the first chapter and built it into a system. Communication needs a representation. The receiver rebuilds meaning from it. Different forms give different evidence. The author used to fix the form in advance, and the form can now be generated. Generating it well needs a structured reading of the source, explicit relations, declared obligations and a check on what survived.

But look at what the system can now do. For any source it can produce a preview, a diagram, a table, an annotated version and a margin of related material, and for any reader. Each representation is cheap, and around every source it can find still more: related incidents, telemetry, conversation, documentation. That creates a new problem that this part has not touched. The browser perfects the encounter with a document that is already open in front of someone. It does nothing for the thousands of documents, talks and threads that never reach them: the forty hours of conference video in a queue, the papers published this week, the advisories nobody has time to open. Once representations are cheap to produce, there are far more of them than anyone can consume, and the scarce thing is no longer the form. It is the reader’s attention. The question changes from what form should this take? to what deserves to reach me at all?