Wednesday, September 30, 2026

Multimodal production work, such as building slides, narration, video and 3D assets from source recordings and documents, is still hard to do with general-purpose agents. Omni-IO Skills addresses this with a plug-and-play harness. It adds any-to-any capability across seven artifact types (text, image, audio, video, document, 3D and code) through loadable Skills, and it leaves the host agent's model and reasoning untouched.

• Its 27 Skills are split into 19 Atomic primitives (for example image generation or 3D understanding), 2 Expert workflows (Poster Design and Complex Video Production) and 6 Scenario Skills (for example Education Sharing and Game Asset), and higher-level Skills expand into lower-level ones until every step can be executed.
• Expanded tasks become a Declare Execution Graph that is checked for unresolved references and cycles, then run in "Waves" where independent nodes execute concurrently; when a node fails, only the steps that depend on it are cancelled, and model providers can be swapped through MCP tool and configuration layers without changing Skill definitions.
• An append-only, file-locked Asset Registry records each output with an ID, the turn it came from, and the asset it was derived from, so later turns can reuse or revise earlier outputs and regenerate only the parts that changed.
• On UniM-90, a 90-instance subset of UniM, the harness lifts input support for GPT-5.6 Sol and Claude Sonnet 5 from 40.00% and 38.89% to 100%, and raises relative Semantic–Quality Coupled Score (SQCS) from 26.99 to 74.94 and 27.82 to 77.78, with Strict Structure Scores of 100.00 and 99.78.
• Most of the relative gain comes from wider coverage, since absolute SQCS rises only from 67.49 to 74.94 and from 71.53 to 77.78, and those baselines were measured on smaller supported subsets; the evaluation is also small, has no ablations, uses a benchmark from the same research group, and reports almost no absolute coherence gain for Claude Sonnet 5 (82.29 to 83.28).

arXiv:2609.31847 PDF

As agents move toward long-horizon, cross-domain workflows, hand-engineering one harness per domain stops scaling, and no single harness generalizes across domains. Raven treats each executable model–harness pair as a composable unit, automatically builds and evolves specialized harnesses, and uses a Host Agent to orchestrate them across domains.

• The Host Agent breaks a goal into subtasks, assigns each to a registered specialist (native Raven-Research, Raven-Code, Raven-Design, Raven-Oncall, or third-party agents like Claude Code, Codex, and OpenClaw connected through adapters), and submits a typed dependency DAG that the runtime validates before dispatching nodes and passing artifacts between them.
• Experience carries across tasks in three ways: harness self-evolution (building on HarnessBank) diagnoses failures and tests candidate harnesses against a frozen model, a host archive plus the EverOS backend keep memory, and Skill Forge retrieves reusable procedures from local skills and SkillHub.
• A formal analysis gives sufficient conditions under which composition covers tasks that no single agent in the pool can reliably solve within the same total resource budget: complementary local capabilities, compatible handoffs, and bounded planning and execution errors, with a success lower bound of (1 − η)(1 − ε) that needs no independence assumption.
• On the new MAOB benchmark, which checks specialist selection and dependency prediction against reference graphs, Raven ranks first on all four graph metrics under both tested backbones, with Exact Match gains of 10.4 and 10.5 points over the strongest baseline.
• The limitations are significant: MAOB scores plans before any worker runs, so it says nothing about end-to-end outcomes. The theory offers sufficient conditions rather than guarantees for the implemented system. The evidence for harness evolution and skill reuse comes from the separately published HarnessBank and SkillCorpus experiments, where the curated skill library beat OpenClaw's gains on only two of three benchmarks.

arXiv:2609.33439 PDF

Post-training through RL and on-policy distillation produces large piles of self-generated rollouts that are usually thrown away once the policy moves on, even though they still hold behaviors the later checkpoint no longer produces reliably. ROSS reuses these historical rollouts in an offline SFT stage. It keeps each full trajectory as context but applies the loss only to the model-generated segments an LLM reviewer judges correct and useful.

• The pipeline keeps verifier-positive rollouts, has GLM-5.2 propose and then independently audit which token spans are worth imitating (for example, a recovery from an error but not the error itself), and trains the final checkpoint with a masked teacher-forcing loss, so no new policy rollouts are needed.
• The authors motivate the approach by showing that historical rollouts have NLL close to the current policy's own outputs, and that on hard problems the current policy reaches 99.0% pass@32 but only 37.7% pass@1, meaning it can still find these behaviors but doesn't produce them reliably.
• On Qwen3.6-35B-A3B, ROSS raises the six-benchmark MOPD average from 58.40% to 62.20% and SWE-bench Verified from 64.20% to 68.40%, beating continued RL/MOPD and plain positive-rollout SFT, which actually lowers the MOPD average to 57.70.
• Ablations with the same retained examples show that token-level masking alone adds +3.71 points on MOPD over unmasked training, and applying the same masked data to the original Base checkpoint reaches about the same scores, which suggests the value lies in the rollouts rather than in inherited parameter updates.
• The method depends on an expensive high-thinking LLM judge to annotate tens of thousands of trajectories; the main experiments cover a single model family; and instruction-following data gets no span masking, while excluded tokens stay substantial throughout training (up to about 28% in Code).

