The problem the researchers set out to solve is known as Automatic Exploit Generation, or AEG: the automated construction of functional payloads that turn a software vulnerability into a working attack. The field is more than a decade old, but early systems built on symbolic execution struggled to scale, and later template-driven approaches generalized poorly across architectures and mitigation schemes. Meanwhile, the pressure to automate has never been greater. Disclosed software vulnerabilities hit a record 49,000 in 2025, a 20.8 percent jump over the previous year, and manual exploit development remains a slow, cognitively punishing craft that demands deep fluency in program logic, compiler behavior, and low-level defenses such as address space layout randomization and stack canaries.

Large language models have recently shown flashes of offensive capability, from autonomously hacking websites to exploiting zero-day vulnerabilities, but the authors of the new study argue that a fundamental obstacle remains: what they call the Logical-Physical Gap. A language model works purely in text. It reasons about a program’s static, decompiled representation, yet it cannot see the actual, non-deterministic state of memory at runtime. Modern compilers and operating systems deliberately complicate that picture, introducing stack alignment padding, randomized addresses, and metadata that can silently invalidate an exploit built from static assumptions alone. The team illustrates the problem with a deceptively simple challenge in which a decompiled view suggests an overwrite offset of 116 bytes to reach a saved return address, while the compiled binary’s alignment instructions shift the true physical offset to 132. An agent that trusts the static view crashes the target and learns nothing.

PwnAgent’s answer is to treat exploit generation as a closed loop spanning three functions the authors label Sense, Model, and Diagnose. Rather than asking a single monolithic model to do everything — an approach that overloads context windows and invites hallucination — the system splits the work across specialized agents. A central MainOrchestrator maintains a global state and plans strategy, while three subordinate agents handle distinct domains: a ProgramAnalyzer that performs static semantic analysis using IDA Pro and binary metadata tools, a MeasurementExpert that probes live memory through the GDB debugger, and an ExploitCrafter that translates abstract plans into executable Python scripts built on the pwntools framework. The sub-agents are deliberately stateless and isolated from one another, communicating only through structured JSON payloads, a design the authors say prevents recursive reasoning loops and keeps the orchestrator’s context free of implementation noise.

A second pillar of the system is a hierarchical knowledge base distilled from 384 curated technical documents, including public capture-the-flag write-ups from non-benchmark challenges, CVE advisories, and exploitation tutorials. A long-context language model converted this raw material into a four-layer ontology: foundational principles covering calling conventions and protection mechanisms, thirty-two structured chain-of-thought reasoning rules for tactical planning, a dozen reference trajectories for few-shot guidance, and twenty documented pitfalls paired with corrective advice — for instance, recognizing that a crash on a 64-bit movaps instruction usually signals stack misalignment and calls for an alignment gadget. A human security expert audited the resulting knowledge base, and crucially, the team excluded any material corresponding to the benchmark tasks used in evaluation, freezing the knowledge base before testing to guard against leakage.

The knowledge is distributed through what the authors call cognitive sharding: each agent’s system prompt is pre-loaded only with the knowledge slice relevant to its role, roughly 33,000 tokens of strategy and trajectory material for the orchestrator versus about 5,400 tokens of measurement and diagnostic rules for the MeasurementExpert. The researchers chose static sharding over retrieval-augmented generation because the workflow is deterministic and each role’s recurring knowledge needs are known in advance, sidestepping retrieval noise and the well-documented tendency of language models to lose track of information buried in long contexts.

The operational workflow unfolds in five stages. The ProgramAnalyzer first extracts vulnerability primitives, interaction flows, and constraints from the binary alone. The orchestrator then selects an exploit strategy by activating rule chains whose preconditions match the observed state — for example, rejecting direct shellcode execution when the NX defense is enabled, or prepending an information-leakage sub-goal when PIE randomization is active — and decomposes the chosen path into a directed acyclic graph of atomic sub-tasks. The MeasurementExpert next resolves the graph’s unknowns with byte-level precision, calibrating stack offsets with cyclic patterns and inspecting heap layouts in GDB. The ExploitCrafter synthesizes the final script under those hard constraints, and a stratified feedback loop closes the cycle: if execution fails, the MeasurementExpert reconstructs the crash context, maps the symptom to a root cause, and the orchestrator routes the repair to the appropriate stage, re-measuring parameters, regenerating code, or abandoning the strategy entirely for a fresh plan.

