acceptodds
Under review as a conference paper at ICLR 2027

PiERN: Token-Level Routing for Integrating High-Precision Computation and Reasoning

Abstract

Tasks on complex systems require high-precision numerical computation to support decisions. However, current large language models (LLMs), even with enhanced reasoning capabilities, cannot integrate such computations as an intrinsic and interpretable capability with existing architectures. To this end, we propose **Physically-isolated Experts Routing Network** (PiERN), an architecture that directs computation and reasoning at token level, thereby enabling iterative alternation within a single chain of thought. We systematically evaluate PiERN on representative computation–reasoning tasks, including PDEBench. Results show that PiERN achieves not only higher accuracy than directly finetuning LLMs but also significant improvements in response latency, token usage, GPU energy consumption, and expert routing accuracy compared with mainstream multi-agent approaches, while exhibiting no significant degradation in performance on the general language evaluation MMLU and GLUE benchmarks. PiERN offers an efficient, interpretable, and scalable paradigm for interfacing language models with scientific systems.

Primary area:
applications to physical sciences (physics, chemistry, biology, etc.)
Keywords:
Physically-isolated Experts Routing Network, high-precision scientific computation, joint computation–reasoning, token-level routing, scientific intelligence systems

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 3 reviews, above 27% of the others.
Reviewer_D9fCOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

This paper proposes PiERN, which integrates frozen high-precision scientific computation experts, a Text-to-Computation module, and a token-level Token Router into a single language reasoning chain. The experts are first trained on numerical data, Text2Comp learns to map natural-language tasks to expert inputs, and the Router selects either the LLM or a specific expert at each decision point. Expert outputs are written back into the context, after which language reasoning continues. The authors evaluate the method on five downsampled PDEBench tasks and a synthetic battery management task, reporting Text2Comp RMSE on unseen templates, 100% Router accuracy on predefined decision points, PDE RMSE, latency and energy comparisons with MAF, and retention of MMLU/GLUE performance. PiERN-BMS further demonstrates multi-expert composition by first estimating SoH and then using language reasoning to trigger arbitrage computation. The architectural interface is interesting, but the evidence mainly comes from manually constructed templates and downsampled/synthetic data. Evidence for real-world OOD generalization, fair comparisons with strong baselines, total system cost, and the definition of high precision remains insufficient.

Critical strengths
  1. A unified modular architecture. Token-level routing feeds outputs from specialized numerical experts back into the language model within the same CoT. The interface is clear, interpretable, and easy to modify, and is more compact than explicit multi-agent communication at every step.
  2. Systematic prototype evaluation across tasks. The experiments cover five PDE tasks and a multi-expert battery workflow, reporting error, latency, tokens, energy consumption, and retention of language capabilities. This provides a reusable experimental framework for future research.
Critical weaknesses
  1. Insufficient evidence of generalization and high precision. The unseen split consists of only 20% of the templates within manually constructed template families, and the Router's 100% accuracy comes from predefined decision points. PiERN has higher RMSE than the downsampled experts on all five tasks, so these results do not establish high precision or semantic routing capabilities on real scientific tasks.
  2. Lack of transparency in baselines and system costs. All fine-tuned models produce invalid outputs, with insufficient reproduction details, and the total parameters/FLOPs of the multi-expert system are not clearly accounted for. The MAF energy/latency comparison lacks a measurement protocol and variance estimates, leaving it unclear whether the efficiency gains can be attributed to the architecture itself.
  3. Insufficient novelty. The proposed method integrates high-precision scientific computation experts, a Text-to-Computation module, and a token-level Token Router into a single language reasoning chain, but these all appear to be common approaches. The authors need to clarify the specific novelty relative to existing methods. Integrating high-precision computation experts does not seem to be a particularly effective way to address numerical computation problems; tool integration, such as Python tools, is often a better solution.
Questions for authors

Please focus on the following: (i) Does each expert have its own Text2Comp/Router, and how do total parameters, GPU memory, and FLOPs scale with the number of experts? (ii) Why are all SFT PDE outputs invalid, and can reproducible results be provided under the same output interface and budget?

1 comment

We sincerely thank the reviewer for recognizing PiERN's unified modular architecture and its potential for coordinating multiple scientific computation experts. We clarify the architectural contributions and experimental evidence below.

