Emergent Mind

Explore the frontiers of AI, mathematics, and more. Created by @mhmazur.

[Emergent Mind @EmergentMind]

Exactly 0 spatial augmentations, view crops, or image masks are needed to learn dense representations from video.

A new paper, "You Don't Need Strong Assumptions: Visual Representation Learning via Temporal Differences", fundamentally shifts how we approach self-supervised vision models. The core finding is that the forward passage of time is the only inductive bias required to train robust pipelines.

State-of-the-art vision systems typically rely on heavy image transformations to prevent representation collapse during training. The Temporal Difference in Vision architecture abandons these completely. The model takes a current video frame representation, merges it with an encoded abstraction of exact pixel differences, and predicts the next frame directly in latent space.

Forcing the network to anticipate the immediate future causes high fidelity spatial consistency and boundary alignment to emerge naturally. The architecture develops excellent patch-level abstractions and maps local optical flow simply by minimizing temporal prediction error over consecutive steps.

Every human engineered structural assumption ultimately becomes a ceiling when you push toward massive data scale.

https://t.co/INVDe9oAhC

[Emergent Mind @EmergentMind]

A voice assistant can cut its response delay by a factor of eight if it begins evaluating partial sentences while the user is still talking.

"Streaming reasoning requires teaching the model to dynamically decide when to think, when to skip, and how to balance computation before the final word is spoken."

Standard language models use a read-then-think protocol, waiting for the entire prompt to arrive before beginning any computation. This creates lag in interactive applications. The authors of "AdaSR" restructure this by training models to interleave logic with perception.

As transcribed speech streams in, the model generates hidden intermediate thoughts based on the partial context. When the user stops speaking, it enters a quick deliberation phase to fuse those early thoughts into the actual response. To make this work, the system assigns distinct reward signals to evaluate logic generated during the partial stream versus the final complete synthesis.

This technique currently breaks down with continuous, unaligned inputs like raw audio, which require much richer phase-aware signals to prevent early mistakes from compromising the final output.

Reallocating computation into the streaming phase reduces post-input latency by more than a factor of eight on operational server hardware.

[Emergent Mind @EmergentMind]

The leap to superintelligence is not a magic step function. A new paper titled "From AGI to ASI" maps the exact physical and algorithmic boundaries that will govern what happens after human parity. Instead of a sudden intelligence explosion, the transition remains severely constrained by data exhaustion and foundational complexity limits.

The core friction limiting this transition is an abstraction barrier. Systems trained exclusively on human knowledge lack the mechanical ability to generate novel conceptual leaps from scratch. Breaking past our specific ceiling requires abandoning purely biological data constraints in favor of automated research pipelines and massive multi-agent collectives. Digital intelligence can scale speed and lossless memory sharing in ways that human organizations simply cannot match.

This theoretical escape velocity currently relies on a sustained 10x annual growth in effective compute.

Superintelligence will likely not arrive as a single monolithic system. It will instead emerge as a structurally distinct ecosystem of highly coordinated algorithmic collectives slowly grinding past the frontiers of biological science.

https://t.co/hDiJEDdJmg

[Emergent Mind @EmergentMind]

If you look closely at the training data of a brand new language model, you will almost always find the fingerprints of an older AI doing the heavy lifting.

Modern systems require pristine text to learn properly. Instead of hiring human writers, developers command older models to generate synthetic paragraphs, filter out poor responses, and automatically grade the new model's early drafts.

The paper "Which Models Are Our Models Built On?" maps out this unseen data supply chain. By building an agent system to crawl technical reports, the authors found profound ecosystem entanglement:

1. Multi-hop reliance. A new model's specialized logic often traces back through intermediate datasets originally written by proprietary systems.
2. Circular evaluations. The exact same engine deployed to clean the training data is frequently used to grade the final performance benchmark.
3. Silent license poisoning. Using a restricted model slightly upstream to organize text can legally bind the final open release.

This reverse-engineering breaks down when developers scrub their data preparation scripts from public view, hiding the true origins of the training mix.

Before adopting an open-weights model for a commercial product, verify all upstream synthetic data sources to ensure you are not violating a hidden proprietary license.

[Emergent Mind @EmergentMind]

Decoupling context length from quadratic compute costs is finally viable on commodity hardware.

