Pith. sign in

REVIEW 2 major objections 5 minor 1 cited by

Large Language Models on Small Resource-Constrained Systems: Performance Characterization, Analysis and Trade-offs

T0 review · 2 major / 5 minor · reviewed 2026-08-11 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read One Jetson Orin developer kit, re-flashed to emulate six Orin devices, benchmarks five Pythia LLMs and maps their latency, power, memory, and energy trade-offs.

desk verdict Useful benchmark data and a working test harness for LLMs on Jetson Orin, but every device-specific number inherits the trust placed in a single devkit's emulation. read the letter →

arxiv 2412.15352 v1 pith:BJHUB22Q submitted 2024-12-19 cs.LG cs.CC

Liam Seymour , Basar Kutukcu , Sabur Baidya This is my paper · ORCID
classification cs.LGcs.CC
keywords largelanguagemodelsedgeinferenceNVIDIAJetsonOrinperformancebenchmarkingquantizationpowerconsumptionembeddedsystemslatencymeasurement
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper's goal is to give edge-computing practitioners a baseline for running large language models on current embedded hardware, specifically the NVIDIA Jetson Orin family, without relying on cloud servers. It benchmarks five Pythia models (70 million to 1.4 billion parameters) across six Orin device configurations, varying the NVIDIA power model and 4-bit quantization, and records latency, power, memory, and estimated energy. The authors argue that such a baseline matters because local inference is needed for privacy, connectivity, and security-sensitive applications, and because prior studies target older hardware. They also release a batch-testing utility so other researchers can reproduce or extend the measurements on Orin devices.

What carries the argument

The load-bearing mechanism is the Jetson Orin developer kit's flash-based emulation: NVIDIA's SDK manager re-flashes the kit with configurations that enable or disable CPU/GPU cores and memory so that one physical unit can emulate performance and power for the other Orin devices. Around that premise the paper builds a three-phase measurement loop (IDLE, MODEL LOAD, GENERATE) using the jetson-stats power and memory poller, with median aggregation over five sequential iterations, trapezoidal integration of idle-subtracted power to estimate energy, and a separate accuracy measurement from the LM evaluation harness. The utility ties these together to automate batch testing and to filter results into constraint-based use cases.

What would settle it

Take a retail Orin Nano 8GB and a retail Orin NX 16GB, run the same five Pythia models and power models with the paper's utility, and compare the median loading and generation latencies and peak power to the corresponding entries in Tables II and III; emulation is falsified if the retail medians fall outside the variation seen across the paper's five iterations.

Watch

Extended reading notes

Core claim

On the paper's own terms, the central discovery is a measured trade-off space for running small large language models on current embedded hardware. Across 204 of 210 possible combinations of six Orin device configurations, five Pythia models (70 million to 1.4 billion parameters), four or five NVIDIA power models, and two quantization levels, the authors report median model-loading and token-generation latencies, peak memory, peak power, and estimated energy, with every configuration repeated five times. The headline results are that 4-bit quantization raises generation latency for the three smallest Pythia models but lowers it for the 1b and 1.4b models; that lower power models consistently slow generation; and that the 4 GB Orin Nano cannot load the 1b or 1.4b models without quantization because the system freezes on out-of-memory errors. The paper then converts these measurements into three constraint-based use cases that select the configuration with the best accuracy or lowest latency under limits on power, energy, memory, and accuracy.

Load-bearing premise

The whole device comparison rests on NVIDIA's assertion that flashing the Jetson AGX Orin developer kit into different hardware configurations faithfully reproduces the power and performance of the retail Orin devices; the paper does not independently verify that emulation.

Editorial extensions

