Pith. sign in

REVIEW 4 major objections 4 minor 1 cited by

Enhancing Table Recognition with Vision LLMs: A Benchmark and Neighbor-Guided Toolchain Reasoner

T0 review · 4 major / 4 minor · reviewed 2026-08-10 · deepseek-v4-flash

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

Pith's one-line read This paper claims that a training-free, neighbor-guided toolchain reasoner improves vision large language models' table recognition by selecting image-preprocessing plans through retrieval and reflection.

desk verdict Solid applied framework for VLLM table recognition with large gains on low-quality images, but thin statistics and an unverified neighbor-transfer mechanism keep it from being more than a moderate contribution. read the letter →

arxiv 2412.20662 v3 pith:RGAZL6Y3 submitted 2024-12-30 cs.CV cs.AI

Yitong Zhou , Mingyue Cheng , Qingyang Mao , Feiyang Xu , Xin Li This is my paper · ORCID
classification cs.CVcs.AI
keywords tablerecognitionvisionlargelanguagemodelsneighbor-guidedtoolchainreasonerretrieval-augmentedgenerationTEDSimagepreprocessingreflectionmodulehierarchicalbenchmark
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 sets out to show that vision large language models can recognize tables more accurately when the input image is preprocessed by a short toolchain chosen with hindsight from a similar example. It first builds a hierarchical benchmark and finds that poor image quality, not missing borders, is the main bottleneck for VLLMs. The proposed NGTR framework retrieves a visually similar neighbor from the training set, has the VLLM propose several preprocessing toolchains, scores each toolchain by running it on the neighbor and comparing the VLLM's HTML output against the neighbor's ground truth with TEDS, then applies the best-scoring plan to the test image while a reflection module accepts or rejects each step by comparing before-and-after image quality. On GPT-4o this raises TEDS on PubTabNet from 74.46 to 85.03 and TEDS-Struct on WTW from 40.01 to 52.03, with smaller gains on SciTSR. If this holds, it suggests that a large share of VLLM error in table recognition is recoverable without any fine-tuning.

What carries the argument

The carrying mechanism is the neighbor-guided toolchain with TEDS-scored experience transfer and reflection-based step acceptance. A toolchain is an ordered list of lightweight image operations (upscale, border enhancement, binarization, noise reduction, detection-and-cropping) drawn from a fixed toolkit. For a test image, the framework retrieves its nearest neighbor from the training set by ORB keypoint matching with Hamming distance, has the VLLM propose several toolchains, executes each toolchain on the neighbor, scores the VLLM's HTML output against the neighbor's ground-truth HTML using the tree-edit-distance similarity TEDS, and transfers the highest-scoring plan to the test image. The reflection module then runs each tool in order and asks the VLLM whether the processed image retains at least as much information as the previous one, accepting or discarding the operation. This combination turns the VLLM itself into both the planner and the quality judge, with the neighbor's label supplying the only external supervision.

What would settle it

Take a test image whose nearest neighbor in the retrieval set is visually similar but structurally different (for instance, similar lighting and borders but a very different number of columns or merged-cell layout), apply the neighbor-selected toolchain, and compare the VLLM's TEDS against both no toolchain and a toolchain selected by a deliberately different neighbor; the transfer assumption would fail if the neighbor-selected plan scores worse than no preprocessing.

Watch

Extended reading notes

Core claim

The central discovery is that a training-free preprocessing "toolchain reasoner" can close much of the gap between naive VLLM table recognition and specialized OCR systems, provided the toolchain is chosen by experience transfer from a similar neighbor rather than by prompting alone. The framework's key step is to treat the neighbor image as a rehearsal: generate several candidate toolchains, execute each one on the neighbor, score the resulting HTML against the neighbor's ground truth using TEDS, and transfer the winner to the test image. A reflection module then supervises execution by having the VLLM compare the image before and after each tool operation, rejecting operations that lose information. The paper reports that this pipeline lifts GPT-4o from 74.46 to 85.03 TEDS on PubTabNet and from 40.01 to 52.03 TEDS-Struct on WTW, while ablations show both the experience-learning and reflection modules contribute. The paper also claims that VLLMs rely little on table borders and that column tasks are easier than row tasks.

