ReThinker Architecture in AI Systems

• ReThinker Architecture is a set of integrated software and hardware frameworks that support iterative, confidence-aware reasoning and adaptive planning.
• In software, it employs a Solver–Critic–Selector pipeline to generate, evaluate, and select multi-stage reasoning paths using dynamic compute allocation and guided reflection.
• In hardware, it introduces a dedicated Reasoning Unit that fuses symbolic and neural processing to achieve significant speedups and energy-efficient execution.

ReThinker Architecture refers to a set of methods and systems for native, iterative, and confidence-aware reasoning, developed both in software (agentic frameworks and LLM orchestration) and hardware (augmented computing architectures with native reasoning capabilities). The unifying objective of ReThinker architectures is to enable dynamic reasoning, self-reflection, and goal-directed planning—sometimes at the algorithmic level via agent orchestration and self-evaluation, and in advanced cases as a fundamental execution property of the computational substrate itself. This entry details both the software agentic ReThinker paradigm, focusing on multi-stage LLM reasoning and adaptive compute allocation (Tang et al., 4 Feb 2026), and the hardware ReThinker architecture, which introduces a Reasoning Unit co-processor for system-level artificial general intelligence (Singh et al., 22 Jul 2025). Variants for vision-language and reinforcement learning settings are also reviewed (Wang et al., 10 Apr 2025).

1. High-Level Architectural Principles

ReThinker architectures are defined by their embrace of iterative, multi-stage reasoning with explicit confidence or uncertainty modeling at each step. In software, the canonical paradigm is a stage-wise Solver–Critic–Selector framework, where multiple reasoning paths are generated, critiqued, and adaptively selected based on confidence and reflection (Tang et al., 4 Feb 2026). In hardware, ReThinker extends the Von Neumann model with a dedicated Reasoning Unit (RU) as a parallel co-processor that executes symbolic inference, multi-agent coordination, and hybrid symbolic-neural computation as fundamental architectural primitives (Singh et al., 22 Jul 2025).

Common foundational principles include:

• Dynamic compute allocation based on model confidence or task complexity, rather than fixed pipelines.
• Iterative, multi-path search in reasoning or planning spaces, often parallelized at the agent level.
• Integrated symbolic and neural processing, allowing hybrid workflows.
• Native support for introspection and guided reflection, at either the agentic or hardware-execution level.

2. Agentic ReThinker: Solver–Critic–Selector Reasoning

The software ReThinker architecture employs a three-stage pipeline:

Pipeline Structure

1. Solver: $N$ independent reasoning paths are generated in parallel. Each path undergoes $T_{solver}$ rounds of iterative answer refinement, optionally interleaving tool calls (e.g., web search, code execution).
2. Critic: Each candidate reasoning chain is summarized as a tuple $(y, a, k)$ where $y$ contains key reasoning steps, $a$ the final answer, and $k$ key areas for improvement. Guided reflection occurs over $T_{critic}$ rounds.
3. Selector: All candidates are scored with an internal confidence measure (perplexity-based). Selection proceeds via permuted candidate presentation (Latin square to avoid positional bias) and confidence-gated iterative re-selection, stopping early when perplexity drops below a threshold $\tau$ (default $\approx 1.2$).

Pseudocode Example

\begin{algorithm}[H] \caption{Single‐Path Solver–Critic with Guided Reflection} \begin{algorithmic}[1] \Require question $q$, rounds $T_{solver}$0 \State $T_{solver}$1 \For{$T_{solver}$2 to $T_{solver}$3} \State $T_{solver}$4 \EndFor \State $T_{solver}$5 \State $T_{solver}$6 \For{$T_{solver}$7 to $T_{solver}$8} \State $T_{solver}$9 \EndFor \State \Return $(y, a, k)$0 \end{algorithmic} \end{algorithm}

Compute and iteration budgets are allocated adaptively using a gating rule:

$(y, a, k)$1

Evaluation and Results

On the "Humanity's Last Exam" benchmark, ReThinker (Gemini-3-Pro) achieves 52.2\% Pass@1—a significant improvement over standalone LLMs. Ablation studies attribute gains specifically to Solver re-answering (+1.4%), Critic guided reflection (+3.8%), and Selector confidence-guidance (+5.6%) (Tang et al., 4 Feb 2026).

3. Hardware ReThinker: Architecting Reasoning Co-Processors

The hardware ReThinker system extends classical architectures with an integrated Reasoning Unit (RU) designed for native, high-throughput symbolic and hybrid reasoning (Singh et al., 22 Jul 2025).

Block-Level Overview

Component	Function	Key Parameters
CPU Complex	Scalar/vector execution, dispatch, microcode	Traditional plus RU dispatch
Reasoning Unit	$(y, a, k)$2 lanes, each a six-stage cognitive pipe	$(y, a, k)$3 GHz, $(y, a, k)$4
RU–CPU Bridge / SIB	100 GB/s bi-directional message passing	Low-latency, speculative DMA
Memory Subsystem	Numeric/cognitive tier caches, DRAM	$(y, a, k)$5 GB/s, $(y, a, k)$6 GB/s

Reasoning Unit ISA

Key instructions (32-bit fixed width, type bit for symbolic vs. numeric):