Regarding generalization and numerical accuracy, PiERN integrates existing scientific computation capabilities into LLM reasoning through semantic-to-numerical alignment and token-level expert routing. Text2Comp maps language-conditioned requests into expert-compatible numerical inputs, while the Token Router dynamically monitors the token generation process and determines whether to continue language generation or invoke a computation expert based on the current contextual representation. Importantly, routing decisions are made dynamically during inference rather than being restricted to manually specified invocation positions or fixed task-specific rules. The reported 100% Router accuracy evaluates its classification performance on the constructed token-level evaluation samples. Our held-out-template evaluation further demonstrates generalization across unseen language templates within the evaluated operation families. We will clarify the scope of these evaluations in the revised manuscript. Regarding numerical accuracy, PiERN is designed to make existing expert capabilities accessible through language-conditioned inputs, rather than to improve an expert that already receives exact numerical inputs. The additional end-to-end error reflects the effect of semantic-to-numerical alignment, which is further quantified in our existing Diffusion-Sorption component evaluation.

Regarding system scalability, our five-task deployment uses one shared response LLM and one shared Token Router, while each task has its own Text2Comp module and numerical expert. The resident parameter count is therefore P_total = P_LLM + P_Router + Σ_k(P_Text2Comp,k + P_Expert,k). With nominal 0.8B backbones, the shared LLM and Router contribute 1.6B parameters, while the five independent Text2Comp modules contribute approximately 4.0B, resulting in approximately 5.6B backbone parameters before adding numerical experts and task-specific heads. This modular design allows additional computation experts to be incorporated without replicating the entire language model and Router. We will distinguish resident parameters from per-request active computation and provide the corresponding resource accounting. For SFT baselines, "Invalid" denotes outputs that cannot be parsed into a non-empty numerical sequence with the required number of elements, rather than outputs with large numerical errors. This highlights the difficulty of directly generating high-dimensional structured numerical outputs through autoregressive language generation, motivating PiERN's separation of language reasoning from numerical computation.

Regarding methodological novelty and the comparison with Python tools, PiERN is not intended to replace general-purpose programming tools or develop a numerical expert that surpasses existing solvers. Its contribution is a unified architectural mechanism for integrating heterogeneous computation experts, including pretrained neural models and conventional non-neural numerical solvers, into LLM reasoning. Our evaluation already includes a Programmatic baseline based on LLM-generated Python code execution (Appendix C, Table 4 and Figure 9). For Qwen3.5-0.8B, PiERN achieves inference latencies of 0.62–0.77 s across the five PDE tasks, compared with 19.99–52.83 s for Programmatic, corresponding to approximately 32–71× lower latency. GPU energy consumption is also reduced by approximately 22–69× across these tasks. These results demonstrate the practical efficiency advantages of PiERN's integrated computation-reasoning architecture over the evaluated Python code execution workflow. Importantly, PiERN combines Text2Comp-based numerical input construction, token-level computational routing, and the integration of expert outputs into the ongoing language context. Furthermore, PiERN-BMS demonstrates compositional computation-reasoning: the LLM first receives battery health estimation results, reasons over the intermediate state, and subsequently invokes another expert for profit computation. This illustrates how heterogeneous computational capabilities can be coordinated within a single reasoning process rather than treated as isolated tool calls.

Finally, regarding the reproducibility of SFT baselines, we will explicitly document the output parsing criteria and evaluation procedure, distinguishing structural generation failures from numerical inaccuracies. We will provide representative saved outputs and corresponding reproduction details where available.

We thank the reviewer again for these constructive comments. We believe these clarifications better demonstrate PiERN's contribution as a unified architecture for integrating heterogeneous scientific computation capabilities into LLM reasoning.

Reviewer_dBpVOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper proposes PiERN, a framework that integrates pretrained scientific computation experts with LLM reasoning through token-level routing. The architecture combines numerical experts, a text-to-computation module, and a learned router. Experiments on PDEBench and battery management tasks demonstrate improvements in numerical accuracy over fine-tuned LLMs and reductions in latency and energy consumption compared with multi-agent frameworks.

Critical strengths
  • The paper addresses an important problem of integrating numerical computation with language reasoning. The modular architecture allows existing scientific models to be incorporated without modifying the underlying LLM.

  • The experiments cover several PDE tasks and demonstrate promising improvements in inference efficiency. The battery management example also illustrates the potential for coordinating multiple computational experts.

