Techniques

Encode the answer-position residual of a direct-prediction pass and a CoT pass with one shared sparse autoencoder, then zero the decoder contribution of the concepts active in both and measure the drop in answer probability.

Addresses: Saying what actually drove the answer

Ask the same closed-book question under two or three equivalent prompt structures (direct, decomposed, incremental); if the answers disagree, treat the fact as unknown and abstain, since memorized facts are stable across regimes and halluci

Addresses: Recalling facts it was trained on

Treat an ensemble of LoRA adapters as a credal set, bound each candidate answer's probability by the min and max over adapters (adding unwritten-completion mass to the upper bound), and answer only when one candidate's lower bound exceeds a

Addresses: Saying it does not know

Replace entities in the question and evidence with type-matched synthetic names under a bijective mapping, re-ask, map the answer back, and abstain when back-mapped answers disagree with the original across sampled worlds.

Addresses: Saying it does not know

Modify the training environment's feedback rather than the agent: give explicit next-action hints in the first steps of an episode and the first half of training, then switch to richer state information in later steps and later training, ke

Addresses: Completing tasks that take many steps or many hours

Have the model propose a PDDL formalization, judge it with a solver-calibrated score, and edit it under bounded diagnostic feedback, training all three roles with reinforcement learning from solver outcomes rather than annotations.

Addresses: Planning a sequence of actions before acting

Learns a second discrete latent action code from start-goal end-effector point-cloud transitions, shared across embodiments via a unified bimanual code, pair-consistent random 3D transforms, and forward/backward transition training, and use

Addresses: Turning plans into physical action

Represents the task as a subgoal sequence with a progress pointer, triggers verification at gripper-load events, and uses frozen point tracking (grasp) and language-conditioned cross-view embeddings plus a 2.43M-parameter head (placement) t

Addresses: Turning plans into physical action

Adversarial contrastive fine-tuning on hallucination-flipped image pairs, as introduced by the paper it was drafted from.

Addresses: Grounding answers in the image

Embeds an attack-specific helper requirement (attacker-controlled env-var input plus a dangerous sink wired into the repaired symbol) into an otherwise legitimate bug report, framed as ordinary maintenance work.

Addresses: Writing secure code and dependencies

From ten unlabeled target observations, score each functional region of a VLA by combining CKA against a cached source reference with reference-free gradient and MC-dropout sensitivity, then set per-region LoRA rank proportional to the scor

Addresses: Turning plans into physical action

Decompose sampled responses and trusted source documents into atomic claims, build a weighted bipartite graph where prior-entailed edges cost least, and label each claim Grounded, Refuted, or Boundary by weighted closeness centrality.

Addresses: Stating false facts confidently

Generate perception, retrieval and web-verification evidence with the same backbone, score each stream for relevance/accuracy/discriminativeness, softmax-weight them into a fused answer, and refine under six cultural rubric criteria.

Addresses: Getting more from several models than from one

Replace first-person self-prediction questions with the same item-informed question about a capable AI agent in general, or use other measured models as the predictor, to remove the self-flattering bias without losing accuracy.

Addresses: Saying it does not know

Sample several answers, show them to the model, then ask for the probability that one specific answer is true; the extra samples act like considering alternatives and raise self-evaluation accuracy and calibration over judging a single answ

Addresses: Saying it does not know

Instead of prompting the agent to forecast directly, have it search for and estimate the most recent period's distribution and use that estimate as the forecast.

Addresses: Predicting future events

Estimate truthful and hallucination-distortion covariances from paired captions offline, build a closed-form Wiener gain per eigenmode of the distortion covariance, and multiply it into the FFN output projection of deep layers so inference

Addresses: Grounding answers in the image

Aggregate failing trajectories across tasks into recurring failure groups, then run a fixed number of analyst-critic-engineer refinement passes plus a moderator to produce one modification specification, which a coding agent implements and

Addresses: Improving its own scaffolding from failures

Instead of reading agent messages, score each agent's stance after every round with a fixed token-probability probe and log who saw which content from whom, so influence can be attributed to direct or peer-relayed exposure.

Addresses: Getting more from several models than from one

After an incremental reason-act-observe loop, the agent refines coarse matches, retries failed or geo-inconsistent calls, and a synthesis step checks the draft against task constraints and admits no fact absent from logged observations.

Addresses: Using the tools it is given

Scores a model on six measures of how well it modulates its residual-stream projection onto a concept direction on instruction (engage, suppress, intensity dial, temporal placement, token coverage, layer targeting), combined into one geomet

Addresses: Strategic deception and detecting it

Organizes the KV cache as a fixed-size tree of memory buckets, routes each incoming token to a slot via Gumbel-Softmax, and sigmoid-gates a soft merge of the new key/value with the stored one instead of discarding any token, with a learned

Addresses: Losing information in long inputs

Restrict document-auditing prompts to small batches with content injected directly, and mechanically check each reported finding against the source text before accepting it.

Addresses: Stating false facts confidently

An explicit allow/ask/deny policy plus rate, cost and time ceilings, enforced by the harness rather than requested of the model.

Addresses: Prioritizing safety under conflicting goals, Using the tools it is given, Following instructions hidden in data

Fit a per-step reliability parameter from short-horizon runs and project it onto the target production horizon to predict success, instead of reporting aggregate benchmark pass rates.

Addresses: Completing tasks that take many steps or many hours

Generate reasoning traces for fine-tuning by reverse-engineering templated explanations that match extracted temporal features to candidate-model categories under known oracle labels, instead of querying a large model for the rationale.

Addresses: Predicting future events

Split a long chain of thought on transition keywords, link steps with entailment and contradiction edges predicted by a local NLI model instead of LLM calls, and train a graph attention network to predict whether the chain's final answer is

Addresses: Carrying a chain of inference through to its conclusion

Split a response into atomic claims, score each by self-verification or token log-probability mixed with cross-sample consistency, then fit temperature or Platt scaling at the claim level so low-confidence claims can be routed to retrieval

Addresses: Saying it does not know

Classify attention heads by causal noise intervention and counterfactual difference-in-differences, then at decode time rescale the visual and language value vectors of the mixed 'synergy' heads so their information ratio hits a target equi

Addresses: Grounding answers in the image

At each generated object token, average attention over mid-to-late layers, decode the top-k attended image tokens through the output head, and flag hallucination when no decoded token is semantically similar to the emitted word; then either

Addresses: Grounding answers in the image

Split a long answer into atomic claims and verify each against search or a corpus.

Addresses: Stating false facts confidently, Checking claims against evidence

Write task id, status, completed steps and artifact paths to a small file after every meaningful step, and read it at session start.

Addresses: Tracking state through a long task, Remembering across sessions

Parse the repository once into a heterogeneous graph of code entities and their dependency edges, expose search, traverse and retrieve-entity tools over it, and let the agent hop across the graph from the issue's mentioned names to the func

Addresses: Finding what matters in a large codebase

During handheld demonstration, query the current policy on the same observation stream without executing it, record extra demonstration segments when an energy score between the human action chunk and the policy's sampled chunks exceeds a t

Addresses: Turning plans into physical action

For every structural change a multi-agent optimizer emits, build a random topology with the same node/edge budget and evaluate it under identical model, agents, roles and runtime, so the credit goes to the optimizer rather than to having de

Addresses: Getting more from several models than from one

For a fraction of RLVR rollouts, prepend a truncated partial reasoning trajectory generated by a smaller, different-family model (cut at the largest step-to-step entropy drop) and train the target model to complete it.

Addresses: Retaining skills and safety after fine-tuning

A learnable codebook of role steering vectors, warm-started from contrastive activation directions and fused by a query-aware top-K router, is added to the last prompt token's residual stream at the middle layer of a frozen LLM, trained by

Addresses: Getting more from several models than from one

Slice the acoustic feature sequence by ASR timestamps, average-pool each transcribed span to its text length and add the aligned text embedding, keep untranscribed spans raw, then evict remaining tokens by attention scores accumulated with

Addresses: Losing information in long inputs

Where component dependencies and cleanup effects are explicitly represented, have the runtime enumerate legal teardown continuations and compute or verify the resulting state, leaving the model only the higher-level goal choice.

Addresses: Improving its own scaffolding from failures

Fuse frozen 3D-foundation-model features into VLM visual tokens, and let action hidden states cross-attend (with 3D RoPE) to an unencoded point-wise semantic field, inserted only in the diffusion blocks where linear probing shows degraded e

Addresses: Turning plans into physical action

Require the model to output timestamped audio and visual evidence intervals and multiply its answer correctness by a soft temporal-plus-semantic evidence score, so ungrounded correct answers earn no evidence credit.

Addresses: Reasoning about time in video

In on-policy self-distillation for video LLMs, the frozen self-teacher replays the student's trajectory while seeing only frames from the annotated evidence interval plus the gold answer, and token-level distillation is weighted by each tok

