Gelo Blancada

in 🇸🇬

[Sebastian Raschka @rasbt]

Whoa, Meta released a new open-weight LLM yesterday, something that hasn't happened since the good old Llama days.

Their Meta Muse Glimmer model is a 30B multimodal reasoning model with a Gemma-like architecture design. (“Glimmer” is probably a wordplay on “Spark,” the more likely capable model from which Glimmer was distilled. Muse Spark is only available through Meta’s Model API, though.)

Architecture-wise, here are some of the main points:

1. "Only" a 131k context window, compared to Qwen3.6 and Gemma 4, which support 2x that natively; it's reasonable, but maybe on the shorter end in the age of agent harnesses

2. It's a dense model, not a mixture-of-experts. (So, it's fairer to compare it to Qwen3.6 27B than Qwen3.6 30B-A3B.)

3. Hybrid attention with grouped-query attention (GQA) and sliding window attention (SWA); the SWA:GQA pattern is a 3:1 local:global ratio. Other models like Gemma 4, which uses similar components, have a 5:1 ratio for comparison.

4. It adopts gated attention for both GQA and SWA; gated attention has become quite common in recent months. It basically applies a sigmoid gate to the attention output to decide how much of the attention information enters the residual connection. The interesting point is that it uses relatively standard GQA and SWA rather than hybrid attention mechanisms such as Nemotron or Qwen3.6.

5. A very extreme GQA ratio: 32 query heads and only 2 KV heads; for comparison, Gemma 4 31B uses 32 Q / 16 KV in the local heads and 32 Q / 4 KV in the global heads. This means that Meta Glimmer has a very small KV cache.

Overall, the probably most similar architecture is Gemma 3 27B (including the Gemma-style pre/post RMSNorm placement) and Gemma 4 31B, but with some tweaks like SwiGLU instead of GeGLU activations, gated attention, and the more extreme GQA:SWA pattern mentioned before.

What stands out is its extreme KV-cache efficiency.
I.e., the KV CACHE / TOKEN ratios (in BF16) are:

- Muse Glimmer: 52 KiB (lower is better)
- Qwen3.6 27B: 64 KiB
- Gemma 4 31B: 840 KiB

Modeling-performance-wise, their own benchmarks show that it's mostly ahead of Qwen3.6. According to the independent composite benchmarks on the Artificial Analysis Intelligence Index, it's slightly behind Qwen3.6 (see figure below). So, a few days of using it will tell where it really ranks.

Overall, it looks like a solid model, particularly for agentic workflows. What stands out most is its very low memory footprint and also pretty fast prefill and decode speed. It’s also just great to see Meta releasing open weights again :).

[Ben Burtenshaw @ben_burtenshaw]

Finally, I got it to optimize its own deployment for H100 architecture.

[Ben Burtenshaw @ben_burtenshaw]

If you just want to try the model, I set up this research agent on the hub: https://t.co/VI53RMVWpp

[Ben Burtenshaw @ben_burtenshaw]

Next: “Muse Glimmer, deploy yourself.”

It deploys to a protected Hugging Face Inference Endpoint, verifies health and chat completion, then connects its claw to the endpoint.

You can also just do this with: https://t.co/Rm1O2YnJJs

[Ben Burtenshaw @ben_burtenshaw]

Meta is back with Muse Glimmer: a 30B open-source multimodal model built for local, agentic use.

HF is shipping day-0 support and I built a few demos to see what it can do.

First: we gave Glimmer tools and asked it to quantize itself.

[Unsloth AI @UnslothAI]

Meta releases Muse Glimmer, a new 30B open model that runs on 18GB RAM.

Muse Glimmer is Apache 2.0 licensed, supports vision and is the strongest agentic model for its size.

Run and train the model via Unsloth.
GGUF: https://t.co/AoVKEDmcxI
Guide: https://t.co/uBwdINO0PS

[Google Gemma @googlegemma]

Check out this interesting demo from the latest Gemma 4 hackathon.

This live meeting copilot runs at 1,000+ tok/s, turning spoken conversations into working prototypes before the meeting even ends.

[François Chollet @fchollet]

A third trend that you should expect in the future is that the symbolic layers will be learned / evolved, rather than hand-engineered.

[François Chollet @fchollet]

An accurate characterization of the arc of AI is that it is shaped by two trends:

1. Moving more and more logic to a neural model for tasks where training data can be densely sampled (e.g. the shift from pre-DL feature engineering to end-to-end learning circa 2013-2016, and more recently the trend of baking more and more harness functionality directly into models over time)

2. Achieving more and more powerful / generalizable systems by leveraging those neural models in sophisticated neurosymbolic architectures, e.g. AlphaGo instead of an end-to-end Go-player model (2016), the Waymo neurosymbolic architecture instead of a single end-to-end vehicle control model (early 2020s), TTA LRMs and coding agent harnesses instead of plain LLM inference (now).

As far as I can tell, this dual trend will keep going. You can always do more with a neurosymbolic system than with just the neural model inside it.

[François Chollet @fchollet]