Load-bearing premise

The load-bearing premise is that the preprocessing toolchain that scores best on a retrieved neighbor image will also be the best toolchain for the test image, even though the reflection module only checks relative image quality and never checks recognition accuracy.

Editorial extensions

If this is right

  • GPT-4o's PubTabNet TEDS rises from 74.46 to 85.03 with NGTR, a gain larger than switching between any of the six evaluated VLLMs.
  • On the wild-image WTW dataset, NGTR lifts GPT-4o TEDS-Struct from 40.01 to 52.03, but the framework does not close the gap to specialized structure-recognition models like LORE.
  • The reflection module contributes independently: removing it drops PubTabNet TEDS from 85.03 to 82.08, and removing the experience-learning module drops it to 80.57.
  • Tool invocation adapts to dataset characteristics: image upscaling is preferred on low-resolution PubTabNet, detection-and-cropping on wild WTW images, and border enhancement on clean SciTSR tables.
  • VLLMs show asymmetric structure sensitivity: column-related recognition is more accurate than row-related recognition, and border visibility has little effect on performance.

Reading between the lines

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

  • Because the framework is training-free and tool-agnostic, the same neighbor-guided scoring loop could be applied to other output formats besides HTML (e.g., Markdown or JSON) and to other document-understanding tasks where a ground-truth label and a structural similarity metric exist.
  • The neighbor-transfer premise suggests a cheap diagnostic: if retrieval quality is measured (e.g., by TEDS between neighbor and test ground truths), the framework's ceiling on a new dataset can be predicted before running the VLLM.
  • The reflection module's reliance on image-quality judgment rather than recognition accuracy implies that a tool which preserves visual information but confuses the VLLM (e.g., upscaling that changes font rendering) would pass the reflection gate yet still hurt downstream TEDS; testing this could reveal whether reflection should be conditioned on the recognition target.
  • The benchmark's finding that VLLMs ignore borders is testable in reverse: inserting strong but false border cues into a borderless table image could measurably change recognition output, indicating whether structural priors are learned from text rather than vision.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

4 major / 4 minor

Summary. The paper introduces a benchmark for evaluating VLLM-based table recognition under a training-free paradigm and proposes NGTR, a framework that preprocesses table images by retrieving a similar training neighbor, generating candidate toolchains via the VLLM, scoring those toolchains by executing them on the neighbor and comparing the VLLM's output against the neighbor's ground-truth HTML with TEDS, and finally applying the winning toolchain to the test image with a reflection module that accepts or rejects each tool step. The authors report large gains on PubTabNet and WTW (e.g., GPT-4o TEDS from 74.46 to 85.03 on PubTabNet and TEDS-Struct from 40.01 to 52.03 on WTW) and smaller gains on SciTSR. The paper also contributes a hierarchical task benchmark and an analysis of VLLM robustness to image degradation.

Significance. If the reported results hold, the paper makes a useful contribution to table recognition with vision LLMs by demonstrating that lightweight image preprocessing, guided by retrieved neighbors, can substantially improve zero-shot VLLM performance on low-quality inputs. The manuscript ships code, proposes a training-free framework with modular tools, and provides a systematic benchmark across multiple VLLMs and three public datasets. The bottleneck analysis (Section 3.4) is a helpful diagnostic. However, the central mechanism relies on an unverified transfer assumption, and the experimental reporting lacks statistical rigor; the small SciTSR gains may not be significant.