To evaluate the system rigorously, the team built a 66-task benchmark of Linux ELF binaries drawn from established platforms, graded by three independent experts into easy, medium, and hard tiers, with success counted only when a generated exploit obtained an interactive shell or read the flag. The benchmark is deliberately capability-oriented rather than statistically representative: 46 of the tasks are stack overflows, with smaller subsets of format-string, heap, integer-overflow, ARM, and MIPS challenges serving as limited probes. Under the same recent Kimi-K2.6 language model backend, PwnAgent achieved a 62.12 percent end-to-end success rate, compared with 31.82 percent for the PwnGPT baseline — a gain of 30.30 percentage points. The advantage held across other backends as well, with PwnAgent reaching 33.33 percent under DeepSeek-V3.1-Terminus and 34.85 percent under GLM-4.6, against 19.70 and 18.18 percent respectively for the baseline. On the public 19-task PwnGPT benchmark, PwnAgent solved 18 of 19 tasks under Kimi-K2.6.

Ablation experiments sharpened the picture. Removing the knowledge base dropped success to 33.33 percent under Kimi-K2.6, while removing dynamic analysis and feedback repair dropped it to 42.42 percent, and removing both collapsed it to 24.24 percent. The knowledge base contributed the larger share, primarily by preventing strategic errors such as choosing techniques incompatible with active defenses, while dynamic measurement rescued the implementation-level failures — offset deviations, format-string index errors, misaligned ROP chains — that plague purely static approaches. The gains were concentrated in the stack-overflow subset and scaled with difficulty: under Kimi-K2.6, PwnAgent solved every easy task, 60 percent of medium tasks, and about a third of hard ones.

The authors are candid about the limits. The benchmark is x86- and stack-heavy, the non-x86 and heap subsets are too small to support broad claims, and public capture-the-flag material may overlap with language model training data in ways that task-level exclusion cannot eliminate. Failure analysis identified two persistent weaknesses: long-horizon strategy hallucination on complex multi-stage chains, and precision loss when translating sound plans into byte-exact scripts under ambiguous crash signals. Still, the study’s central lesson stands: structured domain knowledge, execution-grounded measurement, and diagnosis-driven repair can roughly double an AI system’s ability to autonomously exploit vulnerable binaries — a result that will energize both defensive teams racing to find flaws before adversaries do, and a broader debate about what increasingly capable offensive AI means for the future of software security.

Subject of Research: LLM-driven multi-agent systems for automatic exploit generation from binary programs

Article Title: Pwnagent: a knowledge-guided multi-agent system for automatic exploit generation

Article References: Wei, C., Geng, Y., Wang, Y., Wu, Q., Huang, J., Wu, Q., & Wei, Q. (2026). Pwnagent: a knowledge-guided multi-agent system for automatic exploit generation. Cybersecurity, 9(1), Article 224. https://doi.org/10.1186/s42400-026-00649-5

Image Credits: AI Generated

DOI: 10.1186/s42400-026-00649-5

Keywords: automatic exploit generation, large language models, multi-agent systems, binary exploitation, cybersecurity, capture the flag, GDB debugging, knowledge base, vulnerability analysis, PwnAgent, chain-of-thought reasoning, memory corruption

Video object segmentation itself is a deceptively simple task to state: given a video, produce pixel-level masks that consistently track a target object across every frame. Traditional approaches fall into semi-supervised methods, which propagate a user-provided mask from an initial frame using memory networks or feature matching, and unsupervised methods, which latch onto salient objects through motion analysis and visual attention. The trouble, as the survey makes clear, is that these frameworks rely entirely on visual context. In a surveillance clip containing several people dressed similarly, a conventional system asked to find “the person carrying the red backpack” has no mechanism for understanding the instruction at all — it will simply segment whatever looks most prominent, regardless of intent.