The weak AI code gen we had until late last year was most useful to low-skill programmers -- it was raising the floor. It was essentially useless to high-skill programmers -- you could move faster and ship better code without.

This has been completely flipped: the strong AI code gen we have now is *most* useful to high-skill programmers, while low-skill programmers are vastly underutilizing it or sometimes drowning in it. It went from a crutch to a power tool.

[Ole Lehmann @itsolelehmann]

i'm obsessed with AI DIY projects.

my favorite one right now is this broccoli farmer in hokkaido, japan using Codex to run his 100-hectare farm

this guy never studied agriculture, never inherited land, started out as a civil servant.

but he wanted his farm to run better, and instead of paying an engineering firm he couldn't afford, he just built the tools himself.

here's what he's built on his own:

> remote control of his greenhouse vents from a chat app, wired up with an esp32 board, a motor driver, and cloudflare workers

> a bot that checks each greenhouse's temperature and opens the vents when it gets too hot

> satellite crop-health data laid over a map of his own fields

> an airtable base linking his plots, tasks, materials, and sensors

> wiring diagrams of his electrical panels, generated from a photo

stuff like this used to be locked behind machinery and engineers only the big agribusinesses could pay for.

but this legend just breezed past all of it with a laptop and Codex lol

[alex zhang @a1zhang]

In case you're curious about why dynamic workflows are so powerful and the future, read the RLM paper! Opus 4.8 + dynamic workflows in Claude Code is perhaps the first instance of a frontier model seriously trained to be an RLM.

I suspect within a year they'll just become the standard for nearly all coding agent interactions.

[Chahat Sharma @Chahatusharma]

@sundarpichai E2E RCS means developers building on top of messaging now have a secure baseline across both platforms. Big deal for anyone shipping AI features into chat without rolling their own encryption.

[Andrej Karpathy @karpathy]

This works really well btw, at the end of your query ask your LLM to "structure your response as HTML", then view the generated file in your browser. I've also had some success asking the LLM to present its output as slideshows, etc.

More generally, imo audio is the human-preferred input to AIs but vision (images/animations/video) is the preferred output from them. Around a ~third of our brains are a massively parallel processor dedicated to vision, it is the 10-lane superhighway of information into brain. As AI improves, I think we'll see a progression that takes advantage:

1) raw text (hard/effortful to read)
2) markdown (bold, italic, headings, tables, a bit easier on the eyes) <-- current default
3) HTML (still procedural with underlying code, but a lot more flexibility on the graphics, layout, even interactivity) <-- early but forming new good default
...4,5,6,...
n) interactive neural videos/simulations