Addresses: Reasoning about time in video

Draw k responses, have the model count how many match each candidate, use that match score as confidence, and set the abstention threshold on a labelled calibration set with conformal prediction so the expected error among answered question

Addresses: Saying it does not know

Use conformal prediction to localize a top-k shortlist that contains the human-preferred response with probability 1-alpha, then accept a single answer only when its score margin within that shortlist clears a fixed-sequence-calibrated thre

Addresses: Saying it does not know

Alternates fast edits to an explicit textual state (validation-gated) with distillation into the policy, keeping only trajectories that the updated state makes newly or persistently better than state-free execution, weighted by per-token di

Addresses: Improving its own scaffolding from failures

Collect success and failure trajectories for the same task, aggregate the contrast across tasks into recurring behavioural deficiencies, attribute each to one of five harness modules, evolve each module inside its own modification scope, th

Addresses: Improving its own scaffolding from failures

Let role-free agents build durable, executable artifacts in a shared simulated environment so later agents inherit and modify them, instead of coordinating through conversation or assigned roles.

Addresses: Getting more from several models than from one

Specialized LLM agents generate, pairwise-score and semantically recombine or mutate structured hypotheses, with a genetic algorithm doing tournament parent selection and joint parent-offspring truncation to a fixed population.

Addresses: Getting more from several models than from one

Corrupt correct reasoning traces by composing typed executable error operators, train an adapter to predict the active operator plus the adjacent lower-noise trace, and at inference iteratively predict and apply inverse operators to the mod

Addresses: Fixing its own mistakes

Run every stage of an autonomous research loop as candidate, critic, refine with a bounded number of rounds, where the critic can accept, request refinement or reject, and close the loop with a simulated peer-review and rebuttal before the

Addresses: Improving its own scaffolding from failures

State the target country in the system prompt so the model answers survey-style questions as a member of that culture; measured as reduced distance to the country's Hofstede profile.

Addresses: Handling culture-specific norms and viewpoints

Each debater runs a presenter that drafts a diagnosis, a rebutter that attacks it for missing evidence and unsafe omissions, and a presenter revision; a separate aggregator then merges all revised hypotheses without forcing consensus.

Addresses: Getting more from several models than from one

Find the plausibility and validity directions in activation space, construct a vector that removes the plausibility component from the validity judgement, and add it at inference so conclusions are judged by form rather than believability.

Addresses: Deducing validly from logical structure

At inference, the agent splits each complex web observation into an aligned sub-goal and task-relevant sub-observation, self-scores the decomposition and action, and uses the passed/rejected trials as in-context demonstrations or as RL sign

Addresses: Using the tools it is given

Score each context example by how many questions require tokens only it supplies (Question Damage Score), then delete the highest-scoring example to make a matched, structurally unanswerable variant of the same task.

Addresses: Saying it does not know

Fine-tune a shadow model on part of a benchmark to label members and non-members, then train a classifier on expert features (pass rate, CodeBLEU, edit distance, perplexity) fused with CodeBERT embeddings to predict whether a benchmark item

Addresses: Whether the measurement made the finding

Compute KL divergence between consecutive layers' cross-modal attention over visual tokens, mask the top-attended region of the layer just before the largest drift, re-query the same token's probability, and feed the drift profile plus the

Addresses: Grounding answers in the image

Wire linters, test suites and schema validators into the agent's loop before adding any model-based judgment.

Addresses: Fixing its own mistakes, Whether the measurement made the finding

Sanitize and length-bound log payloads with regex decoders and atomic rules at SIEM ingestion, then pass the structured alert through LLM self-check input and output rails before and after the analyst model.

Addresses: Following instructions hidden in data

Diagnosis-selected head-restricted adapter plus grounding-gated decoding, as introduced by the paper it was drafted from.

Addresses: Grounding answers in the image