Critical weaknesses
  • The methodological novelty over existing tool-calling frameworks needs further clarification. The proposed architecture combines pretrained numerical experts with a learned router and a text-to-computation module. Comparisons with simpler approaches, such as a single LLM with structured function calling, would help establish the advantages of token-level routing.

  • The numerical accuracy results raise concerns. In Table 2, PiERN consistently has higher RMSE than the underlying downsampled models across all five PDE tasks, which needs further explanation given the bold highlight. Moreover, all fine-tuned LLM baselines are marked as ‘invalid’, without clearly defining the criteria or explaining why they failed.

  • The efficiency comparisons may not be entirely fair. The multi-agent baselines generate thousands of tokens, while PiERN reportedly uses only eight. More controlled comparisons using the same numerical experts and comparable workflows would help isolate the benefits of the proposed architecture.

Questions for authors

In Figure 10, the reported battery profit appears inconsistent with eq. (12). Could the authors clarify how the profit is calculated and whether any normalization is applied?

1 comment

We sincerely thank the reviewer for recognizing the importance of integrating numerical computation with language reasoning and the potential of PiERN's modular architecture.

Regarding methodological novelty, PiERN goes beyond conventional tool calling by integrating semantic-to-numerical alignment, token-level computational routing, and compositional computation-reasoning into a unified architecture. Specifically, Text2Comp maps language-conditioned requests into expert-compatible numerical inputs, while the Token Router dynamically coordinates language generation and expert execution. The resulting numerical outputs are incorporated into the ongoing language context to support subsequent reasoning and further expert invocation. Importantly, PiERN accommodates heterogeneous computation experts, including pretrained neural models and conventional numerical solvers. Our existing Programmatic baseline (Appendix C, Table 4 and Figure 9) also evaluates LLM-generated Python code execution. Unlike this explicit code-generation workflow, PiERN provides a learned interface for integrating scientific computation into language reasoning. We will further clarify these architectural distinctions in the revised manuscript.

Regarding numerical accuracy, PiERN aims to integrate existing expert capabilities into language reasoning, rather than improve the accuracy of an expert receiving exact numerical inputs. The standalone expert directly receives reference inputs, whereas PiERN additionally reconstructs expert-compatible inputs through Text2Comp. For a fixed expert f, reference input x, reconstructed input x_hat, and target y, the end-to-end error can be expressed as f(x_hat)-y = [f(x)-y] + [f(x_hat)-f(x)], separating expert approximation from the effect of input reconstruction. We will clarify this distinction in Table 2. For the SFT baselines, "Invalid" denotes outputs that cannot be parsed into a non-empty numerical sequence with the required number of elements, rather than outputs with large numerical errors. This illustrates the difficulty of directly generating high-dimensional structured numerical outputs through autoregressive language generation, motivating PiERN's separation of language reasoning from numerical computation.

Regarding inference efficiency, PiERN substantially reduces token usage and execution overhead in our evaluated tasks. This advantage comes from avoiding extensive intermediate numerical serialization and explicit multi-agent coordination through its integrated computation-reasoning interface. Importantly, all compared methods follow the same token-accounting convention, excluding prompt tokens and counting generated tokens. Thus, the reported efficiency gains reflect the actual generation overhead of the evaluated workflows.

Finally, we thank the reviewer for identifying the outdated numerical example in Figure 10. The final evaluation implements Eq. (12) directly, without additional profit scaling or clipping. We verified all 10,000 formula-derived labels with zero inconsistencies at a tolerance of 10⁻¹². Recomputing the MSE over all 1,000 saved test predictions yields 1.771957 × 10⁻⁵, consistent with Table 6. The inconsistency is confined to the illustrative example in the earlier version of Figure 10. We will replace it with a traceable record from the final dataset and clearly distinguish the degradation coefficient α from battery SoH, as well as ground-truth profit from model predictions.

Reviewer_QvLNOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper proposes PiERN, a token-level routing framework that combines high-precision numerical computation experts with LLM reasoning. This framework consists of three sequential training phases: (i) training numerical computation experts with MSE loss, (ii) freezing the pre-trained experts and training a text-to-computation (text2comp) module, and (iii) training a token-level router. This sequential training methodology is a way to reduce interference between different types of optimization objectives along the process. Compared to multi-agent framework, PiERN achieves lower latency and GPU energy consumption in its inference, while outperforming fine-tuned LLM baselines in numerical prediction accuracy. Experiments on PDE prediction and battery-related tasks evaluate the proposed framework.