major comments (4)
  1. [Sections 4.3–4.5, Eqs. (1)–(4)] The core of NGTR is the transfer of a toolchain selected by scoring it on a retrieved neighbor's ground-truth HTML to the test image. The manuscript never measures whether the neighbor's best toolchain actually matches the test image's best toolchain. The limitation section acknowledges that an inappropriate neighbor can degrade performance, but no analysis quantifies how often this occurs. Please provide an oracle comparison on a labeled subset: for each test image, compute the toolchain that maximizes TEDS on the test image itself (using the test ground truth), and compare its performance against the NGTR-selected toolchain. Report the agreement rate between the two selections and the TEDS gap. Without this, the reported gains could be driven by plans that are optimal for the neighbor but not for the test image; the w/o EXP ablation in Table 5 does not isolate this, as it compares no scoring against neighbor scoring rather than neighbor scoring against test-image scoring.
  2. [Section 4.5, Eq. (4), Figure 19] The reflection module accepts or rejects each tool step based on whether the post-processing image 'contains more information' or whether 'no information is lost.' This criterion is not directly tied to downstream table recognition accuracy; for example, binarization can make an image look cleaner while erasing faint text or thin borders, and the current prompt would likely accept it. Please analyze whether the reflection decisions correlate with downstream TEDS improvements, for instance by labeling accepted/rejected steps on a held-out subset with known ground truth, or by modifying the reflection prompt to incorporate a recognition-aware check (e.g., asking the VLLM whether any table content would be lost). Reporting the acceptance rate and the proportion of accepted steps that improve TEDS would make the module's contribution measurable.
  3. [Section 5.5 and Implementation Details] The hyperparameters L (maximum toolchain length) and N (number of plans) are chosen based on the sensitivity analysis in Figure 6, but the manuscript does not state which data split was used for this tuning. Since the SciTSR and WTW evaluations use their complete test sets, any tuning of L or N on these test sets would inflate the reported results. Please specify the tuning split explicitly. If hyperparameter selection used test-set information, either report results with hyperparameters fixed a priori (e.g., L=3, N=3 without tuning) or use a validation split from the training data for tuning. The same transparency is needed for the PubTabNet evaluation subset: it is a random selection of 1,500 validation images, but no seed or exact list is provided, which affects reproducibility.
  4. [Tables 4 and 5] All reported numbers are single-run point estimates without error bars, confidence intervals, or significance tests. The SciTSR gains are small (GPT-4o TEDS +0.92, Gemini TEDS +1.88, and +1.36/+1.58 for TEDS-Struct) and may be within run-to-run variability, especially for closed-source APIs where temperature 0 does not guarantee deterministic output. Please report the variance across multiple runs (e.g., 3–5 runs) or, at minimum, the number of test samples and a paired significance test for the smaller gains. The large PubTabNet and WTW improvements are likely robust, but the 'significantly enhances' claim in the abstract and Section 5.2 should be qualified for datasets with small margins.
minor comments (4)
  1. [Section 3.3, Figure 3] The row/column sensitivity analysis uses a subsample where the difference between rows and columns does not exceed three, but the exact filtering procedure and the resulting sample sizes are not described; please clarify how 'difference' is computed and report the number of samples in each bar.
  2. [Section 5.4, Table 6] The tool usage rates are described as 'the proportion of samples that invoke a particular tool among all samples where tools are invoked,' but the denominator is not stated numerically; please specify whether the denominator is all test samples or only samples where at least one tool was accepted, and how 'invoked' is counted when a tool is rejected by the reflection module.
  3. [Appendix D] The parameter settings mention temperature 0.8 for generating tool invocation plans and temperature 0 for other experiments; please clarify whether the reflection module also uses temperature 0, and whether the VLLM-based tool-plan generation in Eq. (2) uses any special decoding parameters beyond temperature.
  4. [Equation (2) and Figure 18] The notation N(Itest) is used to denote the set of retrieved neighbor images, but it is not formally defined as a function returning a set; please define it explicitly, and clarify whether the planning prompt includes the test image itself or only the neighbor images, since Figure 5 suggests the test image is also shown to the VLLM during planning.

Circularity Check

0 steps flagged · score 0.0 of 10

No circular derivation: NGTR's toolchain selection is scored against retrieved-neighbor ground truth, while final results are reported on held-out test and validation images, so the central claim is not forced by its inputs.

full rationale

