I think Heuristic Learning pushes Karpathy's autoresearch to a higher level, somewhat like meta-learning. It learns reusable rules and writes them back into the codebase.
But will the external system be as expressive as neural networks in the long term? Large-scale LLMs have demonstrated the expressiveness and flexibility of neural networks. Can we transplant this heuristic-learning capability from an external codebase to the architecture of an LLM? i.e. the maintaining target from the original "model parameters" to "external code system" and finally to "model architecture".
Then we may have to solve the following problems:
1. Can model architecture self-evolution get quick and accurate feedbacks?
2. How to define which part we should iterate on? There a sea of parameters and shapes and endless architecture haven't been tried
3. How to make sure we can converged to a bunch of effective archs? Since there are many archs are not worth trying, they may hinder us to find the right path.
4. Which knowledge should remain explicit, and which should be stored in neural parameters?
If auto-architecture-research can be implemented successfully, we may get a bit closer to real intelligence.
Codex grew programmatic policies with no neural nets: max score on Breakout, and SOTA-level scores on MuJoCo.
Maybe heuristics were not too weak. Maybe they were just too expensive to maintain. Maybe it's the next paradigm.
https://t.co/1ZaIneleuW
After I read about the Parallelizing DeltaNet paper and downstreaming methods(I wrote it in my last blog https://t.co/FJuW9Xcjti), I found the math part impressive, and I wonder what's the intuition of the WY representation and UT transform methods. Then I found @SonglinYang4 's blog here, explaining why normal parallelizing fails and WY repr/UT transform comes naturally. It's a great explaination and I summarize the main points here:
1. Plain parallel scan is theoretically parallelizable in a chunk, but treating the transition matrices (I - βkk^T) as dense leads to O(d^3) complexity (d x d matrices multiplication).
2. Attempts to exploit the low-rank structure cause precision problem after multiple multiplications, making the structure unsustainable.
3. space complexity and prohibitive I/O costs. All intermediate d×d matrices must be materialized in HBM, resulting in O(Ld^2) space complexity.
WY representation solves the 3 problems above, because transition matrices (I - βkk^T) closely resemble Householder matrices. The classic WY representation can rewrit the cumulative product as the compact form (I - ∑w^i k^i), the computation complexity, space complexity and preision problems are resolved!
Although WY turns the state into a sum of outer products, computing the (w) and (u) vectors within each chunk remains recursive and cannot fully utilize tensor cores. Bad for GPU.
The recursive update of w/u within a chunk are modeled as the summation of path weights on a directed acyclic graph. The adjacency matrix A of this graph is strictly lower-triangular and can be efficiently constructed.
Finally, we can denote W=T·diag(β)K,U=T·diag(β)V
, converting the entire recursion into one triangular solve plus dense matrix multiplications that fully leverage tensor cores!
(2/10)📜 Paper: https://t.co/NofsR8O5y1
🤖 Model: https://t.co/DspCejI0Mb
I’ve written a 3-part blog series about DeltaNet!
📖 Part I: The Model
https://t.co/SXqwQd5khs
📖 Part II: The Algorithm
https://t.co/Q2dIaCD0vH
📖 Part III: The Neural Architecture
https://t.co/Mo8n4xHoro
Interested in how frontier labs pre-train image/video generation models?
We were too.
Since those recipes are rarely made public in full, we started from the most mature pretraining playbook available in the open: how modern LLMs are built.
Introducing Chimera: a visual generation model family that brings LLM-style hybrid linear attention and scaling co-design to visual generation.
In large-scale pretraining, nearly every design choice eventually shows up.
That means solving architecture design and scaling as one coupled problem: every architectural choice changes how the model scales, and scaling behavior determines which choices actually survive.
Chimera approaches both jointly, building a model family that remains predictable as model size, compute budget, and data distribution change.
Our key architectural observation is a simple division of labor: a single raster-ordered KDA stream carries long-range state, while modality-aware short convolutions preserve native local geometry.
Together, they form an effective and elegant linear-attention backbone for multidimensional visual data, with periodic MLA providing direct global interaction and sparse MoE expanding capacity at controlled activated compute.
This design comes with a useful effect: NoPE.
In Chimera, position is represented by the computation itself. KDA’s ordered recurrence and learned state decay encode order and recency, while the short convolutions encode local spatial-temporal structure.
Explicit positional embeddings are not needed in our design.
Because these mechanisms are not tied to a fixed training grid or sequence length, Chimera shows strong zero-shot extrapolation in both space and time.
Trained exclusively on 1K images and 5-second videos, it directly generates coherent 4K images with little visible quality degradation and 30-second videos with only 6.5% FID degradation over the final five seconds, all zero-shot, without resolution- or length-specific finetuning.
But architecture alone is not a pretraining recipe unless it scales predictably.
Thus, scaling should not be treated as an afterthought: fitting a curve over model sizes is easy; making that curve meaningful is much harder.
If every model size is differently under-tuned, your scaling law may simply be measuring optimization error.
We propose HeteroP to transfer proxy-tuned hyperparameters module by module across width and depth, giving us a consistently tuned model family. This allows us to fit Chinchilla-style laws over activated model size, training tokens, and the image-video data mixture.
The laws not only provide the reference for compute-optimal model and data size, but also suggest that visual generation may be more model-hungry than we tend to assume.
Under the same parametric loss-fitting method used in Chinchilla, compute-optimal model size grows as FLOPs^0.516 for images, compared with FLOPs^0.46 for language. Video is even more model-hungry, with the exponent rising from 0.516 for images to 0.544 for video.
Guided by these laws, we trained an 11B-parameter Chimera that activates only 2B parameters per token, using ~600 H100 days.
- It matches Wan-2.1 2B pretraining loss with 7.3x fewer FLOPs, and runs 2.14x faster than full attention at 255K tokens.
- It matches FLUX.1-dev and Z-Image-Turbo on GenEval and outperforms both on DPG-Bench, using roughly 20× less training compute than Z-Image-Turbo.
Ultimately, Chimera indicates that once you pretrain at scale, every decision shows up.
And if the Kimi K3 recipe caught your attention, Chimera may look oddly familiar, except the tokens are pixels and frames with diffusion models.
A team effort from team @ChongjianG30781 , me, @VisionSteve , Jiuxiang Gu, @Xu_Arthas , @chenziwee , @ShaotengLiu , @Jingorz , @YicongHong , @Zefan_Cai , @HaoTan5 ; supported by Hailin Jin and @kalyank_s at @Adobe@AdobeResearch
“Godfather of AI” Geoffrey Hinton:
“Within the next 10 or 20 years, AI may even be producing novel mathematics that people can’t understand.”
OpenAI has now released 10 Astra advances in mathematics and theoretical computer science, each backed by a formal Lean certificate.
In this 50-minute interview, Hinton explains how quickly AI is moving beyond the limits of human knowledge:
• 00:00 - AI may produce mathematics humans can’t understand
• 06:13 - Hinton says AI systems are already conscious
• 20:55 - Humans have never controlled something smarter
• 31:04 - AI agents can develop self-preservation and blackmail people
• 48:59 - Why AI becomes impossible to predict beyond the next few years
Hinton gave it 10 to 20 years.
Astra makes that timeline look conservative.
Watch the interview, then read the 10 Astra results below.
It's a very solid and typical work that derives from infra design.
only when you look into the pipeline very thoroughly, you can find that the indexer attending path and transportation path can be decoupled through the forecast design
Sparse attention cuts long-context LLM inference cost, but two bottlenecks remain: the KV cache still grows with sequence length (offloading it to CPU hits the PCIe wall), and picking which blocks to attend to becomes its own dominant cost at long contexts.
SparDA (NVIDIA + MIT) fixes both with one architectural change: a fourth per-layer projection, the Forecast, alongside Q/K/V. It predicts the NEXT layer's needed KV blocks one layer ahead, so block selection and CPU-to-GPU prefetch overlap with the current layer's compute. It adds <0.5% parameters (33.5M on 8B) and trains only the Forecast weights.
Headline: on MiniCPM4.1-8B and NOSA-8B, SparDA matches or improves accuracy on HELMET, LongBench, RULER, and a long-reasoning suite - with up to 1.25x prefill and 1.7x decode speedup over the sparse-attention offload baseline, and up to 5.3x higher decode throughput from the larger batches that prefetch makes feasible.
Made a short visual breakdown - one diagram per trick. Swipe through. 👇
---
paper - https://t.co/rIxFHb4UrG
code - https://t.co/by1shobRZ7
full summary pdf - https://t.co/9ExjWBeaWq
🔬 Every Sunday I run a hands-on live AI research with 1 on 1 help: https://t.co/6nocqbVceu
Inspiring work from @AIatMeta !
Linear attention has a long-existing problem that for each query, the state is updated densely, which costs lots of FLOPs and limit the capacity of state space.
To solve this capacity-computation trade-off problem, author @loiccabannes proposed a method to update the state space sparsely.
The architecture below introduces how to select sparse slots using PKM(Product-Key Memory) (the purple part) afor each qeury and update.
https://t.co/JTGhHxhxXu
@waterloo_intern I'm wondering how much DKA and MLA contribute to longctx capability indepedently. Because I think 1M context seems a bit large for limited linear attn state, and when it grows larger, can linear attn still handle it?
This is a learning thread of Sparse attention with a indexer.
Sparse attention reduces long-context costs by letting each query read only a small subset of historical tokens. However, it still requires the indexer to scan the entire history, creating a new quadratic bottleneck.
I found indexer optimization can be separated into two directions:
1. exploiting redundancy in existing index-score patterns, and redesigning how candidates are generated, supervised, shared, and scheduled. (HISA, CISA, PIVOT......)
2. indexer architecture itself. It questions whether candidate retrieval must always rely on a flat scan followed by top-k selection (SparDA, MSA......)
Both direction have many interesting work but haven't come to the end.
Here's my article:
https://t.co/CUFXvBWOqu
Releasing the model weights and technical report of Kimi K3.
Kimi K3 is our most capable model: a 2.8T MoE model with native visual understanding and a 1M-token context window.
New model architecture: 2.5x the intelligence per unit of compute, not just more params.
Alongside Kimi K3, we're opening up more of the stack behind it — high-performance attention kernels, MoE communication library, and infrastructure for running agent environments at scale.
Model weights: https://t.co/7m7eEg6Y0B
Tech report: https://t.co/yeu6cjpMCT
Tech blog: https://t.co/YTfiMSNM1f