Source-linked AI summary
Transfiver: Human-AI Co-Inference through a Shared Editable State
Minji Park, Seunghyun Yoon, Hyuk Lim
TL;DR
Long-term assistant use requires deciding when previously stored information no longer applies, but users cannot directly control the model’s evolving inference state. Transfiver addresses this with one persistent, shared state that humans and models update, and a narrow evaluation shows that a frozen state can support multiple read rules whose readouts change when the rule or reference changes.
Problem
Long-term assistant interactions become difficult when stored information becomes outdated or project-specific, raising who can decide that an old entry no longer counts.
Method
Transfiver maintains interaction-specific information in one persistent state that the model updates implicitly and a person edits explicitly, while state fields preserve identity, content, relations, history, provenance, and lifecycle.
Results
One frozen persistent state retained enough temporal structure to support four disagreeing read rules, and replacing the named rule or reference redirected the readout accordingly.
Takeaways & Limitations
The architecture makes shared-state identity and its history, intervention, and restoration requirements explicit and falsifiable, while the test model demonstrates only part of the contract in a narrow learned system.
Takeaways & Limitations
Preserving the broader architecture’s intended dissociations together in one system remains an open problem rather than a result reported here.
Abstract
from arXiv · showhide
Long-term human-AI interaction is difficult because the information that guides inference is updated implicitly by the model and is not directly inspectable or controllable by the user. We introduce the TRANSparent Framework for Interactive, Verifiable, Editable Representation (Transfiver), an architecture for human-AI co-inference through a shared editable state. Its central idea is that interaction-specific information is maintained in a single persistent state $(S_t)$ that both the model and the human update. Transfiver distinguishes two modes of state evolution. In an implicit stream update, the model interprets ongoing interaction and decides whether new information revises an existing state item or creates a new one. In an explicit directed edit, a human inspects and modifies an addressed item. Both act on the same underlying state, so a human correction changes the state that subsequent computation reads, rather than adding another instruction or separate record. The architecture separates shared parameters $(θ)$, learned before ordinary use, from the persistent state $(S_t)$, which evolves during deployment without parameter retraining. Extending Transfiver to rich natural-language, relational, and large-scale shared states remains open.
1 Introduction
Transfiver addresses stale or obsolete information in long-term human-AI interaction by making the inspectable, editable state the same state used for computation. It defines a shared persistent state updated by both model and human, while reporting a narrow evaluation of an earlier implementation.
- Transfiver requires the state a person sees and edits to be the same persistent state from which the model computes and answers.Human edits therefore operate on the state subsequent computation reads, rather than adding a separate instruction or record.
- The architecture supports implicit model updates and explicit human edits, including retiring, restoring, or rewriting addressed entries.The difference between merely omitting an entry and retiring it appears on the next turn, when the omitted entry can return but the retired one does not.
- Long-term interaction accumulates corrections, obsolete beliefs, meanings, conflicts, evidence, and decisions that may later need revision.
- Transfiver is intended to operate at the architectural level of a Transformer or state-space model, or within a larger system if it remains the sole persistent interaction-specific state.
- The paper introduces an information model, human-facing renderings, and a history-sufficiency and causal-intervention contract distinguishing Transfiver from separable memory or displays.
- One held-out evaluation of an earlier persistent-state implementation found that one frozen state supported four disagreeing read rules and redirected readouts when the named rule or reference changed.
2 Related Work
Related work addresses persistent memory, model updating, human-intervenable representations, and shared mental models from different angles. Transfiver’s distinguishing requirement is that persistent state be inspectable, editable, and the causal computational substrate for future interaction.
- Prior work studies persistent states by asking who writes them, who reads them, and whether they are the only path from past interaction to future computation.
- Memory-augmented and state-changing models add external or rapidly updated state, but Transfiver additionally requires persistent state to be directly inspectable, editable, and used for computation.
- Supersede improves model-managed memory for changed facts, whereas Transfiver assigns users authority to retire, restore, and correct items that subsequent computation reads.Supersede does not expose memory for human inspection or editing and does not test intervention, rollback, or save–restore.
- Retrieval systems and memory-tier architectures keep records outside or around a generator, while Transfiver makes the readable state itself the computational object under study.
- Shared mental-model research values aligned internal representations but leaves their operational data structures and processes open; Transfiver offers one architectural operationalization.
- Concept bottleneck and related models support intervention or faithfulness, while Transfiver makes the intervenable object persistent and dynamically evolving.
3 Transfiver Architecture: How Information Lives in Transfiver
Transfiver represents interaction-specific information as an evolving relational state whose items can belong to multiple contexts without copying. Its boundary preserves interaction history and requires the serialized canonical state to contain everything that can affect later outputs.
- An item may belong to several projects without copying, while relations follow events or relationships rather than lexical similarity.For example, a server and its random password may be related despite lexical distance, whereas similar bank and server passwords should not be merged.
- The conceptual state contains items, current relations, and retained relation or event history, with item fields for identity, content, occupancy, time, standing, use, provenance, and lifecycle.Identity is stable; the other fields may change as the state evolves.
- Relations are sparse, and contextual messages influence the current read without being written into neighbors unless the transition observes a new event about them.This keeps derived influence reversible and attributable.
- The state boundary retains raw turns, local context, transport evidence, and event history while leaving interpretation and uncertainty to the learned transition and readable provenance.
- The canonical serialized state must contain every interaction-specific record that can affect later output, including order, source, modality, relations, lifecycle changes, and edits.A hidden cache, conversation window, or model-specific history outside serialization violates the one-state contract.
4 How Transfiver Learns and Changes
Transfiver changes its persistent state through implicit stream updates and explicit directed edits, while separating offline learning of dynamics from deployment-time state evolution. Its design favors expressive existing distinctions over proliferating semantic flags or fixed user-judgment rules.
- Directed edits and stream updates: A directed edit addresses a visible item, changes its value, preserves unrelated items, and supports exact restoration.
- Directed edits and stream updates: A stream update supplies no address, so the system must decide whether an event revises an existing item or creates a new one.
- Directed edits and stream updates: Transfiver requires both update modes because directed editing alone does not accumulate repeated changes, while stream updates and edits fail in different ways.
- Offline learning and online state evolution: Offline future-task loss trains the transition dynamics, whereas deployment fixes θ and evolves S through forward stream transitions.
- Offline learning and online state evolution: Directed edits modify S directly at a user-supplied address without changing θ, so learning from one event means state change without gradient retraining.
- Design constraints: New failures should first be tested against existing distinctions and expressive reads rather than automatically receiving new semantic flags or fixed semantic weights.
5 What Makes a System Transfiver?
Transfiver requires the visible, editable state to be history-sufficient and to constitute the system’s sole persistent computational path. It tests this through serialization, path-completeness, edit, rollback, and permutation properties.
- History sufficiency: History sufficiency requires identical saved states and future inputs to induce identical future behavior distributions.
- Path completeness: The complete transition maps a persistent state and input to a next state, model output, and record of contributing state entries.
- History sufficiency: Interaction-specific persistent variables must belong to serialized S_t; unlogged caches or hidden history violate the one-state contract.
- Path completeness: Path auditing checks whether logged state-entry contributions reconstruct the actual pre-decode logits; in the small model, the residual is zero by construction.
- Intervention and symmetry: Edit protocols measure intended target change, preservation of unrelated outputs, restoration after undo, and agreement between logged contributions and actual output.
- Intervention and symmetry: Permutation symmetry requires slot reordering to permute next-state distributions while leaving output distributions unchanged, with lifecycle operations independent of storage index.
- Intervention and symmetry: Rollback restoration guarantees identical future behavior after an edit and undo restore the serialized state exactly, assuming fixed θ and history sufficiency.
6 A Small Test Model
The small test model implements a bounded editable key–value state with no persistent recurrent hidden state. It makes state-entry contributions explicit so the model’s pre-decode output can be audited.
- Architecture: The implementation uses slot keys, values, occupancy, and trainable empty-slot anchors, while keeping the current event and query step-local.
- Architecture: A learned unsupported sentinel contributes alongside occupied-slot terms, and the pre-decode logits are exactly the sum of these contributions.
- Architecture: A hierarchical router first chooses whether to touch an existing identity or create a new one, then selects among available anchors.
- Editable interface: The public interface decodes occupied slots into a categorical key–value schema and writes user edits into canonical K and V tensors.
- Editable interface: The bounded schema limits public-interface content while enabling exact round-trip evaluation through the same readout used for ordinary answers.
7 Experiments and Results
On 44 real multi-session records, prompt deletion and state retraction look identical immediately but diverge on later turns: retraction prevents stale-entry return and preserves current-value accuracy. Earlier-value recovery remains limited, and serialization omits some state fields.
- Real interaction records: The experiment uses 44 records containing annotated old and new values for the same subject, with a learned read selecting four entries.
- Real interaction records: Prompt deletion and state retraction render the same number of entries, refill the removed slot identically, and therefore cannot differ through a one-shot display advantage.
- Real interaction records: 31 of 44 items return the old entry after prompt deletion, reducing next-turn accuracy to .432–.523; retraction prevents return and preserves .659–.705 accuracy.
- Real interaction records: Only state retraction preserves access to the earlier value because the retracted entry remains available for later reading.
- Real interaction records: Earlier-value recovery reaches only 14–17 of 44 items, far below the 31/44 items where the old entry is visible.
- Scope boundary: Serialization retains content, standing, and relations, restores event times relatively, but does not yet serialize provenance, importance, or usage counts.
8 Limitations, Predictions, and Open Problems
Transfiver makes design-level predictions that can be tested and falsified, but the current implementation exercises only some core principles. Important open problems include scaling, richer state capabilities, human correction failures, and deployment obligations.
- Table 2 pairs each predicted property with a construction intended to refute it.Some predictions are partially exercised by the synthetic experiments, while others remain untested.
- Scaling to free-form language and comparison with full-scale long-term-memory systems remain open problems.A fuller system should also support visualization, source tracking, information liveness, complex relations, and reversible lifecycle.
- Human inattention to identified errors may produce identity mistakes, forced merges, meaning splits, false provenance, history contamination, or discarded important information.These are presented as possible failure modes when humans do not correct errors they identify.
- Persistent user-specific state creates privacy, security, and governance obligations, including provenance, deletion, export, access control, and visible uncertainty.Personalization may also adapt to harmful user behavior, creating safety risks beyond privacy.
9 Conclusion
The conclusion frames Transfiver as an evolving shared state that integrates memory, reasoning, output, inspection, and correction. Its broader dissociations remain design goals, while falsifiable predictions define work for future testing.
- Transfiver aims to represent quiet, recoverable, cross-project, differently interpreted, and subsequently changed information in one state.
- One evolving state is intended to remember, support reasoning, produce output, expose contents, and accept correction.History-sufficiency, intervention, and restoration requirements make this architectural claim falsifiable.
- Table 2 summarizes falsifiable predictions and proposed tests, with some predictions only partially exercised and others still untested.
- Preserving context without fragmentation, multiple belonging without copying, and correction without hidden bypass remains a design goal rather than a reported result.The broader list also includes relation, liveness, and qualified observation dissociations.
A Synthetic tests
The synthetic tests use a constructed state and trained model, so they establish that parts of Transfiver’s contract are satisfiable rather than demonstrating that the whole contract holds in real-world use.
- The synthetic tests establish satisfiability of parts of Transfiver’s contract, not that the complete contract holds in the wild.The passage distinguishes these tests from the real-record results in Section 7.1.
A.1 Contexts and overlap
The context experiment tests whether the same key remains separately bound to different contexts and whether context can be withdrawn and restored through state occupancy. The section also describes a held-out readout test showing that one frozen state can support four disagreeing temporal rules.
- Context separation: Four of five seeds in the first condition and all five in the second kept identical keys in separate context-specific entries.The query followed the named context rather than the most recent write, and switching only the query context returned the other value.
- Context withdrawal and restoration: Withdrawing a context by clearing its items’ occupancy changed the prior answer, while restoring the saved occupancy reproduced it from a tensor-identical state.The items themselves were not edited; after withdrawal, answers came from the remaining context rather than the unsupported sentinel.
- Context separation: One of five seeds in the first condition merged contexts, opening 3.9 rather than eight entries and reducing context-conditioned accuracy to .486.For that seed, the other context’s value was returned in .436 of queries and cross-context overlap fell to .190; it succeeded when context was carried in the state.
- Four-rule readout: A separate held-out experiment asks one frozen persistent state to support most-recent, earliest, as-of-section, and nth-value rules using a shared readout over five temporal features.The readout uses 385 parameters, scores 205 candidate values, and is evaluated on a fixed test partition without retries or regeneration.