Wednesday, October 21, 2026

LLM kernel generators mostly target server GPUs. Edge devices are harder targets: their hardware and software stacks are fragmented, and memory budgets are tight. The approach here has the LLM write its computation, scheduling, and memory decisions in one shared IR, which deterministic TVM-based adapters then lower to each backend; the benchmark comes with a layered agent that optimizes one IR level at a time.

• The benchmark has 331 PyTorch tasks, organized by complexity (single operators, composed operator graphs, compact model graphs such as MobileNetV2 and TinyLlama decoder blocks) and by edge domain, and is instantiated as 650 task instances across CPU/LLVM (Snapdragon 8 Gen 3), CUDA (Jetson AGX Orin), and OpenCL (Mali-G610) backends.
• In one-shot generation against a tuned MetaSchedule baseline, the best model reaches 64.5% Correct@1 but only 25.5% Fast@1.0, and the top Fast@1.0 falls from 51.0% at Level 1 to just 0–4% at Level 3, so correct code rarely turns out faster than the compiler.
• Memory errors (34.0% of failures, mostly about allocation legality rather than running out of capacity) and syntax/API errors (25.4%) dominate, and models with strong correctness don't necessarily produce fast code: DeepSeek-V4-Pro hits 75.3% correctness on CPU Level 2 but only 3.2% Fast@1.0 there.
• LEKA gives each IR level its own agent (Relax graph, TIR schedule, then CUDA/OpenCL/LLVM code), keeps a candidate tree that records how each candidate was derived, and sends each hardware profiling result to the level that owns the relevant decision.
• On a 69-instance subset, with the same GLM-5.3-Flash base model and the same time budget, LEKA raises Fast@1.0 to 43.5%, compared with 13.0% for one-shot generation and 26.1% for Claude Code, and is 3.8× faster than Claude Code by geometric mean; however, the gain shrinks to 2.9× at Level 3, the agent was tested on only a small sample, and only one compiler stack (TVM) was evaluated.

arXiv:2610.24648 PDF

Most research agents work within a single model session, but real investigations often take far longer. Épi is built to carry one investigation across many sessions. It keeps a persistent research state, uses hierarchical memory and versioned branches, and gets independent review from a second model, while a fixed verifier checks every candidate result before it counts as an improvement.

• Short-term memory holds the current state and handover notes, long-term memory stores reusable lessons and documented dead ends, and every alternative method lives on a versioned branch the agent can backtrack to; all of this runs on Breadboard infrastructure with model weights (GPT-5.6 Sol, GPT-6-Astra) kept fixed.
• Across mathematical campaigns Épi set 120 records: 20 numerical bounds across 12 families and 100 constructions across eight families (97 of them geometric packings), including an ~84-fold narrower interval for the n-queens constant and a >3.6-million-fold narrower rigorous interval for the quartic Feigenbaum attractor dimension.
• Exact dual certificates show the Cohn–Elkies linear-programming bound cannot be sharp in dimensions 10 and 11, with lower bounds exceeding known packing upper bounds by about 0.35% and 1.92%; separately, exact certificates for 560 neighborhood profiles plus a truncation lemma give a computer-assisted proof of Tuza's conjecture for split graphs with an eight-vertex clique part and at most three triangle-active neighborhood types.
• The lightweight Épi-turbo configuration beat Codex on 30 FrontierOR operations-research tasks, using the same model and a $20 budget per task: it scored 53.96 vs. 51.21 (5.4% higher) at 64% of the model cost ($7.30 vs. $11.35 mean per task), with a median research time of 22 vs. 37 minutes.
• Limitations: FrontierOR results come from one run per task with no significance testing, and the advantage comes mostly from faster programs, since in direct comparisons on 119 instances Codex found the better solution 61 times versus 18 for Épi-turbo.

arXiv:2610.24944 PDF

Agents that co-evolve their harness (the tools, prompts and control flow around the model) and their model weights suffer from a "brain–body mismatch": the evolved harness asks for behaviors the model never learned, or blocks capabilities it already has. CoEvo-RSI addresses this with bidirectional historical inheritance: a meta-agent draws on a shared archive of past harnesses, model checkpoints and their outcomes, choosing which earlier harness design to build on and which earlier checkpoints to reuse or merge for it, instead of always pairing the latest model with the latest harness.

