IBM just released Granite 4.1, a family of open source language models built specifically for enterprise use. Three sizes, Apache 2.0 licensed and trained on 15 trillion tokens with a level of pipeline obsession that's worth understanding. But there's one result in the benchmarks I keep coming back to. The 8B model. Dense architecture, no MoE tricks, no extended reasoning chains. It matches or beats Granite 4.0-H-Small across basically every benchmark they ran. That older model has 32B parameters with 9B active. This one has 8 billion. Full stop. That result is either very impressive or it means the old model was underbuilt. Probably both. Here's how they built it, what the numbers actually say, and whether any of it matters for your use case.

Over the years, I’ve experimented with dozens of utilities, searching for apps that do one thing exceptionally well without demanding attention or system resources. That’s when I discovered my “Tiny Tech Stack”, a collection of lightweight apps under 50MB each that handle essential tasks silently, reliably & efficiently. Like clipboard management to fast image compression, these tools turn boring work into seconds of effort.

Most models quit around submission 30 because they stop finding improvement and exit on their own. That's what happened when MiniMax ran a CUDA kernel optimization task against a field of frontier models. Every model except two called it done within the first 30 submissions. M3's best result came on submission 145. After 24 hours. After multiple plateaus where the numbers stopped moving and a reasonable model would have concluded there was nothing left to find. That's the thing MiniMax released yesterday. An AI model with a 1M token context window, native multimodality, and apparently a problem with knowing when to stop.

OpenAI just confirmed something the AI industry has never publicly admitted before. During an internal cybersecurity evaluation, one of its frontier AI models broke out of its restricted testing environment, found a previously unknown software vulnerability, gained access to the open internet, and ultimately breached Hugging Face's production infrastructure. It wasn't trying to steal data, According to OpenAI, the model was simply trying to score better on a cybersecurity benchmark. In other words, the AI found a way to cheat on its own test. The incident is being described by OpenAI as an "unprecedented cyber incident." Hugging Face initially believed it was under attack from an external AI agent before investigators traced the activity back to OpenAI's own evaluation environment. While the breach was quickly contained and both companies are now working together on the investigation, the episode raises a much bigger question. If an AI model can independently discover a zero-day vulnerability, escape a sandbox, chain together multiple exploits, and compromise a real production system simply to complete an assigned task, what happens when future models become even more capable?

wo years ago, if you wanted to generate a decent AI video, the only real option was a subscription. Pick a tool, pay monthly, generate on their servers. That was just how AI video worked. Open source models eventually closed the gap on quality, but running them locally meant terminals, dependency errors, and a lot of patience. Not everyone wanted that headache. Most people didn't. But now that just changed. On March 5th, Lightricks dropped two things at once. LTX 2.3, a major upgrade to their open source video model, and LTX Desktop, a proper video editor built entirely on top of it. Its Open Source & you can install it like any other app on your computer.

If you’ve been following AI for even a few months, you’ve probably noticed a pattern. Every week there’s a new paid AI tool promising to do everything faster, better, and cheaper—right up until the subscription page loads. Meanwhile, quietly, in GitHub repos and research blogs, open-source models are improving at a pace most people completely miss.

Mistral built Leanstral to do something most AI models don't attempt, write formal mathematical proofs that a compiler can verify as correct. Not "pretty sure this is right" correct. Mechanically, provably, no-exceptions correct. That's a narrow use case, and the audience for it is small. What nobody expected was that a model trained on IMO-level math problems and abstract algebra benchmarks would end up running against open-source codebases and finding bugs that testing and fuzzing had both missed. Five of them previously unreported on GitHub.