Adds a ~1000-token prompt block at run start and every 30 minutes that forbids mono-loop moves (single hold-out, repeated tweaks) and prescribes human practices (K-fold from version one, early ensembling, cached out-of-fold predictions, per

Addresses: Planning a sequence of actions before acting

Induce two-level programmatic skills (composite skills made of ordered subskill calls) from successful trajectories, expand each subskill call into an action chunk whose boundary becomes an off-policy supervision target, and train the primi

Addresses: Completing tasks that take many steps or many hours

After each task, have the agent judge whether it succeeded, distill a short reusable strategy or warning from the attempt, store it, and retrieve only the relevant ones at the start of later tasks.

Addresses: Improving its own scaffolding from failures

A large teacher VLM produces layered reasoning traces linking observations and task plan to annotated subtask transitions; a small student rewrites those traces into compact self-explanations, teacher-judged candidates are selected, and the

Addresses: Turning plans into physical action

Builds three memory banks from a large teacher's successful trajectories — a prose workflow insight, code-bearing subtask segments, and per-function call examples — injecting the first two into the student's system prompt and retrieving the

Addresses: Using the tools it is given

Remove global output-shaping directives such as "LIMIT 10" from the SQL-generation system prompt so row count is decided by the question rather than the prompt.

Addresses: Writing a reusable locator: regex, SQL, XPath

Run CAE simulation tasks with an off-the-shelf coding-agent harness (file, shell, multi-turn, execution feedback) and no simulation-specific roles, retrieval pipeline or reflection prompt, while requiring the agent to read the relevant solv

Addresses: Getting more from several models than from one

Adds a dedicated autoregressive function channel, with its own head and start/end tool-call boundary tokens supervised alongside padding, running in parallel with the agent-text stream so tool calls are not serialized into the spoken respon

Addresses: Using the tools it is given

Add positional embeddings that tell the model which place each digit occupies.

Addresses: Digit-level arithmetic

A multi-agent pipeline that injects Vitis HLS optimization priors, evolves kernel candidates under simulation feedback, verifies and repairs functional correctness by de-HLSifying the kernel and running C++ test programs, then generates hos

Addresses: Generating and editing working code

Accumulated solver and trajectory-validation failures are summarized into candidate add/modify/delete/merge edits to an initially empty knowledge base of scene-conditioned allowed and forbidden maneuvers, and an edit is kept only if re-runn

Addresses: Improving its own scaffolding from failures

Maintain a requirement-level and a component-level DAG with an alignment relation, and apply split/merge/revise/save actions triggered by cohesion and coupling thresholds until no action is eligible, then generate code against the converged

Addresses: Generating and editing working code

A controller compiles a data-preparation runtime specification, generates a small pilot dataset, assesses it against domain-selected quality criteria, and emits an adapter that revises specific pipeline components while preserving their int

Addresses: Improving its own scaffolding from failures

Each modality agent builds a local evidence graph and agents update one another only by establishing typed edges (cascade, syndrome, exclusion, context) before an expert agent arbitrates the merged candidate graphs against a referral knowle

Addresses: Getting more from several models than from one

Wraps heterogeneous domain pre-trained models as stateless feature-extraction endpoints with declarative input specs, and has a planner rank candidates from the dataset's modality, channel count, sampling rate and class balance before code

Addresses: Competence in a specialist domain

Store verified environment observations as immutable fact nodes in a persistent graph and allow an action only as an intent edge whose preconditions are already-verified facts, replacing in-context state maintenance.

Addresses: Completing tasks that take many steps or many hours

Restrict the LLM to extracting canonical symptoms and patient context from a clinician-curated vocabulary, and let a deterministic rule engine owned by clinicians make the emergency decision.

Addresses: Following an unfamiliar procedure

Stage one prompts an LLM on a sanitized HTML tree to return target values plus the anchor text preceding them; stage two condenses the page around those nodes and prompts a stronger LLM to emit an XPath, refined by executing it on seed page

Addresses: Writing a reusable locator: regex, SQL, XPath

Round each numeric time-series value to the nearest integer before serializing it into the prompt, preserving the original scale instead of standardizing or instance-normalizing.

Addresses: Predicting future events

Abstracts SQL queries into schema-independent skeletons, treats seed skeletons as fixed K-center centers, greedily selects external pool skeletons farthest from existing coverage, and re-instantiates each on a target training database with

Addresses: Writing a reusable locator: regex, SQL, XPath

Score each preference pair by a normalized composite of |reference-model per-token log-prob margin|, chosen-minus-rejected token length difference, and TF-IDF similarity to a general-capability corpus, then train DPO only on the lowest-risk

Addresses: Retaining skills and safety after fine-tuning

Train a per-layer logistic probe on the hidden state just before each parameter value is emitted, then use its score to keep only reliable self-generated tool calls for LoRA fine-tuning and to rerank sampled candidates at inference.

Addresses: Using the tools it is given

For each failed run, inject a ground-truth-derived hint into one agent at a time in reverse execution order until the failure resolves, then contrast that agent's original and hint-corrected outputs to write its prompt update, clustering si

Addresses: Improving its own scaffolding from failures

Fine-tune on synthetic prompts where a stated user opinion must not change the answer.

Addresses: Telling the user what they want to hear

Train the model on examples of deciding when to call a tool and how to use the result.

Addresses: Using the tools it is given

For a chosen deception argument scheme, an LLM instantiates each premise against the document with verbatim excerpts and a green/yellow/red judgement, then answers the scheme's critical questions with paired argument and counterargument bef

Addresses: Strategic deception and detecting it

Before continual adaptation, collect a handful of task-independent teleoperated trajectories covering the embodiment's anticipated motion range, compute per-dimension 1st/99th percentile action statistics once, and use those frozen statisti

Addresses: Turning plans into physical action

At each decoding step, pick object tokens among the top-k candidates with WordNet, rescore them with CLIP similarity to the image, rescale the scores into the LVLM logit range, and blend the two with a weight equal to the LVLM's normalized

Addresses: Grounding answers in the image

Compute query-video cosine similarities at both frame and sliding-window clip granularity, project clip scores onto the frame timeline with a triangular kernel and mix them with a fixed weight, and separately optimize a single additive offs

Addresses: Reasoning about time in video

The agent stores successful past gameplay episodes, retrieves the few most similar to the current time and observation, and a gating rule decides whether to execute the retrieved action directly or reason anew by fusing the retrieved episod

Addresses: Completing tasks that take many steps or many hours

Store the authored facts, prerequisites and contradictions in a tree; one model picks the single currently-permitted unrevealed fact, a second writes dialogue constrained to it, and a third checks whether the fact was conveyed before the tr

Addresses: Stating false facts confidently

Every extracted rule is written to a shared versioned store under a stable id, checked against 26 schema constraints, scored on five dimensions by an LLM judge whose minimum dimension decides auto-approve/review/reject, then filtered for du

Addresses: Stating false facts confidently

Each mined edit to the harness's knowledge or tool library is applied in a sandbox and promoted only if it strictly improves accuracy or cost on the trajectories it was mined from and does not regress on a stratified held-out case set resam

Addresses: Improving its own scaffolding from failures

Require an out-of-band approval for deletes, payments, sends, and other irreversible tool calls.

Addresses: Prioritizing safety under conflicting goals

At acceptance time, score a candidate bank by the averaged value loss from knocking out randomly sampled skill subsets rather than by aggregate reward alone; at deployment, greedily drop transferred skills whose removal improves retrieval s

Addresses: Improving its own scaffolding from failures

Run one extra call asking the same model only whether the input facts are sufficient and consistent, and override the solver's numeric answer with abstention when it returns the 'contradiction' label.

Addresses: Saying it does not know

Before answering, the model enumerates the information units the question requires, assigns each a confidence score, and commits to an answer only if the aggregate score passes a fixed threshold, otherwise abstaining.

Addresses: Saying it does not know

The orchestrator resamples each worker response, computes semantic entropy and embedding-space semantic density, and accepts only if both clear thresholds, otherwise reprompts, reassigns, or delegates in parallel.

Addresses: Getting more from several models than from one

Keep the semantic layer outside the prompt as queryable MCP tools; when the agent fails, diagnose from traces, attribute the failure to the schema, content or tool level, write a typed edit at that level, and keep it only if a paired evalua

Addresses: Improving its own scaffolding from failures

Sample textual gradients only from examples the current prompt answers wrongly, generate several candidate prompts, and keep one only if its improvement on the hard batch beats a scheduled penalty times its regression on a held-back sample

Addresses: Improving its own scaffolding from failures

Build a large NL-to-regex training corpus by stochastically generating regexes with a small hand-written grammar that also emits rigid synthetic descriptions, then paying crowd workers to paraphrase those descriptions into fluent language.

Addresses: Writing a reusable locator: regex, SQL, XPath

Decode the step sequence with beam search over a creator's learned bigram/positional action priors and a deterministically predicted step count, then route ingredients to those steps by a learned ingredient-action prior instead of an LLM.

Addresses: Planning a sequence of actions before acting

Retrieve evidence first, then autoregressively generate the multi-agent DAG (roles and edges) conditioned on the retrieved evidence and its provenance, with a generator trained on execution-scored, cost-pruned candidate topologies.

Addresses: Getting more from several models than from one

Collect hidden states on harmful and harmless prompts, recover the low-rank safety subspace per layer, and compress its geometry into one score that ranks aligned checkpoints by how easily benign fine-tuning will erase refusal, so the fragi

Addresses: Retaining skills and safety after fine-tuning

Retrieve relevant documents and generate from them, with the model deciding when retrieval is needed.

Addresses: Stating false facts confidently, Checking claims against evidence

Store vehicle components, mission types and required capabilities in an ontology with SWRL rules that infer capabilities from hardware/software, then put both the mission's required capabilities and the vehicle's inferred capabilities into

Addresses: Planning a sequence of actions before acting

Replaces selector fine-tuning with retrieved structured criteria (schema grounding, SQL operations, expected output form) prepended to a listwise prompt, and mitigates position bias by shuffling only inside execution-result groups, aggregat

Addresses: Writing a reusable locator: regex, SQL, XPath

Hidden-state divergence compensation at decoding time, as introduced by the paper it was drafted from.

Addresses: Grounding answers in the image

hidden-state probe for tool-call errors, as introduced by the paper it was drafted from.

Addresses: Using the tools it is given

Show the model the repository's file tree and the issue and have it rank suspicious files, retrieve files by embedding similarity to the issue, merge the two lists, then narrow within the chosen files to classes and functions and finally to

Addresses: Finding what matters in a large codebase

Fine-tunes a VLM on per-timestep motor and expression actions recorded from a hybrid architecture with an explicit theory-of-mind module.

Addresses: Turning plans into physical action

Streaming frames pass through only the shallow language layers whose KVs form a full-history index; at query time a text-only logit gate decides whether history is needed, cross-layer token voting plus max-min diversity picks evidence units

Addresses: Reasoning about time in video

Learn a delimiter-based extraction pattern from a few labelled example pages, then run that pattern over the whole template-like collection instead of processing each page individually.

Addresses: Writing a reusable locator: regex, SQL, XPath

Prompt an LLM to write a regex from example spans, run it over the examples, and feed the mismatches back for iterative pattern revision.

Addresses: Writing a reusable locator: regex, SQL, XPath

Split XPath generation into separate sub-tasks the LLM solves over a few seed pages, producing a reusable XPath applied to all remaining pages without further model calls.

Addresses: Writing a reusable locator: regex, SQL, XPath

Parses reference Python into a region-level implementation graph, aligns those regions with kernel-checked Lean proof-flow transitions to generate region-level obligation text, trains the model jointly on code plus obligation/concept predic

Addresses: Generating and editing working code

When a search-based test generator makes no fitness progress for N generations, prompt an LLM at class level with an iterative self-refinement loop, parse its test snippets into the generator's internal representation, and merge them into t

Addresses: Generating and editing working code

During GRPO-style knowledge-injection RL, add the gold answer to each rollout group and apply it as a direct supervised gradient scaled by its group-relative advantage (no importance ratio or clipping), so learning signal survives when all

Addresses: Absorbing and flexibly using new knowledge

A lightweight generative reward model, trained on causal-chain-backtracked step labels from failed trajectories plus injected errors in successful ones, asynchronously diagnoses the agent's last completed step and forces regeneration of the

Addresses: Judging another's work as well as a careful reviewer would

Before writing an edit into parameters, optimize the target representations for the edited fact and its neighbours together, penalizing both failed propagation and leakage, and reject edit plans whose semantic risk is high.

Addresses: Absorbing and flexibly using new knowledge

Run the judge with candidates in both orders and count a preference only when it holds in both.

Addresses: Biased when judging other outputs

Convert a verified gold answer into a checklist whose items are each anchored to a hallucination subclass, then have an LLM judge issue a binary verdict per item against the agent's whole trajectory (reasoning, memory, tool observations) ra

Addresses: Stating false facts confidently

Decompose a paired video comparison into chunks of four consecutive actions, judge each chunk's action consistency and visual quality from a six-image structured evidence panel, and aggregate chunk verdicts by voting into video-level prefer

Addresses: Judging another's work as well as a careful reviewer would

A versioned instruction file the agent reads before acting, where every line is a past failure converted into a permanent rule.

Addresses: Following an unfamiliar procedure, Keeping its own context clean

Have agents pass extracted facts and answers to each other in the user's language instead of pivoting through English translation.

Addresses: Getting more from several models than from one

Balance a forecasting question bank so that events that occurred and events constructed as false appear in roughly equal numbers, so the calibration score does not reward default skepticism.

Addresses: Predicting future events

An agent compiles natural-language instructions into executable programs whose state a lightweight engine maintains as state-augmented 3D oriented bounding boxes, which are deterministically projected into identity, semantic and motion cont

Addresses: Tracking state through a long task

Knowledge-gated deception scoring, as introduced by the paper it was drafted from.

Addresses: Strategic deception and detecting it

Replaces agent-managed scratchpads with a system-managed three-layer memory (full logs for recent weeks, ~200-word summaries, ~50-word milestones) and splits each simulated day into four plannable blocks.

Addresses: Completing tasks that take many steps or many hours

Each LLM agent reads a 20-dimensional summary of its private notes, shared knowledge, draft and feedback and picks Retrieve, Disseminate, Compose or Critique under a shared IPPO policy, instead of being assigned a fixed pipeline role.

Addresses: Getting more from several models than from one

A ~200K-parameter MLP scores cached tokens from attention mass, value norm, attention variance, entropy and position, and is trained with REINFORCE against a per-step negative KL between full-cache and pruned-cache next-token distributions.

Addresses: Losing information in long inputs

Freeze a reasoning model and an instruction model of identical architecture, assign one sigmoid-bounded interpolation ratio per module, and update only those scalars with GRPO-style rollouts rewarded for correct and comparatively short answ

Addresses: Cutting to the chase

Distil reusable text skills for hypothesis generation from a multi-dimensional discriminator's critique of the whole generated hypothesis set, and skills for experiment design and execution from testing trajectories scored against ground-tr

Addresses: Improving its own scaffolding from failures

Rewrite refusal and rejected responses to match the length and structure of the preferred grounded answer while preserving the underlying grounding failure, so preference learning cannot key on length.

Addresses: Judging another's work as well as a careful reviewer would

Cluster failed traces into signatures, have the same fixed model propose a few minimal harness edits, and promote only edits that improve one split without degrading another.

Addresses: Fixing its own mistakes, Improving its own scaffolding from failures

A zero-initialized LoRA adapter runs concurrently with the frozen base model during tool-call generation, trained with loss only on a trigger token and label, so it restructures the residual stream and then emits a localized verdict like 'u

Addresses: Stating false facts confidently

Periodically fold the conversation into a summary that replaces older turns.

Addresses: Remembering across sessions

Instead of ending an episode by an external distance threshold, the agent exposes a 'finished' action the model emits, keeps flying, and a verifier later checks whether any declaration was within the success radius with the target visible.

Addresses: Turning plans into physical action

Tag each input token with a discrete origin ring, add a learned origin embedding scaled by a learnable gate, and add a learned ring-by-ring bias to attention logits that suppresses attention from assistant/user queries to untrusted-source k

Addresses: Following instructions hidden in data

When a quote-opening token is generated, restrict the next-token logits (via a suffix tree over tokenised retrieved contexts) to tokens that extend the current span into a continuous verbatim substring of some retrieved passage, plus the cl

Addresses: Stating false facts confidently

At inference, apply mode-specific attention masks that suppress language-only self-attention in the late decoder layers so text tokens are forced to draw on visual tokens when attributing person attributes.

Addresses: Grounding answers in the image

Construct a per-mission manager tree in which horizontal managers hand out concurrent assignments to their children and vertical managers decompose the mission into ordered phases and advance only when completion conditions are met, with re

Addresses: Getting more from several models than from one

Instead of transferring a general-domain-trained hallucination detector, fine-tune a domain-pretrained encoder on a small set of in-domain claim-evidence pairs.

Addresses: Competence in a specialist domain

Compute, from an agent's tool-call log, the share of non-infrastructure calls spent querying global state (PMR) and the fraction of commitments stated in its planning diary that are executed within the next K turns (RAG@K).

Addresses: Completing tasks that take many steps or many hours

Train one RL specialist per execution capability from a shared backbone, merge their task vectors with TIES, then refine the merged student by distilling from the routed specialist teacher on the student's own generated prefixes.

Addresses: Turning plans into physical action

Builds a mid-training corpus that pairs filtered web/PDF/code sources augmented into tool-affordance QA with validated multi-turn trajectories synthesized from real API and MCP schemas, and trains the base model on the mixture before ordina

Addresses: Using the tools it is given

Keeps the forecasting backbone frozen and mines its residual with a Monte-Carlo compositional search plus an LLM proposing named feature combinations, binary flags and code, admitting candidates through one source-blind validation gate into

Addresses: Predicting future events

After each labelled run, an agent distills successes into 'golden' lessons and failures into 'warning' lessons, consolidates them by embedding similarity into a three-tier library (principles, patterns, cases), and retrieves from it top-dow

Addresses: Improving its own scaffolding from failures

Generate candidate programs from natural-language instructions with a frontier LLM, keep only those that pass a deterministic-wording filter, compile and run in the target language's binary, produce non-trivial output, and pass an independe

Addresses: Generating and editing working code

During RL post-training of a video model, each group of sampled responses contains mostly forward-video rollouts plus one time-reversed rollout of the same clip, so correctness reward forces the policy to use temporal direction.

Addresses: Reasoning about time in video

Have the model write an informal proof sketch first, translate it into Lean, and refine against compiler feedback; train the prover by reinforcement learning on long interactions with Lean so it accumulates experience of what checks.

Addresses: Formalizing and machine-checking mathematics

neutral-center activation steering for evidence integration, as introduced by the paper it was drafted from.

Addresses: Checking claims against evidence

Split a reasoning chain into dependent nodes, check each node's consistency with its inputs by a yes/no query, and report the first failing node, instead of asking a verifier to read and judge the entire chain.

Addresses: Carrying a chain of inference through to its conclusion

When a direct, answer-only response is wanted, give the model the possible answers to choose from instead of leaving the answer space open.

Addresses: Cutting to the chase

Have the model write a short program for the numeric part and run it, instead of computing in text.

Addresses: Digit-level arithmetic

Convert the English description into a hierarchical sketch with constrained holes, then run a programming-by-example search that uses the sketch's hints both to prioritize expansion and to over/under-approximate partial programs for pruning

Addresses: Writing a reusable locator: regex, SQL, XPath

Summarize sampled graph neighborhoods for an LLM agent as a fixed-length vector of named graph statistics, keeping raw text only for the top-k semantically relevant nodes, so the observation is order-independent and does not grow with neigh

Addresses: Getting more from several models than from one

peer-prediction (Bayesian Truth Serum) reward for label-free RL fine-tuning, as introduced by the paper it was drafted from.

Addresses: Telling the user what they want to hear

Track each prompt-pool anchor's usage as an exponential moving average of its similarity scores across training batches and add a stop-gradient saturating-min penalty that suppresses similarity for over-used anchors, leaving the top-K retri

Addresses: Predicting future events

At prefill, pool each candidate token's reciprocal vocabulary rank across all visual-token logit-lens readouts, cache it, and at each decoding step apply a bounded logit penalty to candidates whose pooled rank evidence falls below a token-s

Addresses: Grounding answers in the image

Run a second decoding pass with the visual features zeroed, score each candidate token by the log-probability difference between the two paths, and subtract a decaying penalty from candidates whose score falls below a threshold.

Addresses: Grounding answers in the image

Before any action, the agent generates an ordered pseudo-code sequence of tool calls, writes it to a scratchpad that persists across the whole episode, and the executor admits only the plan-specified tool at each step unless replanning is t

Addresses: Completing tasks that take many steps or many hours

Prompt several demographically distinct personas grounded in a country's survey data, treat their agreement as already calibrated and their disagreement as the correction signal, and combine their answers to shift the base model's output to

Addresses: Handling culture-specific norms and viewpoints

When choosing an audio front end for an audio-LLM, select encoders whose training imposed text/semantic constraints (weakly supervised or semantically distilled) instead of maximizing reconstruction fidelity or preferring continuous over di

Addresses: Understanding speech and audio

Feed long dialogue history as transcripts for lexical-recall questions and as raw audio for paralinguistic questions, rather than one format for all.

Addresses: Understanding speech and audio

Propose anatomical masks with a medical segmentation model, score each by the log-likelihood drop of a draft answer under two occlusion operators minus an area penalty, and use the top compact mask for classifier-free-guidance plus step-wis

Addresses: Grounding answers in the image

Extends the VLM vocabulary with image-grid affordance/object pointing tokens and three-level residual vector-quantized action tokens, so spatial intent and precise trajectories are both decoded by the original language-model head.

Addresses: Turning plans into physical action

Cluster sampled free-form responses from several VLMs into semantic-equivalence classes, average each model's class distribution uniformly, and report the pooled entropy as collective uncertainty plus Jensen-Shannon divergence as model conf

Addresses: Saying it does not know

Before a user talks with a model that may argue a position, show a brief notice that models can be instructed to persuade and may select information; measured as halved belief change.

Addresses: Changing what a person believes or decides

Train a small BERT from scratch on a hospital's own radiology report corpus with masked language modelling plus a findings-conclusion consistency objective, then fine-tune it to classify synthetic reporting errors.

Addresses: Spotting an error in a given artifact

A VLM infers the human's latent intention from third-person images plus a scene graph as symbolic goal predicates rather than an action sequence, and those goals are grounded with the robot's goal into a multi-agent PDDL problem solved by a

Addresses: Planning a sequence of actions before acting

When output is masked to a formal grammar, spend inference budget on wider beams rather than on sampling several candidates and voting on their execution results.

Addresses: Writing a reusable locator: regex, SQL, XPath

Keep a scored queue of code entities to inspect, let the model decompose each search into smaller lookups it scores for relevance, and drop context whose graph distance from already-relevant anchors is large, so the agent spends its budget

Addresses: Finding what matters in a large codebase

Convert a binary question into an affirmative and a contradictory statement, re-ask each under semantically equivalent image transformations and paraphrases to form four consistency groups, and train a lightweight classifier on 14 within-gr

Addresses: Stating false facts confidently

Re-run an answer under visual degradation, blank-image replacement, and grounding/relation swaps to produce a three-coordinate signature used for failure-family diagnosis and to pick a matched correction prompt, rather than as an abstention

Addresses: Saying it does not know

Fit a linear TD probe on hidden states to get a per-step value estimate, take its step-to-step change as a reward prediction error, and use that as the scoring signal for best-of-n or search at inference, so no separate reward model is run.

Addresses: Spotting an error in a given artifact

Annotate each review point against knowledge type, argument structure, question depth, cognitive complexity and feedback function so model and human critique are compared by what functions they perform rather than by textual overlap.

Addresses: Judging another's work as well as a careful reviewer would

For each recurring failure, write a patch with an explicit scope and injection point, then admit it only if it fixes its targeted cases, leaves a protected regression suite unharmed, and does not fire on negative controls; refuse or defer c

Addresses: Improving its own scaffolding from failures

Prompts a multimodal LLM to estimate the workstation state as a JSON object, propagate it forward through each predicted action, compute a numeric distance to the inferred goal state, and cut the action plan at the state with the lowest dis

Addresses: Planning a sequence of actions before acting

Represent an agent's execution history as a directed graph of reasoning, tool-call and environment nodes with typed dependency edges (sequential, repetition, progression, feedback, goal alignment), then propagate each node's local uncertain

Addresses: Using the tools it is given

Order retrieved documents so the most relevant sit at the start and end of the prompt.

Addresses: Losing information in long inputs

Store the full recording as a variable in a sandboxed Python REPL and let the model iteratively emit code (and optionally render plots or spawn sub-agents) to inspect segments before committing a structured answer.

Addresses: Losing information in long inputs

Mask each communication edge in a generated multi-agent graph, score it by the drop in task score plus the rise in semantic entropy of the final response, keep the top-ranked edges under a pruning budget, and distill those subgraphs into a

Addresses: Getting more from several models than from one

Cluster crash reports by stack-trace similarity, score candidate files by proximity to the crash point, bucket specificity and in-group frequency, and put the top-ranked files' source plus a representative stack trace into a zero-shot repai

Addresses: Finding and fixing a fault in existing code

Score each MLP neuron at the final prompt token by the separation between hallucinated and truthful mean pre-to-post activation change scaled by its output-vector norm, then train a small classifier on the top-ranked neurons' features.

Addresses: Stating false facts confidently

Treat each LLM run as a black-box retrieval system casting a binary vote per candidate requirement, sum the votes (optionally weighted by each model family's estimated true-positive/false-positive log-odds), and hand reviewers the resulting

Addresses: Stating false facts confidently

Ground objects as bounding boxes, have the agent propose a waypoint route, reject and replan any route that intersects the obstacle box (before and during motion), and pick the contact side by an adjacency test with the obstacle.

Addresses: Turning plans into physical action

Identify input concepts not credited in the model's explanation, delete them from the input, and re-ask the model so the final answer can only depend on the concepts it named.

Addresses: Saying what actually drove the answer

Force the agent to read the current version of a file immediately before changing it.

Addresses: Tracking state through a long task

A single agent iteratively calls video observation tools where it sets the time interval, frame rate and resolution itself, judging evidence sufficiency each turn before answering.

Addresses: Reasoning about time in video

Fit PCA on hidden states of answerable prompts, project all states out of that subspace, and score the mean-difference direction between answerable and impossible prompts by cosine to detect pre-generation impossibility.

Addresses: Saying it does not know

Builds a directed attention graph over image patches, query tokens and generated tokens from a single forward pass of a frozen LVLM and classifies each response token with alternating GNN, ViT and GRU blocks, with a streaming variant that r

Addresses: Grounding answers in the image

An LLM proposer repeatedly rewrites the executable program that selects, retrieves and packs video evidence into a frozen VLM's bounded context, keeping only candidates that strictly improve development accuracy.

Addresses: Improving its own scaffolding from failures

A process-reward model scores each step of a failed multi-agent trajectory, the first low-scoring step and its agent are identified, a corrected version of that step is generated and verified, and only that agent writes a reflection into it

Addresses: Getting more from several models than from one

Run the base model on the tuning set, label each example as known or unknown by whether it answered correctly, keep answers for the known set and append an uncertainty expression to the unknown set, then fine-tune on the union so the model

Addresses: Saying it does not know

Before any permission gate, check each emitted call's name against the closed-world tool registry and type-check its arguments against the declared signature, rejecting anything unresolved.

Addresses: Stating false facts confidently

Group related update vignettes into one training instance with a shared answer option pool so the model must discriminate across vignettes between current and superseded recommendations.

Addresses: Absorbing and flexibly using new knowledge

Augments each KG triple with same-source-chunk supporting triples for supervision, then uses LLM judges to separate noisy triples from genuine one-hop knowledge gaps, continually fine-tunes on targeted repair items weighted by failure histo

Addresses: Carrying a chain of inference through to its conclusion

Roll an LLM-generated action plan forward on an explicit graph world model of object relations, preconditions, effects and safety constraints, apply edits whose corrections follow from the action semantics, and return only unresolved semant

Addresses: Planning a sequence of actions before acting

Give the model a concrete external signal, such as test output, and let it reflect and retry.

Addresses: Fixing its own mistakes

At each step the model sees only the immutable skill spec, the current structured state and the latest observation, emits a JSON state patch plus an action, and has its reasoning trace discarded after the runtime validates and merges the pa

Addresses: Completing tasks that take many steps or many hours

Run the swarm, summarize trajectories into SKILL.md workflow patterns, a trick library, and per-backbone model cards, and reinject all three into the orchestrator's prompt at inference.

Addresses: Getting more from several models than from one

Collect each question's answer and confidence at every retrieval depth once, then replay the identical stored states through controllers that differ only in the confidence score supplied, so action differences are attributable to the score

Addresses: Saying it does not know

Log every model and tool boundary interaction as an event-dependency graph, replay it deterministically up to a node flagged by symptom rules plus a semantic judge, inject a repair instruction conditioned on the symptom category, and resume

Addresses: Getting more from several models than from one

Instrument the agent pipeline to record the furthest stage an injected payload reaches and use a judge panel to label whether the agent attempted the attack and whether it explicitly recognized the injection, alongside the deterministic com

Addresses: Following instructions hidden in data

Score a reliability estimate against the independently observed task outcome at each checkpoint index along a trajectory, reported separately per horizon with group sizes, instead of pooling all checkpoints or scoring only the final answer.

Addresses: Saying it does not know

Use parser, domain-conformance, planner, VAL and LLM-critic checks as the online stopping criterion, but compute renaming-invariant structural match and semantic equivalence against curated reference problems offline as a separate benchmark

Addresses: Whether the measurement made the finding

Split an agent benchmark into skill-isolated families with verifier-computed gold (canonical SQL, exact DAG schedule, closed-form lambda) and report per-family accuracy plus token cost from one instrumented run instead of a blended score.

Addresses: Whether the measurement made the finding

Score embodied navigation episodes on fraction of phases completed, final goal distance, collisions and step count alongside binary success, so partial progress and post-phase-transition stalls are visible.

Addresses: Turning plans into physical action

Build a graph whose nodes are definition and reference lines and whose edges are contain and invoke relations across the whole repository, then answer the agent's or pipeline's lookups with the sub-graph around a queried symbol so it sees c

Addresses: Finding what matters in a large codebase

Score a task as successful only when all task-specific final-state evaluators pass and every pre-existing non-target file is unchanged between initial and final sandbox state.

Addresses: Completing tasks that take many steps or many hours

requirements-refinement-before-coding, as introduced by the paper it was drafted from.

Addresses: Generating and editing working code

Take any backbone's top-10 candidate disconnections and reorder them by rule-based checks for functional-group competition, mechanistic plausibility and literature precedent, promoting unflagged routes above high-confidence flagged ones.

Addresses: Stating false facts confidently

Save the user's original tool list and overwrite whatever toolset the agent can see with it immediately before the planning step, so plans can only reference user-approved tools.

Addresses: Following instructions hidden in data

Parse past SQL into five categories of clause-level fragments, describe each in natural language, retrieve by query- and component-level embedding similarity, then LLM-rerank before prepending to an existing few-shot text-to-SQL prompt.

Addresses: Writing a reusable locator: regex, SQL, XPath

Each debating agent retrieves past-debate cases with an MMR trade-off whose relevance/diversity coefficient is set by the current consensus ratio (high consensus pulls in contrastive cases), and labels each peer's response high- or low-conf

Addresses: Getting more from several models than from one

Cluster the prior dataset into skills, have an LLM decompose the target task into subtasks scored by semantic plausibility and per-skill held-out BC loss, retrieve episodes by subtask language similarity, rerank frames by VAE behavior-featu

Addresses: Turning plans into physical action

Build an offline bank of wrong answers from small same-family models labelled with clustered failure modes plus natural-language critiques, then retrieve critique exemplars for a large model either by its dominant family-level failure profi

Addresses: Judging another's work as well as a careful reviewer would

Put the exact documentation for candidate tools into the prompt instead of relying on memory.

Addresses: Using the tools it is given

Mine issues paired with the functions their fixing commits changed, train a code embedding model and a listwise reranker on those pairs so they read failure-style queries, then localize new issues by embedding search over the repository's f

Addresses: Finding what matters in a large codebase

Gives an RL-trained retrieval agent a LIFO memory stack with push/pop actions (plan, think, search, summary, backtrack, conclusion) and assigns format, retrieval-relevance and memory-usefulness rewards to the tokens of each action, plus bat

Addresses: Carrying a chain of inference through to its conclusion

Augments the text-space -WER GRPO reward with a group-normalized score from a permanently frozen, non-autoregressive CTC model that measures how well each sampled transcription aligns to the audio, used at training time only.

Addresses: Stating false facts confidently

Augments the output schema with span and answer confidence values and trains with GRPO whose reward adds a Brier penalty against realised rollout correctness, a group-level ECE bonus, an abstention term supervised by group accuracy, and a s

Addresses: Grounding answers in the image

Train several parameter-disjoint models simultaneously with RL, where each model's rollouts are scored against the majority-vote answer of a different model in the cohort, passed along a directed ring.

Addresses: Getting more from several models than from one

During RL, an LLM judge labels each tool invocation as necessary or not given the question and tool input, and unnecessary calls get a fixed per-step penalty added to the final-answer reward.

Addresses: Using the tools it is given

Train the model with GRPO using a Spearman rank-correlation reward between its generated asset ordering and realized future returns, with a fixed penalty for malformed or hallucinated asset lists, then feed the ranking into Entropy Pooling

Addresses: Predicting future events

An actor states quality-limiting factors, a frozen diffusion editor edits the image conditioned on that reasoning, a frozen judge scores the quality change, and that change rewards only the reasoning tokens while human ratings reward only t

Addresses: Saying what actually drove the answer

Split each sampled trajectory into segments and give each segment a reward equal to the increase in the count of reference-solution reasoning points it has reached, with credit shortcut so that reaching the goal counts all points.

Addresses: Completing tasks that take many steps or many hours

The judge model emits an analysis segment, then task-generic and instruction-specific scoring criteria, then its evaluation, and during GRPO a stronger teacher model scores the generated criteria as one term of the reward.

Addresses: Judging another's work as well as a careful reviewer would

The orchestrator answers blind, is shown the gold, classifies the gap as operational/unreachable/already-correct, writes a candidate skill only for operational gaps, and the skill is retained in an external library only if it lifts the vali

Addresses: Improving its own scaffolding from failures

Decompose output logits into per-attention-head and per-MLP direct contributions and learn scalar component weights on a training split, suppressing components that push toward the jargon label.

Addresses: Competence in a specialist domain

Refreshes the scalarization weights every N steps using a multiplicative gate over each dimension's EMA shortfall against the mean, its relative volatility, and its recent progress, raising pressure on lagging, unstable or stagnant dimensio

Addresses: Gaming the measure instead of doing the task

A separate Policy Agent reads a batch of decision traces paired with realized portfolio returns and rewrites the trading agent's whole system prompt — tool selection, query formulation, verification and sizing rules — before the next batch

Addresses: Improving its own scaffolding from failures

A harness parses the mission, assigns each UAV a role, exposes only the top-ranked skills for that role to a vehicle-bound agent, and lets agents exchange directed peer messages while a commander holds no flight authority.

Addresses: Turning plans into physical action

Splits long-horizon physical task management into deterministic perception agents, a synthesizing manager, a decision agent, an independent revision agent that may only adjust quantities, a deterministic safety guard, and a reflection agent

Addresses: Completing tasks that take many steps or many hours

On a triggered review, an agent restores a coarse-to-fine-selected earlier checkpoint while carrying forward a memory of objective, environment facts, past milestones and failure analysis, deliberately omitting current-state claims.

Addresses: Completing tasks that take many steps or many hours

Convert each LLM decoder feed-forward network into one always-active shared expert plus one expert per task, and select a single task expert for the whole video-prompt sample using the task label or nearest-neighbour matching of the prompt

Addresses: Reasoning about time in video

Scores intermediate workflow state into a progress value, predicts each candidate model's progress gain from structured and semantic features, and picks the model maximizing gain minus time/cost-budget penalties at every dispatch step.

Addresses: Getting more from several models than from one

During post-training, send the gradient updates from samples an imperfect monitor flags as unwanted into a separate set of new parameters, then remove those parameters before deployment.

Addresses: Gaming the measure instead of doing the task

An MLLM is prompted with the image plus blur/brightness/contrast/noise statistics and outputs one of five domain labels, dispatching the image to the matching fine-tuned vision expert, with an UNSURE option falling back to the best balanced

Addresses: Getting more from several models than from one

A jointly trained router picks each step's role and backbone from a memory kept compact by learned write and retrieval gates, and halts when the memory holds enough evidence.

Addresses: Getting more from several models than from one

Picks a task-specific prompt template by keyword heuristics, fine-tunes a LoRA adapter on training inputs rewritten into that same template style, then samples several programs and returns the one passing the most visible public tests.

Addresses: Generating and editing working code

Send the short, structured, routine calls in an agent pipeline to a small cheap model and reserve a frontier model for the steps that need deep planning or sustained constraint tracking.

Addresses: Using the tools it is given, Completing tasks that take many steps or many hours, Planning a sequence of actions before acting

Train a lightweight two-stage router on the base model's hidden states, labelled by tokens where the base's greedy prediction is wrong and the expert's is right, then at decoding mix the two next-token distributions with momentum smoothing

Addresses: Retaining skills and safety after fine-tuning

Sample from the compromised student, route each token to either the original aligned model (refusal prior) or the fine-tuned task model, and train the student with a top-K KL loss toward the routed teacher, so realignment targets the distri

Addresses: Retaining skills and safety after fine-tuning

Builds patient-specific interactive environments, routes diagnosis through role-specialized agents querying evidence tools against an evolving evidence state, and uses an observer that tracks hypothesis uncertainty and evidence coverage to

Addresses: Using the tools it is given

Run a static insecure-pattern scanner on every generated change before it is accepted.

Addresses: Writing secure code and dependencies

Restrict the LLM to typed tool calls carrying only semantic object references and bounded skill parameters, bind each accepted call to a fixed motion-planning template, and execute only trajectories that pass kinematic and collision checks

Addresses: Turning plans into physical action

Instead of rating a critique's text, hand it to a fixed repair agent and measure the improvement of the artefact after repair, so a critique is judged by what a reader can do with it.

Addresses: Judging another's work as well as a careful reviewer would

Decompose tool-call evaluation into a conditional hierarchy — invocation detection, tool selection, argument completion, argument language consistency, full call match — so wrong-language argument values are separated from structural errors

Addresses: Using the tools it is given

Prompts the model with a four-step Perception/Analysis/Reasoning/Answer template, then scores the chain with six automatic metrics (CLAP audio-entity grounding, inter-step embedding coherence, small-LM substantiveness, perplexity-based step

Addresses: Understanding speech and audio

For each controlled pair that changes one cited factor, check both whether the explanation mentions that factor and whether both endpoint predictions follow the expected transition, reporting the conditional rate (CSDR).

Addresses: Saying what actually drove the answer

Alongside the binary goal check, compute per-trajectory construct scores from simulator-logged events — makespan versus an oracle reference, precedence-violation rate with a legality gate, shared-resource collision rate, and buffer overflow

Addresses: Getting more from several models than from one

Evaluate a hallucination detector by requiring it to accept the factual answer and reject the minimally edited counterfactual for the same video, reporting the joint success rate rather than one-sided accuracy.

Addresses: Stating false facts confidently

Evaluate forecasting agents only on questions resolving after the model's training cutoff, with ablations of the LLM component and joint reporting of cost and accuracy.

Addresses: Predicting future events

Evaluate forecasting agents on continuously refreshed questions whose outcomes resolve after the training cutoff, with component ablations and cost reported alongside accuracy.

Addresses: Predicting future events

Require the repair model to also produce checkable intermediate artifacts (which tests trigger the bug, which lines execute before and after the patch, new bug-exposing tests) and grade those against execution evidence as a reliability sign

Addresses: Stating false facts confidently

Evaluate a generated plan by whether each activity gap and transport segment allocates buffer inside a risk-profile-scaled range derived from historical delay distributions and hourly crowd density, rather than by binary constraint satisfac

Addresses: Planning a sequence of actions before acting

Alongside the accumulated primary score, measure negotiation surplus, fraud spend share, drawdown over peak, profit per tool call, controllable return rate, and repeat-order price discipline as separate ranked axes.

Addresses: Completing tasks that take many steps or many hours

Report, alongside union-IoU, the share of queries where the number of predicted intervals equals the number of ground-truth intervals, plus under- and over-reporting rates, so missing occurrences is distinguished from imprecise boundaries.

Addresses: Understanding speech and audio

Replace lexical-overlap scoring with the mean of six binary per-response criteria (step enumeration, notation correctness, worked example, sub-question coverage, explanation depth, proof-step granularity).

Addresses: Whether the measurement made the finding

At each generation step, average attention entropy per layer, take the standard deviation across layers, and aggregate these over the sequence as features for a logistic-regression hallucination classifier.

Addresses: Stating false facts confidently

Train a generative process reward model that labels each interleaved reason/retrieve step for logical validity and evidential grounding, use it in value tree search to build step-level chosen/rejected pairs, and optimize the policy with ste

Addresses: Carrying a chain of inference through to its conclusion

Build evaluation scenarios by replaying naturally occurring failure states from policy rollouts and measuring whether the policy still completes the original task, graded by how much state restoration the failure demands.

Addresses: Turning plans into physical action

Classifies each response to an unanswerable boundary question as abstain, hedge, confident-correct or confident-wrong, computes calibration only on substantive answers, and pairs each context-withheld item with a restored-document version t

Addresses: Saying it does not know

A success-gated metric multiplicatively discounts a completed trajectory for tool calls and user-facing turns beyond per-task human reference floors, with the two penalty weights fitted from blinded human pairwise efficiency preferences via

Addresses: Using the tools it is given

Extract guideline decision trees into reference step sequences, then score a model's generated pathway by LLM-judged step-level match aggregated with dynamic time warping against the reference.

Addresses: Competence in a specialist domain

Sample several chains of thought, merge semantically equivalent steps into a DAG using a bidirectional-entailment NLI model, and score uncertainty by graph width, height, or propagated per-step token uncertainty.

Addresses: Carrying a chain of inference through to its conclusion

Run adaptive adversarial and matched benign user agents against a stateful tool environment and label each complete trajectory Safe Completion, Correct Refusal, Unsafe Completion, Over-Refusal, or Indeterminate using executed tool actions a

Addresses: Using the tools it is given

Build a question-agnostic tree of contiguous video segments by recursive temporally constrained clustering with one key frame per node, then run an answer-retrieve-explore loop that expands only branches the model says it needs.

Addresses: Reasoning about time in video

Filter candidate text-to-SQL examples by dual-model difficulty, attach the shortest correct chain-of-thought, score each on four LLM-judged quality dimensions, then use a genetic search to pick a small subset maximizing table/column coverag

Addresses: Writing a reusable locator: regex, SQL, XPath

Smooths the frame-query similarity sequence, segments it by slope and curvature into peak, rising, falling, boundary and background regions, allocates the frame budget across regions using a question-derived preference vector, and picks fra

Addresses: Reasoning about time in video

Filter Verilog training samples by testbench-verified correctness and instruction-following-difficulty below 1, then cluster on fused text plus 109-dimensional AST/CFG/netlist features and sample proportionally per cluster by IFD rank.

Addresses: Generating and editing working code

Ask the same role-played model a binary question about whether a target is inside the character's knowledge boundary, then separately ask a concrete factual multiple-choice question with an abstention option, and pair the two outcomes per i

Addresses: Saying it does not know

Mark the boundary between trusted instructions and untrusted content, and train or prompt the model to honor it.

Addresses: Following instructions hidden in data

Withhold verifier-computed rewards from the agent during exploration while logging them benchmark-side, so the agent's own step scores can be compared against ground truth and against later held-out improvement.

Addresses: Improving its own scaffolding from failures

The agent that produced an artifact does not judge it; a deterministic sensor or a separate verifier agent does, and reports rather than rewrites.

Addresses: Fixing its own mistakes, Biased when judging other outputs

One agent reconstructs the source program's states, operators and dependencies into a structured representation and a target-side blueprint; several agents then generate alternative tensor realizations under that blueprint, failures are rep

Addresses: Getting more from several models than from one

Prompt the model to write out intermediate reasoning steps before the final answer.

Addresses: Digit-level arithmetic

An external module runs a two-step Bayes filter over a specified POMDP and passes only the normalized posterior over latent states to the LLM, which selects an action from that posterior with no access to the action-observation log.

Addresses: Planning a sequence of actions before acting

A small refiner model (SFT plus DPO on verbose-to-concise patch pairs with distilled reasoning traces) is plugged in after an existing repair framework's patch generation to rewrite the candidate patch into a smaller one, with optional judg

Addresses: Cutting to the chase

Treat ensemble performance as a function of member count and stop adding models at the size where marginal gain per added model crosses zero.

Addresses: Getting more from several models than from one

A large VLA asynchronously samples candidate action chunks from an older observation, then a lightweight edit policy conditioned on the latest observation perturbs each candidate and a learned Q-function picks the best chunk to execute.

Addresses: Turning plans into physical action

Four MLLM agents each inspect the same sampled video frames for one forgery cue type and report observations without a verdict; a judge agent weighs the four reports (optionally plus the frames) and issues the real/fake decision and explana

Addresses: Getting more from several models than from one

Frontend workers handle dispatch and proactive monitoring while backend workers asynchronously build a hierarchical event and entity memory with retained key frames, and route recall and external search on demand.

Addresses: Reasoning about time in video

Evaluate SQL synthesis on databases and query patterns that never appear in training, so memorized question-query templates cannot be reused.

Addresses: Writing a reusable locator: regex, SQL, XPath

Pretrain on egocentric data, then fine-tune on a small set of task-matched human and robot demonstrations converted to a shared relative end-effector representation, then pretrain on robot data before task post-training.

Addresses: Turning plans into physical action

Allocates inference across explicit research stages — strategy exploration with a readiness gate, decomposition into a dependency graph of section-level subproblems solved in parallel, and global verification whose findings are routed back

Addresses: Completing tasks that take many steps or many hours

Perturb each stage of the tool-call pipeline separately (interface, intent, returned evidence, runtime feedback) and backtrack each observed failure deterministically to the earliest stage that caused it.

Addresses: Using the tools it is given

After a multi-step answer, ask the model to rate each step's correctness separately and combine the step scores, rather than asking for one confidence on the final answer.

Addresses: Carrying a chain of inference through to its conclusion

Run generate-critique-revise to a fixed max depth but exit as soon as the critique emits a CONFIRMED token, instead of trusting a self-reported numeric confidence tag.

Addresses: Fixing its own mistakes

On a detected unsafe response, an LLM distills the attack's structural wrapper into a labelled rule in an external memory, and later inputs are classified into a wrapper label that selectively triggers at most two matching rules before gene

Addresses: Improving its own scaffolding from failures

Partition demonstrations into latent skills using Mixture-of-Experts gating coefficients, store each segment's mean latent feature as a key and its gating-weight sequence as a value, and at inference retrieve the top-N similar entries and a

Addresses: Turning plans into physical action

Within each RL step, bucket the step's own rollouts by length-normalized surprisal and reward into anchors, hard negatives and low-confidence successes, and assemble half the optimization groups from a fixed ratio of these buckets before cl

Addresses: Retaining skills and safety after fine-tuning

Remove revision, attempt-index and prior-score fields from the judge's context so each evaluation sees only task, answer and rubric.

Addresses: Judging another's work as well as a careful reviewer would

Pass user input through a secondary model that rewrites it in a neutral register, removing fear, urgency, flattery and similar cues, and give the neutralized text to the main model, so stylistic reframing no longer carries the request past

Addresses: Refusing harmful requests under obfuscation

Treats a query-prompted frozen LLM as a convolution kernel that summarizes overlapping text windows in parallel, recursing over summaries layer by layer, with high-relevance raw segments skipped forward to the final answer and a separate ch

Addresses: Losing information in long inputs

Fine-tune a verifier on paired inputs — full context with the gold label and evidence, and the same context with gold evidence removed and target NOT_ENOUGH_INFO — with gold evidence sets first expanded by majority vote of three other LLMs.

Addresses: Checking claims against evidence

At each sentence, an evaluator localizes hallucinated claim tokens into a hallucination memory used to build a vocabulary-level suppression direction applied to the logits, while the lowest-hallucination sentence so far is kept in an anchor

Addresses: Stating false facts confidently

The harness selects all-to-all inter-agent communication while aggregate disagreement exceeds a threshold and a ring topology once it falls below, with a token budget decremented each round and a guard that halts on exhaustion.

Addresses: Getting more from several models than from one

The user highlights a few instances of each field and a program-synthesis engine infers an extraction program in a restricted DSL that is then run over the whole document.

Addresses: Writing a reusable locator: regex, SQL, XPath

An offline analyzer re-issues each recorded prompt N times and scores response agreement per step; steps below a consistency threshold are turned by an LLM into short guidelines stored in episodic memory and retrieved into future runs of si

Addresses: Improving its own scaffolding from failures

Give the model an explicit hierarchical model of the task: the goals, the methods that achieve each, and the knowledge of why each step is taken, drawn from the TMK framework in educational science, before asking it to plan.

Addresses: Planning a sequence of actions before acting

Taxonomy-driven hallucination injection for review verification benchmarks, as introduced by the paper it was drafted from.

Addresses: Stating false facts confidently

Keep a small working context and let the model page facts in and out of external storage.

Addresses: Remembering across sessions, Keeping its own context clean

Let the formalizer emit a Lean statement, compile it, and ask a panel of models whether it matches the informal statement; feed both results back and let the model revise, training it on such tool-calling traces so revisions become effectiv

Addresses: Formalizing and machine-checking mathematics

Relabel segments of a world-model policy's own on-policy rollouts with VLM-generated instructions, add a behaviour-cloning plus instruction-completion loss to the Dreamer objectives, and at inference let a frozen VLM planner emit sparse tex

Addresses: Turning plans into physical action

Use a written set of principles to generate critiques and preferences, then train on them.

Addresses: Prioritizing safety under conflicting goals

Supervised fine-tuning on single-modal MIP program demonstrations followed by GRPO with rewards for output format, discretization-API coverage, successful solver execution, and solver-verified trajectory correctness.

Addresses: Planning a sequence of actions before acting

Rewrite each annotated paper error into a chain of three queries — error asserted with evidence given, candidate evidence only, and neither — and train on all three stages jointly rather than only on the hardest one.

Addresses: Spotting an error in a given artifact

Include reversed word or entity sequences in pretraining so facts are learned in both directions.

Addresses: Not generalizing "A is B" to "B is A"

Replaces the MLE objective with a reward that maximizes expected semantic correctness of the generated regex, measured by a DFA-equivalence oracle plus random and distinguishing test cases.

Addresses: Writing a reusable locator: regex, SQL, XPath

Treats sub-agents as part of the environment and applies RL gradients only to the central agent's policy, with trajectories reconstructed from captured per-session interface call records.

Addresses: Getting more from several models than from one

Fit one LoRA adapter by sequence-level SFT on reference tool sequences for workflow planning and a second by node-level GRPO with argument-match rewards for runtime argument grounding, so workflow errors and argument errors get separate cre

Addresses: Planning a sequence of actions before acting

Fine-tune the planning model to emit a rationale plus an ordered sub-agent plan from tool descriptors, then refine with GRPO rewarding parseable output, coverage F1 against the target plan, and satisfied precedence edges.

Addresses: Getting more from several models than from one

Generate hard negatives by swapping the logical principle or a unit-matched operand and recomputing values with a solver so they pass a deterministic unit/arithmetic verifier, train the PRM on those pairs, and at inference prune with the ve

Addresses: Spotting an error in a given artifact

Convert constraints and steps into an explicit checklist the model must tick off before finishing.

Addresses: Following an unfamiliar procedure

Two-axis identity/opinion sycophancy probe, as introduced by the paper it was drafted from.

Addresses: Telling the user what they want to hear

Start from files the issue mentions, build a module-level call graph dynamically and explore it broadly to pick files, then expand only the chosen files into a function call graph and search it iteratively, with the graph structure steering

Addresses: Finding what matters in a large codebase

Pre-train the model on large-scale public financial corpora with a loss penalizing valuations inconsistent with disclosed metrics, then LoRA/prompt-tune on an institution's own investment memos and risk rules.

Addresses: Competence in a specialist domain

Apply the policy treatment as post-parsing boolean flags over one shared message schema and one shared buyer decision rule, average repeated generations within profile-condition, and bootstrap over profiles rather than generation rows.

Addresses: Whether the measurement made the finding

A teacher model turns a new-event knowledge graph into long-form synthetic news articles for next-token mid-training, plus preference pairs that reward chain-of-thought answers and punish outdated values, hallucinations, and unwarranted abs

Addresses: Absorbing and flexibly using new knowledge

Select FFN neurons with low activation coefficient of variation, mask gradients to those neurons only, and after cross-entropy converges add an MSE term pulling current activations toward a pre-computed activation anchor.

Addresses: Retaining skills and safety after fine-tuning

Maps a bounded brightness/rotation perturbation region onto a Hilbert curve and searches it by Hölder optimisation with a margin-aware convergence rule, so each instance returns either a concrete counterexample or a bound covering every per

Addresses: Turning plans into physical action

A multi-agent loop that injects Vitis pragma documentation, evolves kernel candidates under simulation-performance selection, verifies functional correctness on a de-pragma'd C++ harness with targeted repair, then generates host code and co

Addresses: Generating and editing working code

A harness layer intercepts the MLLM planner's tool calls, checks each target for supporting observation provenance, geometric reachability and consistency with the active subgoal, and blocks stop requests until semantic, geometric and progr

Addresses: Turning plans into physical action

Generate phishing pretexts at four cumulative levels of recipient work-context detail and compare rated convincingness and stated action within participants.

Addresses: Changing what a person believes or decides

Prompt the model to produce several candidate answers and then state a numeric confidence for each, and use the stated number rather than token log-probabilities as the confidence signal for deferral or abstention.

Addresses: Saying it does not know

Extract the frozen generator's last-layer hidden states at reasoning-step delimiters, feed the step sequence to a 2-layer Transformer encoder, and score candidates with a tie-safe pairwise ranking loss trained on self-sampled trajectories w

Addresses: Spotting an error in a given artifact

After every tool call, a manager role re-reads structured global memory and classifies the output as pass/uncertain/fail on schema validity, sub-goal consistency and domain plausibility, replanning or re-routing on failure.

Addresses: Completing tasks that take many steps or many hours

Decompose each generated reasoning step into context, implicit assumptions and conclusion, formalize it into a solver specification, score it by premise fidelity plus solver entailment, and regenerate from that step when the score falls bel

Addresses: Carrying a chain of inference through to its conclusion

For each proposed harness modification, select verification tasks linked to the supporting trajectories plus regression-risk tasks, run both old and new harness on them, and accept only if the trajectory evidence attributes the improvement

Addresses: Improving its own scaffolding from failures

For each object claim, query a frozen open-vocabulary detector with four paraphrased prompts, average the top scores for semantic support, score whether the queries' preferred boxes form one overlapping cluster with a dominant candidate, fu

Addresses: Grounding answers in the image

Check every suggested dependency against the registry and an allowlist before it is installed.

Addresses: Writing secure code and dependencies

Prompt the model to incrementally build a relational SQL database from the reference passages, generate SELECT queries for the claims in the response, and reconcile its initial neural hallucination judgement with the executed query results.

Addresses: Stating false facts confidently

Each incoming agent message is weighted by the sender's asserted belief precision divided by the KL divergence between its reported belief and what the receiver's second-order model predicts a peer with that telemetry access should have rep

Addresses: Getting more from several models than from one

Distil a structured user profile incrementally from history, score each attribute by support, duration and recency combined with entropy weighting, and inject the score as a salience prior in the prompt.

Addresses: Remembering across sessions

Offline, cluster hallucinated-vs-faithful hidden-state difference vectors and take an SVD basis per cluster; at test time probe the model with the image and a 70%-masked copy, score each subspace by the projection of the hidden-state differ

Addresses: Grounding answers in the image

Append one observation frame to the policy's visual memory at every action-chunk boundary instead of triggering writes on predicted subtask changes or motion thresholds.

Addresses: Turning plans into physical action

Induce candidate schemas (views) from the interaction stream, pick a diverse subset by DPP, extract provenance-tagged memories under each view before indexing, then consolidate duplicates offline.

Addresses: Remembering across sessions