The derivation chain is self-contained against the reported evaluation. NGTR's toolchain selection (Sections 4.3-4.5, Eqs. 1-4) chooses a plan by executing candidate toolchains on a retrieved neighbor image and scoring the VLLM output against the neighbor's ground-truth HTML using TEDS (Section 4.4); the reported gains (Tables 4-5) are then computed on held-out PubTabNet validation, SciTSR test, and WTW test images. No fitted parameter, learned weight, or scoring function takes the test image's ground truth as an input, so the reported improvements are not forced by construction. The paper's own Limitation section acknowledges that an inappropriate neighbor can lead to suboptimal performance; this is an unvalidated transfer assumption, which is a correctness risk rather than circularity. The self-citations in the paper (e.g., Cheng et al. 2025b and Liu et al. 2024b for the hierarchical design philosophy) are not load-bearing: the central framework, its equations, and its evaluation do not reduce to those citations. One caveat is that NGTR spends training-set labels at inference time to score neighbor plans, but this is transductive use of labels and is not circular with respect to the held-out evaluation.

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

The framework introduces no new physical or conceptual entities. The main assumptions are about the validity of neighbor transfer and the reliability of the VLLM's reflection judgment. The free parameters are inference-time design choices (L, N, retrieval pool, evaluation subset) rather than fitted constants in a derivation; however, their values are selected using the same evaluation data, which is a mild form of tuning.

free parameters (5)
  • Toolchain length L
    Maximum length of the tool execution plan; tuned via sensitivity analysis in Section 5.5, but the per-dataset optimal value is not reported.
  • Number of plans N
    Number of tool invocation plans generated per iteration; tuned via sensitivity analysis in Section 5.5 without a separate held-out set.
  • Retrieval pool size |D'|
    The size of the training subset used for neighbor retrieval is not specified for any dataset; it is a researcher choice that affects transfer quality.
  • PubTabNet evaluation subset = 1500
    The paper randomly selects 1,500 images from the PubTabNet validation set for evaluation, a sampling choice that affects the reported numbers.
  • Row-column difference threshold = 3
    In the row-column sensitivity analysis, samples with |rows-columns|>3 are excluded; this is a post-hoc filter used only for the analysis in Section 3.3.
assumptions (5)
  • domain assumption ORB feature matching with Hamming distance is an adequate similarity measure for table images.
    Used in Equation 1 (Section 4.3) to retrieve neighbors; no validation that ORB correlates with table structure or content similarity.
  • domain assumption Similar images benefit from similar preprocessing toolchains.
    Stated as a hypothesis in Section 4.3; the entire neighbor-guided plan transfer rests on this premise.
  • domain assumption The VLLM's reflection decision, which image contains more information, is a reliable proxy for downstream recognition quality.
    The reflection module in Section 4.5 accepts or rejects a tool step based on the VLLM's judgment, but no evidence is given that this judgment correlates with TEDS accuracy.
  • standard math TEDS and TEDS-Struct are valid metrics for table recognition quality.
    TEDS is a widely used metric from Zhong et al. (2020); the paper adopts it without modification.
  • domain assumption The retrieval pool D' is representative of the test scenarios.
    The Limitation section acknowledges that if neighbor candidates do not cover the range of test scenarios, suboptimal plans may be selected.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Enhancing Table Recognition with Vision LLMs: A Benchmark and Neighbor-Guided Toolchain Reasoner." pith.science (2026). https://pith.science/paper/RGAZL6Y3

@misc{pith2026241220662,
  author       = {Pith},
  title        = {Pith review of: Enhancing Table Recognition with Vision LLMs: A Benchmark and Neighbor-Guided Toolchain Reasoner},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/RGAZL6Y3}},
  note         = {Machine review of arXiv:2412.20662}
}
read the original abstract

Pre-trained foundation models have recently made significant progress in table-related tasks such as table understanding and reasoning. However, recognizing the structure and content of unstructured tables using Vision Large Language Models (VLLMs) remains under-explored. To bridge this gap, we propose a benchmark based on a hierarchical design philosophy to evaluate the recognition capabilities of VLLMs in training-free scenarios. Through in-depth evaluations, we find that low-quality image input is a significant bottleneck in the recognition process. Drawing inspiration from this, we propose the Neighbor-Guided Toolchain Reasoner (NGTR) framework, which is characterized by integrating diverse lightweight tools for visual operations aimed at mitigating issues with low-quality images. Specifically, we transfer a tool selection experience from a similar neighbor to the input and design a reflection module to supervise the tool invocation process. Extensive experiments on public datasets demonstrate that our approach significantly enhances the recognition capabilities of the vanilla VLLMs. We believe that the benchmark and framework could provide an alternative solution to table recognition.