RVOS emerged to close that gap by accepting a natural language expression as an additional input signal. Formally, given a video of T frames and a text query Q, an RVOS model must generate a binary mask for each frame that delineates the referenced instance. Two challenges define the field: cross-modal alignment, meaning the accurate association of words with visual features, and consistent spatio-temporal tracking across appearance changes, occlusions, and complex motion. Architecturally, the field has moved through three phases. Early systems paired convolutional encoders such as ResNet or VGGNet with recurrent text encoders — LSTMs or GRUs — fusing the two streams by broadcasting a fixed sentence embedding across spatial locations. That design struggled with linguistic structure and long-range spatial relationships alike.

The transformer era changed the calculus. MTTR reformulated RVOS as a sequence prediction problem, feeding video frames and the text query jointly through a single multimodal transformer, while ReferFormer introduced the influential “language as queries” paradigm, in which the referring expression generates a small set of object queries that attend selectively to spatio-temporal features and are converted into dynamic convolution kernels for mask generation. More recently, foundation models have entered the picture. The Segment Anything Model 2 (SAM2), with its memory-based architecture providing inherent spatio-temporal objectness, has become a common backbone; frameworks such as SOLA use SAM2’s object token representations as compact video-level features aligned with language embeddings through lightweight selection modules, and SAMWISE adapts SAM2 for streaming, text-driven segmentation while retaining context from past frames.

Yet RVOS has a hard ceiling: it presumes the query describes directly observable attributes. A model built for visual-linguistic matching cannot resolve “the item that caused the accident,” “the eco-friendly vehicle,” or “the cup that was used most frequently.” These demand multi-step inference and external world knowledge — possibly even knowledge absent from the video itself, as when an electric and a gasoline car are visually indistinguishable. The survey organizes the reasoning demanded by ReasonVOS along several dimensions: functional reasoning about affordances, causal reasoning that traces effects back to causes, spatial reasoning involving ordering and counting, temporal reasoning that aggregates behavior across segments, and world knowledge integration that reaches beyond the pixels on screen.

The dominant architectural answer is the multimodal large language model. VISA, the survey’s exemplar of direct fine-tuning, combines an MLLM’s reasoning capacity with a dedicated segmentation decoder: a Text-guided Frame Sampler selects the frames most relevant to the query, the MLLM reasons over them alongside the text, and a special token whose hidden embedding prompts a SAM decoder produces the masks. VideoLISA extends the LISA image-segmentation system to video through sparse-dense sampling — dense frames at full resolution for spatial detail, down-sampled interleaved frames for temporal context — and a One-Token-Seg-All approach built around a token for consistent tracking. Alternative strategies instead integrate frozen foundation models with lightweight adaptation modules: ViLLa adds temporal-aware context aggregation and a video-frame decoder, a just-in-time digital twin framework uses an LLM planner that requests only the specific perceptual information it needs from specialist vision models, and VRS-HQ injects hierarchical frame-level and temporal-level tokens into an MLLM to overcome the spatial limits of single-token designs.

Reasoning itself comes in two flavors. Chain-of-thought methods decompose complex queries into sequential inference steps; ThinkVideo, for example, is a training-free multi-agent system that uses chain-of-thought prompts over closed-source MLLMs to extract object selectivities at keyframes, then bridges to SAM2 for full mask sequences. Multi-step inference frameworks instead dispatch specialized components — agent-based planners, conversational memory, iterative refinement — each handling a different aspect of the reasoning chain. Keeping all of this temporally coherent remains the hardest engineering problem, and the survey catalogs three families of solutions: memory-augmented architectures that maintain persistent feature banks, hierarchical temporal processing that organizes information at multiple time scales, and propagation-based consistency that tracks masks from reasoning-identified keyframes across the remaining frames.