If this is right

  • Practitioners can use the published medians and the released analysis script to choose a device, power model, quantization level, and Pythia model that satisfy given latency, power, memory, and accuracy limits, as demonstrated by the three use-case tables.
  • Because all six device configurations were measured on the same physical developer kit with the same logging stack, the sweep provides a consistent cross-device comparison that separate single-device studies cannot offer.
  • The counterintuitive quantization result implies that 4-bit quantization should not be applied blindly on unified-memory Jetson devices: for models below roughly one billion parameters it increases generation latency rather than reducing it.
  • The five-iteration, 512-token protocol is sufficient to establish relative ordering and rough magnitudes across configurations, but the authors note that more iterations would tighten the medians and make the baseline more precise.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • A direct spot-check on retail units, comparing one physical Orin Nano or Orin NX against the emulated medians in Tables II and III, would settle whether flash-based emulation reproduces power and thermal behavior; the paper never independently validates this.
  • The quantization result suggests a testable hypothesis: on these unified-memory devices, 4-bit dequantization overhead outweighs memory savings for small models; repeating the sweep with pre-quantized checkpoints or a different quantization backend would show whether the reversal is an artifact of the authors' on-device quantization path.
  • Because accuracy was measured on remote hardware rather than on the Jetson devices, the use-case tables that mix accuracy constraints with on-device latency and power implicitly assume quantization loss is hardware-independent; an on-device accuracy run would test that assumption.
  • The three-phase logging and median aggregation could be applied to other model families and to variable output lengths, which would reveal whether the observed device rankings and use-case recommendations persist beyond 512-token generation.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

2 major / 5 minor

Summary. The paper reports an empirical benchmark study of six NVIDIA Jetson Orin configurations (the AGX Orin developer kit plus five configurations intended to emulate retail Orin devices) running five Pythia LLMs with and without 4-bit quantization under each device's default NV power modes. It measures model-load and token-generation latency, power, memory, energy (via idle-baseline subtraction), and accuracy (via the LM Evaluation Harness), presents median results in Tables II and III and Figures 1-7, and provides a public GitHub repository for reproducing and extending the tests. The authors position the work as a baseline characterization and hardware/software trade-off analysis for resource-constrained LLM inference.

Significance. If the data are trustworthy, the paper is a useful empirical reference: it covers currently relevant embedded hardware and LLM sizes, reports 204 successful configurations with 1,020 logs, and ships reproducible tooling and analysis scripts. The energy-estimation method is standard, and the choice of medians over means is a reasonable robustness measure. However, the value of the dataset depends on two points that are not established in the manuscript: whether developer-kit emulation of five retail devices is faithful under sustained LLM execution, and whether the reported quantization trends are stated accurately. The paper contains no theoretical derivation or machine-checked proof; its contribution is purely experimental, so the credibility of the measurements is the central issue.

major comments (2)
  1. [Section III, Tables II and III] All device-specific measurements were taken on a single AGX Orin developer kit re-flashed into six configurations, relying on NVIDIA's statement that the devkit 'can emulate performance and power for any of the [devices]' [23]. The paper provides no independent validation that this emulation preserves thermal throttling, voltage/frequency trajectories, or PMIC power readings under sustained token generation. Since every latency, power, energy, and memory number in Tables II and III and Figures 1-7 is attributed to a named retail device, this assumption is load-bearing for the paper's central claim. Please either validate emulation on at least one physical non-devkit device (e.g., an Orin Nano 8GB) under the same workload, or reframe the results as measurements of emulated configurations rather than physical devices and soften the device-specific claims accordingly.
  2. [Section IV-A2, Table III] The text states that 'the expected behavior returns for the larger models (1b, 1.4b) and quantization reduces the latency from the baseline' and that this pattern 'can be seen in Figure 1a when sliced, showing a correlation across each device.' This is contradicted by Table III for the AGX Orin Devkit and AGX Orin 32GB rows. For example, at MAXN power on the devkit, pythia-1b generation latency is 20.171 s with 4-bit quantization versus 17.157 s without, and pythia-1.4b is 28.229 s versus 23.596 s; similar inversions appear in the AGX Orin 32GB rows and at several power modes. The claimed cross-device trend actually holds only for the Orin NX and Orin Nano families. Please re-analyze the quantization effect and restrict the claim to the configurations where it is supported by the data.
