Iterated Insights

In “A Cognitive Architecture for Machine Consciousness and Artificial Superintelligence: Thought Is Structured by the Iterative Updating of Working Memory” (arXiv:2203.17255), I, Jared Reser lay out a proposal for what a thought process would look like if we tried to engineer it directly into AI, rather than treating intelligence as something that falls out of ever-larger pattern recognizers.

Reser, J. 2022. A Cognitive Architecture for Machine Consciousness and Artificial Superintelligence: Updating Working Memory Iteratively. arXiv: 2203.17255 

You can also see this article at aithought.com with videos.

The paper’s central claim is simple to state: the workflow of thought is iterative. Instead of one working-memory state being replaced wholesale by the next, each new state should preserve some proportion of the previous state while adding and subtracting other elements. This “partial updating” causes successive states to overlap, so a train of thought becomes a chain of intermediate states that remain causally and semantically linked over time.

I argue that this overlap is not just a philosophical gloss, it’s grounded in the biology of persistent activity. Mammalian working memory is framed as having two key persistence mechanisms operating on different time scales: sustained firing (seconds) supporting the focus of attention, and synaptic potentiation (minutes to hours) supporting a broader short-term store. In this view, as some items drop out and others enter, the remaining coactive subset “stitches” the stream together, making continuity and multi-step reasoning possible.

Crucially, the paper doesn’t stop at saying states overlap. It proposes a mechanism for how the next update is chosen: the currently coactive working-memory contents jointly “cospread” activation across the network, performing a multiassociative search over long-term memory for the most context-relevant next addition(s). This repeated “search → update → search again (with modified context)” is presented as a compounding process that can build structured inferences, predictions, and plans across multiple steps.

Because the manuscript is meant to be both explanatory and constructive, it also explicitly positions iterative updating as an engineering blueprint: a way to implement a global-workspace-like working set that is updated continuously, supports long-range dependencies, and can be trained developmentally by expanding persistence/overlap over time. The paper even provides a glossary of introduced terms (e.g., iterative updating, cospreading, multiassociative search, SSC/icSSC, iterative compounding, iterative thread) intended to carve the system into reusable conceptual parts.

What this blog entry will do

In the rest of this post, I’ll first list a set of concrete claims and “working insights” extracted from the paper, phrased as testable or at least operationally meaningful statements. Then I’ll attempt to formalize several of the key ideas mathematically, with the goal of turning the architecture into something that can be simulated, ablated, and compared against alternatives (both in cognitive modeling and in AI implementations).

A) Core computational principle

1. Thought is organized by continuous partial updating: each new working-memory state preserves a proportion of the prior state (not complete replacement), making the stream of thought a chain of overlapping iterations.
2. Iterative overlap is the mechanism of continuity: overlap between successive working-memory states creates “recursive nesting” so each state is embedded in the one before it, enabling stateful cognition rather than stateless reactions.
3. Iterative updating is simultaneously (i) an information-processing strategy, (ii) a model of working memory, (iii) a theory of consciousness, and (iv) an AI programming principle. Cognitive Architecture Iterativ…

B) Working memory structure: two persistence tiers + iteration in both

4. Working memory has two key persistence mechanisms with different timescales: sustained firing maintains the FoA (seconds), while synaptic potentiation maintains a broader short-term store (minutes to hours).
5. Both stores iterate: the FoA iterates via sustained firing; the short-term store iterates as a pool of synaptically potentiated units that is continuously added to and subtracted from, yielding isomorphic “incremental updating” across neural and psychological levels. Cognitive Architecture Iterativ…
6. The persisting “topic” of thought corresponds to the longest-lasting active units, while other contextual features come and go around it. Cognitive Architecture Iterativ…

C) Control variables and “modes” of thought

7. Rate of updating is a control parameter (how much of the set changes per step) that tunes looseness vs tightness of coupling—superficial/distractible vs concentrated/systematic processing.
8. Implicit vs explicit processing is framed as different overlap regimes (system-1-like = faster updating / less overlap; system-2-like = slower updating / more overlap and longer maintenance of intermediates). Cognitive Architecture Iterativ…
9. Dopamine is proposed to reduce the rate of updating (stabilize the set), mediating a shift toward explicit/effortful processing under novelty/surprise/reward/error. Cognitive Architecture Iterativ…
10. Boundaries between “thoughts” are marked by intermittent non-iterative updates (high-percentage replacement events), while within-thought processing shows sustained low-percentage turnover. Cognitive Architecture Iterativ…

