The Stack Behind Ephemeral Interfaces

Part 3 imagined a chart that appears in response to a question about ocean temperatures and storm intensity. Generating the chart is the easy part. The harder questions arrive a minute later: Which observations produced this curve? What period do they cover? Why did the system choose these papers? If I return next week, can I pick up the same line of inquiry without trusting an opaque summary of it?

The data must carry meaning and structure together. Semantic representations can help find a related passage when the wording differs. Stable identifiers, source records, and explicit relationships let a person check where that passage came from and how it connects to another one. Neither alone is enough. Similarity can suggest a connection without proving it; a carefully structured database can still miss a connection nobody encoded.

Even “the same information” is a slippery category. A note can quote a paper, a spreadsheet can extract numbers from it, and a conversation can turn those numbers into a claim. If the system merges them into one object, it loses the difference between evidence and interpretation. If it keeps them completely separate, the person has to rebuild the relationships every time. The layer needs to hold both the distinctions and the paths between them.

The state of an inquiry matters too. A conversation establishes terminology, rejects approaches, and leaves open questions. A generated report captures only some of that. When a session ends, losing the rest can feel less like closing a window than misplacing the path by which you reached a thought. Preserving every token is not the answer. The system needs a selective, inspectable record of what was said, what was inferred, and what the person chose to keep.

I picture five layers, though a working implementation could draw the boundaries differently. The layers describe responsibilities, not a mandated product architecture.

Connect sources

Adapters give the system access to notes, messages, web pages, datasets, and other sources through their existing interfaces. They normalize enough of each source to make it usable elsewhere while retaining a link back to the original. An adapter should also respect the source’s permissions; the ability to connect two systems does not grant permission to combine all their contents.

Keep history

Ingestion assigns stable references and records source, authorship, time, and revisions. A quotation in a temporary interface should still point to the document and version it came from after that interface disappears. Where the system produces a summary or inferred relation, that derived item needs its own lineage. Otherwise a later reader may mistake an interpretation for source material.

This becomes important when a source changes. Suppose a dataset is corrected after the first chart was made. A stable address should let the earlier chart remain inspectable while identifying the revised data and any conclusions that may need another look. A history of changes is more useful here than a single “latest” pointer. Cryptographic verification could help establish that a record has not been altered, but it would not by itself establish whether the record was accurate.

Relate information

The memory layer holds explicit links alongside semantic representations. A graph can record that a paper cites a dataset or that a note challenges a claim. A vector index can suggest passages with related meaning even when no link has been made. In the climate example, those mechanisms might connect an ocean temperature observation to cited papers, similar measurements in another region, and the researcher’s earlier notes. The graph gives the known paths; similarity offers candidates for new ones. A candidate still needs examination.

Retrieve in context

Retrieval uses the current question and the saved trail to choose what to bring forward. For a comparison, it might follow citations to the measurement methods, search for relevant notes, then rank the results. The person needs to see why a result appeared and be able to change the scope. “Relevant to me” cannot be a hidden, permanent judgment inferred from past behavior.

This layer also has to balance focus against surprise. Repeatedly retrieving material close to the current view can make an initial framing feel better supported than it is. A researcher comparing two climate studies might need the third paper that uses a different definition of “storm intensity,” even if it scores poorly against the original query. Retrieval should make room for such counterexamples without presenting every remote association as equally valuable.

Assemble and revise

An integration layer turns retrieved material into a table, map, chart, or text view and keeps the links to the material underneath. An orchestration layer may coordinate several tool calls when the task requires them. If the researcher notices that two studies use different baselines, the system should be able to revise the comparison and show the mismatch. That loop connects the stack to the ephemeral surface; a one-off generated view would stop at presentation.

The architecture makes a specific bet: a surface can change shape without making the inquiry beneath it disposable. Whether that bet works depends on the quality of the links, the retrieval decisions, and the person’s ability to contest them.

The most interesting material is sometimes in the spaces between finished artifacts. In a long exchange, you establish shorthand, test an explanation, discard it, and notice a contradiction that you cannot yet resolve. A document may contain the conclusion but none of those turns. I think of them as liminal data: provisional context that may matter when the inquiry resumes.

Some traces should be saved explicitly: a note, a source, a branch the person wants to revisit. Others could be proposed for retention, such as a term that kept recurring or a question left unanswered. The distinction matters. A system that silently promotes its inference about my interests into durable memory can gradually narrow what it shows me. It should expose those inferences, let me correct them, and allow forgetting.

There is an emotional dimension to this. After a long exchange, the moment an idea turned may matter more than the final formulation saved in a document. Returning to an assistant that knows the formulation but has lost the turn can be strangely disorienting. Capturing that turn could help, provided the system does not pretend its reconstruction is a faithful account. The trail should be revisable and sometimes deliberately incomplete.

Provenance applies to this layer as much as to a paper or dataset. If a future interface says I rejected an approach, I need to know whether I said so, whether the system inferred it, and from which exchange. Continuity without that distinction can turn a convenient memory into a false one.

Basic retrieval augmented generation (RAG) often splits sources into chunks, embeds them, and finds chunks close to a query. That can supply a useful passage to a model. It can also detach the passage from its document hierarchy, neighboring argument, or the version in which it appeared. A result may be semantically close and still answer the wrong question.

GraphRAG adds explicit entities and relationships, making it possible to follow a citation, dependency, or conceptual connection. It is useful where those relations have been recorded and kept current. It does not automatically solve granularity: a graph of broad concepts may still leave the precise sentence, dataset row, or revision difficult to recover.

Nor is the graph a neutral map of everything a source contains. Someone, or some model, decides which entities count and which relationships to extract. That choice shapes what can later be traversed. A retrieval system should preserve the underlying passages so a person can inspect a relation and notice when the graph has made two distinct concepts look identical.

For an interface that lets a person move between overview and evidence, I would keep several levels linked to the same source. A summary points to its sections; a section points to passages; a passage keeps its document and version. Retrieval can then move up for orientation and down for inspection. How We May Think We Think explores this movement between levels in more detail. The hierarchy is a design choice, and the generated summaries remain interpretations rather than replacements for their sources.

Performance is one constraint. Searching vectors, traversing relations, resolving versions, and assembling a surface all cost time. An interface that arrives only after the question has passed is not much use. Indexing and caching may help, but the system must also decide when a partial view is enough and show what it has not yet retrieved.

Privacy and agency are harder. A layer that crosses applications could expose material in a context where it was never meant to appear. Permissions need to account for the intended use, not merely whether an adapter can read a source. It should be possible to inspect what the system remembers, restrict where it can draw from, and remove a trace. These controls are part of the substrate, because every generated surface inherits its access.

Integration is also constrained by the applications and platforms that hold the data. Standards and adapters can make access possible where interfaces permit it, but they cannot dissolve technical or commercial boundaries by architectural preference alone. A universal layer would be built unevenly, through specific connectors and agreements, with gaps the interface should not disguise.

The chart from the opening might therefore begin with only two accessible datasets and one paper. It can still be useful if it names that boundary, keeps the sources in reach, and allows the researcher to add a missing one. The surface may dissolve. The limits of what it knew should remain.