• Each round, a Curator diagnoses failures and pulls relevant history from the archive, eight independent editors each pick a historical base harness to modify, and the meta-agent either selects a single checkpoint or blends several with TIES-Merging, scoring candidates by task score and a new diagnostic, the Turn-level Interface Mismatch Rate (TIMR: the share of model turns with malformed outputs or calls to unavailable tools); the chosen pair is then refined with SFT on its own verifier-accepted trajectories.
• On failure attribution, Qwen3.5-9B reaches 70.78% agent accuracy on TraceElephant (+14.16 over DeepSeek-V4-Pro) and 69.43% on Who&When Pro (vs. 65.03% for Qwen3.8-Max), and on Who&When Hand it scores 68.39% at 22× lower inference cost than DeepSeek-V4.1-Flash.
• In other domains it achieves the best Safe-EX on RBAC Spider (80.85%, with a 1.57% access-violation rate) and raises the HomeBench valid multi-device success rate from 10.91% to 75.51%, 4.90 points above GLM-5.3.
• In ablations, evolving only the harness keeps TIMR above 1% in eight of ten rounds (full method: at most 0.22%), and the best RBAC result came from reviving a round-3 checkpoint in round 10, a pairing a latest-only approach would miss; a three-round run costs about $2.72 in API fees and 17.5 hours.
• Limitations: the evolved pairs are explicitly domain-specialized with no claim of cross-domain transfer, the method trails baselines on Who&When Algo. (62.17% vs. 68.25%) and on step-level accuracy where RL baselines win, its out-of-distribution BIRD Safe-EX (60.15%) lags coding-agent harnesses (about 71–75%), and TIMR captures only interface-level mismatch, not deeper capability gaps.

arXiv:2610.25078 PDF

Diffusion models are expensive to train, and inference-time guidance such as autoguidance improves samples only by running extra model evaluations at every sampling step. SWIFT moves that weak-to-strong correction into training: it pushes each clean regression target further away from what a frozen weak denoiser predicts. The final model is a single denoiser that uses the original sampler.

• The training target becomes y = x0 + α(x0 − D_weak(x_t)), where D_weak is a frozen, smaller or earlier-checkpoint denoiser that runs without gradients; this costs about 9% extra FLOPs per step plus roughly 10 baseline-equivalent epochs to pretrain the guide, and the guide is discarded after training.
• A spectral analysis of finite-time kernel gradient flow in an RKHS proves that, with an early-stopped guide, some nonempty range of positive α gives strictly lower posterior-mean error than standard training run for the same time, even though the shifted target is itself biased.
• On ImageNet-256 with RAEv2/DINOv3-L, unguided FID drops from 1.56 to 1.15 and guided FID from 1.04 to 0.99, while the best internal-guidance scale falls from 1.78 to 1.20, which suggests training has absorbed part of the guidance correction.
• One fixed recipe (α = 0.4) lowers unguided FID in all 18 DiffusionBench configurations, covering VAE, representation-autoencoder, end-to-end latent, and pixel-space models, by 16.3–49.4% (median 31.3%), and guided FID also improves in every configuration.
• On DINOv2-B, SWIFT reaches FID 1.50 at epoch 120, beating the baseline's best of 1.53 through 320 epochs with about 0.45× the training FLOPs even after counting guide costs; limitations are that the theory covers denoising MSE rather than FID, performance is U-shaped in α with a model-dependent optimum, and guides that are too small or undertrained degrade results quickly.

arXiv:2610.25844 PDF

Rubric rewards for open-ended RL tend to break down as training goes on. Either scores collapse to uniformly low or high values and stop separating responses, or they separate responses in ways that don't track quality: in a rubric-based GRPO run, 61.6% of response pairs fell into one of these failure modes. HarnessRL addresses this with a training-time harness that changes task sampling, rollout guidance and rubric criteria alongside the policy, and it checks each change on the current frozen policy before applying it.

• An evolver uses a memory of each task's history plus similar criteria from other tasks to sort each criterion into one of three failures: blind (the policy can't produce what the criterion asks for, fixed by adding guidance to the rollout prompt), saturated (every rollout already passes, fixed by sampling that task less often) or spurious (rewards surface cues rather than quality, fixed by rewriting the rubric); a proposer drafts each update, and a just-in-time critic accepts it only if its measured reward effect falls within a calibrated band.
• On the new five-domain Rubric-Mix-10k suite, Qwen3.5-4B reaches 64.5 in-domain and 49.8 out-of-distribution (OOD), which is +3.0 / +2.8 over the strongest baseline AMARIS++; at Qwen3.5-9B it reaches 69.5 / 57.3, a margin of +2.9 / +3.1, and it wins on every seed with p < 0.001.
• Agreement between reward rankings and an oracle judge rises to 48.9% versus 38.4% for GRPO, and only 1.6% of rubric edits are later reversed, against 18.2% for AMARIS++.
• Ablations show the gains depend on the critic and the memory together: without the critic, OOD falls to 45.9, below AMARIS++, and removing memory as well leaves 44.1, within 0.2 points of plain GRPO.
• The harness costs 1.6× GRPO's compute per step, but the best OOD checkpoint arrives at step 250 instead of 475 (17.5 versus 20.4 cluster hours); the gain is smallest on instruction following (+0.9), and the frozen gemma-4-31B-it judge also runs every evolver role, so how well the method depends on judge quality is untested.