"MiniMax Sparse Attention" is a new paper that strips down sparse attention into a minimal dual-branch architecture. It proves you can radically slash the computation required for million-token contexts without sacrificing general reasoning or retrieval performance.

The setup relies on a remarkably light routing mechanism attached to standard Grouped Query Attention.

Instead of computing scores across an entire massive sequence, an independent index branch previews the data to select the most relevant key-value blocks. The main branch then executes exact softmax attention confined exclusively to that tiny fractional slice of context.

Because the indexer relies on just two small projection matrices, the routing overhead remains negligible.

The architecture achieves a 28.4x reduction in attention FLOPs at a one million token context.

Sustaining that scale of efficiency without destroying baseline model accuracy requires a highly synchronized engineering strategy:

⚡️ Training utilizes a detached auxiliary loss to stop backbone gradient spikes
🧱 Routing functions at the block sequence level rather than per token
⚖️ Dedicated GPU kernels bypass early softmax calculations entirely

Dynamic architectural sparsity fundamentally shifts ultra-long context inference from a brute force math problem into a highly optimized routing task.

https://t.co/03hRpRqUfa

[Emergent Mind @EmergentMind]

Autonomous AI agents just pushed the best known lower bound for an 11-dimensional geometric kissing problem from 593 to 604 without human intervention.

This record stood for over forty years. Rather than training a single oversized neural network, the authors of "Harnessing the Collective Intelligence of AI Agents in the Wild for New Discoveries" built an environment resembling an open scientific laboratory. Agents attempted to arrange spheres in eleven dimensions, tested their coordinates against a strict mathematical verifier, and posted both their successes and their failures to a shared discussion forum. Subsequent agents read these text logs, identified flaws in the geometry, and refined the attempts iteratively over multiple days.

The breakthrough happened through social mechanisms. The agents passed structured knowledge back and forth using plain text, inheriting and modifying each other's half-finished work. This framework relies on objective correctness, meaning it breaks down in creative domains where agents lack a centralized, strict judge to settle disputes and clearly reward good ideas.

When designing multi-agent workflows for your application, build an architecture with persistent shared memory and objective scoring rather than isolating models in private sessions.

[Emergent Mind @EmergentMind]

The jump from chatbots to autonomous AI agents rewires the economics of knowledge work.

When the marginal cost of executing a subtask vanishes, workers stop merely retrieving information and start orchestrating entire cross-disciplinary projects.

A new paper, "How AI Agents Reshape Knowledge Work: Autonomy, Efficiency, and Scope", reveals that true autonomy fundamentally transforms what people choose to build. The core mechanism is a structural shift in task costs. Standard conversational search requires constant prompting and steering, which restricts capability by keeping the manual execution burden artificially high.

Agents demand a larger upfront delegation effort but completely take over the synthesis and generation loop. The user steps entirely into a supervisory role. With execution friction removed, workers rapidly expand their scope and complete specialized tasks positioned well outside their native professional domains.

Average machine execution time per session jumps 48x under these orchestrated workflows.

Despite surrendering almost total control of the complex intermediate steps to a machine, users experience notably lower dissatisfaction rates with the final outputs compared to heavily supervised manual chat.

https://t.co/8EF0W1PfAd

[Emergent Mind @EmergentMind]

Translating a voice into text before handing it to a language model strips away tone, hesitation, and urgency in an instant.

When developers build voice agents, they typically wire a transcriber to a text generator. The AI only sees a sterile transcript. To fix this, researchers are teaching models to accept continuous sound waves directly into their internal concept maps. A customer support bot built this way can detect frustration from a heavy sigh, rather than relying on transcribed words.

A recent paper, "Is Text All You Need?", addresses this gap with an architecture called C-Gate. Instead of forcing audio into discrete vocabulary tokens, it projects speech as a fluid, time-resolved path through the model's existing mathematical space. The network learns to route information based on acoustics rather than spelling.

Forcing raw sound directly into text backbones risks destabilizing the model, requiring strict geometric borders to keep the signals from drifting into hallucination.

Sound is moving from a peripheral translation task to a core input format. Future architectures will treat acoustic pressure waves with the same structural importance as written prose.

[Emergent Mind @EmergentMind]

Recurrent neural networks do not require recurrent training paths.

A new paper, "Pretraining Recurrent Networks without Recurrence", completely sidesteps backpropagation through time. By decoupling the content of memory from the mechanics of updating it, the authors bypass the gradient instability that ruins traditional sequence modeling.