D) How new content is selected: pooled search (multiassociative search)

11. Selection of the next update is a pooled spreading-activation search: the currently coactive set combines (“cospreads”) activation energy through the global network to converge on the most context-relevant next item(s).
12. Multiassociative search is described as an explicit stepwise algorithm (items maintained vs dropped vs newly activated; plus mechanisms where the newest addition redistributes activation weights and can contextually alter the “fuzzy” composition/meaning of items). Cognitive Architecture Iterativ…
13. The search contributors are not just FoA items: potentiated short-term-store units plus active sensory/motor cortex, hippocampus, basal ganglia, and other systems all contribute to the pooled search that selects the next update.
14. Multiassociative search produces novel inference as a standard case: even when the set of assemblies is unprecedented, the system can converge on either recall (same result as last time) or a new item (novel inference) depending on current coactivity.
15. Multiassociative search implies multiassociative learning: each search event can retune associative strengths (Hebbian-style), so search doesn’t just use memory—it updates semantic/procedural structure over time. Cognitive Architecture Iterativ…

E) Prediction and inference as the product of iteration

16. Updates generated by search are predictions: iterative updating + pooled search is framed as a brain-level autoregressive mechanism that captures conditional dependencies across sequences of events.
17. Iterative compounding: the product of one search becomes part of the next state’s cue-set, so search is repeatedly modified by its own outputs, compounding inferences/predictions across steps.

F) Reasoning patterns as working-memory dynamics (figures → mechanisms)

18. Iterative inhibition: when the newest update is judged unhelpful/prepotent, it is inhibited so the remaining set must converge on the next-most-pertinent item; repeated inhibition rounds progressively restrict the search tree. Cognitive Architecture Iterativ…
19. Planning = dense iteration: planning is characterized as (i) lower update rate, (ii) fewer full “jumps,” and (iii) more intermediate iterations before action—explicitly mapping planning to “chain-of-thought-like” intermediate steps.
20. Attractor states as beliefs/truths: iterative updating tends to converge toward stable item-sets (attractors) interpreted as beliefs; thinking is framed as progressive narrowing/compression toward generalizable statements. Cognitive Architecture Iterativ…

G) Threading, subproblems, and compositional problem solving

21. Iterative thread: a line of thought is a chain of iteratively updated states that can be reiterated or “picked up where it left off.”
22. Subproblem decomposition via store cooperation: the FoA iterates on a subproblem while the short-term store holds the broader objective; interim results can be suspended and later reactivated.
23. Merging of subsolutions: outputs from separate iterative episodes can be coactivated in a new state and used together for multiassociative search to yield a hybrid/final solution.
24. Backward reference / conditional branching emerges when prior threads/subsolutions are stored and later reconverged upon, allowing departures from the default forward-iterative flow.
25. Schemas as dynamic packets that can be recalled and co-iterated: a previously learned multi-item schema can be pulled in midstream and used as an organizing heuristic/script that iterates with the current line of thought.
26. Transfer learning as “recognize partial overlap → import prior thread content”: encountering a later situation that shares items with an earlier episode triggers reuse of prior iterative structure to generalize toward a similar conclusion. Cognitive Architecture Iterativ…

H) AI training/development implications (as stated)

27. Maturational training schedule for AI: start with minimal working-memory span/overlap and gradually expand toward superhuman span as experience accumulates. Cognitive Architecture Iterativ…
28. Long-horizon inference depends on persistence preventing “cache misses”: prolonging persistence makes each search more specific (more constraints) and preserves intermediate results long enough to compound into higher-order inferences. Cognitive Architecture Iterativ…

Mathematical Formalization of Iterative Updating Working Memory

This section provides a minimal mathematical formalization of an iterative working-memory architecture in which (i) a limited-capacity focus-of-attention working set is updated incrementally over discrete cognitive iterations, (ii) the next working-memory content is selected by pooled multi-cue (multiassociative) search, and (iii) an inhibitory steering mechanism can suppress unhelpful candidates to force exploration of alternatives. The same formalization can be interpreted as a cognitive/neural process model or as an implementable AI module.

1. Representational Objects