Critical strengths

This paper demonstrates the effectiveness of the proposed framework through strong experimental results compared with multi-agent frameworks, which is a widely used approach in LLM-based agentic systems. Another advantage of this approach is its modularity; each component serves distinct roles which as a whole results in much faster LLM reasoning with high-precision computation. This modularity allows individual components to be trained or updated independently when necessary, making the framework practical and potentially easier to extend to different computational tasks.

Critical weaknesses

Despite the promising numerical results, I am a bit skeptical in why the sequential training should be the training method of choice. As an end-to-end optimization framework, there is no (numerical) evidence behind why not using joint optimization. It makes sense that for high-precision computation expert, it should be pre-trained before actual training of entire system. But I wonder if joint optimization of next phases enhance the overall performance, either in its latency, GPU energy consumption, or accuracy of output.

Furthermore, it seems that whole reason of having phase 1, which is pre-training high-precision computation expert, is to have a neural surrogate to the computationally expensive phase of computation. This is very helpful when solving problem which requires extensive computation overhead, but I am worried if the experiment presented in paper successfully addresses such cases.

Finally, the approximation errors of the numerical experts and the input reconstruction errors from the text2comp phase jointly affect the final numerical accuracy. But the paper currently does not have a detailed analysis of these error sources or their propagation through the inference pipeline.

Questions for authors

Q1 (Sequential training vs. joint optimization) Can authors provide numerical evidence that the sequential training (of the paper) is preferable to joint optimization? Particularly, I am curious to see that, after freezing the expert, joint optimization on other two phases can improve either latency, GPU energy consumption, or accuracy.

Q2 (Computational benefits of neural surrogate) How much does using the experts can be compared to using conventional numerical solvers (which can be computationally expensive)? For instance, can conventional numerical solvers take much more time in original PDE dataset rather than downsampled ones?

Q3 (About error propagation) Can the authors provide a quantitative breakdown of the numerical errors introduced by the pre-trained experts and the text2comp phase? This would help explain the observed differences between standalone expert accuracy and end-to-end PiERN accuracy.

1 comment

We sincerely thank the reviewer for recognizing the effectiveness and modularity of PiERN. We appreciate the insightful questions regarding training strategies, computational benefits, and error propagation.

Regarding sequential training, our primary motivation is to preserve the independently validated capabilities of heterogeneous computation experts while enabling modular integration with LLM reasoning. The numerical expert, Text2Comp, and Token Router serve distinct purposes and have different optimization objectives. Sequential training allows each component to be independently trained, validated, and updated without modifying the underlying computation expert. We have also explored joint-training configurations in our preliminary experiments. However, the historical PDE experiments jointly optimized the expert as well, and therefore do not constitute a controlled comparison with the reviewer's proposed setting of freezing the expert while jointly optimizing Text2Comp and the Router. We adopt sequential training primarily for modularity and independent validation, rather than claiming universal optimization superiority.

Regarding the computational benefits of experts, we emphasize that PiERN is a general framework for integrating existing computational capabilities into LLM reasoning, rather than a method for improving the underlying numerical solvers. Its experts can be either pretrained neural models (e.g., FNO and DeepONet) or conventional non-neural numerical solvers. The key contribution is that PiERN provides a unified mechanism for the LLM to understand computational requirements, construct expert-compatible inputs through Text2Comp, invoke appropriate experts through token-level routing, and incorporate their outputs into subsequent reasoning. Our PDE experiments instantiate this architecture using pretrained neural experts on downsampled PDEBench tasks.

Regarding error propagation, for a fixed expert f, reference input x, reconstructed input x_hat, and ground-truth output y, the end-to-end error can be decomposed as f(x_hat)-y = [f(x)-y] + [f(x_hat)-f(x)], separating expert approximation from the output-space effect of input reconstruction. Furthermore, our existing Diffusion-Sorption component evaluation shows input NRMSEs of 0.006607 and 0.006569 on seen and held-out templates, respectively, with corresponding output propagation NRMSEs of 0.004197 and 0.004163. These results quantify how the learned interface interacts with a fixed computation expert. We will clarify this error decomposition and distinguish component-level evaluation from end-to-end accuracy in the revised manuscript.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.