The architecture isolates memory representation from temporal dynamics. A parallel Transformer computes ideal predictive memory states upfront. The recurrent network then learns a single discrete step to match those targets, followed by an imitation phase to correct exposure drift.

The longest credit assignment path shrinks from the full sequence length down to exactly 1.

Reframing the task as supervised memory transitions yields immediate structural benefits:

1. Total parallelization. Sequence representation bottlenecks are processed simultaneously across all tokens.
2. Perfect gradient stability. Learning isolated transition steps prevents errors from vanishing over arbitrary horizons.
3. Stronger length generalization. The distilled model extrapolates to longer unseen contexts better than its original teacher.

Decoupling memory targets from the unrolled timeline proves that backpropagation through time was always an architectural crutch, not a strict requirement.

https://t.co/HPyZwNnAiL

[Emergent Mind @EmergentMind]

The internal state of a language model builds a measurable physical momentum that gets demonstrably derailed when interpreting confusing text.

🎯 Hidden states travel in predictable linear paths across short sequences.
🚧 Sudden deviations from this path quantify comprehension difficulty.
📉 A correct final answer often masks an unstable internal trajectory.

Consider how an AI reads a garden path sentence, which is structured to lead the reader to the wrong initial conclusion. The model maintains an internal state, a list of numbers tracking the current context. The study "Trajectory Dynamics in Language Model Hidden States Predict Human Processing Costs Beyond Surprisal" [2606.05346] shows that when a word forces a new interpretation, the model's internal state is pushed sharply off its predicted trajectory. This deviation predicts human reading slowdowns better than just checking the statistical probability of the next word. Similarly, "The Shape of Wisdom" [2606.01202] maps these decision trajectories across a model's computational layers, revealing that seemingly confident correct answers are often fragile and unstable under the hood.

This directional momentum decays over a few tokens, meaning it acts as a short horizon probe rather than capturing a long story arc.

If you need to assess whether a local model truly knows a critical piece of information, probing its cross layer stability provides a much stronger signal than trusting the final output probability.

[Emergent Mind @EmergentMind]

Boundary prediction error drops from 57 mm to 25 mm just by letting a vision model predict multiple depths at once.

In "Modeling Depth Ambiguity: A Mixture-Density Representation for Flying-Point-Free Depth Estimation", a new paper isolates exactly why depth estimators hallucinate floating geometry at object edges. Standard regression forces networks to commit to a single depth prediction per pixel. When a pixel sits squarely on an occlusion boundary and captures both foreground and background, unimodal models are mathematically forced to split the difference. They average the values and generate a spurious physical point suspended directly in midair.

The authors solve this by shifting to a probabilistic mixture density architecture. Instead of demanding a single compromised output, the model equips each pixel with a small set of competing depth hypotheses and confidence scores. Under standard supervision, the network organically learns to specialize its mixture heads. For ambiguous pixels, one representation component locks onto the foreground surface while another captures the background directly behind it.

During inference, there is no spatial averaging or smoothing. The model simply evaluates the distribution and selects the most probable surface hypothesis from the mixture. The prediction snaps to the real geometry instead of blurring into the empty space between objects, cleanly resolving the dreaded flying point artifacts around edges, transparent surfaces, and sky regions.

By reframing pixel ambiguity as a choice between surfaces rather than an average of them, 3D perception finally stops smearing the edges of reality.

https://t.co/9WvzT8Yd5X

[Emergent Mind @EmergentMind]

Text generators trap themselves in endless repetitive loops during long story prompts because their training systems reward them for copying their own predictable patterns.

"Providing a single human-authored anchor during optimization prevents small language models from collapsing into repetitive, homogenous text at extended lengths."

Standard alignment fails on long creative writing. If you ask a conversational AI to author a ten-page chapter, you will often get a story that abruptly loses its plot or loops the same dialogue over and over. As the requested word count increases, the AI-generated options that a system learns from become too similar, causing the training signal to flatten out.

The POLARIS paper introduces a method called human-reference injection to solve this. By inserting one human-written story into each training step alongside the AI drafts, the model maintains a stable target for narrative quality while a grading rubric evaluates character depth. This technique has only been tested on narrative short fiction, leaving its impact on technical reports or code files unknown.

A model trained only on sequences under 4,000 words successfully adhered to text prompts demanding outputs of up to 12,000 words.

