From ambiguous utterances to governed reuse classes: canonicalization, quotient invariance, and conditional decidability

Language-processing systems that optimize for a single resolved output risk losing ambiguity. With incomplete context, competing interpretations may be compressed prematurely. We specify Non-Resolution Reasoning (NRR) as an explicit retention-commitment interface for preserving context-indexed alternatives until evidence supports commitment. NRR organizes context-indexed alternatives, independently active weights, declared retention and commitment operations, and non-destructive output projection around three principles: Context-indexed Non-Identity, Approximate Identity, and Non-Resolution. It specifies a retained state and candidate operator vocabulary, and proposes Multi-Vector Embeddings, Non-Collapsing Attention, and Contextual Identity Tracking as implementable architectural realizations. In a reproducible synthetic two-turn task, one gated Multi-Vector-Embedding instantiation maintains high output entropy before disambiguating context arrives ($H = 0.91$ bits, near the $1.0$-bit maximum), while a controlled single-embedding baseline has low entropy ($H = 0.15$ bits); both tested systems resolve correctly after context arrives. Thus, high pre-context output uncertainty and accurate later resolution can coexist in the tested gated configuration. This result does not validate the full NRR architecture or matched-parameter superiority; the specification, proposed components, and demonstrated behavior remain distinct contribution layers. NRR targets premature commitment, not commitment itself: alternatives can remain available while evidence is incomplete, and commitment occurs at explicit output or action gates. The question is not whether AI should resolve ambiguity, but when, how, and under whose control. Implementation: https://github.com/kei-saito-research/nrr-core. Series hub: https://github.com/kei-saito-research/nrr-series-hub.

Modern retrieval-augmented generation(RAG) deployments increasingly rely on caching to reduce token cost and time-to-first-token(TTFT). Prefix-level KV reuse is now standard in serving stacks such as vLLM, and chunk-level and position-independent reuse have been pushed further by recent systems(RAGCache, TurboRAG, CacheBlend, EPIC, ContextPilot, PCR, LMCache). Output-level semantic answer caches, by contrast, remain fragile: similar prompts can map to different correct answers, retrieved evidence drifts as the corpus is updated, and adversarial collision attacks have been shown to hijack cached responses. We argue that the right framing for cached answer reuse is not how to reuse faster but when reuse is safe. We propose GroundedCache, an evidence-validated cache router that admits a cached answer only when 4 cheap gates simultaneously hold: query similarity, retrieved-evidence overlap, source-version validity, and lexical (or judge-based) support of the cached answer by the freshly retrieved evidence. We build a six-regime workload that stress-tests cache safety rather than only hit rate, and introduce an operator-facing metric, the unsafe-served rate (USR), fraction of all queries that received a wrong cached answer. Across 2 datasets and 12,000 real-LLM generations(Qwen2.5-7B-Instruct on vLLM with Automatic Prefix Caching), GroundedCache drives USR to 0.0% on every HotpotQA regime(vs. 15-35% under naive caching) and to 1.5% on mtRAG document drift(vs. 51.5%), a 34x reduction on the design-point adversarial regime and 3-10x reductions across the other mtRAG regimes, while end-to-end p50 latency stays within 1.04-1.07x of a no-cache RAG baseline. A per-gate ablation isolates the lexical support gate as the load-bearing safety mechanism on both datasets, with the remaining gates providing defense-in-depth at near-zero cost. We release the implementation, workload, and evaluation harness.

Multi-agent latent reasoning composes agents' KV-caches into one context for a final agent. Prior work (Agent Primitives) does this by concatenating caches along the sequence axis with RoPE re-encoding, which we call BagMerge. BagMerge is non-commutative, and the best input ordering is unpredictable, shifting with the regime, the latent-step budget, and the model scale. We make this exchange a convergent replicated state. First, CanonicalMerge fixes the layout by content: ordering caches by mean K-norm at a middle layer renders the merged cache byte-identical under any input permutation, verified algorithmically (arity N<=5) and bit-for-bit on real Qwen3-1.7B and 4B state. Second, we separate the replicated state from decode-time layout: the state is a set of content-addressed latent fragments whose merge is set union, a state-based CvRDT (commutative, associative, idempotent, absorbing), and CanonicalMerge is its deterministic render. Because the render is byte-equivalent, every N=2 accuracy number carries over unchanged and re-delivered duplicates are absorbed rather than re-concatenated. On a partitioned-reasoning benchmark, CanonicalMerge matches the best BagMerge ordering in every regime-by-budget-by-ordering cell without knowing which order is best, trading a small, statistically insignificant accuracy margin for an unconditional structural guarantee. The behaviour transfers to real multi-document QA (HotpotQA), while the closest training-free output-fusion baseline (PackLLM) loses by 45 points at matched budget, placing cache-level merging in a regime distinct from output-level fusion. Finally, at k>2 the approach transports and colocates latent traces but does not by itself compose them, which we characterize to motivate future work.