Introducing TabFM, a foundation model designed specifically for tabular data classification & regression. This approach allows generation of high-quality predictions on previously unseen tables in a single forward pass.
Learn more and try out the model →https://t.co/OTbVQ8oUQs
1-bit GLM-5.2 GGUF vs. Claude 4.8 Opus vs. GPT-5.5
We gave 3 models the same prompt and compared one-shot outputs.
The 1-bit GLM-5.2 GGUF ran locally on a Mac Studio M3 Ultra with 256GB RAM at ~21.6 tok/s.
Which output do you like best?
GGUF: https://t.co/BMkxswdj5N
Introducing Aurora, a new optimizer for training frontier-scale models.
We train Aurora-1.1B, which achieves 100x data efficiency on open-source internet data. Despite having 25% fewer parameters, 2 orders of magnitude fewer training tokens, and using fully open-source internet-only data, Aurora matches Qwen3-1.7B on several benchmarks.
Aurora was developed after identifying a major failure mode that can occur under Muon, an increasingly popular optimizer that has shown strong gains over Adam(W). We find that Muon can cause a huge percentage of neurons to effectively die early in training, reducing effective network capacity so that many parameters no longer meaningfully contribute to network outputs.
By redistributing update energy more uniformly across neurons while preserving Muon’s stability properties, Aurora prevents neuron death and recovers substantial model capacity.
What makes this work especially exciting is that it points toward a broader direction for ML research: better optimizers may not come purely from elegant mathematical abstractions, but from understanding and addressing the concrete dynamics and pathologies that emerge inside real training systems.
Terence Tao is answering a fundamental question regarding the safety and reliability of modern AI: "How can we use a tool that is powerful, but unreliable?"
W = ∑(wᵢ ⋅ xᵢ) + b
AI isn’t just about “smart”; it’s about the probability of *looking* right. We’ve built systems where the weights (wᵢ) are optimized for plausibility, not veracity.
This creates a “convincing mirror” that confidently serves dangerous advice in medicine or finance. The gap between “convincing” and “correct” is the most critical variable we need to solve for.
check it out for yourself -- https://t.co/RemCQwkjli !
finally, some thoughts on ai/design tools: claude design is really good at executing broader frontend layouts and animations but much less reliable at pixel-level refinement and asset design. also, special shoutout to @shedsgns's ascii art generator -- super fun to use !
I can't go back to the regular YouTube UI after this 😅
Obsidian Reader now makes the transcript interactive so you can scrub, highlight, auto-scroll. It feels so nice.
Got a 16GB GPU? You can run all of these right now.
Tested 4 Qwen3.5-based models on ToolCall-15 & BugFind-15:
Models:
- Qwen3.5:9b Q8 (Official)
- Qwopus v3 Q8 by Jackrong
- OmniCoder-9B by Tesslate
- Qwen3.5-9b-Sushi-Coder by bigatuna
Summary:
- ToolCall-15: Qwopus v3 went perfect 30/30, Sushicoder beat base Qwen3.5
- BugFind-15: Omnicoder flipped the script and took #1 at 83%
No single model won both, that's the fun part.
Open source community is cooking.
How well can Qwen3.5 models debug code?
I built BugFind-15 — 15 buggy snippets across Python, JS, Rust, and Go. Docker sandbox compiles and validates every fix. Two trap scenarios where the code is correct and the model must resist "fixing" it.
Tested every Qwen3.5 size from 0.8B to 397B, plus Jackrong's popular distilled model (V2).
The 0.8B scored 5%. The 2B scored 10%. At 4B, debugging ability jumps to 69%.
The hardest scenario: BF-03, a Rust trap. The code compiles fine — format! borrows, it doesn't move. Not a single model figured this out. From 0.8B to 397B, every one of them "fixed" a bug that doesn't exist.
Category C (subtle bugs — mutable defaults, integer overflow, slice aliasing) was 100% across every model 4B and above.
Category D (red herring resistance) told the real story — can it resist fixing code that isn't broken? No model scored above 90%.
Small models can't debug.
Mid-size models fix obvious bugs but fall for traps.
Large models fix the hard bugs but still invent problems that don't exist.
- Drafted a blog post
- Used an LLM to meticulously improve the argument over 4 hours.
- Wow, feeling great, it’s so convincing!
- Fun idea let’s ask it to argue the opposite.
- LLM demolishes the entire argument and convinces me that the opposite is in fact true.
- lol
The LLMs may elicit an opinion when asked but are extremely competent in arguing almost any direction. This is actually super useful as a tool for forming your own opinions, just make sure to ask different directions and be careful with the sycophancy.
Which local models can actually handle tool calling?
I built a framework to find out.
15 scenarios. 12 tools. Mocked responses. Temperature 0. No cherry-picking.
Tested every Qwen3.5 size from 0.8B to 397B, and since some of you asked after the distillation tests: yes, I included Jackrong's Qwen3.5-27B-Claude-4.6-Opus-Reasoning-Distilled too.
Only two models went all green: the 27B dense and the distilled 27B.
The 397B? Failed two tests. The 122B? Failed one. The 35B? Failed two.
The timed-out results — mostly on the smaller models, are cases where the model got stuck in a loop, repeating the same tool call until it hit the 30-second limit.
The test that exposed the most models: "Search for Iceland's population, then calculate 2% of it." Simple, but 35B, 122B, and 397B all used a rounded number from memory instead of the actual search result. They didn't trust their own tool output.
Small models hallucinate data.
Big models ignore data.
The 27B just threaded it through.
Doing these 2 things right takes your DeepSearch/DeepResearch impl from mid to GOAT: (1) selecting the best snippets from lengthy webpages and (2) ranking URLs before crawling. After some iterations, we've discovered uncommon yet effective uses for classic retriever models in DeepSearch/DeepResearch systems. By adding them, we've significantly improved the quality DeepSearch result. We'd like to share these insights with fellow practitioners working in this space.
We're launching new tools to help developers build reliable and powerful AI agents. 🤖🔧
Timestamps:
01:54 Web search
02:41 File search
03:22 Computer use
04:07 Responses API
10:17 Agents SDK