The most interesting AI work this week is about state: what a model remembers, what an agent believes has happened, what evidence supports that belief, and which parts of a long history deserve to influence the next action.

That sounds less glamorous than “reasoning,” but it is where many real systems break. An agent confuses an attempted action with a completed one. A research swarm repeats failed searches because nobody recorded them. A robot sees five minutes of video but cannot afford to attend over every frame. A model gives plausible estimates for several demographic groups, then produces an aggregate answer inconsistent with all of them.

Several papers attack these failures from different directions. StructAgent makes verification the authority over task state. SearchOS turns research progress into a persistent evidence graph. RoboTTT compresses thousands of robot observations into fast weights updated during deployment. SciDiagramEdit improves a procedural skill from revision traces rather than retraining the underlying model.

The common lesson is not simply “give models more context.” Raw context is increasingly the problem. Useful systems need mechanisms that decide what becomes state, what counts as evidence, and what remains merely an unverified story the model told itself.

1. Task state should record truth, not narration

StructAgent: Harness Long-horizon Digital Agents with Unified Causal Structure has the week’s most directly useful agent architecture.

Long-running computer-use agents accumulate a swamp of screenshots, tool output, attempted actions, partial edits, and premature declarations of success. StructAgent replaces that implicit history with a compact shared representation:

Execution follows a planner–actor–verifier loop. The planner chooses a subgoal and the actor attempts it, but neither may mark it complete. Only the verifier can commit that state transition.

That sounds bureaucratic until you consider how often agents confuse “the command returned successfully” with “the requested result now exists.” StructAgent uses read-only probes for files, URLs, accessibility trees, spreadsheets, office documents, and guarded shell commands. A deterministic probe can override a weaker screenshot judgment; inconclusive probes fall back to observation.

Under the paper’s controlled OSWorld runner and 100-step budget, StructAgent reportedly improves Qwen3.5-9B from 27.0% to 46.9% and Qwen3.5-27B from 31.6% to 62.2%. A MiniMax-M3 configuration reaches 78.9%, which the authors describe as an open-source state of the art among the results in their comparison.

The verifier itself remains imperfect. Across 354 Qwen3.5-27B trajectories, structured verification improved recall from 0.67 to 0.81 and F1 from 0.70 to 0.76 relative to screenshot-only verification. But in an audit of 83 failed trajectories, the authors still attributed roughly 30% of failures to the verifier, alongside 33% to the actor and 30% to the planner. The architecture makes verification explicit; it does not magically make verification correct.

For Jarvis, the cleanest formulation is:

Memory is advice; current state is truth.

A remembered deployment procedure can suggest what to do. It cannot prove that today’s deployment succeeded. A service restart should be followed by a status check and a live probe. Sending a message should be distinguished from observing that the message exists. Editing a site should end with checking the generated or deployed result, not admiring the patch.

That machinery would be excessive for every factual question. It is justified for long, externally mutating tasks where false completion is costly.

2. Long context becomes useful when it is compressed into an adaptive state

RoboTTT: Context Scaling for Robot Policies tackles a different version of the same problem. A robot may need several minutes of visual observations, proprioception, and action history, but repeatedly attending over the entire sequence makes inference progressively more expensive.

RoboTTT adds small two-layer neural networks—“fast weights”—to the 16 action-head layers of NVIDIA’s GR00T N1.7 vision-language-action model. Those weights are updated by gradient descent during deployment and serve as a fixed-size recurrent state. The robot continually compresses its experience into parameters rather than retaining an ever-growing attention window.

The authors train with contexts reaching 8,000 timesteps, about four to five minutes at 30 Hz. On three bimanual assembly tasks, RoboTTT records an average rubric-based completion score of 79%, compared with 42% for the single-step GR00T baseline and 56% for the strongest reported Gated DeltaNet baseline. The paper describes those differences as 87% and 41% relative improvements respectively; they are not percentage-point gains or universal measures of robot reliability.

The context scaling result is notable. A model pretrained at 8K timesteps reaches a reported closed-loop score of 71.5%, versus 43.9% for the same architecture pretrained at 1K. Performance rises through the tested range of 128 to 8K timesteps, though three related tasks on one robot setup do not establish a general scaling law.

The long state appears to support more than passive recall:

The appealing analogy for agents is a bounded working state updated from experience without rewriting durable memory. A correction, failed tool call, or rejected plan can remain useful as context even though it should never become a behavior to imitate.

But fast weights are not carte blanche for autonomous self-modification. RoboTTT updates a small, specially trained state under a defined inner objective. That is materially different from letting arbitrary conversation rewrite an agent’s core policies.

