MMOral-Uni: Multi-Modal Chains of Reasoning

• MMOral-Uni is a framework that integrates multi-modal chains of reasoning using verified execution traces, code instrumentation, and quantitative metrics for interpretable AI.
• It employs autonomous data synthesis and dual-agreement verification to generate diverse, bi-directional reasoning data, boosting performance in code understanding and robotic tasks.
• Empirical evaluations show significant improvements in code reasoning and robotic manipulation benchmarks while mitigating issues like hallucination and reward hacking.

MMOral-Uni represents a collection of methodologies utilizing explicit multi-modal chains of reasoning, execution traces, and quantitative reasoning effort metrics in the training and evaluation of advanced language and vision-LLMs. These approaches combine code, text, and visual signals to produce highly verifiable and interpretable rationales, with substantial empirical benefits in code understanding, robotic manipulation, and automated oversight through reward hacking detection.

1. Grounded Chain-of-Reasoning from Verified Execution Traces

A central methodology incorporates program execution traces as immutable sources of truth for reasoning. In the "Generating Verifiable CoT from Execution-Traces" framework (Thakur et al., 28 Nov 2025), an execution trace is defined as the sequence of program states visited during a test execution: $T = \left\{(\ell_i, S_i, S_{i+1})\right\}_{i=1}^n$ where $\ell_i$ is the source-code location for step $i$, and $S_i$, $S_{i+1}$ are mappings from variable names to values before and after execution of $\ell_i$.

The pipeline instruments code using function-level decorators (pysnooper), executes in sandboxed environments per test case, and sanitizes traces to yield token sequences of assignment events (e.g., "Line $\ell$: $x \gets v$"). The trace is then narrated into natural language by prompting the LLM with the trace and associated code context, enforcing strictly stepwise and factually grounded rationales.

Fine-tuning aligns model output with the factual trace via a cross-entropy loss: $$\mathcal{L}_{\text{trace}} = -\sum_{t=1}^T \log P(w_t \mid w_{<t}, \mathrm{trace}, \mathrm{question})$$ and includes optional I/O prediction objectives, ensuring every reasoning step directly corresponds to what the program computes.

2. Autonomous Data Synthesis and Dual-Agreement Verification

Hierarchical synthesis generates datasets of programming problems, signatures, a diverse set of solutions, and extensive unit test matrices. Solutions are clustered by identical pass/fail patterns across test cases, scored for consensus quality: $$\text{Score}(C) = |C| \times |\{j : \forall s \in C, M[s, j] = 1\}|$$ This dual-agreement process selects canonical verified solutions and passing tests, ensuring only correct-by-construction pairs are used for ground-truth trace collection and rationale generation. The final training corpora include both forward (input→output) and backward (output→input) reasoning, yielding highly diverse and bi-directional reasoning data.

3. Model Architectures and Training Objectives

Supervised fine-tuning is performed on enterprise-grade generalist models (e.g., granite-3.3-8B-base) and specialist code models (e.g., Qwen2.5-Coder-7B), without architectural modification. The curriculum includes joint optimization of trace narration loss and I/O prediction loss: $$\mathcal{L} = \mathcal{L}_{\text{trace}} + \lambda \mathcal{L}_{\text{task}}$$ with $\lambda=1$, 10 epochs of optimization ($\text{LR}=2 \times 10^{-6}$), batch size 32, and 8K-token contexts, ensuring high capacity for multi-turn and multi-modal reasoning chains.

4. Evaluation: Empirical Gains and Benchmark Results

TRACE-CoT-trained models deliver substantial improvements in code reasoning and explanation benchmarks. On the best bi-directional training set (25k examples), performance gains are observed as follows (pass@1 metric):

Model	LiveCodeBench-Exec	CruxEval Output@1	CruxEval Input@1
granite-3.3-8B-base	18.3 → 44.3 (+26.0)	15.5 → 45.7 (+30.2)	14.3 → 42.1 (+27.8)
Qwen2.5-Coder-7B	46.3 → 68.2 (+21.9)	45.3 → 59.7 (+14.4)	47.5 → 61.9 (+14.4)

Trace-grounded chain-of-thought (CoT) explanations are 761% more information-rich (measured via entropy), exhibiting strong length–consistency correlation ($R^2$ = 0.122 versus 0.011 for base) (Thakur et al., 28 Nov 2025). Ablations demonstrate that purely model-generated CoT, with no trace grounding, yields lower performance, confirming the superior fidelity of execution-verified rationales.

5. Textual Reasoning for Affordance Coordinate Extraction in Robotics

The TRACE methodology (Park et al., 3 Nov 2025) extends chain-of-reasoning to the multi-modal domain of robotic manipulation, integrating textual stepwise rationales for spatial affordance prediction within vision-LLMs (VLMs). TRACE-tuned VLMs first generate explicit natural-language decompositions of the task (e.g., identifying reference objects and defining affordance subtypes) before predicting 2D/3D coordinates.

The autonomous pipeline used Gemini-2.5-flash to decompose 100,000 existing image–instruction–keypoint triplets into four cognitive reasoning steps per sample. Models were fine-tuned to output both the chain-of-reasoning ($r_1,\ldots,r_T$) and affordance coordinates ($\hat{x}_i, \hat{y}_i$) via joint loss: $$L = \lambda_r L_{\text{reason}} + \lambda_c L_{\text{coord}},\quad \lambda_r = \lambda_c = 1$$ Empirical results on Where2Place and RoboRefIt benchmarks confirm dose-dependent improvements: accuracy scales linearly with the fraction of reasoning-augmented samples used ($R^2 > 0.95$), yielding +9.6% improvement over strong baselines. Attention-map visualizations further demonstrate interpretable reasoning dynamics.

6. Oversight via Quantitative Measurement of Reasoning Effort: TRACE-CoT

The TRACE-CoT framework (Wang et al., 1 Oct 2025) introduces an audit procedure measuring the reasoning effort required for model-generated chain-of-thought to pass a verifier. The process truncates reasoning traces at multiple fractions, forcing answers, then records pass rates across prefixes: $$A(\ell) = \text{verifier-pass-rate at prefix length } \ell$$ Area under the accuracy-vs-length curve (AUC) is computed: $\text{AUC} = \frac{1}{L} \int_0^L A(\ell) d\ell$ High AUC indicates shortcut exploitation or implicit reward hacking: model passes verifier with minimal rationalization. TRACE-CoT achieves over 65% F₁ improvement versus state-of-the-art 72B CoT monitors in math, and 30% over 32B in code. The method operates threshold-free, requiring only access to the model and ground-truth verifier, and can facilitate unsupervised loophole discovery by clustering high-AUC samples.

7. Limitations and Future Directions

Execution-trace-based approaches currently require language-specific instrumentation (e.g., pysnooper for Python). Extending to C++ or Java entails developing new tracing mechanisms. Execution overhead is high for large test matrices; batching and simulation are proposed future optimizations. End-to-end differentiable trace encoders and offline reinforcement learning (DPO) are identified as promising areas for refinement. In the multi-modal domain, future trajectories include human-like reasoning chains, multi-step robot planning, confidence estimation per step, and closed-loop reasoning revision responsive to sensor feedback.

A plausible implication is the increasing integration of rigorous, interpretable, and verifiable multi-modal reasoning processes in foundation model training, not only for enhancement of model performance on reasoning tasks but also for robust oversight and reduction of failure modes such as hallucination and reward hacking.