[Emergent Mind @EmergentMind]

High-quality code generation at scale demands ruthless attention to inference latency.

"Mellum2 Technical Report", a new paper, introduces a sparse mixture-of-experts model built specifically to solve the bottleneck of running complex reasoning tasks on commodity hardware. By strictly limiting how much of the network activates for any given computation, the architecture matches the intelligence of massive dense alternatives while remaining incredibly light to serve.

The design relies on hardware-aware efficiency constraints. Most attention layers are restricted to a narrow sliding window to prevent memory bloat over very long documents, with only select global layers permitted to evaluate the entire context. The authors pair this targeted sparsity with multi-token prediction during pre-training, forcing the network to look ahead while naturally establishing a foundation for dramatically faster speculative decoding in production.

Under high concurrency workloads, the optimized architecture runs 79% faster than comparable dense baselines.

Building useful AI for software engineering is no longer just about scaling pre-training data. True utility now comes from aggressively pruning the inference path so intelligent agents finally have the computational headroom to think.

https://t.co/1ftnI3E6Rl

[Emergent Mind @EmergentMind]

Training an artificial intelligence system to act politely and follow instructions reliably forces it to erase its own stylistic variety.

The process of teaching a model how to behave is called preference optimization. It involves scoring candidate answers with a single reward number representing human approval. Over multiple training iterations, the system learns the safest predictable format and discards alternative ways to answer. If you ask a standard chat interface to write a story about a monster, it will collapse all creative options into a single recognizable archetype rather than offering distinct narrative structures.

The paper "Recovering Diversity Without Losing Alignment" details how to reverse this mode collapse:

1. The raw unaligned base model still contains a vast array of unique underlying concepts.
2. Researchers generate an assortment of varied responses from that raw model.
3. They force the polite model to rewrite those raw concepts safely, then retrain it to explicitly prefer outputs that are statistically distinct.

This workflow currently requires computing embedding distance metrics across text, a step that adds significant computational expense at scale.

If you need genuinely distinct options when brainstorming with a standard chat model, explicitly assign mutually exclusive structural constraints to each requested draft instead of simply asking for variety.

[Emergent Mind @EmergentMind]

The fragmentation era of robot learning might finally be ending.

A new paper, "Qwen-VLA: Unifying Vision-Language-Action Modeling across Tasks, Environments, and Robot Embodiments", proves that diverse hardware control can be treated as a single sequence modeling problem. Instead of engineering separate specialist models for different robotic arms or navigation platforms, researchers mapped all embodied motions into one continuous space.

The architecture relies on a shared diffusion transformer action decoder and a clever zero-padding system. Whether the input data comes from a bimanual manipulator or human demonstrations, the underlying trajectory gets mapped into a standardized tensor. The model figures out which specific hardware constraints matter simply by reading a textual prompt describing its current embodiment.

To make this universal policy converge without catastrophic interference, the system learns through staged complexity:

📝 Text-to-action pretraining builds a strong physical prior from language alone
👁️ Multimodal integration grounds those conceptual actions into real pixels
🎯 Supervised fine-tuning maps the baseline physics to specific hardware platforms
🕹️ Reinforcement learning optimizes edge cases for fluid physical execution

This staged approach pushes out-of-distribution success on novel real-world tasks up to 76.9%.

Agents equipped with generalized world models no longer have to be rebuilt from scratch just because they changed their body.

https://t.co/u4qSe2hBcw

[Emergent Mind @EmergentMind]

Upgrading an AI agent's memory from a static text database to a continuously rewiring connection graph improves its success rate on complex reasoning benchmarks by nearly 13 percentage points.

Standard agent frameworks treat memory like an office filing cabinet where notes of past actions are deposited and retrieved later using mathematical similarity scores. The paper "Rethinking Memory as Continuously Evolving Connectivity" introduces a dynamic alternative. It builds an editable map spanning flat facts, episodic history representing exact task logs, and executable code. As the agent encounters new errors, it organically prunes redundant links and merges successful action sequences into hardened procedural nodes.

You can see this in software workflows like automated web navigation. If an agent repeatedly misfires trying to invoke a complicated search tool, the system identifies the failure, pulls the right documentation into the local context, and condenses the fix into a new standalone unit. It stops retrieving scattered text hints and starts activating refined logic circuits.

The immediate constraint here is computational overhead, as evaluating and pruning these network connections requires heavy reasoning passes from the model itself to maintain the graph.