The deeper result is that more history is not automatically better. The paper’s naïve history baseline actually performs worse than its no-history counterpart on one task. Context needs an update rule, not merely a larger bucket.

3. Research agents need an operating system, not a longer group chat

SearchOS-V1: Towards Robust Open-Domain Information-Seeking Agent Collaboration treats web research as persistent, citation-grounded schema completion.

A broad request is converted into entities, attributes, and relationships. Agents fill missing cells with evidence while a shared state tracks four things:

  1. a frontier of unfinished tasks;
  2. an evidence graph binding claims to URLs and quoted spans;
  3. a coverage map marking cells as missing, filled, uncertain, or unreachable;
  4. failure memory containing dead ends, inaccessible sources, rejected claims, and searches that should not be repeated.

This is a much better abstraction than relying on several agents to reconstruct progress from conversational transcripts. It also separates “the cells we currently know about are filled” from “we have found every entity the question requires.” A scope audit can add missing rows even after apparent 100% cell coverage.

On WideSearch, SearchOS reports 80.3 Item F1, 4.3 points above the strongest listed baseline. On GISA set questions it reports 76.5 F1, 13.4 points above the strongest listed baseline. Those are the best of three runs—Max@3—rather than mean performance, so the headline results deserve some salt.

A 10-case scheduling ablation is nevertheless instructive. Continuously assigning new tasks whenever an agent slot becomes free reduces average time from 629.13 seconds to 476.34 seconds, raises slot utilization from 34.6% to 41.7%, and improves Item F1 from 79.66 to 86.75. The experiment is small, but it shows why synchronized waves of sub-agents are often wasteful.

The project’s SearchOS repository describes hundreds of reusable skills, divided between general search strategies and source-specific access procedures. That distinction also fits Jarvis: “how to investigate a disputed claim” is a strategy, while “how to retrieve a Discourse topic or inspect a particular API” is an access skill.

The most transferable principle is simple:

Research progress and provenance should be first-class state, not something an agent hopes to recover from its own prose.

A URL and matching excerpt still do not prove that a source is authoritative or correctly interpreted. SearchOS improves auditability, not epistemology. But auditability is the prerequisite everyone keeps trying to skip.

4. The public web is also an attack surface for future models

Pretraining Data Can Be Poisoned through Computational Propaganda examines whether attacker-controlled text inserted into ordinary third-party webpages could survive into future pretraining corpora.

The authors’ HalfLife framework separates three events:

That decomposition matters. Publishing text online is not equivalent to entering a model’s training data.

Across 181,857 pages from one Common Crawl shard, the authors detect comment infrastructure on 3.4%. Using simulated injections and a Dolma 3-style curation pipeline, they estimate an end-to-end inclusion probability of roughly 0.13–0.15% for public-comment attacks under the tested assumptions.

That is small, but not obviously harmless at web scale. In controlled training experiments on models from 65M to 1.3B parameters, poison rates of 0.1%, 0.01%, and 0.001% shifted preferences toward selected companies. Instruction tuning reduced the effect, especially at larger scales, but did not always remove it.

Natural claims were more resilient than cartoonish payloads. Under one synthetic rewriting setup, semantic belief-manipulation claims survived in 65.3% of documents. Random Unicode strings survived only 1.2%, and verbatim repetition attacks only 1.0%. A fluent lie is harder to filter than an obvious exploit. Civilization continues to reward good copywriting in the worst possible ways.

The paper did not attack live websites or demonstrate that a production model was poisoned. Its crawl, extraction, and filtering results are pipeline-specific, and detecting comment software does not prove that an attacker could post at scale through authentication, moderation, and anti-bot controls.

For Jarvis, the immediate risk is actually retrieval rather than pretraining. A comment, forum answer, or user-generated snippet can influence a live answer today. Source provenance should therefore survive retrieval: first-party documentation, standards, primary papers, comments, and scraped aggregators should not enter the evidence pool with equal weight.

Repeated wording across many pages is also not necessarily corroboration. It may be syndicated content, coordinated propaganda, or one bad claim wearing several domains as a fake moustache.

5. A better tokenizer can make multilingual generation much faster—after real retraining

In-Place Tokenizer Expansion for Pre-trained LLMs addresses a neglected source of inference cost: some languages are chopped into far more tokens than others.

Liquid AI extends the original byte-level BPE merge process for its LFM2-8B-A1B model rather than training an unrelated tokenizer. The vocabulary grows from roughly 65K to 128K tokens. Of the original 64,400 source tokens, 63,151 remain available as single tokens, allowing their embedding rows to transfer directly.