arXiv:2609.35954 PDF

Deep-research agents that keep refining one growing report run into three problems: context pressure, early findings anchoring the rest of the search, and wasteful full-report rewrites. LongCat-DeepResearch instead does its early iteration on a compact, executable plan called ResearchSpec, then hands sections to independent researchers and coordinates their drafts through targeted editing.

• Several Planning Writers search the web before proposing a plan, and a Judge, Critic and Reviser merge and refine the candidates into a validated ResearchSpec listing each section's scope, research questions, required entities and source leads; the spec is then fixed while parallel Researchers investigate and write their own cited sections in separate contexts.
• After the sections are assembled, a Global Editor assigns ownership of overlapping material and flags conflicts, and Local Editors revise only their assigned sections, so no single call has to regenerate the whole report; the same stage interfaces also produce the rubric-grounded tasks and trajectories used in LongCat mid-training and post-training.
• The system scores 55.25 on DeepResearchBench, 51.35 on DeepResearchBench II and 79.83 on ResearchRubrics, ahead of the best of the Gemini, ChatGPT and Claude Deep Research products by +0.30, +3.17 and +5.62 points, with the biggest dimension lead in analysis on DeepResearchBench II (60.69 vs. 52.26); on an in-house benchmark it places second at 76.04, 0.55 points behind ChatGPT.
• Ablations show the harness itself matters: moving the previous LongCat release from ReAct-style research with direct writing to the new harness lifts the three-benchmark average from 47.04 to 58.05, and the current model raises it to 62.14; collapsing planning to one writer or research to one whole-report researcher lowers development-subset scores.
• Limitations include weaker readability, presentation and citation-quality scores than some competitors, mixed returns from additional Critic/Reviser planning rounds, and no statistical significance testing; the ablations also run on previously inspected development subsets, and the contributions of training data and individual training stages are not isolated.

arXiv:2609.36071 PDF

On-policy distillation (training a student on its own generated text while the teacher scores it) breaks down when a weak student drifts into reasoning paths the teacher would rarely produce, so much of the teacher's feedback lands on unrepresentative states. SAKI has the student generate from a teacher-guided policy kept close to itself, and it uses each token's accept-or-correct outcome to decide how that token is supervised.

• Method: the guided policy q blends the student and teacher distributions under a trust-region limit KL(q‖p) ≤ ε (taken from TRB) and is sampled through maximal coupling, which keeps a student proposal with probability min(1, q/p) and otherwise draws a correction token; kept tokens get the usual reverse-KL update, while corrected positions get a direct loss on the teacher's top-1 token.
• Theory: the correction probability equals exactly TV(p, q), the lowest intervention rate any coupling can achieve, and it is bounded by √(ε/2), so one trust-region radius limits both how far generation drifts from the student and how often the teacher-token loss fires.
• Main results: distilling Qwen3-1.7B-Base and Qwen3-0.6B-Base from a Qwen3-4B-Base-GRPO teacher on DAPO-Math-17K and testing on seven math benchmarks, SAKI beats matched TRB by +1.1 Mean@8 / +2.9 Pass@8 at 1.7B (29.0 / 47.5) and +1.2 / +2.0 at 0.6B (18.4 / 35.6), and beats SKD by 4.5–6.3 points.
• Placement controls: giving teacher-token updates to the same number of positions chosen at random (Random-TM, 28.30 / 45.50) or weighted by TV (TV-Weighted-TM, 28.24 / 46.77) does worse than using coupling corrections, and a fixed-prefix probe shows the student's probability on the teacher's top-1 token stays +4.26 pp above TRB at step 200, long after corrections stop at step 51.
• Systems and limitations: a speculative verifier inside the inference engine speeds up exact guided sampling by 4.22× (3,276 vs 776 tokens/s) but still reaches only about 42% of student-only throughput; the gains are about one Mean@8 point, come from single runs on math tasks with small models, require the student and teacher to share a tokenizer, and use correction-routed supervision only during the first 50 of 200 steps.

arXiv:2609.36601 PDF

Agents that search a large document collection with plain tools like grep have to work out, for every query, how the documents relate to each other, so they often miss evidence split across sources and use a lot of tokens doing it. CorpusMap works out those links once, offline: it finds the entities that recur across documents (people, projects, incidents), merges the different mentions of each one, and gives the agent a page per entity that links to every document mentioning it.