Assume a universe of $N$N candidate items (assemblies, concepts, perceptual features, memory entries, or latent vectors) indexed by $i\in\{1,\dots,N\}$i∈{1,…,N}. Each item has a representation vector in $\mathbb{R}^d$Rd.

Candidate pool

At iteration $t$t, the system has access to a candidate pool$$C_t \in \mathbb{R}^{N\times d},$$Ct​∈RN×d,

where row $C_{t,i}$Ct,i​ is the $d$d-dimensional vector for candidate $i$i. In an AI setting, $C_t$Ct​ may be (a) token embeddings in a context window, (b) retrieved long-term memory vectors, (c) perceptual feature vectors, or (d) a mixture of all three.

Working memory (focus of attention)

Working memory is a capacity-limited set of $K$K vectors:$$W_t \in \mathbb{R}^{K\times d}.$$Wt​∈RK×d.

We interpret $W_t$Wt​ as the content currently held in the focus of attention (FoA). The core “iterative updating” assumption is that $W_{t+1}$Wt+1​ is formed by retaining a fraction of $W_t$Wt​ and recruiting a fraction of new items from $C_t$Ct​, rather than replacing the entire content at each step.

Inhibition trace (optional)

To steer away from lures and repeated mistakes, maintain an inhibition state over candidates:$$h_t \in \mathbb{R}^N_{\ge 0}.$$ht​∈R≥0N​.

Large $h_{t,i}$ht,i​ reduces the probability that candidate $i$i is recruited at iteration $t$t.

---

2. A Continuity Metric (Overlap)

A central measurable quantity is the degree to which successive working-memory states overlap. Because the AI implementation uses explicit “keep” masks, overlap is directly trackable.

Let $K_t \subseteq \{1,\dots,K\}$Kt​⊆{1,…,K} denote the set of indices of retained slots from $W_t$Wt​. Then a natural overlap statistic is$$O_t \;=\; \frac{|K_t|}{K} \;\approx\; r,$$Ot​=K∣Kt​∣​≈r,

where $r\in[0,1]$r∈[0,1] is the retention fraction (defined below). If the model uses “soft” retention (continuous gates), an analogous graded overlap can be computed from cosine similarity between pooled summaries of $W_t$Wt​ and $W_{t+1}$Wt+1​.

Overlap is a control knob: increasing $r$r produces more continuity and longer-horizon constraint accumulation; decreasing $r$r produces faster topic shifts and more exploratory dynamics.

---

3. Pooled Multiassociative Search (Selecting New Content)

The next working-memory recruits are selected by a pooled search driven by the entire current working set. This can be implemented in a differentiable way using a pooled query vector.

Pooled query

Define a pooled query$$q_t = f_{\text{pool}}(W_t)\in\mathbb{R}^d,$$qt​=fpool​(Wt​)∈Rd,

where $f_{\text{pool}}$fpool​ is a learned pooling function. Common choices include mean-pooling plus an MLP,$$q_t = \text{MLP}\!\left(\frac{1}{K}\sum_{k=1}^K W_{t,k}\right),$$qt​=MLP(K1​k=1∑K​Wt,k​),

or attention-based pooling,$$q_t = \sum_{k=1}^K \alpha_{t,k}\,W_{t,k},\quad \alpha_t = \text{softmax}(u^\top W_t),$$qt​=k=1∑K​αt,k​Wt,k​,αt​=softmax(u⊤Wt​),

with learnable vector $u\in\mathbb{R}^d$u∈Rd.

Candidate logits (pooled similarity + inhibition)

Score each candidate by similarity to the pooled query, subtracting inhibition:$$\ell_{t,i} \;=\; \frac{q_t^\top C_{t,i}}{\sqrt{d}} \;+\; b_i \;-\; \lambda\,h_{t,i},$$ℓt,i​=d​qt⊤​Ct,i​​+bi​−λht,i​,

where $b_i$bi​ is an optional learned bias and $\lambda\ge 0$λ≥0 controls the strength of inhibition.

Convert logits to a probability distribution:$$p_t \;=\; \text{softmax}(\ell_t/\tau),$$pt​=softmax(ℓt​/τ),

with temperature $\tau>0$τ>0. Low $\tau$τ yields near-deterministic convergence; higher $\tau$τ yields more exploratory recruitment.