Opcode	Mnemonic	Semantics
0x08	PERCEIVE	Ingest semantic data to belief reg
0x12	INFER	Forward/backward chaining
0x1A	UNIFY	Pattern-match, occurs-check
0x1F	PLAN	STRIPS-style plan synthesis
0x2C	BELIEVE	Belief state update and detection
0x33	COMMIT	Validate precondition, issue action
0x3D	GEXPAND	Expand semantic graph adjacency
0x44	GMATCH	Subgraph match
0x50	NEUROCALL	Dispatch to neural co-processor

Pipeline Model

Each lane processes with a six-stage pipeline: Perceive, Reason, Act, State, Memory, Writeback. For balanced stages ($(y, a, k)$7 cycles):

• Pipeline latency: $(y, a, k)$8 cycles
• Per-lane throughput: $(y, a, k)$9 G instr/sec
• Peak system throughput: $y$0 G instr/sec (all lanes)

Throughput for unification: $y$1 GOPS, for planning: $y$2 GOPS.

Memory Hierarchy

Memory is partitioned into numeric (L1/2 data + DRAM, 256 bit width) and cognitive (belief, knowledge caches, symbolic heap/graph) tiers. The cognitive-to-numeric bandwidth ratio is $y$3, reflecting a 64 vs. 256 bit data path.

Cognitive data is stored as compressed sparse row (CSR) graphs, edge dictionaries, and semantic caches (Bloom filter arrays).

Agent-Aware Kernel Abstractions and Runtime

The kernel schedules symbolic and numeric jobs with separate ready queues ($y$4, $y$5), balancing via graph locality. Memory is managed with dual-mode allocators, and agent namespaces are implemented for per-agent goal submission, query, and plan retrieval (RCI).

Runtime structures track {$y$6, $y$7, $y$8, $y$9, $a$0}. Goal-directed planning and introspective hooks enable real-time adaptation, including dynamic voltage-frequency scaling (DVFS).

Hybrid Symbolic–Neural Computation

Symbolic and neural tasks are co-scheduled using a weighted function:

$a$1

Where resource allocation is proportional to task complexity. Interleaved throughput follows:

$a$2

NEUROCALL allows symbolic instructions to offload to either fused MAC units (neural primitives) or an external LLM co-processor, with coherent memory shared across the RU and neural hardware.

Performance

On cycle-accurate simulation:

• Symbolic inferences: $a$3 GIPS
• Planning latency: $a$4 ms vs. $a$5 $a$6s ($a$7 speedup)
• Knowledge graph navigation (100 K nodes): $a$8 ms (RU) vs. $a$9 ms (CPU)
• Multi-agent negotiation: $k$0 ms (RU/16 agents) vs. $k$1 ms (CPU)
• Energy per inference: $k$2 $k$3J

4. Data Synthesis and Training Strategies

To reduce human annotation cost, ReThinker employs two complementary strategies (Tang et al., 4 Feb 2026):

1. Expert QA Synthesis: Domain-specific LLMs generate seed noun phrases (10 per domain, 23 domains), which are expanded via web search and automatic QA generation.
2. Trajectory Recycling: Agent logs in the form $k$4 are filtered by correctness, format, deduplication, and balanced via resampling. Validated trajectories are converted into multi-turn SFT training examples:

$k$5

Pseudocode for data recycling is explicitly provided in the original paper (Algorithm 2).

This enables scalable training of agentic ReThinker systems without extensive expert labeling.

5. Extensions: Vision-Language and Reinforcement Learning Variants

VL-Rethinker applies ReThinker principles to vision-LLMs (Wang et al., 10 Apr 2025). It builds on Qwen-VL-2.5-Instruct:

• Adds a learned "[RETHINK]" token and its embedding.
• Retains the underlying Transformer and cross-attention blocks.
• Relies on reinforcement learning (Group Relative Policy Optimization, GRPO) with Selective Sample Replay (SSR) to prioritize high-advantage examples, mitigating gradient starvation due to vanishing advantages.
• Implements "Forced Rethinking": during RL, a trigger token is appended to model rollouts and the model re-decoded, motivating explicit self-reflection and correction.

Training leverages batches of multimodal queries and rollouts, with learning signals from both RL surrogate loss and supervised NLL on successful rethinking responses.

VL-Rethinker achieves open-source state-of-the-art on multimodal reasoning benchmarks (MathVista 80.4%, MathVerse 63.5%) and narrows the gap with proprietary models such as OpenAI-o1.

6. Impact and Future Directions

ReThinker architectures—both hardware and software—introduce reasoning, planning, and adaptation as first-class, intrinsic execution primitives rather than overlay abstractions. In the hardware realization, this is achieved through cognitive pipelines, agent-specific kernel abstractions, a unified symbolic/numeric memory hierarchy, and native hybrid workloads (Singh et al., 22 Jul 2025). In the agentic orchestration paradigm, dynamic reasoning emerges from Solver–Critic–Selector pipelines, confidence-guided compute allocation, and adaptive supervision without direct human annotation (Tang et al., 4 Feb 2026). The vision-language RL variant demonstrates that explicit self-reflection can be robustly tuned using forced rethinking triggers and prioritized experience replay (Wang et al., 10 Apr 2025).

A plausible implication is that these architectural strategies—especially hardware/software co-design for reasoning primitives—enable efficient, scalable artificial general intelligence capable of real-time, introspective, and multi-agent task execution at throughput and latencies previously unachievable in classical computing frameworks. Possible future work includes parallelizing orchestration stages, extending context lengths, and integrating specialized tool modules such as symbolic provers.