minor comments (5)
  1. [Section III-B] The sentence beginning 'To isolate our testing as much as possible and to reduce extraneous processes from using resrou' is incomplete and contains a typo; it should be rewritten.
  2. [Section IV-A2] There are several typographical errors, including 'out tests' and 'use to to compare'; please proofread this subsection.
  3. [Section IV-A] The paper mentions that five iterations were run per configuration 'to allow us to compare the behavior of the initial run to subsequent loading and generation,' but no such comparison is actually presented. Either include that analysis or remove the stated motivation.
  4. [Tables II and III and Figures 1-7] Only median values are reported, with no indication of dispersion across the five iterations. Given the text's own observation that some configurations show a markedly different first iteration, adding IQR or min-max ranges (at least in supplementary material) would materially strengthen the empirical claims.
  5. [Section IV-A2 and Figure 3] The phrase 'when sliced' in reference to Figure 1a is vague; please specify exactly which slice of the data is being compared and how it supports the claimed cross-device pattern.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity: all reported quantities are direct measurements or standard arithmetic summaries; the sole overlapping-author citation is background and not load-bearing.

full rationale

The paper is a measurement/benchmarking study and contains no derived prediction whose output collapses into its input. Energy is computed from measured power by subtracting the median IDLE-period power and integrating (Section III-B), a standard baseline-correction procedure rather than a circular reduction. Time per token is generation latency divided by token count, an arithmetic summary of a direct measurement. The 'use cases' in Section IV-B filter the same measured dataset by constraints and select extrema; that is the normal function of a benchmark, not a prediction from fitted parameters. Accuracy was obtained independently with EleutherAI's LM Evaluation Harness on remote hardware (Section III-A), so it is not an on-device quantity manufactured by the testbed. The dependence of all device-specific numbers on a single devkit's emulation of other Orin SKUs (Section III, relying on NVIDIA [23]) is an external-validity risk, not circularity: it concerns whether the measured quantities describe retail devices, not whether any result was assumed into existence. The only overlapping-author citation, [13] (Kutukcu and Baidya), appears in Related Work as an example of older-Jetson optimization and is not load-bearing for any measurement, figure, or conclusion. The paper also explicitly scopes limitations—five iterations per configuration, only 512-token generations at present, and reliance on jtop (Sections III-B and V)—which are acknowledged imprecision, not self-referential derivation. No circular step can be exhibited with a specific reduction; score 0.

Assumptions & free parameters 0 free parameters · 3 assumptions · 0 invented entities

The paper introduces no free parameters, since it fits no models to data. Its central claim rests on three domain assumptions: the fidelity of devkit emulation, the accuracy of the jtop power/memory measurements, and the representativeness of five iterations. These are stated or implied but not validated against ground truth.

assumptions (3)
  • domain assumption The Jetson Orin developer kit, when flashed with different emulation configurations, faithfully reproduces the performance and power of the target Orin devices.
    Invoked in Section III (Approach) via NVIDIA's user guide claim [23]; all device-specific results depend on this, and it is not independently validated in the paper.
  • domain assumption jetson-stats (jtop) power and memory readings are accurate at the stated sampling interval.
    Section III-B states jtop was 'the most reliable method we found'; the energy estimates integrate these samples, so errors propagate into all energy and power figures.
  • domain assumption Five sequential iterations, summarized as medians, are sufficient to characterize steady-state performance.
    Section IV-A notes first-iteration outliers but still relies on the median of five; no variance or confidence information is given.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Large Language Models on Small Resource-Constrained Systems: Performance Characterization, Analysis and Trade-offs." pith.science (2026). https://pith.science/paper/BJHUB22Q

@misc{pith2026241215352,
  author       = {Pith},
  title        = {Pith review of: Large Language Models on Small Resource-Constrained Systems: Performance Characterization, Analysis and Trade-offs},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/BJHUB22Q}},
  note         = {Machine review of arXiv:2412.15352}
}
read the original abstract

Generative AI like the Large Language Models (LLMs) has become more available for the general consumer in recent years. Publicly available services, e.g., ChatGPT, perform token generation on networked cloud server hardware, effectively removing the hardware entry cost for end users. However, the reliance on network access for these services, privacy and security risks involved, and sometimes the needs of the application make it necessary to run LLMs locally on edge devices. A significant amount of research has been done on optimization of LLMs and other transformer-based models on non-networked, resource-constrained devices, but they typically target older hardware. Our research intends to provide a 'baseline' characterization of more recent commercially available embedded hardware for LLMs, and to provide a simple utility to facilitate batch testing LLMs on recent Jetson hardware. We focus on the latest line of NVIDIA Jetson devices (Jetson Orin), and a set of publicly available LLMs (Pythia) ranging between 70 million and 1.4 billion parameters. Through detailed experimental evaluation with varying software and hardware parameters, we showcase trade-off spaces and optimization choices. Additionally, we design our testing structure to facilitate further research that involves performing batch LLM testing on Jetson hardware.