Recruiting $m=(1-r)K$m=(1−r)K new items

Let the number of new recruits be$$m = (1-r)K,$$m=(1−r)K,

with retention fraction $r\in[0,1]$r∈[0,1]. Recruit $m$m candidates from $p_t$pt​ using a top-$m$m operator (or a differentiable approximation).

Conceptually:

• Discrete: $A_t = \text{TopM}(p_t, m)$At​=TopM(pt​,m) (indices of the $m$m strongest candidates)
• Differentiable: use Gumbel-Top-$m$m (straight-through), soft top-$k$k, or matching relaxations.

Let $R^{\text{new}}_t\in\mathbb{R}^{m\times d}$Rtnew​∈Rm×d be the matrix of recruited vectors.

---

4. Retention / Eviction (Keeping $rK$rK Slots)

In addition to recruiting new items, the system decides which existing FoA slots to keep.

Keep scores

Assign a keep-score to each slot $W_{t,k}$Wt,k​ given the current pooled context:$$g_{t,k} = f_{\text{keep}}(W_{t,k}, q_t)\in\mathbb{R},$$gt,k​=fkeep​(Wt,k​,qt​)∈R,

where $f_{\text{keep}}$fkeep​ can be an MLP on concatenated inputs:$$g_{t,k} = \text{MLP}([W_{t,k}; q_t]).$$gt,k​=MLP([Wt,k​;qt​]).

Select $rK$rK slots to retain:

• Discrete: $K_t = \text{Top}(g_t, rK)$Kt​=Top(gt​,rK)
• Differentiable: relaxed top-$k$k or straight-through top-$k$k

Let $R^{\text{keep}}_t\in\mathbb{R}^{rK\times d}$Rtkeep​∈RrK×d be the retained slot vectors.

---

5. The Iterative Updating Operator

The next working-memory state is formed by concatenating retained slots and new recruits:$$W_{t+1} = \text{Concat}\!\left(R^{\text{keep}}_t,\; R^{\text{new}}_t\right) \in\mathbb{R}^{K\times d}.$$Wt+1​=Concat(Rtkeep​,Rtnew​)∈RK×d.

This is the explicit retain–drop–add operator that makes overlap a controllable parameter. It also defines a concrete internal notion of “within-thought” continuity (high $r$r) versus “thought boundary/reset” (low $r$r or a reset event).

---

6. Iterative Inhibition (Search Steering)

To implement “reject-and-research” dynamics, we update the inhibition trace for candidates that were selected (or attempted) but deemed unhelpful.

Let $z_t\in[0,1]^N$zt​∈[0,1]N be a (possibly soft) indicator of which candidates were selected at iteration $t$t. Update inhibition as$$h_{t+1} = \kappa h_t + \gamma z_t,$$ht+1​=κht​+γzt​,

where $\kappa\in[0,1)$κ∈[0,1) controls decay and $\gamma>0$γ>0 is the increment for selected/rejected candidates.

This mechanism progressively suppresses repeated lures and forces the pooled search to converge on alternatives, effectively pruning a local attractor basin.

---

7. Optional: Contextual “Meaning Shift” Within Working Memory

To capture context-dependent remapping (the idea that the “same item” can shift meaning depending on the most recent update and current set), define a context-conditioned transform applied to each slot before pooling:$$\hat W_{t,k} = W_{t,k} + \Delta(W_{t,k}, q_t),$$W^t,k​=Wt,k​+Δ(Wt,k​,qt​),

where $\Delta$Δ is a learned function (e.g., MLP). The pooled query is computed from $\hat W_t$W^t​ rather than $W_t$Wt​. This makes representational drift an explicit, measurable part of the model.

---

8. Training Objectives

The iterative working-memory module can be trained end-to-end inside larger models (transformer, recurrent agent, world model). The following losses are common and complementary.

8.1 Task loss (supervised or self-supervised)

If the system produces outputs $y_t$yt​ (next token, next action, next-step label), train with a standard task loss:$$\mathcal{L}_{\text{task}} = \sum_t \text{CE}(y_t, y^*_t) \quad \text{or} \quad \mathcal{L}_{\text{task}} = \sum_t \|y_t – y^*_t\|^2.$$Ltask​=t∑​CE(yt​,yt∗​)orLtask​=t∑​∥yt​−yt∗​∥2.