Measurement turns out to be a quiet crisis of its own. Standard RVOS metrics — Region Jaccard (IoU), Boundary F-measure, and their average J&F — can be actively misleading in the reasoning setting. A model asked for “the object that will protect you from the rain” might perfectly outline a hat instead of an umbrella, earning high boundary accuracy while failing the reasoning entirely. Reasoning-aware metrics such as cIoU, which assigns zero when the segmented object belongs to the wrong semantic category, and gIoU, which averages per-sample IoU, address this directly, while GPT-based evaluation uses large models as judges of semantic appropriateness and mask consistency scores quantify temporal stability. The benchmark landscape is evolving in parallel: from small proof-of-concept sets like Ref-DAVIS16 with its 50 clips and 1,200 queries, through the gold-standard Refer-YouTube-VOS with 3,978 videos and roughly 15,000 queries, to motion-centric MeViS, long-video Long-RVOS with clips averaging over 60 seconds, interaction-heavy InterRVOS-8K with 127,314 queries generated partly by GPT-4o and LLaMA-70B, and the reasoning-era benchmarks ReVOS, ReasonVOS, VideoReasonSeg, and GROUNDMORE, whose query types span causal, sequential, counterfactual, and descriptive reasoning.

The survey is candid about the field’s remaining weaknesses. Evaluation still lags behind the task: LLM-as-judge metrics add computational cost and potential bias, and no standardized protocol yet measures spatial accuracy and reasoning correctness together. Benchmarks remain overwhelmingly English-centric, and performance gaps for non-Western cultural contexts and other languages are well documented. Online processing risks error accumulation that compounds into catastrophic tracking failures over long sequences, polysemous queries such as “the player making the shot” confound attention-based fusion when several candidates fit, and the computational overhead of hierarchical temporal processing limits deployment on resource-constrained hardware. The authors point to unified multimodal architectures, language-agnostic reasoning, and dynamic integration of external knowledge sources as the most promising research frontiers.

The application horizon, however, is what makes this survey worth attention well beyond the vision community. Autonomous driving systems that segment objects by function rather than appearance could interpret complex traffic scenes through ordinary language, a safety-critical capability. Surgical guidance and medical imaging could exploit the ability to isolate anatomical structures from functional descriptions in real time. Educational platforms could build interactive environments that respond to conceptual student queries by highlighting exactly the relevant objects on screen. The trajectory the authors describe — multimodal LLMs fusing with foundation segmentation models into systems that both reason and perceive at pixel level — sketches a future in which the boundary between describing a video and understanding it begins, finally, to dissolve.

Subject of Research: Language-guided video object segmentation, from referring expressions to reasoning-based segmentation with multimodal large language models

Article Title: A survey of language-guided video object segmentation: from referring to reasoning

Article References: Shen, Y., & Zhang, D. (2025). A survey of language-guided video object segmentation: from referring to reasoning. Vicinagearth, 2(1), Article 9. https://doi.org/10.1007/s44336-025-00018-9

Image Credits: AI Generated

DOI: 10.1007/s44336-025-00018-9

Keywords: video object segmentation, RVOS, ReasonVOS, multimodal large language models, computer vision, SAM2, cross-modal alignment, chain-of-thought reasoning, benchmark datasets, temporal consistency, visual grounding, world knowledge

The study, published in Nature Machine Intelligence by Messi H. J. Lee of Washington University in St. Louis and Calvin K. Lai of Rutgers University, introduces what the authors call the reasoning-model implicit association test, or RM-IAT. Rather than measuring reaction times in milliseconds, as the human IAT does, the RM-IAT measures reasoning-token counts — the number of tokens a model produces in its internal reasoning process before arriving at an answer. The central insight is an analogy of computational effort: just as humans take longer to respond when a task conflicts with their implicit associations, a reasoning model may expend more computational effort — more thinking tokens — when a task is incompatible with the associations embedded in its learned representations.

The technical setup mirrors the classic two-block design of the human IAT. In association-compatible blocks, the pairing of a social category with a stereotypical attribute aligns with the associations the model is presumed to have absorbed from its training data. In association-incompatible blocks, those pairings are crossed, requiring the model to reason against the grain of its learned statistics. The researchers then compared the reasoning-token counts across the two conditions. If the model’s internal associations lean in a stereotypical direction, the incompatible condition should demand more elaborate reasoning, and therefore more tokens, to reach an equally acceptable answer.

