Information Theory · arXiv:2610.29641 v2 · submitted 21 Oct 2026
Recursive Code Evolution for Task-Oriented Semantic Communications
The paper says
“Semantic communication jointly optimizes inference accuracy, channel use, and computation, yet the underlying communication program is typically specified before training. This paper presents ComRSI (Communications-Oriented Recursive Self-Improvement), a framework for recursively evolving that program through large-language-model-assisted code edits.”
more of the abstract
An agent modifies the encoder, channel adapters, decoder, loss, and training policy; a protected evaluator screens candidates under prescribed budgets and resource constraints. Accepted code and textual feedback inform subsequent proposals, while candidate weights are trained from scratch. In the original ten-generation CIFAR-100 lineage, eight accepted revisions produce an attention-pooled code achieving 74.3% test accuracy over an Additive White Gaussian Noise (AWGN) channel at 32 complex symbols per image, compared with 67.2% at 256 symbols for the initial design. The program also improves fading-channel accuracy and transfers to Tiny-ImageNet after retraining, where a separate ComRSI search demonstrates further recursive improvements. A repeat study with ten searches per method compares ComRSI against non-recursive agents with and without textual history. Mean final search scores balancing accuracy, transmission rate, and computational cost are 0.7587, 0.7376, and 0.7089, respectively; the mean numbers of accepted revisions per search are 6.0, 5.0, and 2.1. The advantage over the memoryless agent is supported by a two-sided rank test, whereas the difference from the history-equipped agent remains statistically inconclusive at this sample size. Archived proposals show that pooling can yield a large improvement, while retained history supports subsequent refinement. These results support recursive program optimization within the evaluated setting and expose its remaining rate-robustness and compute-placement trade-offs.
from the abstract
Pith says
Machine review · deepseek-v4-flash · 22 Oct 2026 · of version 1 of the paper; version 2 is newer · what was read was not recorded · not checked by a person
It can be wrong. Challenge this review or reply to it.
Holds up, with conditions. Careful, honest empirical paper on LLM-driven code evolution for semantic communications, but the ingredient that is supposed to be the contribution—recursive code inheritance—is not statistically separated from text-only history. This line is wrong
3 major objections · 6 minor
How often objections from reviews like this one are right: not yet measured
Not checked: figures, code, what the references say.
The paper says, at Section V.G.2, Eq. (16)
The review did not quote this passage.
Pith says: Objection 1 of 3 · major
The claim that ComRSI accumulates performance improvements through successive accepted revisions rests on G_rest point means (0.0553, 0.0447, 0.0133) reported without spread or significance tests, although the same ten-search records that produced the p=0.0010 contrast in Table V could yield a Mann-Whitney test on G_rest.
more of objection 1
With the Table V spreads (final-search-PS standard deviations 0.024-0.028), the standard error of the ComRSI-versus-NR-H difference is about 0.012, so the 0.0106 G_rest gap is less than one standard error and its significance cannot be assessed from the paper. Moreover, G_rest has a mechanical component: each acceptance must improve PublicScore by at least 0.005 (Section III.E), and with mean acceptance counts of 6.0 versus 5.0 the gate floor alone predicts about half of the observed G_rest gap (0.005 of 0.0106), so the ordering may partly reflect how many revisions each method happened to accept rather than the quality of successive refinement. The same applies to the hidden-accuracy columns of Table V (74.0 versus 72.5 AWGN-5), which are reported without a test. Please add rank tests on G_rest and on the hidden metrics, plus an analysis conditioned on the number of accepted revisions, or soften the cumulative-refinement conclusion.
The paper says, at Section V.G.3
The review did not quote this passage.
Pith says: Objection 2 of 3 · major
The post-pooling refinement statistics do not isolate recursive code inheritance and are not even nominally favorable to ComRSI. Refinement frequencies are 7/7 for ComRSI and 4/4 for NR-H (identical rates), the mean additional PublicScore gains after pooling are 0.0234 (ComRSI) versus 0.0239 (NR-H) versus 0.0040 (NR-0), and pooling adoption is 7/10 versus 4/10, which is within sampling variation (Fisher exact p about 0.37).
more of objection 2
Taken as reported, this subsection supports the general value of retained history (history-equipped agents versus NR-0), a distinction already carried by the significant NR-0 contrast, but it provides no quantitative evidence that code inheritance adds anything beyond textual history. Please report rank tests on post-pooling gains and on the adoption rates, and reframe the conclusion to match what those tests show.
The paper says, at Section IV.B and Table II
The review did not quote this passage.
Pith says: Objection 3 of 3 · major
The method's sensitivity to the proposal model is of the same order as the headline treatment effect, and the implication for the central claim is under-drawn. Replacing claude-opus-5-5 with claude-sonnet-5-5 drops fresh-seed PublicScore from 0.784 to 0.704 (a gap of 0.080), about four times the ten-search mean ComRSI-versus-NR-H gap of 0.021.
more of objection 3
The paper does report this run, and credit is due for that, but the consequence is that with a different plausible model snapshot the recursive-inheritance advantage over NR-H, and a large part of the advantage over NR-0, could disappear; the central claim therefore holds only for one archived, opaque model combined with an unpublished prompt and proposal protocol. Because the prompts, protocol, manifests, and candidate diffs are not released, none of the agent-based comparisons can be audited or re-run by independent readers. Archiving the full protocol and artifacts for at least the ten-search repeat study, and discussing the model-sensitivity magnitude in the central-claims section, is necessary for the stated evidence to carry the weight assigned to it.
6 minor objections
The paper says, at Abstract and Section V.A
Pith says: minor objection 1 of 6
The initial-system PublicScore appears as 0.669 in Tables II and V but as 0.666 in Section V.A; reconcile the two values.
The paper says, at Table V
Pith says: minor objection 2 of 6
The caption promises mean plus/minus sample standard deviation for every row, but the 'Mean gain beyond the largest step' row reports only point means; include the spreads or amend the caption.
show 4 more
The paper says, at Section IV.B
Pith says: minor objection 3 of 6
The sentence 'The original search was subsequently continued to ten generations' is ambiguous about which proposal model produced the original lineage; state explicitly how the Sonnet run and the main Opus lineage relate.
The paper says, at Section V.C
Pith says: minor objection 4 of 6
The fresh-seed comparisons (0.784 versus 0.715 versus 0.722) are single-lineage runs and are presented without noting that the ten-search study in Table V shows a much smaller ComRSI-versus-NR-H gap; flag these entries as single runs and point to Table V as the method-level comparison.
The paper says, at Abstract
Pith says: minor objection 5 of 6
The abstract contains the typo '(A WGN)'; it should read '(AWGN)'.
The paper says, at Sections III.C and III.E
Pith says: minor objection 6 of 6
A brief sensitivity check on the author-set constants (alpha=0.02, beta=0.01, and the 0.005 acceptance margin) would clarify how much of the reported ranking depends on these choices; at minimum, note in the text that no such check was performed.
What would settle it
Using the archived ten-search records behind Table V, apply the same exact two-sided Mann-Whitney test already used for final PublicScore to (i) G_rest per Eq. (16) and (ii) post-pooling additional PublicScore gains, each ComRSI versus NR-H with n=10 per group, plus Fisher's exact test on pooling adoption (7/10 versus 4/10). If all are non-significant, the mechanism claim in Section V.G.2 must be narrowed to 'retaining discoveries in any form helps' and the paper should state that code inheritance is not distinguished from textual history at this sample size; if any reaches significance with appropriate multiplicity handling, the code-inheritance mechanism gains empirical support and this concern is retired.
from the skeptic's reading
How the review went
4 readings by deepseek-v4-flash · 22 Oct 2026
- Reader holds up, with conditions
- Skeptic partly agrees
- Editor wrote the verdict above
- Referee major revision: 3 major objections, 6 minor
Not run on this paper: the simulated authors' defence.
Pith did not check this review's objections against the paper.
The review in full
The review in brief, machine-written
Here is my read. This is a serious paper and the effort put into evaluation is real. It adapts the FunSearch/AlphaEvolve program-search paradigm to task-oriented semantic communication, and the co-design of architecture, rate, and compute is genuinely new in this subfield. More importantly, the validation protocol is far better than the norm: hidden test images, fresh retraining seeds, fading-channel tests, SHA-256 protected manifests, ten independent searches per method, and a paired-bootstrap acceptance gate. The authors also state plainly that their key head-to-head comparison is inconclusive, which is rare and to their credit. The single-lineage result—eight accepted revisions producing a 32-symbol program that beats the 256-symbol starting point—is plausible and well documented.
The soft spot is exactly what the stress-test note identifies. The one contrast that isolates code inheritance from everything else is ComRSI versus NR-H: same proposal model, same evaluator, same budgets, same textual history, differing only in inherited source code. That contrast is not significant on the primary score (p = 0.1212). The authors acknowledge this for the final search score but then support the cumulative-refinement mechanism with two quantities that are never significance-tested: G_rest and the post-pooling gains. Given the reported standard deviations, those gaps look small, and NR-H's post-pooling gain actually nominally exceeds ComRSI's. The paper's conclusion that ComRSI accumulates improvements through successive accepted revisions is therefore not yet supported against the text-only control. The supported claim is closer to: retaining previous discoveries in any usable form helps. The archived ten-search records could settle this with simple rank tests, and I think the authors should be asked to run them before publication.
Two other weaknesses, both acknowledged but still substantial. The method is heavily dependent on one opaque archived LLM, claude-opus-5-5; swapping to the earlier agent moved fresh-seed PublicScore from 0.784 to 0.704, a bigger shift than the ComRSI-versus-NR-H difference. And no code, prompts, or archived proposals are released, so the central empirical claim is not independently reproducible. Neither concern is a demonstrated error, but both limit what the paper establishes.
Who is this for? Researchers working on automated design of communication systems and on LLM-driven program search more broadly. It would be good reading-group material as a case study in protected evaluation. It deserves a serious referee cycle rather than a desk rejection, but the revision should add significance tests on the mechanism metrics, release the artifacts, and tone down the inheritance-specific claims until the evidence supports them.
The strongest objection
The central claim requires that recursive code inheritance specifically drives the observed gains. The experiment that isolates that ingredient is ComRSI versus NR-H: same Opus model, same evaluator, same budgets, same textual-history access, differing only in inherited source code (Section IV.B). This is the one contrast that fails: final search PublicScore 0.7587 versus 0.7376, two-sided rank test p=0.1212 (Table V). The authors honestly acknowledge this for the primary score (abstract; Section V.G.2), but then support the cumulative-refinement mechanism with two quantities that are never significance-tested: G_rest (Eq. 16, Section V.G.2) at 0.0553 versus 0.0447 versus 0.0133, and post-pooling gains (Section V.G.3) at 0.0234 versus 0.0239 versus 0.0040 with refinement frequencies 7/7 versus 4/4 versus 1/5. The same ten-search records that produced p=0.001 against NR-0 could have produced these tests. With final-search-PS standard deviations of 0.024-0.028 (Table V), the 0.0106 ComRSI-versus-NR-H G_rest gap is reported without spread or a test, so its significance cannot be assessed from the paper; NR-H's post-pooling gain nominally exceeds ComRSI's, and pooling adoption (7/10 versus 4/10; Fisher exact p≈0.37) is within sampling variation. If rank tests on G_rest and post-pooling gains are also non-significant, Section V.G.2's conclusion that 'ComRSI accumulates performance improvements through successive accepted revisions' is unsupported against the text-only control, and the supported claim reduces to 'retaining discoveries in any form helps.' The reader's model-dependence concern is real but secondary: the earlier-agent gap (0.784 versus 0.704, Section V.C) is acknowledged by the authors, and even a stable, representative model would not fix the within-design attribution gap described here.
I read the paper as an honest and internally coherent empirical study. Its safeguards are real: hidden test images with disjoint channel seeds, fresh-seed retraining (seeds 100-102), ten independent searches per agent variant, a paired-bootstrap acceptance gate with margin and lower-bound conditions, SHA-256-protected manifests, and candid reporting that the ComRSI-versus-NR-H advantage is inconclusive (abstract; Section V.G.2). The strong scoped results — 74.3% versus 67.2% hidden AWGN-5 at one-eighth the rate, fresh-seed PublicScore 0.784 versus 0.669, p=0.001 against the memoryless agent — are credible as far as they go. The single most load-bearing gap is attribution of the gain to the paper's distinctive mechanism. NR-H is a well-constructed control for code inheritance: same model, protocol, budgets, and text history, with only inherited source code differing. That contrast is non-significant (p=0.1212). The paper acknowledges this for the headline score but then relies, for the cumulative-refinement conclusion, on G_rest (Eq. 16) and post-pooling gains that are presented without significance tests, although the ten-search records would permit them. NR-H's post-pooling gain (0.0239) nominally exceeds ComRSI's (0.0234), and pooling adoption (4/10 versus 7/10) is within sampling variation (Fisher exact p≈0.37), so the secondary evidence does not obviously favor code inheritance either. If the missing tests are non-significant, the supported claim narrows to 'retaining discoveries, in code or in notes, helps,' and the title's 'Recursive Code Evolution' framing is not established above the text-history control. The reader's model-dependence concern is genuine but secondary for this verdict: the earlier-agent experiment (0.784 to 0.704, Section V.C) quantifies a sensitivity the paper already reports, and the qualitative improvement over the human design survives that model swap. Even granting a stable, available, representative model, the within-design attribution gap described above remains. A CONDITIONAL verdict is therefore still right; my check would sharpen the condition by requiring significance tests on the mechanism-level metrics. The paper's honesty and safeguards rule out rejection.
The referee's report
The experimental protocol is the strongest asset of this paper: hidden test images, three fresh retraining seeds per program, SHA-256-protected manifests, paired-bootstrap acceptance gating, a noise-permutation integrity check with a cheating-fixture detector, and ten independent searches per method are genuine safeguards, and the authors openly report the inconclusive ComRSI-versus-NR-H contrast on the primary metric. The control design that separates code inheritance (ComRSI) from textual history (NR-H) from no history (NR-0) is the right experiment, even if underpowered at ten searches per arm. If the mechanism claim survives, the framework would be a reusable template for auditable LLM-assisted design of communication programs, and the protected-evaluation apparatus is a methodological contribution in its own right. As it stands, the specific mechanism (recursive code inheritance beyond textual history) is not statistically supported on the primary score, the two metrics that carry the mechanism claim are never significance-tested, the method is highly sensitive to a single unarchived proposal-model snapshot, and no code, prompts, or manifests are released.
Pith's reading of the paper (a machine's summary, not the authors')
The paper's claim is that a communication program — the source code defining the semantic encoder, channel adapters, decoder, loss, and training-SNR policy — can itself be the evolving artifact: a fixed large-language-model agent proposes edits, a protected evaluator screens them, and each accepted program becomes the parent of the next generation while weights are retrained from scratch. On CIFAR-100, one ten-generation search accepted eight revisions and turned a 256-complex-symbol human design into a 32-symbol attention-pooled program with 74.3% hidden-test AWGN accuracy versus 67.2% for the original, and the program improved fading-channel accuracy and transferred to Tiny-ImageNet. Ten repeated searches per method support the recursive recipe over a memoryless non-recursive agent (mean final PublicScore 0.7587 versus 0.7089, two-sided rank test $p = 0.001$), while the advantage over a non-recursive agent that keeps textual history (0.7376) is acknowledged as statistically inconclusive at this sample size. If the claim holds, the designer's bottleneck in task-oriented communication shifts from hand-specifying architectures and training objectives to specifying the score and the search protocol, because the code lineage itself becomes inspectable, replayable, and portable.
What carries the argument. The load-bearing mechanism is the recursive inheritance loop with a statistically gated acceptance rule. At each generation, the fixed agent sees the incumbent program, public diagnostics (per-SNR accuracy, rate, FLOPs, class-level errors, confidence), and the archived textual history; it proposes four candidate revisions, which are validity-screened, proxy-trained with one seed, and then the two best are trained from scratch at full budget with three seeds. A candidate replaces the incumbent only if its estimated PublicScore improvement over the parent exceeds 0.005 and the fifth percentile of 2,000 paired bootstrap resamples of validation-image score differences stays above zero. Because candidate weights are reinitialized every generation, any gain must come from the program's code and configuration, not from continued training. The other central object is the discovered transmit representation: three attention heads and a global-average branch produce pooled features $p_0 = \tfrac{1}{N}\sum_j v_j$ and $p_\ell = \sum_j a_{\ell j} v_j$, which are concatenated and projected to $2k$ real outputs paired into $k = 32$ complex symbols; the receiver concatenates equalized symbols with two SNR features, $\gamma_{\mathrm{eff}}/10$ and $10^{-\gamma_{\mathrm{eff}}/20}$, before a single linear classifier.
Core claim. The central discovery is that inheriting accepted program code — rather than inheriting weights, or merely remembering past proposals as text — is what lets a fixed agent accumulate improvements in a task-oriented communication system. In the recorded lineage, early revisions tuned the training-SNR range, regularization, and label smoothing and deepened the encoder; at G8 the search replaced the spatial latent with a 64-symbol pooled semantic vector and a new compact receiver, G9 halved the rate to 32 symbols, and G10 added learned attention pooling (three attention heads plus a global-average branch) to lift accuracy at that rate. The final design reaches 74.3% AWGN-5 accuracy and remains competitive under Rayleigh and Rician fading, while the 64-symbol G8 ancestor is the more robust low-SNR and fading program (67.1% versus 64.0% Rayleigh-7), which the authors read as a rate-robustness trade-off that the composite score encodes. They frame the evidence as supporting recursive program optimization within the evaluated setting, explicitly noting that attention pooling is not claimed as a new primitive, that the search is heuristic with no global-optimality guarantee, and that the setting is image classification over simulated channels.
The premise it rests on. The load-bearing premise is that the archived language-model snapshot and its unpublished proposal protocol are stable and representative enough that the observed gains can be attributed to recursive code evolution rather than to one opaque proposer; the paper's own swap to a different archived model cuts the fresh-seed PublicScore from 0.784 to 0.704, a drop larger than the entire ComRSI-versus-history-aware-agent gap, so if that proposer is unavailable or changes, the central empirical claim does not transfer.
If the paper is right (Pith's inferences, not the authors')
If correct, communication-system design becomes auditable program search: every accepted improvement is a code diff, so the evolved lineage can be inspected, replayed, and re-targeted rather than treated as a black-box weight update.
Evolved structure transfers: the CIFAR-100 program retrained from scratch on Tiny-ImageNet outperforms the initial design and a random-search-found program there while still using only 32 symbols, so the discovered architecture carries reusable structure across datasets.
Rate-robustness trade-offs become steerable objectives: the same lineage yields a fading-robust 64-symbol ancestor and a rate-efficient 32-symbol descendant, implying that re-weighting the composite score would push the search to different operating points.
The repeat study bounds what recursion alone contributes: with ten searches per method the gain over a history-equipped non-recursive agent is not significant ($p = 0.121$), so direct code inheritance's marginal value over textual memory remains an open quantitative question the authors flag.
Compute placement is an emergent output: the evolved transmitter carries 5.203M parameters and 1.145 GFLOPs per image while the receiver shrinks to 0.086M parameters and 0.17 MFLOPs, meaning the search itself decided that semantic processing belongs largely at the transmitter.
My extension: the comparison that most limits the claim is the proposal-model swap already reported in the paper — a different archived model drops fresh-seed PublicScore from 0.784 to 0.704, a fall larger than the ComRSI-versus-NR-H gap — which suggests the practical recipe is a strong fixed proposer plus recursion, and that the central numbers should be re-derived with a second comparable model
My extension: a direct test of objective-dependence would be to re-run the ten searches with rate and compute penalties re-weighted (the paper fixes $\alpha = 0.02$ on rate and $\beta = 0.01$ on FLOPs before search); if the lineage then converges to G8-like 64-symbol designs, the discovered operating point is an artifact of the chosen score rather than an intrinsic property of the task.
My extension: because proposals and rationales are archived, an audit could replay each accepted diff against its parent with the agent removed, quantifying how much of the cumulative gain is carried by the single G8 pooling transition versus the surrounding refinements; the paper's own residual-gain statistic already moves in this direction.
My extension: a cleaner ablation of expressive power would match the same agent against a fixed high-performing architecture under identical training FLOPs; if most of the gain survives, the advantage comes from the search protocol, whereas if it collapses, unrestricted code editing is the active ingredient.
Check this review
Pith stored no record of this review's passes and took no fingerprint of it. Reviews made by code from 13 Nov 2026 on carry both.
How often reviews like this one are right
Reviews like this one: written by deepseek-v4-flash, where what was read was not recorded.
How often objections from reviews like this one are right: not yet measured
Reviews by people
This review was written by a machine. No person has reviewed this paper on Pith yet. A scientist listed on Pith can review it for a fee, and their review is published here whatever it concludes.
The paper
Abstract
Semantic communication jointly optimizes inference accuracy, channel use, and computation, yet the underlying communication program is typically specified before training. This paper presents ComRSI (Communications-Oriented Recursive Self-Improvement), a framework for recursively evolving that program through large-language-model-assisted code edits. An agent modifies the encoder, channel adapters, decoder, loss, and training policy; a protected evaluator screens candidates under prescribed budgets and resource constraints. Accepted code and textual feedback inform subsequent proposals, while candidate weights are trained from scratch. In the original ten-generation CIFAR-100 lineage, eight accepted revisions produce an attention-pooled code achieving 74.3% test accuracy over an Additive White Gaussian Noise (AWGN) channel at 32 complex symbols per image, compared with 67.2% at 256 symbols for the initial design. The program also improves fading-channel accuracy and transfers to Tiny-ImageNet after retraining, where a separate ComRSI search demonstrates further recursive improvements. A repeat study with ten searches per method compares ComRSI against non-recursive agents with and without textual history. Mean final search scores balancing accuracy, transmission rate, and computational cost are 0.7587, 0.7376, and 0.7089, respectively; the mean numbers of accepted revisions per search are 6.0, 5.0, and 2.1. The advantage over the memoryless agent is supported by a two-sided rank test, whereas the difference from the history-equipped agent remains statistically inconclusive at this sample size. Archived proposals show that pooling can yield a large improvement, while retained history supports subsequent refinement. These results support recursive program optimization within the evaluated setting and expose its remaining rate-robustness and compute-placement trade-offs.
The paper's own sentences, arranged, kept beside the review and separate from it. Each label is drawn from a closed vocabulary; the number beside it is the probability the classifier gave that label. No sentence in this record was written by a model.
abstract compiled · 2026-10-22
The authors' main claim, as the classifier picked it out 1.00
“These results support recursive program optimization within the evaluated setting and expose its remaining rate-robustness and compute-placement trade-offs.”
How the main claim is stated: asserted 0.69
What the abstract itself states, as probabilities: claims first 0.06 · states limitation 0.96 · human participants 0.02 · controlled comparison 0.96 · randomized assignment 0.02 · states quantitative result 0.99 · compares with prior results 0.97 · mentions code or data availability 0.04
The abstract, sentence by sentence
This table labels the abstract only (arXiv listing abstract v1). The number is the probability the classifier gave the label.
| Sentence | Role | The authors' own work | States the main conclusion | Strength |
|---|---|---|---|---|
| Semantic communication jointly optimizes inference accuracy, channel use, and computation, yet the underlying communication program is typically specified before training. | background 0.75 | 0.08 | 0.02 | asserted 0.99 |
| This paper presents ComRSI (Communications-Oriented Recursive Self-Improvement), a framework for recursively evolving that program through large-language-model-assisted code edits. | contribution 0.98 | 0.85 | 0.08 | asserted 0.99 |
| A fixed agent modifies the encoder, channel adapters, decoder, loss, and training policy; a protected evaluator screens candidates under prescribed budgets and resource constraints. | method 1.00 | 0.72 | 0.03 | asserted 0.99 |
| Accepted code and textual feedback inform subsequent proposals, while candidate weights are trained from scratch. | method 1.00 | 0.78 | 0.03 | asserted 0.99 |
| In the original ten-generation CIFAR-100 lineage, eight accepted revisions produce an attention-pooled code achieving 74.3% test accuracy over an Additive White Gaussian Noise (AWGN) channel at 32 complex symbols per image, compared with 67.2% at 256 symbols for the initial design. | result 1.00 | 0.95 | 0.11 | asserted 1.00 |
| The program also improves fading-channel accuracy and transfers to Tiny-ImageNet after retraining. | result 1.00 | 0.93 | 0.06 | asserted 1.00 |
| A repeat study with ten searches per method compares ComRSI against non-recursive agents with and without textual history. | method 0.82 | 0.94 | 0.03 | asserted 0.89 |
| Mean final search scores balancing accuracy, transmission rate, and computational cost are 0.7587, 0.7376, and 0.7089, respectively; the mean numbers of accepted revisions per search are 6.0, 5.0, and 2.1. | result 1.00 | 0.96 | 0.08 | asserted 1.00 |
| The advantage over the memoryless agent is supported by a two-sided rank test, whereas the difference from the history-equipped agent remains statistically inconclusive at this sample size. | result 0.63 | 0.95 | 0.07 | asserted 0.95 |
| Archived proposals show that pooling can yield a large improvement, while retained history supports subsequent refinement. | interpretation 0.78 | 0.87 | 0.08 | hedged possibility 0.59 |
| These results support recursive program optimization within the evaluated setting and expose its remaining rate-robustness and compute-placement trade-offs. | interpretation 0.99 | 0.84 | 0.85 | asserted 0.69 |
What kind of paper the classifier reports this is: method or tool 1.00 · evidence from simulation or computation 0.55
What was examined, and what was not
Sources read
- arXiv listing abstract v1
Not examined
- full text
- figures and tables
- references and citing sentences
- relations to other papers
Levels run
- P abstract
Not run
- S sections
- T body sentences
- C citations
- R cross-paper relations
How the labels were made
Compiled by classifier-1.13.0 via TypeSafe API, question bank abstract-p1-20260923, 2026-10-22: 1 request, 8,348 input tokens.
Every quoted sentence on this record is the authors'. Every label is from Pith's closed vocabulary, with the probability shown beside it. This record as JSON
Figures (7)
Figures are the authors', reproduced from the paper.
Challenges and discussion
Disagree with the review, or know something it missed? Leave a comment, or challenge this review formally: a challenge becomes a permanent entry in this paper's record, and its decision is published here.
Come back by email
A short list of the week's newly reviewed papers. Nothing is sent until you confirm from your inbox, and every email has a link that stops it. No account.
No comments yet.
Sign in to comment