Figures

Figures reproduced from arXiv: 2412.15352 by the authors.

Figure 1
Figure 1. Latency results across all device configurations, for both model loading and token generation. [PITH_FULL_IMAGE:figures/full_fig_p004_1.png] view at source ↗
Figure 2
Figure 2. Accuracy of each LLM, tested using the LM Evaluation [PITH_FULL_IMAGE:figures/full_fig_p006_2.png] view at source ↗
Figure 3
Figure 3. A comparison of the effects of quantization on median [PITH_FULL_IMAGE:figures/full_fig_p006_3.png] view at source ↗
Figures from the paper (2 more)
Figure 5
Figure 5. Figure 5: Median peak power usage (in watts) during token [PITH_FULL_IMAGE:figures/full_fig_p007_5.png]
Figure 6
Figure 6. Figure 6: Estimated median energy usage (in joules) during total [PITH_FULL_IMAGE:figures/full_fig_p007_6.png]

Discussion (0). Continue with ORCID to comment.

Forward citations

Cited by 1 Pith paper

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

  1. Understanding the Performance and Power of LLM Inferencing on Edge Accelerators

    cs.DC 2025-06 conditional novelty 6.0 of 10

    An empirical benchmark of a 64GB Jetson Orin AGX shows that LLMs up to 32B parameters can run with INT8 quantization, but token throughput drops sharply as sequence length grows, and quantization slows smaller models.

Reference graph

Works this paper leans on

32 extracted references · 23 canonical work pages · cited by 1 Pith paper

  1. [23]

    ”Jetson AGX Orin Developer Kit User Guide”

    NVIDIA. ”Jetson AGX Orin Developer Kit User Guide”. Accessed: 2024-08-20. [Online]. Available: https://developer.nvidia. com/embedded/learn/jetson-agx-orin-devkit-user-guide/index.html

    work page 2024

  2. [1]

    Generative ai,

    S. Feuerriegel, J. Hartmann, C. Janiesch, and P. Zschech, “Generative ai,” Business & Information Systems Engineering , vol. 66, no. 1, 2024

    work page 2024

  3. [2]

    A survey of large language models,

    W. X. Zhao, K. Zhou, J. Li, T. Tang, X. Wang, Y . Hou, Y . Min, B. Zhang, J. Zhang, Z. Dong et al. , “A survey of large language models,” arXiv preprint arXiv:2303.18223, 2023

    arXiv 2023

  4. [3]

    Generative ai and chatgpt: Applications, challenges, and ai-human collaboration,

    F. Fui-Hoon Nah, R. Zheng, J. Cai, K. Siau, and L. Chen, “Generative ai and chatgpt: Applications, challenges, and ai-human collaboration,” pp. 277–304, 2023

    2023

  5. [4]

    Pre-trained language models and their applications,

    H. Wang, J. Li, H. Wu, E. Hovy, and Y . Sun, “Pre-trained language models and their applications,” Engineering, vol. 25, pp. 51–65, 2023

    work page 2023

  6. [5]

    Chatgpt and open-ai models: A preliminary review,

    K. I. Roumeliotis and N. D. Tselikas, “Chatgpt and open-ai models: A preliminary review,” Future Internet, vol. 15, no. 6, p. 192, 2023

    2023

  7. [6]

    Llmcad: Fast and scalable on-device large language model inference,

    D. Xu, W. Yin, X. Jin, Y . Zhang, S. Wei, M. Xu, and X. Liu, “Llmcad: Fast and scalable on-device large language model inference,” 2023. [Online]. Available: https://arxiv.org/abs/2309.04255

    arXiv 2023

  8. [7]

    Embedded ai perfor- mances of nvidia’s jetson orin soc series,

    A. Archet, N. Gac, F. Orieux, and N. Ventroux, “Embedded ai perfor- mances of nvidia’s jetson orin soc series,” in 17eme Colloque National du GDR SOC2 , 2023

    work page 2023