Figures

Figures reproduced from arXiv: 2412.20662 by the authors.

Figure 1
Figure 1. Comparison of modeling paradigms: domain-specific [PITH_FULL_IMAGE:figures/full_fig_p001_1.png] view at source ↗
Figure 2
Figure 2. Experimental results of VLLMs for the proposed hierar [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗
Figure 3
Figure 3. Row-Column Sensitivity Analysis of VLLMs on Hierar [PITH_FULL_IMAGE:figures/full_fig_p003_3.png] view at source ↗
Figures from the paper (11 more)
Figure 4
Figure 4. Figure 4: Evaluation results of bottleneck scenarios: abbreviations [PITH_FULL_IMAGE:figures/full_fig_p004_4.png]
Figure 5
Figure 5. Figure 5: Illustration of a pipeline for table image preprocessing leveraging a toolkit of lightweight vision models. [PITH_FULL_IMAGE:figures/full_fig_p005_5.png]
Figure 6
Figure 6. Figure 6: The impact of the number of tools (shown on the left) and [PITH_FULL_IMAGE:figures/full_fig_p007_6.png]
Figure 7
Figure 7. Figure 7: Table size distribution and its impact on TR performance [PITH_FULL_IMAGE:figures/full_fig_p010_7.png]
Figure 8
Figure 8. Figure 8: A case study is conducted using a sample from PubTabNet. [PITH_FULL_IMAGE:figures/full_fig_p011_8.png]
Figure 12
Figure 12. Figure 12: Prompt template on visual table size detection task. [PITH_FULL_IMAGE:figures/full_fig_p012_12.png]
Figure 13
Figure 13. Figure 13: Prompt template on merged cell detection task. [PITH_FULL_IMAGE:figures/full_fig_p012_13.png]
Figure 11
Figure 11. Figure 11: Chain-of-Thought prompt template for VLLMs on table [PITH_FULL_IMAGE:figures/full_fig_p012_11.png]
Figure 14
Figure 14. Figure 14: Prompt template on content-based cell recognition task. [PITH_FULL_IMAGE:figures/full_fig_p013_14.png]
Figure 15
Figure 15. Figure 15: Prompt template on index-based cell recognition task. [PITH_FULL_IMAGE:figures/full_fig_p013_15.png]
Figure 19
Figure 19. Figure 19: Prompt template for the reflection-driven tool utilization [PITH_FULL_IMAGE:figures/full_fig_p013_19.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. LLM-as-a-Judge Scores Are Unreliable Optimization Signals in Closed-Loop Table Recognition

    cs.CL 2026-07 conditional novelty 5.0 of 10

    Reference-free LLM judge scores failed to select better table-extraction outputs over eight regeneration iterations on FinTabNet and OmniDocBench; keeping the first output was safest.

Reference graph

Works this paper leans on

27 extracted references · 26 canonical work pages · cited by 1 Pith paper

  1. [1]

    Use the <thead> and <tbody> tags to distinguish the table header from the table body

    work page

  2. [2]

    Prompt 10: Simplified prompt template for VLLMs on table recog- nition tasks

    Use only five tags: <table>, <thead>, <tr>, <td>, and <tbody>. Prompt 10: Simplified prompt template for VLLMs on table recog- nition tasks. Prompt 2 Instruction: Step 1: Step 2: Step 3: Note: Answer: You are a table recognition expert, and you are very good at recognizing tabular data in pictures and the structure of tables. Now you need to Identify the ...

    work page

  3. [3]

    Figure 11: Chain-of-Thought prompt template for VLLMs on table recognition tasks

    Please do not omit and give me all the results. Figure 11: Chain-of-Thought prompt template for VLLMs on table recognition tasks. Figures 12-17 illustrate the prompt templates designed for our benchmark evaluation of hierarchical evaluation tasks. Each template corresponds to a specific hierarchical task: • Visual Table Size Detection Task. (Figure 12) • ...

    work page

  4. [4]

    Use only five tags: <table>, <thead>, <tr>, <td>, and <tbody>

    work page

  5. [5]

    Use rowspan and colspan to better interpret the structure information of the table

    Pay attention to the structure of the table. Use rowspan and colspan to better interpret the structure information of the table

    work page

  6. [7]

    The dimensions of the table are represented by the number of rows and columns

    work page

  7. [8]

    The row and column numbers start from 1

    The dimensions of the table are two integers. The row and column numbers start from 1

    work page

  8. [10]

    chain_of_thought

    Your answer must be returned in the following json format. {"chain_of_thought": "Your thought process for complete this task.", "rows": 0,"columns": 0} Figure 12: Prompt template on visual table size detection task. Prompt 3.2 Instruction: Note: Answer: Please identify the table in the picture and retrieve the merged cells in the table and output. {image}

    work page

Show all 27 references
  1. [11]

    The merged cells are represented by the cell content

  2. [12]

    If there are merged cells, return a list of type string

    If there are no merged cells, please return an empty list. If there are merged cells, return a list of type string

  3. [13]

    If the detected merged cell contains no content, its content will be represented as an empty string

  4. [14]

    chain_of_thought

    Your answer must be returned in the following json format. {"chain_of_thought": "Your thought process for complete this task.","merged_cells": []} Figure 13: Prompt template on merged cell detection task. • Content-based Cell Recognition Task. (Figure 14) • Index-based Cell Re...

  5. [15]

    The row and column numbers start from 1

    The cell position is represented by the row and column numbers of the cell. The row and column numbers start from 1

  6. [16]

    If the cell is not found, please return an empty string

  7. [18]

    chain_of_thought

    Your answer must be returned in the following json format. {"chain_of_thought": "Your thought process for complete this task.", "row_index": 0,"col_index": 0} Figure 14: Prompt template on content-based cell recognition task. Prompt 3.4 Instruction: Note: Answer: Please identi...

  8. [19]

    The row and column numbers start from 1

    The coordinates of the cell are represented by the row and column numbers of the cell. The row and column numbers start from 1

  9. [20]

    The cell value is a string, and the output format is a string

  10. [21]

    If the cell is empty, please return an empty string

  11. [23]

    chain_of_thought

    Your answer must be returned in the following json format. {"chain_of_thought": "Your thought process for complete this task.","content": "The cell content."} Figure 15: Prompt template on index-based cell recognition task. Prompt 3.5 Instruction: Note: Answer: Please identify...

  12. [24]

    The row number starts from 1

  13. [25]

    Returns a list of string types in the json "content" field

    The row is a string list of cells. Returns a list of string types in the json "content" field

  14. [27]

    content" value must be a string list. {

    Your answer must be returned in the following list format. The "content" value must be a string list. {"chain_of_thought": "Your thought process for complete this task.","content": []} Figure 16: Prompt template for row index recognition task. Prompt 3.6 Instruction: Note: Ans...

  15. [28]

    The column number starts from 1

  16. [29]

    Returns a list of string types in the json "content" field

    The column is a string list of cells. Returns a list of string types in the json "content" field

  17. [30]

    When counting the number of rows and columns, the header and body of the table are also counted

    All operations are performed on the entire table, including the head and body. When counting the number of rows and columns, the header and body of the table are also counted. If there are headers and columns, The row count starts from the header row. The columns count starts ...

  18. [31]

    chain_of_thought

    Your answer must be returned in the following json format. {"chain_of_thought": "Your thought process for complete this task.","content": []} Figure 17: Prompt template for column index recognition task. Prompt 4.1 Instruction: Tool List: Output Format: Answer: You are an imag...

  19. [1464]

    [Wang et al., 2024a] Jiahao Wang, Mingyue Cheng, et al

    IEEE, 2011. [Wang et al., 2024a] Jiahao Wang, Mingyue Cheng, et al. Tabletime: Reformulating time series classification as training-free table understanding with large language models. arXiv preprint arXiv:2411.15737, 2024. [Wang et al., 2024b] Zilong Wang, Hao Zhang, Chun-Lia...

    2011

Pith tools

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