arXiv:2610.26426 PDF

Enterprise agents answering questions over workplace records must cope with information that is shared, corrected and revised across chats, emails, documents and figures, while the old versions stay in the workspace. MMEnterprise-Bench tests this with 1,613 questions over 30 simulated collaboration projects whose superseded records are kept rather than overwritten, so the 7,140-record retrieval corpus contains both cross-source and temporal conflicts.

• Each project starts from a public paper or government report; an LLM plans a timeline of collaborative events, such as sharing a result, spotting an error and issuing a correction, and turns them into Slack messages, Notion entries, emails, slides and PDF pages, with 5,725 textual and 1,415 visual records in total.
• Questions fall into three categories: Evidence Reasoning, which has five subtypes; Conflict Resolution, split into cross-source and temporal; and Unanswerability. They come from rule-based and LLM generation, are filtered by LLM validation, and none of 50 LLM-accepted items was rejected in a blind three-person human check.
• In a RAG setup using Qwen3-VL-Embedding-2B retrieval, the best of 10 models, GPT-5.6 Sol, reaches only 52.6% at k=10 and 68.0% at k=50, while the best open model, Qwen3.5-27B, reaches 50.3% at k=50.
• Conflict questions are the hardest: at k=10, accuracy ranges from 11.8–36.3% on cross-source conflicts and 13.2–33.5% on temporal ones, and GPT-5.6 Sol drops from 83.3% on single-text-record questions to 27.5% when the evidence spans multiple images.
• Better retrieval does not reliably help: a larger 8B retriever and k up to 100 raise evidence recall from 41.3% to 67.3%, but smaller models stagnate or decline. Strong overall accuracy also doesn't mean good abstention, since GPT-5.6 Sol scores 65.5% on unanswerable questions against 87.4% for Gemini 3.8 Flash. Limitations include records that are simulated and LLM-generated, a small unanswerable set of 87 questions, and an automatic judge (GPT-5.6 Luna) that is itself one of the evaluated models.

arXiv:2610.27911 PDF

Agentic VLMs (vision-language models) for 3D spatial reasoning often get the right evidence from their perception tools and still answer wrong, because the model misreads the measurements or ignores them. S-Agent 2.0 addresses this with no training: it gives a stock general-purpose coding agent a command-line perception toolkit, which stores everything it measures in a persistent scene memory and returns each reading already stated in plain spatial language.

• The toolkit wraps frozen off-the-shelf models: Depth Anything 3, GeoCalib and π³ build a metric, gravity-aligned reconstruction, and SAM 3 segments objects from text prompts; the agent can also add instances of its own (such as an imagined observer) with add_instance, remove bad tool detections with drop, and read sizes, distances, directions and motion straight from the stored geometry by object name.
• With the open Qwen3.8-27B backbone it scores 66.5 on MMSI-Bench and 82.3 on ReVSI, ahead of the specialized SpatialClaw system on the same backbone (62.6 and 74.5), and the toolkit adds +13.9 and +20.5 points over the same agent without tools; it also leads every agentic baseline on MindCube, SPAR-Bench and MMSI-Video-Bench.
• With Gemini-3.8-Flash it reaches 74.1 and 90.5, the highest averages among all compared models including GPT-6, and its tool gain on ReVSI stays at +9.6, while SpatialClaw's drops from +13.2 to +2.7.
• In ablations, removing the model's ability to add and drop instances hurts most (−8.8 on MMSI-Bench, −5.9 on ReVSI), more than removing the scene memory (−3.5/−2.5) or the plain-language readouts (−1.3/−1.2), and the method holds up when the OpenHands harness is swapped for Codex or Claude Code (82.3, 76.6 and 79.1 on ReVSI).
• On limitations, the remaining errors come from turning the question into the right measurement, such as simulating an imagined viewpoint wrongly or measuring an object's elevation when the question asks for its height; absolute distance still trails SpatialClaw, and GPT-6 keeps the lead on some MMSI-Bench categories, such as camera motion and multi-step reasoning.

arXiv:2610.28354 PDF

Decision models handle routing, guardrails and output verification in LLM systems, but item accuracy alone hides whether they react correctly when one decisive detail changes, and whether their confidence can be trusted. DecisionPivot tests both with 48 tasks and 40,033 items across seven decision roles: a generated core track of contrast groups whose answers are checked by independent solvers, plus a reference track of 35 public test sets.