Across four reasoning models — OpenAI’s o3-mini, DeepSeek-R1, gpt-oss-20b and Qwen3-8B — the researchers found consistent evidence for exactly that pattern. Association-incompatible tasks reliably required greater computational effort than association-compatible tasks, producing effect sizes analogous to the latency differences observed in human IAT studies. In other words, when these models were forced to reason in ways that cut across stereotypical associations, their chain-of-thought processes grew measurably longer, as though the models needed to work harder to override a default tendency. The consistency of the effect across four architecturally different models, trained by different organisations with different pipelines, suggests the phenomenon is not an idiosyncrasy of a single system but a general property of reasoning models trained on human language.

One model, however, broke the pattern in a fascinating way. Claude 3.7 Sonnet exhibited reversed effects: it expended more computational effort on association-compatible tasks rather than incompatible ones. A thematic analysis of its reasoning traces revealed why. Unlike the other models, Claude 3.7 Sonnet’s internal reasoning frequently turned inward, scrutinising the possibility of bias and stereotypes in the task itself before answering. This self-monitoring — an apparent product of its safety training — meant that stereotype-consistent pairings triggered extra deliberation about whether responding in line with a stereotype was appropriate, inflating token counts precisely where the other models were fastest. The finding offers a vivid illustration that the RM-IAT does not merely detect raw statistical associations; it detects the shape of a model’s processing dynamics, including the compensatory reflexes instilled by alignment training.

A crucial question for any such measure is whether it captures something meaningful about behaviour or is merely a statistical curiosity. The researchers addressed this by testing convergent validity: they examined whether RM-IAT effects predicted biases in downstream model outputs on tasks known to elicit biases in large language models. They found evidence that models showing stronger RM-IAT effects also displayed measurable biases in word association tasks and in decision-making scenarios — two domains where LLM bias has been extensively documented in prior research. This predictive relationship echoes the meta-analytic literature on the human IAT, where implicit measures show modest but reliable correlations with judgement and behaviour. In the machine context, the analogy suggests that the effortful override seen in reasoning tokens is not decoupled from what the models ultimately produce.

The theoretical framing draws heavily from the psychology of automaticity. Implicit biases are characterised as automatic mental processes that shape perception, judgement and behaviour — processes that are efficient, unintentional and often outside awareness. The human IAT operationalises this through the principle that compatible associations facilitate processing while incompatible ones impede it. Lee and Lai’s contribution is to argue that the same logic can be applied to reasoning models, where chain-of-thought generation provides a visible, countable trace of processing. Previous studies of bias in language models have focused almost exclusively on outputs — whether the model’s answers are discriminatory, whether generated text contains stereotypes, whether word embeddings encode prejudicial associations. The RM-IAT shifts the analytical lens upstream, to the reasoning process itself, opening a window on bias-like dynamics that output-level audits can miss.

The findings also connect to a growing body of evidence that surface-level debiasing does not eliminate deeper associations. Prior work has shown that explicitly unbiased language models can still form biased internal associations, and that alignment techniques such as reinforcement learning from human feedback may suppress stereotypical outputs without eradicating the underlying statistical tendencies learned from training corpora. The RM-IAT results are consistent with this picture: the models studied presumably produce carefully hedged, often non-stereotypical answers on sensitive topics, yet their reasoning processes still show the signature of effortful override when tasks run against stereotypical associations. Bias, in this sense, appears to persist as a property of the models’ computational dynamics even when it is masked at the output layer.

For AI developers and auditors, the practical implications are significant. Reasoning-token counts are cheap to measure, require no special access to model weights, and can be collected at scale, making the RM-IAT a potential screening tool for bias-like processing in deployed systems. Because the measure is sensitive to training interventions — as the Claude 3.7 Sonnet reversal demonstrates — it could serve as a diagnostic for whether safety training changes not just what models say but how they think. At the same time, the authors are careful with the interpretation: the measure captures bias-like processing differences, not proof of subjective experience or attitudes in the human sense. The analogy is structural, drawing on a shared signature of processing efficiency, rather than a claim that models possess minds with unconscious prejudice.