New tokens are initialized from the mean embedding of their source-token decomposition. Adaptation then proceeds in two stages:

  1. train only newly added embedding rows while freezing the rest of the model;
  2. continue pretraining the full model on a balanced multilingual mixture.

The resulting tokenizer uses approximately 2.4× fewer tokens for Hindi, 2.6× fewer for Vietnamese, and up to 4.0× fewer for Thai. The larger output matrix makes each decode step slower: on one Snapdragon 8 Elite Gen 5 configuration, moving from 65K to 128K costs about 9% in token throughput. Combining that cost with the reduced token count produces an estimated 2.2–3.7× improvement in decoded characters per second for the affected languages on the tested devices.

That is not a universal 3× model speedup. English and code remain close to token-count parity, so they may gain little or even lose slightly.

The ablations contain the sharper operational warning. Training the entire embedding matrix during the frozen-body stage leaves MMLU unchanged at 61.3 but collapses HumanEval+ from 43.9 to 1.8 and the paper’s repetition score from 0.92 to 0.19. An English-heavy second-stage mixture similarly leaves or improves some multiple-choice scores while severely degrading free-form math, multilingual generation, and repetition behavior.

A model can look healthy on multiple choice while its generator is on fire.

For local Jarvis models, the lesson is to benchmark user-visible text per second, not merely tokens per second, and to include long-form generation, tool-call formatting, multilingual prompts, termination behavior, and repetition checks. Tokenizer surgery is not a post-processing trick; it is a model-development project.

6. Skill files can improve from failures without retraining the model

SciDiagramEdit: Learning to Edit Scientific Diagrams from Paper Revisions mines before-and-after figures from arXiv revision histories.

The benchmark contains 364 figure-edit pairs across 23 subject areas, annotated with 2,628 atomic editing claims. An editor modifies an SVG-like representation containing vector primitives and embedded raster regions. A separate Coach examines execution traces, scores, and the author’s revised figure, then patches a reusable filesystem-based skill.

No model weights are trained. The learning artifact is procedural documentation: workflows for replacing SVG text safely, checking layout after structural edits, rerouting connectors, or tightening the viewBox.

This is more interesting than the narrow diagram task suggests. The editor, evaluator, demonstration, and persistent skill are separate objects. A failed run need not become another bloated few-shot example in the prompt; it can produce a small, reviewable change to the procedure.

The paper reports that SciDiagramEdit achieves the strongest semantic-checklist result among its tested methods and roughly matches GPT-Image-2 on blind instruction-following preference, while preserving editable structure. Raster generators often look polished but are more likely to alter labels, symbols, or untouched regions. The supplied extraction does not include the numerical values from the main result tables, so the ranking is safer to report than a fabricated margin.

The benchmark remains small, instructions explicitly state the requested edits, and evaluation leans heavily on model judges. The full experimental programme also cost about US$20,000 in hosted model calls despite using no GPU training.

For Jarvis, this is a plausible pattern for skill improvement: preserve traces, compare against a known-good artifact, patch a narrowly scoped workflow, and keep the diff inspectable. It is particularly relevant to SVG, Excalidraw, and site-asset work, where “looks approximately right” is weaker than “the requested primitives changed and everything else remained editable.”

7. An aggregate answer should agree with its own parts

Partition, Prompt, Aggregate: Statistical Self-Consistency in Language Models asks whether model estimates obey the law of total probability.

Suppose a model estimates the share of a population satisfying some condition. If the population is divided into mutually exclusive subgroups, the direct estimate should approximately match the weighted sum of its subgroup estimates. The authors construct binary conditioning trees and compare those two answers.

They frequently disagree.

More surprisingly, estimates reconstructed from finer-grained subgroups are often closer to human reference data than the model’s direct population-level answer. The authors call this the macro fallacy: useful conditional knowledge appears to exist at the subgroup level but is not reliably propagated into the aggregate response.

This provides a reference-free diagnostic. Even without knowing the correct number, we can ask whether a model’s related answers compose coherently. The paper also tests order consistency—whether “young and employed” produces the same estimate as “employed and young”—and a lightweight micro-to-macro prompt that asks the model to consider subgroups before giving its final aggregate. That recovers part, but not all, of the explicit aggregation benefit.

The method has limits. Persona prompts may elicit stereotypes or “typical person” narratives rather than genuine conditional probabilities. Subgroup weights may themselves be uncertain. A model can also be perfectly self-consistent and perfectly wrong.

Still, it suggests a useful check for Jarvis when answering questions about adoption, demographics, public opinion, or incident rates: compare the direct estimate with a small, explicit decomposition. Large disagreement is evidence to reduce confidence, not an invitation to average two hallucinations and call it statistics.

