← all research

Persistent Thinking

A specified architecture for preserving unresolved reasoning across sessions as an evidence-backed, branchable reasoning graph - not as a lossy narrative summary.

Persistent Thinking

Resuming unresolved reasoning across agent sessions

Specified research direction Architecture frozen - Phase 1 not implemented.

The failure in current reentry

A session cannot reliably resume reasoning from a summary because summaries preserve conclusions while collapsing unresolved branches, counterarguments, uncertainty, and pending verification. Persistent thinking requires preserving the active reasoning frontier, not narrating the previous session.

Three layers of continuity must be distinguished:

• Memory continuity: what the system believes or remembers.
• Reasoning continuity: what remains unresolved, contested, blocked, or awaiting evidence.
• Execution continuity: what action should happen next and what would prove success.

CSM solves the first. This research specifies the second and touches the third.

What the research found

The three original open questions have been answered at the architectural level.

Representation

Prose summaries are the wrong persistence unit because they collapse epistemic state.

The persistence unit becomes a graph containing:

• reasoning threads and objectives;
• immutable logical-node versions;
• open, tentative, resolved, killed, and orphaned states;
• support, contradiction, dependency, refinement, and supersession edges;
• globally shared evidence;
• branch-local citations and interpretations;
• agent claims: originate, endorse, dispute, abstain;
• pending actions and acceptance conditions.

Reentry loads the active frontier:

open and tentative nodes
+ direct dependency chains
+ live counterarguments
+ unresolved objective forks
+ pending actions
+ resolving evidence requirements

It does not load the whole reasoning graph.

Budget

Summaries are cheap to inject but expensive in hidden re-derivation. The next agent must reconstruct why a conclusion was reached, often producing a plausible but different inference chain.

The proposed graph is more expensive to store but cheaper to resume when loaded lazily:

Load active frontier
-> inspect direct dependencies
-> resolve evidence references only when needed

This connects directly to the existing Virtual Context Windows work, which already explores unexpanded references and lazy context resolution in CSM.

Drift

Drift compounds because every session resumes from the previous session’s interpretation rather than the original evidence.

The proposed controls are:

• provenance instead of restatement;
• evidence validity states;
• stale-node reverification;
• explicit contradiction;
• kill, supersede, and retract operations;
• versioned consolidation and contestation rules;
• bounded evidence-revocation cascades;
• CSM memory statuses that can move from stable to provisional, contested, or retracted.

The reasoning ledger

Shared evidence substrate
        | cited differently
Immutable reasoning-node versions
        | evaluated through
Agent claims and disputes
        | separated into
Reasoning branches
        | reconciled through
Explicit merges
        | checked against
Versioned consolidation rules
        | promoted into
CSM memory

Core invariants:

Evidence is shared.
Interpretation is branch-local.
Content changes create versions.
Agreement creates claims, not mutations.
Disagreement creates claims or branches, never overwrites.
Objective disagreement outranks node disagreement.
Unmerged branches cannot be rendered as settled history.
Only governed positive resolution consolidates.
Only resolved-negative branches may compress.

The full schema is named in the appendix below. The main narrative stays conceptual.

What a reentry packet may summarize

This is the most important practical distinction.

Safe compression:

Two active branches disagree over whether SQLite parity is sufficient. The disagreement concerns operational scope. Neither branch has been merged. A production adapter test would resolve the open dependency.

Unsafe compression:

The previous session concluded that SQLite parity was sufficient, although PostgreSQL-only was also considered.

The first summarizes topology. The second silently adjudicates epistemic status.

A reentry formatter may describe:

- branch count
- branch state
- divergence point
- unresolved contradictions
- objective changes
- required evidence
- pending actions

It may not use:

- concluded
- rejected
- settled
- preferred
- set aside

unless the ledger contains the corresponding durable transition.

This is the practical boundary between persistent thinking and an improved summary generator.

Reasoning under multiple agents

GLM, Codex, Claude, and other agents may work against the same substrate concurrently.

The system needs:

• objective-level and node-level forks;
• immutable versions instead of last-write-wins updates;
• shared evidence with branch-local citation roles;
• originate, endorse, dispute, and abstain claims;
• agent-run lineage;
• deterministic independence grouping;
• explicit branch merges;
• serialized and idempotent consolidation commits.

Independence is defined as connected components:

Each claiming agent run is a vertex.

Runs are connected when they share:
- a parent run
- direct exposure to one another's conclusion
- sufficiently similar reasoning input
- sufficiently overlapping evidence actually cited

Independent claim groups = connected components.

Cited evidence matters more than merely sharing the same council briefing.

Consolidation is reversible governance

Consolidation is not a one-way promotion.

Reasoning frontier
  -> independent claim grouping
  -> version-pinned rule evaluation
  -> serialized consolidation commit
  -> CSM memory marked stable
  -> evidence challenge or invalidation
  -> bounded reverification
  -> provisional or contested memory
  -> explicit audit or adjudication
  -> restore, supersede, or retract

This connects to the existing Belief Promotion system. CSM already describes belief candidates being promoted only after governance, with promotion disabled by default and dry-run inspection available. Persistent Thinking is the stricter reasoning-layer extension:

Promotion without lifecycle reversal is incomplete governance.

Two distinct lifecycle states:

• Superseded: historically valid, but replaced by a newer authoritative formulation.
• Retracted: supporting foundation was invalidated or the conclusion was adjudicated unsound.

Phased implementation plan

Phase 1 - Prove governed consolidation

Build:

• shared evidence and branch-local citations;
• reasoning threads and node versions;
• agent claims and run lineage;
• deterministic independence grouping;
• consolidation evaluator;
• serialized, idempotent consolidation committer;
• minimum CSM memory projection.

Run one real GLM/Codex/Claude thread through:

fork
  -> cite evidence
  -> originate / endorse / dispute
  -> calculate independent groups
  -> evaluate pinned rules
  -> commit exactly one consolidation
  -> project it into CSM
  -> replay the decision from stored inputs

Go/no-go gate: concurrent evaluations must produce one live consolidation, and the decision must be reproducible from stored records.

Phase 2 - Observe real disagreement

No separate telemetry layer. All observations must be queryable from Phase 1’s core tables:

• Which endorsements were independent?
• Which evidence did each agent actually rely on?
• Did branches diverge over objective, claim, evidence interpretation, or acceptance conditions?
• Did an agent see another conclusion before forming its own?
• Was apparent convergence independent or inherited?

Gate: if these questions require bespoke instrumentation, Phase 1’s schema is incomplete.

Phase 3 - Govern reversal

Only after observing real council behavior, add:

• lazy reverification;
• materiality-based contestation;
• atomic memory-status projection;
• retraction proposals and votes;
• proposal-pinned independence grouping;
• supersession;
• explicit retraction adjudication.

What this does not claim

• No implementation exists yet.
• It does not preserve private hidden chain-of-thought.
• It preserves explicit reasoning artifacts, claims, evidence relationships, open questions, and operational continuation state.
• A reasoning graph does not guarantee correct reasoning.
• Independence grouping can conservatively under-count independent conclusions.
• Reentry still involves interpretation; the design makes that interpretation inspectable rather than pretending it did not occur.
• Council quorum rules remain intentionally unspecified until Phase 2 captures actual disagreement patterns.

Appendix: Core schema objects

The public page does not need every column, but the architectural objects are named:

reasoning_threads
reasoning_node_versions
reasoning_edges
reasoning_evidence
reasoning_node_citations
reasoning_claims
reasoning_agent_runs
reasoning_consolidations
memory_consolidation_state

Fields that explain behavior:

reasoning_node_versions
  - logical_node_id
  - thread_id
  - content
  - status
  - parent_version_id
  - created_by_agent_id

reasoning_claims
  - node_version_id
  - agent_run_id
  - claim_type
  - confidence

reasoning_consolidations
  - node_version_id
  - rule_set_id
  - grouping_algorithm_version_id
  - snapshot_hash
  - status

A full technical specification will be linked here once Phase 1 is implemented.