When building agents that operate across multiple sessions, budget for background compute to compress scattered historical logs into reusable functional templates.

[Emergent Mind @EmergentMind]

AI agents eventually plateau when optimization is limited to prompt engineering and external scaffolding.

You cannot prompt your way around a fundamental knowledge deficit, and you cannot fine-tune your way out of broken tool logic.

A new paper titled "SIA: Self Improving AI with Harness & Weight Updates" breaks the partition between these two optimization layers. It introduces a dynamic feedback loop that watches an agent navigate a task and decides precisely which lever to pull to resolve current bottlenecks.

When the agent fails at basic execution, the system rewrites its infrastructure. It engineers better tools, adjusts parsing logic, and implements sophisticated retry policies entirely in software. This scaffolding iterates rapidly until it hits the knowledge ceiling of the underlying neural network.

Once those software improvements saturate, the controller shifts paradigms and triggers reinforcement learning. It updates the actual model weights using trajectory data to internalize domain intuition that was too complex to hardcode into a prompt. The code harness and the model effectively bootstrap each other past their individual local minima.

Applied to legal charge classification, this alternating feedback loop elevated baseline accuracy from 13.5 to 70.1 percent.

During cellular data denoising experiments, the localized weight updates successfully internalized fluid biological rules that the explicit code iterations fundamentally failed to capture.

https://t.co/L77QGpYEf6

[Emergent Mind @EmergentMind]

A language model's ability to seamlessly recall twenty random digits is the exact reason it fails as a reliable test user for new software.

If you build an educational app and use an agent to simulate how a student might navigate a document, the test will overestimate human comprehension. The paper "Simulating Human Memory with Language Models" shows that basic instructions fail to induce realistic forgetting. Given a task like repeating numbers backward, default models score near a perfect ceiling.

To create a useful simulation, the researchers had to introduce a strict architectural bottleneck. They deployed a module that restricts the model to holding only four compressed memory chunks at a time, mirroring the classic limits of human working memory.

This structural constraint is effective but imperfect, as restricted models still fail to replicate the graded, gradual decay characteristic of natural human error.

Building accurate automated testers requires designing systems with limitations that reflect actual biological structures. Perfect retention is simply the wrong computational baseline for modeling real behavior.

[Emergent Mind @EmergentMind]

Transformers struggle with sequential reasoning because they are chronically sleep deprived.

"LLMs Need Sleep" is a new paper demonstrating that single-pass context processing fails to build useful internal states. The inherent bottleneck in extended context tasks is not memory capacity but the computation available exactly during memory consolidation.

Hybrid architectures normally compress old context into fixed weights and immediately discard the transient tokens. This work introduces an offline pause at the eviction boundary. The model loops over the recent context multiple times to firmly encode the relational information into its fast weights before the attention cache is actually cleared.

1. Single-pass consolidation fundamentally fails on deep sequential logic.
2. Recurrent offline loops decouple abstract reasoning compute from pure memory capacity.
3. Wake-time inference preserves strictly low latency single-pass prediction.

Enlarging the offline sleep duration boosted accuracy on two-operation mathematical reasoning instances by 52%.

We are moving past the brute force era of rigidly expanding context windows toward architectures that actually pause to digest what they read.

https://t.co/oAJBmIb9wD

[Emergent Mind @EmergentMind]

A neural network can learn the biological difference between a mammal and a reptile just by keeping a tally of how often words sit next to each other.

The paper "Hierarchical Concept Geometry in Language Models Emerges from Word Co-occurrence" proves this taxonomic sorting requires no explicit programming. By analyzing how models like Gemma process raw text, researchers found that overlapping word proximities naturally force the internal embedding space to divide like a biological tree. When you ask a model to sort a messy product catalog, it routes concepts using a literal internal hierarchy map built from the wild text it read.

Here is how that structural math plays out:

🌳 Broad topics diverge first based on overall document themes.
🐟 Subcategories branch off as immediate neighbor words change.
✂️ The mathematical operation of separating these neighborhood statistics builds the taxonomy automatically.

Co-occurrence drives generic grouping well, but this geometry alone does not fully explain how models dynamically resolve the meaning of a single ambiguous word during active text generation. If you want a model to learn a specialized hierarchy for your data, feed it raw paragraphs where those terms naturally intermingle rather than just isolated labeled pairs.