• The core track has 7,800 items from 13 Python-generated task families, such as filter_match, state_goal and toolcall_valid, in which members of a contrast group differ only in a pivotal detail (for example, a shipping fee that puts a total one cent above or below a limit); a group counts as correct under "pair accuracy" only when every member is answered correctly.
• Aggregate scores hide large gaps: Perplexity Decider and JEV-27B differ by only 2.6 reference-score points but reach 70.1% vs 44.2% core pair accuracy, and 19 of 40 decision models fall below the 16.1% uniform-guess baseline on pair accuracy.
• Probability ordering does not guarantee correct decisions: across 2,400 binary pairs, Perplexity Decider ranks the positive member higher 92.3% of the time but gets both members right only 74.1% of the time, and models with near-identical accuracy, such as Kev 27B (70.6%) and JEV-27B (70.3%), differ in how accurate their high-confidence predictions are (93.8% vs 88.9% at confidence ≥0.90).
• Reasoning helps a lot on arithmetic and temporal contrasts: GLM-5.3 rises from 81.5% to 93.5% pair accuracy at a higher effort setting, and the authors' SL-27B AutoThink reaches 86.9% versus 75.4% for its one-pass Instant variant, although its reference score barely changes (58.9 vs 59.4).
• The main caveats are that the benchmark and the top-ranked StartLux-Decision models come from the same team, the selective-coverage numbers are computed after the fact on evaluation labels, the difficulty levels raise case size and complexity together, and the fresh-sample checks only test stability within the existing generator designs.

arXiv:2610.28522 PDF

Sage-A1.5 is a 35B Mixture-of-Experts agent model built on Agents-A1. It targets long-horizon tasks where step-by-step execution degrades: the context keeps growing, searches repeat, and errors compound. Its core idea is to train capability composition, meaning how work is decomposed, delegated, checked and revised, as a learned model skill rather than leaving it to rules in an external harness.

• Agentic Orchestration has a main agent split work across parallel subagents with isolated contexts, either as alternative hypotheses (exploratory, A∨B∨C) or as complementary subproblems (constructive, A∧B∧C), with each subagent returning a structured self-assessment, its evidence and any open issues.
• Agentic Verification is learned from trajectories in which a supervisor model inserted reflections at stalls, repeated searches or key conclusions; the supervisor prompts are then removed, so at inference the model verifies inside its own reasoning, switched on by a system-prompt flag (Verification protocol:enabled) and with no online verifier.
• Training first fine-tunes multi-domain teachers on curated data, such as an automated Kaggle-to-task factory for ML engineering with windowed-interaction RL (WIRL), leakage-controlled SWE environments, and 3,512 recursively evolved long-context QA pairs on which Qwen3.5-35B-A3B scores only 31.57%; a unified stage then mixes outcome-based RL with multi-teacher on-policy distillation, chosen per sample.
• The authors report that it beats the much larger Kimi-K3, GLM-5.3 and GPT-5.6-sol on FrontierScience-Olympiad, CMT, PinchBench and IFBench, stays competitive on SWE-Bench Pro and BrowseComp, and matches or beats same-size Agents-A1 and Ornith-1.5 on all twelve benchmarks, though the extracted text gives no per-benchmark scores.
• Limitations: the verification-driven context compression is only planned future work; the roughly 80% memory saving claimed for the pVisor sandbox comes from preliminary static tests with one run per condition; and much of the capability is distilled from stronger teacher models.

arXiv:2610.28578 PDF

Computer-use agents usually work through fixed interfaces that people design by hand, so an agent may end up typing a spreadsheet cell by cell or reading terminal output from screenshots. Agent S4 instead treats interface design as something the agent learns: a meta-agent studies task trajectories and evolves a repository of executable interfaces, plus notes on when to use each one, while the task agent's model and harness stay fixed.

• The meta-agent reads trajectories from synthetic training tasks that carry no success labels, then mutates one parent repository or crosses over two; parents are picked by binary tournament on validation scores that the meta-agent never sees, which pushes toward changes that generalize beyond the tasks it studied.
• On the 108-task OSWorld V2, Qwen3.8-27B with the evolved repository reaches 21.3% binary success at $1.10 per task, compared with 5.56% for Qwen CUA running the same model on fixed interfaces, and above the reported 13.0% for GPT-5.5 ($25.50) and 20.6% for Claude Opus 4.8 ($72.40), although those frontier numbers are taken from the benchmark paper rather than re-run.
• On ScienceBoard, a separate evolution run lifts success to 58.6% against 41.4% for Qwen CUA and grows the repository from 15 to 64 functions, with the largest gain on KAlgebra (48% to 68%).
• Much of the improvement comes from the hand-built seed repository and the Prime Agent harness rather than from evolution itself: on OSWorld V2, binary success goes from 15.74% with no repository to 19.44% with the seed and 21.30% after evolution, which is only two extra tasks out of 108, and on ScienceBoard evolution adds about 3.5 points over the seed's 55.03%.
• Run-to-run variance is substantial, since one repository that scored 73.33% on its first validation run averaged 60.00% on re-evaluation; giving the meta-agent a scratch VM raised partial score but not binary success, and the reported costs leave out the price of building the repository.

arXiv:2610.28601 PDF