• How it works: an LLM first proposes a catalog of entity types from the corpus itself; mentions are then extracted and matched against a shared registry, where each one is linked to an existing entity, added as a new one, or left unresolved; only entities that appear in at least two documents get an Entity Page, a set of source-tagged facts plus links, stored as a file next to the raw documents and searchable with the same shell tools.
• Main results: across EnterpriseRAG-Bench, WixQA and HERB with four GPT models, it raises overall quality over raw-corpus agentic search by 6.4–11.7 points while using 34–57% fewer input tokens; for example, GPT-5.5 goes from 66.11 to 72.55 at 0.43× the tokens, and EnterpriseRAG-Bench document recall rises from 61.62 to 76.17.
• Against other approaches: LLM Wiki, Corpus2Skill and page-per-document or page-per-folder layers often fail to beat the raw corpus at all, and retrieve-then-generate methods trail it on EnterpriseRAG-Bench (HippoRAG scores 64.66 and GraphRAG 47.95, against 76.60); the gains also hold for DeepSeek-V4-Pro, MAI-Thinking-1 and the open-weight Qwen3.8-27B.
• Practicality: a map built by the cheap GPT-5.6 Luna for ≤$74.65 still improves every answering model, a version built with no LLM calls using GLinker performs about as well as the LLM-built map, and the map can be updated incrementally as new documents arrive instead of being rebuilt.
• Limitations: building the map with a strong model costs up to about $4,700 and only pays for itself after enough queries; gains on HERB are small (for example 62.31 to 64.37 with GPT-5.5, while Luna uses more tokens there than on the raw corpus); a clear gap to the gold-document oracle remains (72.55 vs 79.62); and gathering everything about a person or project onto one page raises privacy and access-control concerns.

arXiv:2609.37226 PDF

Agents that handle general computer tasks still can't reliably run professional engineering software, where a design has to satisfy geometric and physical constraints and keep dependencies intact across tools and design stages. EngiWorld tests agents on the whole design loop and grades the engineering files they produce, using programmatic domain verifiers rather than checking the final screen state or matching a reference.

• The benchmark has 1,301 expert-curated tasks covering CAD, CAE (simulation), CAM (manufacturing), BIM (building models), EDA (electronic design) and 3D visualization, run on 26 professional platforms such as SolidWorks, ANSYS, Abaqus, KiCad, OpenFOAM and Blender, through either a GUI (610 tasks) or a CLI (691 tasks).
• There are six task types: image-based modeling, choosing the right software, single-software execution, quantitative design, multi-software workflows and open-ended tasks; verifiers reopen the submitted files (for example STEP files, netlists or G-code) to check geometry, topology, simulation outputs and consistency between stages, and quantitative design tasks earn a continuous quality score only after passing a feasibility check.
• Seven frontier models were tested zero-shot on a stratified subset of 300 tasks: Claude Opus 5 leads with an EngiScore of 44.3, followed by GPT-5.6 Sol at 38.0, while every other model scores 26 or below, and all seven models score zero on 128 of the 300 tasks.
• The hardest step is moving work between tools: only 6 of 168 multi-software attempts (3.6%) succeed across all models, CAM is the weakest domain for every model, and strong CLI results don't carry over to the GUI, with DeepSeek V4.1 Flash scoring 48.3 on CLI but 2.0 on GUI.
• Two failure modes account for 94.1% of failures: running out of decision turns, and declaring a task finished (DONE) without producing a verified artifact, which covers 87.0% of GPT-5.6 Sol's failures and 73.9% of Claude Opus 5's; the results come from the 300-task subset rather than the full benchmark, and the top model costs about $19 per task.

arXiv:2609.37686 PDF

Pretrained-encoder latents such as DINOv3 support strong image generation but lose the fine detail needed for faithful reconstruction, and naively fusing intermediate encoder layers tends to yield latents that are harder for a generator to model. HiRAE learns a fusion over the full encoder hierarchy as bounded residual corrections to the deepest-layer representation, so it gains reconstruction detail without drifting away from a generation-friendly latent space.

