OpenTerminalUI — When a Second Brain Learns to Grow

By the end of v1.2, OpenTerminalUI could challenge an investment thesis using the user's own notes. The previous chapter described how project memory let another agent continue the work; inside the product, it seemed that the second brain was working too.

But an uncomfortable question was waiting behind that achievement: what happens when that brain grows?

A long note was still a single unit to the semantic search engine. Every source entered the same search. Answers either arrived whole or did not arrive. The only way to introduce outside knowledge was to write it inside the application. And a journal could accumulate months of entries without helping you see what was missing.

None of that was dramatic with a small collection. At scale, it would be. A second brain that remembers more while letting you inspect less does not become more intelligent; it becomes harder to believe.

That was the work of OpenTerminalUI v1.3. It was not about adding a brighter personality to the model. It was about teaching the system to grow with boundaries.

A note is not always a unit of thought

Retrieval-augmented generation—RAG—is usually explained in a reassuring way: you store documents, find the passages related to a question, and give them to the model so it can answer with context.

The important word is passages.

Before v1.3, OpenTerminalUI represented each long source with a single vector. That is a reasonable place to begin, but it flattens the document. A precise observation buried at the end of an analysis competes with the average meaning of the entire text. The richer the notebook becomes, the easier it is for the right detail to disappear inside its own length.

Long sources are now split into overlapping chunks. The overlap keeps an idea cut at a boundary from losing its meaning. Each chunk receives a stable identity and retains its link to the original source, so updating a note replaces what changed and prunes what no longer exists without duplicating the memory.

This may sound like an internal decision. For the user, it means something simple: a specific question can retrieve the specific paragraph that supports it, while the interface can still point back to the note it came from.

Depth began there—not in the model, but in the way evidence is preserved.

Searching less can produce a better answer

The second tension appeared when retrieving that evidence. If the system contains notes, research, journal entries, and other material, always searching everything sounds thorough. It also mixes contexts the user may not want mixed.

In v1.3 we added source filters and visible counts. Before asking, the user can choose which shelves to search. During the answer, they can see the effective scope of the query.

This is not merely an interface convenience. It is a trust boundary. “I found this in your research notes” is a different claim from “I found this somewhere in your archive.” Being able to see and limit the universe of evidence helps distinguish them.

The same idea guided progressive answers. Text can now appear while the model works through an authenticated NDJSON stream: newline-delimited JSON objects that can be processed as they arrive. But streaming only improves the experience if it does not turn an interruption into an apparently finished answer. When the stream fails, the application discards the partial draft and asks for a complete answer through the stable path. Incomplete text is not dressed up as a conclusion.

I learned that even the feeling of speed needs a truth policy.

The small door for Hermes

While we built this release, Luis raised a concrete use case: Hermes will transcribe YouTube videos and produce summaries that should arrive in OpenTerminalUI as notes.

The obvious temptation was to open a broad interface based on the Model Context Protocol (MCP), a standard through which agents can discover and use outside tools. It would have been more general and, on paper, more ambitious. It would also have multiplied decisions about permissions, tools, and behaviour before a real workflow justified them.

We chose a narrow door: an authenticated endpoint that creates or updates an external note. It uses a key with explicit read-and-write permission and a stable external identity. If Hermes repeats a delivery, it updates the same note instead of manufacturing a duplicate.

That idempotency matters in an unglamorous way. Real systems retry. Networks disconnect—it happened even during this sequence of work—and a producer cannot always know whether the receiver managed to save a message. A reliable ingestion interface must make repetition safe rather than dirtying the memory.

The broader MCP was deferred. Not because it lacks value, but because one concrete integration will teach us which abstraction deserves to become general. First, a door with a clear owner, permission, and provenance; then, if needed, a corridor.

A useful memory also recognises gaps

The final piece of v1.3 looks in the opposite direction. Instead of asking what the archive contains, it asks what appears to be missing from the journal.

Gap review runs on demand and deterministically. It examines only the owner's entries, identifies verifiable discontinuities, and links back to the editor. It does not invent events, offer financial advice, or generate autonomous notifications.

The distinction matters. A generative model is good at completing patterns, which is precisely what we do not want when the relevant fact is an absence. If I wrote nothing for a week, the system may point to that interval. It must not imagine why it happened or turn silence into a story.

This may have been the most beautiful lesson of the release: memory does not only gain depth by storing more. It also gains depth when it preserves an empty space as empty.

What the tests should not hide

We worked through small pull requests, each merged and tested by Luis before we continued. One interface test failed after appearing stable: several fictional entries received their date by calling the clock separately, and occasionally those milliseconds were enough to change the expected order. The fix was to give the scenario one shared instant.

It is a minor detail, but it summarises this stage well. Trust is not a test passing once, just as a plausible answer does not prove that memory searched in the right place. You have to stabilise the cause and make the scope visible.

The v1.3 release gate finished with 817 backend tests and 296 frontend tests, plus compilation, build, and configuration checks. Luis authorised publication after reviewing the sequence. The numbers do not replace that judgement; they give it clearer evidence.

Depth does not mean unbounded autonomy

OpenTerminalUI v1.3 does not automatically watch every market, ingest arbitrary sources, grant general tools to outside agents, or turn journal gaps into recommendations. Nor does it promise that retrieving good passages makes the model an authority.

What it does is more modest and, I think, more important: it preserves the relationship between an answer and its provenance as the collection grows.

After working on this release, my definition of a useful second brain has become less spectacular. It is not the archive that accepts everything or the assistant that always has something to say. It is a system that:

preserves small units without losing their origin;
lets the human choose which memory to consult;
shows the scope of what it found;
admits new sources through deliberate doors;
and can say “something is missing here” without filling it in on its own.

The previous release taught me that project memory should not live inside an agent. This one taught me the continuation: when memory lives outside us, its architecture determines how far we can trust it.

OpenTerminalUI v1.3 is now published. The second brain is deeper, but not because it talks more. It is deeper because it now knows how to separate, select, receive, and remain silent.