Show all 32 references
  1. [8]

    High-level frame- works: Effect on transformer inference time and power on embedded gpu devices,

    M. E. Schubert, D. Langerman, and A. D. George, “High-level frame- works: Effect on transformer inference time and power on embedded gpu devices,” in 2023 IEEE High Performance Extreme Computing Conference (HPEC), 2023, pp. 1–8

    2023

  2. [9]

    Improving the efficiency of transformers for resource-constrained de- vices,

    H. Tabani, A. Balasubramaniam, S. Marzban, E. Arani, and B. Zonooz, “Improving the efficiency of transformers for resource-constrained de- vices,” in 2021 24th Euromicro Conference on Digital System Design (DSD), 2021, pp. 449–456

    2021

  3. [10]

    Benchmarking deep learning models on NVIDIA jetson nano for real-time systems: An empirical investigation,

    T. P. Swaminathan, C. Silver, and T. Akilan, “Benchmarking deep learning models on NVIDIA jetson nano for real-time systems: An empirical investigation,” CoRR, vol. abs/2406.17749, 2024

    2024 arXiv

  4. [11]

    Tensorrt-based framework and optimiza- tion methodology for deep learning inference on jetson boards,

    E. Jeong, J. Kim, and S. Ha, “Tensorrt-based framework and optimiza- tion methodology for deep learning inference on jetson boards,” ACM Trans. Embed. Comput. Syst. , vol. 21, no. 5, pp. 51:1–51:26, 2022

    2022

  5. [12]

    Adaptive deep learning model selection on embedded systems,

    B. Taylor, V . S. Marco, W. Wolff, Y . Elkhatib, and Z. Wang, “Adaptive deep learning model selection on embedded systems,” in Proceedings of the 19th ACM SIGPLAN/SIGBED International Conference on Lan- guages, Compilers, and Tools for Embedded Systems, LCTES 2018 . ACM, 2018

    2018

  6. [13]

    Evosh: Evolution- ary search with shaving to enable power-latency tradeoff in deep learning computing on embedded systems,

    B. Kutukcu, S. Baidya, A. Raghunathan, and S. Dey, “Evosh: Evolution- ary search with shaving to enable power-latency tradeoff in deep learning computing on embedded systems,” in 36th IEEE International System- on-Chip Conference, SOCC 2023, Santa Clara, CA, USA, September 5-8...

    2023

  7. [14]

    Sparsification and separation of deep learning layers for constrained resource inference on wearables,

    S. Bhattacharya and N. D. Lane, “Sparsification and separation of deep learning layers for constrained resource inference on wearables,” in 14th ACM Conference on Embedded Network Sensor Systems, SenSys 2016 , 2016

    2016

  8. [15]

    Rstensorflow: GPU enabled tensorflow for deep learning on commodity android devices,

    M. Alzantot, Y . Wang, Z. Ren, and M. B. Srivastava, “Rstensorflow: GPU enabled tensorflow for deep learning on commodity android devices,” in 1st International Workshop on Embedded and Mobile Deep Learning, EMDL@MobiSys. ACM, 2017

    2017

  9. [16]

    Flightllm: Efficient large language model inference with a complete mapping flow on fpgas,

    S. Zeng, J. Liu, G. Dai, X. Yang, T. Fu, H. Wang, W. Ma, H. Sun, S. Li, Z. Huang, Y . Dai, J. Li, Z. Wang, R. Zhang, K. Wen, X. Ning, and Y . Wang, “Flightllm: Efficient large language model inference with a complete mapping flow on fpgas,” in ACM/SIGDA International Symposium...

    2024

  10. [17]

    Deep learning with edge computing: A review,

    J. Chen and X. Ran, “Deep learning with edge computing: A review,” Proceedings of the IEEE , vol. 107, no. 8, pp. 1655–1674, 2019

    2019

  11. [18]

    Edge assisted real-time object detection for mobile augmented reality,

    L. Liu, H. Li, and M. Gruteser, “Edge assisted real-time object detection for mobile augmented reality,” in The 25th Annual International Con- ference on Mobile Computing and Networking, MobiCom 2019 . ACM, 2019

    2019

  12. [19]

    Deepdecision: A mobile deep learning framework for edge video analytics,

    X. Ran, H. Chen, X. Zhu, Z. Liu, and J. Chen, “Deepdecision: A mobile deep learning framework for edge video analytics,” in 2018 IEEE Conference on Computer Communications, INFOCOM 2018 . IEEE, 2018

    2018

  13. [20]

    Efficient large language models: A survey,

    Z. Wan, X. Wang, C. Liu, S. Alam, Y . Zheng, J. Liu, Z. Qu, S. Yan, Y . Zhu, Q. Zhang, M. Chowdhury, and M. Zhang, “Efficient large language models: A survey,” Trans. Mach. Learn. Res. , 2024

    2024

  14. [21]

    AWQ: activation-aware weight quantization for on-device LLM compression and acceleration,

    J. Lin, J. Tang, H. Tang, S. Yang, W. Chen, W. Wang, G. Xiao, X. Dang, C. Gan, and S. Han, “AWQ: activation-aware weight quantization for on-device LLM compression and acceleration,” in Proceedings of the Seventh Annual Conference on Machine Learning and Systems, MLSys 2024, S...

    2024

  15. [22]

    Sheared llama: Accelerating language model pre-training via structured pruning,

    M. Xia, T. Gao, Z. Zeng, and D. Chen, “Sheared llama: Accelerating language model pre-training via structured pruning,” in The Twelfth International Conference on Learning Representations, ICLR 2024 , 2024

    2024

  16. [24]

    Pythia: A suite for analyzing large language models across training and scaling,

    S. Biderman, H. Schoelkopf, Q. Anthony, H. Bradley, K. O’Brien, E. Hallahan, M. A. Khan, S. Purohit, U. S. Prashanth, E. Raff, A. Skowron, L. Sutawika, and O. van der Wal, “Pythia: A suite for analyzing large language models across training and scaling,” 2023. [Online]. Availa...

    2023 arXiv

  17. [25]

    Accessed: 2024-08-20

    ”HuggingFace Transformers”. Accessed: 2024-08-20. [Online]. Available: https://huggingface.co/docs/transformers/en/index

    2024

  18. [26]

    A. Brundyn. ”Demystifying Unified Memory on Jetson”. Accessed: 2024-09-28. [Online]. Available: https://www.nvidia.com/ en-us/on-demand/session/gtcspring22-se2600/

    2024

  19. [27]

    Accessed: 2024-08-20

    ”Jetson Orin Technical Specifications”. Accessed: 2024-08-20. [On- line]. Available: https://www.nvidia.com/en-us/autonomous-machines/ embedded-systems/jetson-orin/#tech-specs

    2024

  20. [28]

    R. Bonghi. ”jetson-stats”. Accessed: 2024-08-20. [Online]. Available: https://rnext.it/jetson stats/

    2024

  21. [29]

    A framework for few-shot language model evaluation,

    L. Gao, J. Tow, B. Abbasi, S. Biderman, S. Black, A. DiPofi, C. Foster, L. Golding, J. Hsu, A. Le Noac’h, H. Li, K. McDonell, N. Muennighoff, C. Ociepa, J. Phang, L. Reynolds, H. Schoelkopf, A. Skowron, L. Sutawika, E. Tang, A. Thite, B. Wang, K. Wang, and A. Zou, “A framework...

  22. [30]

    Accessed: 2024-09-10

    ”SDK Manager — NVIDIA Developer”. Accessed: 2024-09-10. [Online]. Available: https://developer.nvidia.com/sdk-manager

    2024

  23. [31]

    Accessed: 2024- 09-10

    ”Emulation Flash Configurations - Jetson Linux”. Accessed: 2024- 09-10. [Online]. Available: https://docs.nvidia.com/jetson/archives/r35. 1/DeveloperGuide/text/SD/EmulationSupport.html ©Authors. Personal use of this material is permitted. Permission must be obtained for all ot...

    2024

  24. [2024]

    Available: https://zenodo.org/records/12608602

    [Online]. Available: https://zenodo.org/records/12608602

Pith tools

Reviewed August 11, 2026 · model on record in the stance chip above.