Lab
Embeddings: recompute only what changes
Short answer
A corrected document is rarely new from its first sentence to its last. Yet a search system can process every edit as though the entire document needs to be embedded again. Our work on incremental embeddings began with a practical question: what can safely be preserved when a memory changes?

Why a small edit can trigger a large job
An embedding is a numerical representation used to match a question with text that has a related meaning. Long memories are divided into fragments for this purpose. A new version may revise one conclusion while leaving most paragraphs untouched.
Recomputing every fragment is straightforward. The system does not need to track unchanged pieces, but it repeats work. That repetition consumes computing capacity, occupies processing queues and increases the writes needed to maintain the index. It matters most when the same memories are edited repeatedly.
The alternative is to keep representations for unchanged fragments. The versioned text remains authoritative. An embedding is a search aid that must stay aligned with that text, rather than becoming a separate account of what the memory says.
Reuse requires identity, not a similar meaning
We did not ask a language model whether two fragments “mean roughly the same thing.” A small change can alter a decision, an exception or an effective date. For this purpose, reuse relies on identity according to the inputs that actually determine the representation.
A fingerprint establishes that match. A fragment can move within a document and remain eligible for reuse. Conversely, a passage that looks almost unchanged may need to be embedded again. Semantic similarity and exact identity serve different purposes.
This is also a traceability requirement. Reusing a computation does not entitle an old representation to stand for a different new version. Text, version and representation must still correspond correctly.
The distinction makes the optimisation easier to assess. It reduces duplicated computation without asking an additional model to interpret whether a change is important. The question is whether the original computational result remains valid for the same input.
What our measurement actually shows
During the observation window following the introduction of incremental processing, 746 fragments were reused and 166 recomputed. The resulting proportion is:
746 / (746 + 166) = 81.8% of recomputation avoided for the fragments concerned.
This measures work that the embedding engine did not need to repeat in that sample. It does not mean every Nawame operation became 81.8% faster, or that total operating costs fell by that percentage.
The window is short. It covers 23 written versions, with a particular mix of memories and edits. A longer assessment needs to track reuse across more changes and account for the work that remains: identifying fragments, maintaining the index and serving searches.
Would a different document split help further?
We also examined a plausible improvement: anchor fragment boundaries more firmly to paragraphs. The reasoning sounds attractive. If inserting text near the beginning shifts every later boundary, a more stable split should preserve more existing embeddings.
Measurement showed that this description overstated the problem. The existing splitter can meet a shared paragraph boundary farther down the document. An edit near the beginning therefore does not automatically force a complete recalculation.
In the simulation, the anchored alternative improved some cases but created more fragments. That increases initial computation and storage, and changes the material presented to search. The results did not justify a general change in the splitting approach. Testing the actual mechanism prevented an optimisation built on an exaggerated assumption.
The first pass still has a cost: scope and limits
An older memory without the required fingerprints cannot benefit from reuse immediately. Its first processing pass establishes the correspondences that later edits can use. Performing that work in advance moves the workload; it does not create an additional saving by itself.
The value of incremental embeddings therefore depends on edit frequency, the stable proportion of documents and the overhead of maintaining the index. It is an optimisation of repeated work, with conditions that can be measured.
For Nawame, the lesson is practical: preserving a valid result can be more useful than accelerating every repeated computation. It complements our work on measuring costs before adding complexity and vector indexes. The Lab’s work remains centred on durable memory, with technical representations that follow the source.
Related reading: Why Organizational Memory Needs to Know Information Freshness.


