Record and reasoning, one act.
A language model working through a problem typically produces two things: an answer, and a transcript of how it got there. In most memory designs, a separate step, run later by a summarizer or an extraction pass, decides which parts of that transcript are worth keeping. Live-authorship capture removes the separate step. The decision about what belongs in the record is made by the same reasoning that solves the problem, at the point the problem is solved.
This is one of the primitives described under substrate memory: an entry is not a note taken about the work. It is the work, typed and filed.
Decide first. Document later, by a separate pass.
Several existing memory designs separate the two acts in different ways.
| Pattern | Description |
|---|---|
| explicit extraction | A user commits a specific fact to memory, or a later pass over the conversation extracts what looks salient. The commit is a distinct step from the reasoning that produced the fact. |
| scheduled memory synthesis | A synthesis pass runs over recent conversations on a recurring cycle and produces a summary of what should be remembered. The synthesis is performed by a separate process, after the conversation that generated the material has ended. |
| scheduled pattern extraction | A background process reviews past sessions for recurring patterns and extracts them into memory. Like scheduled synthesis, this runs after the fact, over material the model has already stopped reasoning about. |
| model-directed file memory | The model itself decides what to keep, closer to live authorship than the systems above. The record is typically a flat file rather than a typed graph, so the selectivity does not carry through to relationships between entries. |
One cognition, one act.
Filing a decision as a graph entry asks a model, at the moment it reasons about the decision, to also type and record that reasoning. This is not two questions answered in sequence, a first pass to solve the problem and a second pass to decide what was worth keeping. It is one question, answered once.
In the Vinculum project’s own account of the pattern: a post-action memory system treats “what should I remember about this” as a question separate from “what should I do here.” Live-authorship capture collapses the two. They are not two questions answered by two cognitions in sequence; they are one question, answered once, in the act. Filing a decision entry is not a separate judgment that the decision was important. It is reasoning about the problem in a way that produces a structured record.
What 'live capture' means in current practice.
The phrase already has a dominant meaning outside this context, and it names a different problem.
Five losses in a post-hoc pass.
A pass that filters a transcript after the fact operates on what looks important once the outcome is already known. It misses several kinds of value that live authorship keeps by construction.
| Loss | Description |
|---|---|
| dead ends | A path that was tried and ruled out is itself informative: it prevents a later session from re-deriving the same dead end. A summary organized around what worked tends to omit what did not. |
| backtracks | A correction made in the course of reasoning carries its reason with it, filed alongside the position it replaced. A post-hoc summary usually keeps only the final answer, not the correction that produced it. |
| gaps between sessions | The interval between one session's stopping point and the next session's starting point is itself context for what happens after. A filtered summary describes the work; it does not describe the shape of the pause. |
| unpredictable future questions | A filter applied after the work is done can only preserve what already looks relevant to that work. A typed schema, filled in live, does not need to predict which future question an entry will answer. |
| the reasoning chain itself | Retrieving an answer is a different operation from retrieving the reasoning that produced it. Live authorship keeps the second; a summary optimized for storage and retrieval efficiency tends to keep only the first. |
No later pass to soften an early answer.
When a summarizing pass runs after the fact, a model working through a problem can leave conclusions unresolved or imprecise, on the assumption that the later pass will clean up the record. Live authorship removes that assumption. What is written during the work is the record; there is no downstream editor to catch a vague conclusion before it is filed.
This changes the character of the writing itself, not only its timing. An entry filed in the act of reasoning has to be as precise as the reasoning that produced it, because nothing stands between the reasoning and the record it leaves behind.
A checkpoint, not a discard.
Live authorship has a direct consequence for what happens when a model’s working context is compacted or replaced by a fresh session. Because the reasoning that mattered has already been filed as a graph entry, rather than held only in the context about to be discarded, compaction can be treated as a checkpoint instead of a loss of progress. A fresh session inherits the entries, not only a summary of them.
The write side of that continuity is what gets filed, and when. The read side, whether a later session recognizes an entry as its own prior work, is described separately in cross-session recognition. The mechanics of resuming from those entries after a context reset are described in the entry on booting into continuity.
Common questions.
Is this the same as agent observability?
No. Agent observability instruments a system from the outside, capturing steps for later reconstruction, generally for debugging or compliance review. Live-authorship capture describes the model’s own judgment, exercised once, about what belongs in the record. The two can coexist: a system can log exhaustively and also support a model deciding, at write time, what belongs in its substrate memory.
Can something still be corrected once it has been written?
Yes. Live authorship does not make an entry permanent or unquestionable. Entries are append-only: a later entry supersedes an earlier one rather than editing it in place, so the correction and the reason for it both stay in the record. See supersession and kept contradictions.
Is live-authorship capture specific to Vinculum?
The term is used by the Vinculum project to describe a design choice in its own architecture: the write tool a model calls to record a decision is the same act as making the decision. The formal definition of the entries it produces is set out in the Vinculum Standard.