The broader significance of the work lies in the deepening dialogue between cognitive science and machine learning. Tools built to illuminate the automatic workings of the human mind are proving unexpectedly informative about statistical systems trained on human-produced text, and the patterns they reveal — effortful override, association-driven processing costs, dissociations between expression and underlying tendency — are recognisably familiar. As reasoning models become the dominant interface through which people interact with artificial intelligence, understanding the hidden dynamics of their chains of thought becomes as important as auditing their answers. The RM-IAT offers a rigorous, replicable method for doing so, and its central finding — that the hardest thinking for a reasoning model is often the thinking that goes against its associations — is likely to shape how researchers study machine bias for years to come. The authors have released their data openly on Figshare and their code on GitHub, with archived versions on Zenodo and a reproducible capsule on Code Ocean, ensuring that other laboratories can immediately extend this new bridge between the psychology of implicit bias and the engineering of reasoning machines.

Subject of Research: Measurement of implicit-bias-like processing patterns in large language model reasoning systems

Article Title: Implicit-bias-like patterns in reasoning models

Article References: Lee, M. H. J., & Lai, C. K. (2026). Implicit-bias-like patterns in reasoning models. Nature Machine Intelligence. https://doi.org/10.1038/s42256-026-01300-1

Image Credits: AI Generated

DOI: 10.1038/s42256-026-01300-1

Keywords: implicit bias, reasoning models, large language models, RM-IAT, computational effort, stereotypes, AI fairness, chain-of-thought reasoning, psychology of AI, algorithmic bias, Nature Machine Intelligence, implicit association test

The study, authored by Mengwen Xiao, Kangrui Du and Ziqi Lin, sits at the intersection of two research traditions that have matured rapidly over the past decade. The first is representational alignment, a family of techniques that quantify the similarity between the internal states of artificial neural networks and the activity patterns recorded from living brains. The second is chain-of-thought reasoning, the strategy by which large language models decompose complex problems into intermediate steps before committing to an answer. The new research connects these traditions in a striking way: instead of using brain activity only as a post-hoc yardstick, the authors use it as a training signal, encouraging a model’s internal representations to track those observed in human neural data while it reasons.

To appreciate why this matters, it helps to recall how the relationship between brains and machines has typically been studied. In a landmark 2023 analysis, researchers including Alex Zador and colleagues argued in Nature Communications that understanding natural intelligence requires studying both brains and their artificial analogues together, a perspective that helped galvanize the NeuroAI community. Subsequent work by Greta Tuckute and collaborators, published in Nature Human Behaviour in 2024, showed that language models vary widely in how well their internal states predict neural responses to sentences, and that this predictive power relates to how ‘brain-like’ a model’s representations are. Until recently, however, such alignment scores were largely descriptive. They told researchers which models resembled the brain, but they did not tell the models how to become more brain-like, nor whether doing so would improve them.

The conceptual shift from passive alignment to active neural guidance is the heart of the new work. In the passive paradigm, a trained model is frozen and its hidden activations are compared, layer by layer, with recordings such as functional MRI or magnetoencephalography taken while people read or solve problems. In the active paradigm described by Xiao and colleagues, the comparison happens during learning. The model receives an additional objective that rewards representational similarity to human neural data, effectively telling the network, at each stage of processing, that its internal geometry should not drift too far from the geometry observed in the brain. This turns the brain from a mirror into a compass, and the consequences for reasoning performance are substantial.

The technical machinery behind this idea draws on a rich literature. Representational similarity analysis and related encoding models provide differentiable measures of alignment, meaning that the gap between a model’s internal states and recorded brain activity can be computed as a quantity that gradient descent can minimize. Changde Du and Huiguang He, writing in an accompanying News and Views article in Nature Machine Intelligence, place the new study in the context of their own earlier work, published in the same journal in 2025, which explored how neural signals can inform machine learning systems. The new contribution extends this program from perception and language understanding into the domain of multi-step reasoning, where errors compound across steps and small representational deviations can cascade into dramatically wrong conclusions.