• Each of the 24 frozen DINOv3-L layers gets its own MLP expert, and a signed, spatially varying router mixes them into shallow, middle, and deep groups; each group's residual is norm-capped relative to the deep anchor, at 0.025, 0.075, and 0.15 of its norm respectively, with stronger dropout for shallower groups, and the fusion module and decoder are trained jointly in one stage while the 16×16×1024 latent shape stays unchanged.
• On ImageNet-256, HiRAE-24 cuts reconstruction FID from 0.299 to 0.209 (about 30%) relative to RAEv2, raises PSNR from 22.67 to 26.38 dB and lowers LPIPS from 0.074 to 0.043, while guided generation FID after 80 epochs edges down from 1.060 to 1.038.
• In text-to-image generation it beats RAEv2 on GenEval, DPG-Bench, and GenAI-Bench both before and after supervised fine-tuning, and post-fine-tuning GenEval rises from 84.86 to 87.70.
• The ablations show that reconstruction alone is a poor guide: unbounded or DRoRAE-style fusion reaches much lower reconstruction FID (0.023–0.065) but degrades guided generation FID to between 1.55 and 7.9, so the residual budgets are what keep the latent generation-friendly.
• The gains have limits: without guidance, HiRAE-24's generation FID (2.129) remains worse than RAEv2's 1.650, the caps and dropout rates are hand-set hyperparameters, and all experiments run at 256×256 resolution.

arXiv:2609.37775 PDF

When a GRPO-style RLVR run samples a prompt and every rollout fails, the group gives no policy-gradient signal, yet a different model trained on the same prompts has often already solved it. GRAFT exploits this: it replaces a model's all-fail groups with the corresponding rollout groups from a peer model with a different architecture and tokenizer, then controls the off-policy mismatch so both models improve without a designated stronger teacher.

• A receiver takes a peer group only when its own rollouts all fail and the peer's group has both successes and failures; transfer is balanced across the two directions, and the peer's full group keeps its original, peer-computed advantages rather than being re-normalized or pooled with the receiver's rewards.
• Cross-model mismatch is handled in three ways: a sequence-level compatibility score compares average token log-likelihoods and drops peer responses scoring at or below δ = 0.8, capping kept ones at weight 1; token-level PPO clipping is measured against the receiver's own previous policy; and peer minibatches are processed last, so clipping is already active when they arrive.
• Across three pairings of SmolLM3-3B-Base, Qwen3-1.7B-Base and OctoThinker-3B-Hybrid-Base on five math benchmarks (MATH500, AIME24/25, AMC23, Minerva), GRAFT beats GRPO at the same 8 rollouts per prompt by 2.1 points on average and up to 4.5, and outperforms the co-training baselines HACPO and SGT by 4.0 and 1.5 points.
• In two of the three pairs both models match or beat GRPO with 4× the rollouts, and on the SmolLM3–Qwen3 pair GRAFT scores 1.18 points above it at 0.45× the GPU-hours, while reusing stored peer trajectories without live co-training keeps most of the gain (+1.8 vs +2.1) at 27–76% less compute.
• Gains depend on how complementary the two models are (as low as +0.66 on the weakest pairing), the compatibility score is only a proxy when tokenizers differ, and the study covers only two-model pairs of base models up to 3B on math, with best checkpoints chosen on validation drawn from the evaluation benchmarks.

arXiv:2609.37868 PDF

Long-video question answering often depends on following one specific object or person across hours or days, but memories built from captions or text-extracted entities can't tell two similar "red mugs" apart, and they split one object across differently worded descriptions. Grounded Entity Biographies (GEB) links visually grounded observations of the same physical object into a time-ordered "biography" connected to episodic memory, so retrieval can follow an entity from one event to the others.

• How memory is built: an open-vocabulary detector (YOLOE) and a within-clip tracker (BoT-SORT) produce observations, which Qwen3.5-35B describes from crops, scene frames and nearby narration. A new observation joins an existing entity only if it clears a consistency threshold against every recent reference, strongly matches at least one, and is never seen apart from any of them in the same frames (a bounding-box IoU veto).
• How retrieval works: Personalized PageRank spreads relevance from matched observations through same-object edges to that object's other appearances and their surrounding episodes. The controller also sees a list of appearances it hasn't inspected yet, which gives it concrete targets for its next search.
• Main results: with the same Qwen3.5-35B controller and answer model as the baselines, GEB reaches 72.0% on EgoLifeQA (+4.4 points over MAGIC-Video), 71.3% on Ego-R1-Bench (+6.6 points), and 36.83% on MM-Lifelong Test@Week (+5.41 points over WorldMM). Retrieved context reaches the annotated evidence window for 58.9% of EgoLifeQA questions, up from 37.6%.
• Ablations: dropping association costs 3.4 points, grouping by described name costs 2.8, and simply appending descriptions to captions costs 3.8. This suggests the gain comes from physical-instance identity, not just from extra text.
• Limitations: the 0.83-point lead on the gameplay Test@Day split is within noise, since its confidence interval includes zero. On MultiHop-EgoQA, the answer model reading 60 whole-clip frames without any memory still scores higher (3.64 vs 3.11). The association thresholds are set per recording by visual inspection, and the graph is about 17 times larger than MAGIC-Video's (roughly 350K nodes for one week), with about 13.6 s of retrieval per question.

arXiv:2609.38155 PDF