8.2 Continuity regularization (optional)

To encourage a desired overlap regime, regularize the effective overlap $\hat O_t$O^t​ toward target $r$r:$$\mathcal{L}_{\text{overlap}} = \sum_t (\hat O_t – r)^2.$$Loverlap​=t∑​(O^t​−r)2.

Here $\hat O_t$O^t​ can be computed from keep masks (discrete) or from similarity of pooled summaries (soft).

8.3 World-model prediction (optional)

For predictive learning, minimize error in predicting next observation features $\phi(o_{t+1})$ϕ(ot+1​):$$\mathcal{L}_{\text{pred}} = \sum_t \left\|\hat\phi_{t+1} – \phi(o_{t+1})\right\|^2.$$Lpred​=t∑​​ϕ^​t+1​−ϕ(ot+1​)​2.

This loss incentivizes the module to retain what is causally relevant across time while updating what changes.

8.4 Reinforcement learning (optional)

In RL settings, $W_t$Wt​ conditions the policy $\pi(a_t\mid W_t)$π(at​∣Wt​). The working-memory module is trained jointly by actor–critic losses; overlap/continuity regularizers can be added to shape deliberation.

---

9. Developmental / Curriculum Scheduling of Retention

A key architectural hypothesis is that long-horizon coherence can be scaffolded by gradually increasing retention and persistence. Implement this via a schedule for $r$r over training steps:$$r(\text{step}) = r_{\min} + (r_{\max}-r_{\min})\cdot \sigma\!\left(\frac{\text{step}-s_0}{s_1}\right),$$r(step)=rmin​+(rmax​−rmin​)⋅σ(s1​step−s0​​),

where $\sigma(\cdot)$σ(⋅) is the logistic function and $s_0,s_1$s0​,s1​ control onset and steepness.

Early training (lower $r$r) promotes exploration and rapid updating; later training (higher $r$r) promotes compounding of intermediate results and stable long-horizon inference.

---

10. Key Knobs, Metrics, and Ablations

10.1 Knobs (interpretable control parameters)

• Capacity: $K$K (FoA size)
• Retention / overlap: $r$r (continuity)
• Selection temperature: $\tau$τ (exploration vs convergence)
• Inhibition: $\lambda,\kappa,\gamma$λ,κ,γ (escape from lures)
• Pooling/keep functions: $f_{\text{pool}}, f_{\text{keep}}$fpool​,fkeep​ (learned control policy)

10.2 Metrics

• Overlap / continuity: $O_t$Ot​ or $\hat O_t$O^t​
• Reset frequency: incidence of low-overlap transitions
• Lure perseverance: probability of re-selecting recently inhibited candidates
• Long-horizon coherence: task-dependent (e.g., plan success, multi-step accuracy, discourse coherence)

10.3 Mechanism-proving ablations

Ablations that directly test whether each primitive matters:

1. No overlap constraint: replace all $K$K slots each step (set $r=0$r=0)
2. Overlap without pooled search: recruit using only the newest slot (single-cue)
3. Pooled search without inhibition: remove $h_t$ht​ terms ($\lambda=0$λ=0)
4. Fixed rrr vs curriculum r(⋅)r(\cdot)r(⋅): test developmental hypothesis
5. Remove contextual remapping: set $\Delta(\cdot)=0$Δ(⋅)=0

These ablations tend to produce characteristic failures (derailment, lure trapping, weak bridging inference) that operationalize the theory’s claims.

---

11. Summary (the “kernel”)

The architecture reduces to a small set of commitments:

1. A capacity-limited working set $W_t$Wt​ evolves by an explicit operator

$$W_{t+1} = \text{Keep}_{rK}(W_t) \;\cup\; \text{Recruit}_{(1-r)K}(C_t \mid f_{\text{pool}}(W_t)),$$Wt+1​=KeeprK​(Wt​)∪Recruit(1−r)K​(Ct​∣fpool​(Wt​)),

2. New recruits are selected by pooled multi-cue search (softmax over candidate similarity to a pooled query),
3. Search can be steered by iterative inhibition,
4. Retention $r$r is an interpretable continuity knob that can be trained and scheduled.

This formalization is simultaneously (i) a theory statement (what cognition is doing step-to-step) and (ii) a runnable AI design pattern (how to build an agent that maintains continuity and compounds intermediate results).