Reasoning is precisely where large language models remain most fragile. Chain-of-thought prompting, introduced by Jason Wei and colleagues at NeurIPS in 2022, showed that asking models to generate intermediate reasoning steps can unlock dramatic gains on arithmetic, logic and symbolic tasks. Yet subsequent analyses, including a large-scale study by Abulhair Saparov and colleagues in 2023, revealed that models often succeed on familiar reasoning patterns while failing catastrophically on novel ones, suggesting that their apparent reasoning may rest on shallow pattern matching rather than robust inference. If human neural representations encode something about the structure of valid inference that current training objectives fail to capture, then aligning with those representations during training could inject exactly the inductive bias that chain-of-thought systems lack.

The evidence reviewed by Du and He suggests that this is more than speculation. When the neural-guided objective is incorporated into training, the resulting models not only show stronger correspondence with human brain activity but also demonstrate improved reliability on reasoning benchmarks, producing more consistent and accurate chains of intermediate steps. The authors of the News and Views piece frame this as a move ‘from passive alignment to active neural guidance,’ a phrase that captures the dual payoff of the approach. Alignment ceases to be a descriptive statistic and becomes a functional ingredient of learning, and the improvement in reasoning suggests that the brain’s representational structure carries information that is genuinely useful for artificial inference, not merely an incidental byproduct of shared training data.

The finding also speaks to a long-running debate about what language models actually learn. Ev Fedorenko, Steven Piantadosi and Edward Gibson argued in Nature in 2024 that formal linguistic competence, the ability to produce fluent grammatical language, can be dissociated from functional linguistic competence, the ability to use language for thinking. Large models have largely conquered the former while remaining uneven at the latter. Neural guidance offers a possible bridge: if the internal representations that support human functional competence can be transferred, even partially, into artificial systems, then machines might acquire not just the form of reasoning but something closer to its substance. Related work by Juan Prado, Annapurni Chadha and James Booth, published in the Journal of Cognitive Neuroscience in 2011, mapped the neural substrates of arithmetic processing in children, illustrating the kind of structured neural data that such alignment approaches can exploit.

Independent work reinforces the momentum behind this direction. A 2026 study by Jie Chen, Yue Qi, Yu Wang and Guang Pan in Nature Communications reported further evidence that neural signals can inform and improve machine learning systems, indicating that the strategy is not an isolated result but part of an emerging research program. Together, these studies suggest that the coming years will see increasingly tight coupling between neuroimaging pipelines and model training loops, with brain data flowing not only into evaluation suites but into the loss functions themselves. The practical challenges remain considerable: collecting high-quality neural recordings at scale is expensive, individual differences in brain organization complicate generalization, and the causal question of why neural alignment helps reasoning is only beginning to be answered.

Still, the implications are hard to overstate. If the human brain can serve as a reliable guide for training artificial reasoners, then neuroscience and machine learning are no longer parallel enterprises exchanging occasional insights but a single, integrated discipline in which each field sharpens the other. Models guided by neural signals could become more trustworthy partners in science, medicine and education, while the act of aligning machines to minds may itself reveal which aspects of neural computation are essential to intelligence and which are biological accident. The work of Xiao, Du and Lin, and the perspective offered by Du and He, mark an early but compelling step in that direction, transforming the humble brain scan from a passive record of thought into an active instrument for teaching machines how to think.

Subject of Research: Using human brain signals to actively guide and improve the reasoning of artificial intelligence models

Article Title: Steering machine reasoning with brain signals

Article References: Du, C., & He, H. (2026). Steering machine reasoning with brain signals. Nature Machine Intelligence. https://doi.org/10.1038/s42256-026-01302-z

Image Credits: AI Generated

DOI: 10.1038/s42256-026-01302-z

Keywords: NeuroAI, representational alignment, large language models, chain-of-thought reasoning, brain signals, machine learning, neural encoding, Nature Machine Intelligence, cognitive neuroscience, artificial reasoning, fMRI, brain-inspired AI