Imo the extrapolation (though the technology doesn't exist just yet) ends in some kind of interactive videos generated directly by a diffusion neural net. Many open questions as to how exact/procedural "Software 1.0" artifacts (e.g. interactive simulations) may be woven together with neural artifacts (diffusion grids), but generally something in the direction of the recently viral https://t.co/z21CP5iQfu

There are also improvements necessary and pending at the input. Audio nor text nor video alone are not enough, e.g. I feel a need to point/gesture to things on the screen, similar to all the things you would do with a person physically next to you and your computer screen.

TLDR The input/output mind meld between humans and AIs is ongoing and there is a lot of work to do and significant progress to be made, way before jumping all the way into neuralink-esque BCIs and all that. For what's worth exploring at the current stage, hot tip try ask for HTML.

[hardmaru @hardmaru]

The human brain🧠 is incredibly efficient because it only activates the specific neurons needed for a thought. Modern LLMs naturally try to do this too (> 95% of neurons in feedforward layers stay silent for any given word), but our hardware punishes them for it.

One of the most frustrating paradoxes in deep learning: making a model do less math often makes it run slower. Why? Because unstructured sparsity introduces irregular memory access, and GPUs are built for predictable, dense blocks of math.

We teamed up with @NVIDIA to try to fix this hardware mismatch. Instead of forcing the GPU to adapt to the sparsity, we built a "Hybrid" format that reshapes the sparsity to fit the GPU. Our sparsity format (TwELL) dynamically routes the 99% of highly sparse tokens through a fast path, and uses a dense backup matrix as a safety valve for the rare, heavy tokens.

Through TwELL and a new set of custom CUDA kernels for both LLM inference and training, we translated theoretical sparsity into actual wall-clock speedups: >20% faster training and inference on H100 GPUs, while also cutting energy consumption and memory requirements.

Paper: https://t.co/rqIY9SYBDe
Blog: https://t.co/oRjNbpJKha
Code: https://t.co/FAFaJwpxAJ
⚡️

[Sakana AI @SakanaAILabs]

How do we make LLMs faster and lighter? Don’t force the GPU to adapt to sparsity. Reshape the sparsity to fit the GPU! ⚡️

Excited to share our new #ICML2026 paper in collaboration with @NVIDIA: "Sparser, Faster, Lighter Transformer Language Models". This work introduces new open-source GPU kernels and data formats for faster inference and training of sparse transformer language models:

Paper: https://t.co/3Avj8N8iYO
Blog: https://t.co/SqFkkKvkbd
Code: https://t.co/PHSzMq8pg0

While LLMs are undoubtedly powerful, they are increasingly expensive to train and deploy, with a large part of this cost coming from their feedforward layers. Yet, an interesting phenomenon occurs inside these layers: For any given token, only a small fraction of the hidden activations actually matter. The rest approximate zero, wasting computation. With ReLU and very mild L1 regularization, this sparsity can exceed 95% with little to no impact on downstream performance.

So, can we leverage this sparsity to make LLMs faster? The challenge is hardware. Modern GPUs are optimized for dense matrix multiplications. Traditional sparse formats introduce irregular memory access and overheads that cancel out their theoretical savings for GEMM operations.

Our contribution is twofold:
1/ We introduce TwELL (Tile-wise ELLPACK), a new sparse packing format designed to integrate directly in the same optimized tiled matmul kernels without disrupting execution.
2/ We develop custom CUDA kernels that fuse multiple sparse matmuls to maximize throughput and compress TwELL to a hybrid representation that minimizes activation sizes.

We used our kernels to train and benchmark sparse LLMs at billion-parameter scales, demonstrating >20% speedups and even higher savings in peak memory and energy.

This work will be presented at #ICML2026. Please check out our blog and technical paper for a deep dive!

[Andrej Karpathy @karpathy]

Fireside chat at Sequoia Ascent 2026 from a ~week ago. Some highlights:

The first theme I tried to push on is that LLMs are about a lot more than just speeding up what existed before (e.g. coding). Three examples of new horizons:

1. menugen: an app that can be fully engulfed by LLMs, with no classical code needed: input an image, output an image and an LLM can natively do the thing.
2. install .md skills instead of install .sh scripts. Why create a complex Software 1.0 bash script for e.g. installing a piece of software if you can write the installation out in words and say "just show this to your LLM". The LLM is an advanced interpreter of English and can intelligently target installation to your setup, debug everything inline, etc.
3. LLM knowledge bases as an example of something that was *impossible* with classical code because it's computation over unstructured data (knowledge) from arbitrary sources and in arbitrary formats, including simply text articles etc.

I pushed on these because in every new paradigm change, the obvious things are always in the realm of speeding up or somehow improving what existed, but here we have examples of functionality that either suddenly perhaps shouldn't even exist (1,2), or was fundamentally not possible before (3).

The second (ongoing) theme is trying to explain the pattern of jaggedness in LLMs. How it can be true that a single artifact will simultaneously 1) coherently refactor a 100,000-line code base *and* 2) tell you to walk to the car wash to wash your car. I previously wrote about the source of this as having to do with verifiability of a domain, here I expand on this as having to also do with economics because revenue/TAM dictates what the frontier labs choose to package into training data distributions during RL. You're either in the data distribution (on the rails of the RL circuits) and flying or you're off-roading in the jungle with a machete, in relative terms. Still not 100% satisfied with this, but it's an ongoing struggle to build an accurate model of LLM capabilities if you wish to practically take advantage of their power while avoiding their pitfalls, which brings me to...

Last theme is the agent-native economy. The decomposition of products and services into sensors, actuators and logic (split up across all of 1.0/2.0/3.0 computing paradigms), how we can make information maximally legible to LLMs, some words on the quickly emerging agentic engineering and its skill set, related hiring practices, etc., possibly even hints/dreams of fully neural computing handling the vast majority of computation with some help from (classical) CPU coprocessors.

[Yuekun Yao @yuekun_yao]

Claude Mythos is suspected of being a Looped transformer (LT), but why are LT-based LLMs so powerful?

Our new finding: LT can perform implicit reasoning over their parametric knowledge, unlocking generalization to complex and unfamiliar questions compared to transformers ⤵️

[Tom Turney @no_stp_on_snek]

Google dropped the TurboQuant paper yesterday morning. 36 hours later it's running in llama.cpp on Apple Silicon, faster than the baseline it replaces.

the numbers:
- 4.6x KV cache compression
- 102% of q8_0 speed (yes, faster, smaller cache = less memory bandwidth)
- PPL within 1.3% of baseline (verified, not vibes)

the optimization journey:
739 > starting point (fp32 rotation)
1074 > fp16 WHT
1411 > half4 vectorized butterfly
2095 > graph-side rotation (the big one)
2747 > block-32 + graph WHT. faster than q8_0.

3.72x speedup in one day. from a paper I read at dinner last night.

what I learned along the way:
- the paper's QJL residual stage is unnecessary. multiple implementations confirmed this independently
- Metal silently falls back to CPU if you mess up shader includes. cost me hours
- "coherent text" output means nothing. I shipped PPL 165 thinking it worked. always run perplexity
- ggml stores column-major. C arrays are row-major. this will ruin your afternoon

everything is open source. the code, the benchmarks, the speed investigation logs, the debugging pain, all of it.

https://t.co/7aUaWo7Mm1

paper to parity in 36 hours. what a time to be alive.