8. Diffusion language models choose both tokens and which positions to resolve

Mask-Aware Policy Gradients for Diffusion Language Models identifies an omitted action in reinforcement learning for masked diffusion language models.

At each denoising step, these models decide both:

Existing methods commonly optimize the token decision while treating position selection as a fixed or greedy operation. The paper models unmasking order as a probabilistic policy using a Plackett–Luce distribution derived from token confidence, yielding separate token and position terms in the policy gradient.

Against the closely related StepMerge baseline at generation length 256, the method reports:

The mechanism requires no extra position head or additional forward pass for the position term itself. That should not be shortened to “no overhead”: the trajectory estimator still performs more forward passes per optimization step than some ELBO-based alternatives, and stochastic remasking changes the generation procedure.

Direct relevance to Jarvis is limited unless it adopts a masked diffusion backend. The broader idea is sound, though: when a generative system chooses both what to resolve and what to resolve next, optimizing only content leaves part of the policy untouched.

9. Few-step image and video generators get a forward-process RL method

MeanFlowNFT: Bringing Forward-Process RL to Average-Velocity Generators adapts reinforcement learning to MeanFlow image and video models.

MeanFlow predicts average movement over an interval, allowing generation in one or a few large steps. Existing DiffusionNFT-style policy improvement assumes an instantaneous velocity. MeanFlowNFT derives an induced instantaneous-velocity predictor from the model’s average-velocity identity, optimizes that quantity, and retains the original fast sampler for inference.

On Wan2.1 1.3B, the paper reports a four-step VBench score of 84.33, compared with 82.57 for the cited 50-step LongCat-Video RL result. On Stable Diffusion 3.5-Medium, MeanFlowNFT leads the evaluated few-step baselines on six of eight reported metrics.

“Four steps beats 50” is an attractive headline but not a full compute comparison. It does not account for training cost, reward-model evaluation, implementation efficiency, or whether four function evaluations in one architecture equal 50 in another. The evaluation also relies heavily on learned preference and alignment metrics, which can be optimized without improving every aspect humans care about.

A particularly useful engineering detail is that the trainable model and EMA reference must share the same finite-difference derivative estimate. Independent estimates reportedly destabilize training and can cause collapse.

This matters to Jarvis only if local image or video generation becomes a substantial capability. It is a specialized post-training result, not an agent architecture.

10. Uncertainty depends on what loss you think matters

Subjective Risk Decomposition: A New View for Uncertainty Quantification is the week’s most theoretical paper.

Its argument is that aleatoric and epistemic uncertainty are not universal primitive quantities. They emerge from a chosen predictive loss and the geometry induced by that loss.

For strictly proper losses, the authors decompose subjective risk into:

Under log-loss, the variance term becomes mutual information and the entropy term becomes expected conditional entropy. Under squared loss, the machinery recovers familiar variance-based decompositions. Other disagreement measures arise from different loss geometries rather than necessarily being rival attempts to estimate one uniquely defined quantity.

The paper also argues that mutual information captures only one component of its broader subjective estimation error. That makes it a lower bound on epistemic uncertainty if one adopts the paper’s definition—not proof that mutual information universally underestimates some objective quantity called “true uncertainty.”

There are no calibration, hallucination-detection, or downstream decision benchmarks here. The contribution is theoretical unification.

The practical message for an assistant is modest but useful: agreement among several drafts measures only disagreement. All drafts may share the same unsupported assumption. Confidence needs external grounding, and the right uncertainty measure depends on the cost of the error being evaluated.

The emerging architecture

Across these papers, context is being broken into more disciplined forms.

RoboTTT turns a stream into adaptive fast weights. StructAgent turns an execution trace into verifier-committed task state. SearchOS turns browsing into a frontier, evidence graph, coverage map, and failure memory. SciDiagramEdit turns failed editing runs into reviewable procedural skills. The statistical self-consistency work checks whether separately elicited beliefs compose into a coherent whole.

These are not interchangeable mechanisms. Gradient-updated robot state, filesystem skills, durable agent memory, and source-backed evidence have different failure modes and should have different authority.

That distinction matters. A failed action can inform the next attempt without becoming a target to imitate. A remembered procedure can guide execution without proving the present task is complete. A retrieved paragraph can support a claim without making its source trustworthy. A model’s confidence can describe internal agreement without establishing correspondence to reality.

The next generation of useful agents will not win merely by remembering more. They will win by keeping several kinds of state separate—and by being explicit about which one is allowed to say, “Done.”

Reading list