Sabab

Suburban Mumbai ka middle class Aam Aadmi

[Arindam Majumder 𝕏 @Arindam_1729]

@h100envy I also wrote an article on Loop Engineering:
https://t.co/H0wPRFP1LO

[h100envy @h100envy]

Ex-NVIDIA engineer who built Unsloth explained RL, kernels, reasoning, quantization, and agents in 2 hours 42 minutes - better than $5000 fine-tuning bootcamps.

pick the base model -> write triton kernels for 2x faster fine-tune -> quantize to 4-bit -> run GRPO/DPO -> ship a reasoning model on your single GPU.

That loop is why Unsloth is the default way to fine-tune Llama, Qwen, Gemma, and Phi on hardware you already own.

Unsloth + Triton kernels + 4-bit quantization + GRPO/DPO + single-GPU fine-tuning - that's the stack.

Watch and save it, then fine-tune your first model tonight.

[Loic cabannes @loiccabannes]

Introducing Sparse Delta Memory (SDM) - The first work of my PhD 🎓.

SDM combines the GatedDeltaNet update with Product Key sparsity, enabling a recurrent state 3000x larger at the same FLOPs and significantly improving long-context performance.

Let RNNs be sparse!

[Nicholas Charriere @nichochar]

@theo perfect example of the dogfood advantage that anthropic has
https://t.co/4qu5EDiGoU

[Jarred Sumner @jarredsumner]

Rewriting Bun in Rust

https://t.co/Rl8bcaxBFc

[Mitchell Hashimoto @mitchellh]

I’m glad the Bun rewrite blog post focused mostly on the methodology of the port! It’s a good post! Good work @jarredsumner.

My favorite part is the little detail about the importance of clean context agents for doing different tasks to avoid biases. I’ve found this is a good reason to not use a single long auto compacting coding session for both build and final verify.

On the cost, I think $165,000 at API pricing for Fable (didn’t verify) is an incredible deal. There’s absolutely no way an engineer with that salary would’ve been able to achieve the milestones Claude did in 11 days. No way. (Even if you break it down to N engineers paid $165K total in 11 days it doesn’t math out)

This does, however, also reconfirm my own biases which is that Fable in particular is most excellent at hard, focused tasks with clear reward functions. I’ve been tweeting about this recently.

I would absolutely use Fable for this.

[Simon Klee @simonklee]

Spending over a decade in the Go community and i think its one of the best examples avoiding this type of behavior. Leadership was obviously always opinionated on language and way of running a project, but very technical driven and never engaging in comparison competitions. 16 years of blog posts all about technical decisions, releases and things you actually care about as a user of the language.

https://t.co/e0FAJGvVuA

I think this benefited Go in terms of driving adoption.

[Jamie Birch @birch_js]

@netapy I’ve made a WebView embedding framework for React Native and shipped both mobile and desktop apps with it to over 10,000 offices in Japan, so your move mate

https://t.co/xngwUMZvHG

[Jane Manchun Wong @wongmjane]

X has quietly launched its complete rewrite of X Web, starting with Logged-Out pages

Built with Tanstack Router and Tailwind, which brings in SSR Streaming, Vite, Rolldown, ES Modules, etc all the modern web practices

Congrats to the @Engineering Web team for pulling this off!

[Jarred Sumner @jarredsumner]

rust rewrite blog post Monday

Bun v1.4 hopefully Tuesday (video still editing)

[Shann³ @shannholmberg]

here are 6 habits to run Fable 5 more efficiently and cheaper

Fable 5 is the best model I've run, but it's pricey, around 2x opus.

to use it effectively, you should be routing tasks, use it for the small slice of work that needs the horsepower and run the rest on cheaper models.

and effort matters as much as the model. Fable 5 on low can match older models on high, for less.

when you do use it, these are the habits that get a lot more out of it. (referenced from Nate Herk´s video)

1. give it the why, not just the task

tell it what the work is for. it connects the request to the right context instead of guessing.

2. say what not to do

these are prediction engines, they drift. spell out the lines you don't want it crossing.

3. let it act, dont make it over-plan

long research-then-plan cycles burn time and tokens on high effort. give it enough and let it move.

4. force verification

dont ask is this done. tell it to point to the proof, only report what it can show evidence for. thats how you stop double-checking everything.

5. say less

if your context and tools are set up, short clean instructions steer it better than long rule lists. It doesn't need the essay.

6. don't ask it to explain its reasoning

this one is specific to fable 5. asking it to reveal its thinking can trip a safety check that quietly reroutes you to a weaker model.

that last one ties to a gotcha worth knowing. fable 5 runs a safety check before it answers, and on anything that reads sensitive it can silently hand the task to opus 4.8. in the app you might not notice, on the api you get a signal.

so treat the best model like a specialist. route to it for the hard 10% tasks, feed it the why, make it prove its work, and keep your prompts short

[DAIR.AI @dair_ai]

Highly-recommended read from MIT on the part of RL with verifiable rewards that everyone keeps hitting.

RLVR only optimizes what you can objectively score, so style, structure, and diversity quietly collapse and reward hacking creeps in. The fix here adds an adversarial discriminator trained on human demonstrations, which acts as a learned proxy for the human output distribution.

The generator maximizes both task accuracy and the discriminator's human-likeness signal, so verifiable rewards and imitation of humans get optimized together.

Why does it matter?

Across bug fixing, story generation, and a reward-hacking benchmark, this preserves RLVR's accuracy gains while restoring the fuzzy properties it usually destroys. Bug fixes come out with much lower edit distance, stories score higher win rates and stay diverse, and misbehavior nearly disappears.

Paper: https://t.co/kBZA66WGyC

Learn to build effective AI agents in our academy: https://t.co/LRnpZN7L4c

[Simplifying AI @simplifyinAI]

🚨 Alibaba built a way to give any website its own AI copilot.

It's called Page Agent.

It reads the page as plain text, no screenshots, and lets your own LLM click, type, and navigate for you.

> No browser extension, no backend, just JavaScript
> Reads the page as text, no screenshots needed
> Bring your own LLM: OpenAI, Claude, Qwen, any provider
> Turns 20-click workflows into one sentence
> Optional Chrome extension for multi-page tasks

100 % Free.

[Roy Carrilho @RuiCarrilho5]

ended up finding this book on the matter. it's apparently a more academic, practical version of DDIA.

and it's free!

[Dami-Defi @DamiDefi]

https://t.co/vQvRNI2PhB

[Xudong Han @Xudong07452910]

为什么 AI Agent 的「记忆」通常被设计成外挂的数据库，而不是一种可以被学习的能力？

这篇斯坦福论文 AutoMem 的答案是：记忆本身就是一种认知技能，就像阅读、推理一样，可以被端到端训练。论文把「什么时候存、存什么、怎么找回来」这些记忆决策，和 Agent 的任务动作放在同一个行动空间里，让模型自己学会管理自己的记忆。

具体怎么做：两层嵌套循环。外层元循环优化 Agent 的「记忆架构」（决定用什么样的记忆结构），内层训练一个专职的「记忆技能模型」，用 Agent 自己的历史执行轨迹蒸馏出最优的记忆使用策略。从一个配备文件系统记忆的基础 Agent 出发，经过记忆架构优化和记忆技能训练两个阶段，性能持续提升。

这点很有意思，以前做 Agent 记忆都是工程问题：选什么向量库、检索算法用什么。AutoMem 把它变成了一个学习问题：让 Agent 自己学会「什么时候该记」和「怎么用记住的东西」。这一步的转变，意味着 Agent 的记忆能力不再依赖人工调参，而是随任务经验一起进化。

这提醒我们，Agent 的记忆能力不是终点，学会管理自己的记忆才是关键。

https://t.co/0tEqXyVv9N

[Rahul @sairahul1]

This is the best site on the internet to find agent loops you can use right now.

Free. Completely.

Most AI engineers are still writing these from scratch.

https://t.co/FHDHGXam6Z

Bookmark this site.

Then read this ↓

[Elvis @elvissun]

send this to fable along with your hardest engineering problem.

thank me later.

[ModelScope @ModelScope2022]

SciJudge-30B and 4B learn to predict which scientific work will carry stronger citation impact.
License: Apache-2.0 🚀

30B 🔬 https://t.co/LdUd49JtQy
4B 🔬 https://t.co/JXm1JmL4Fq
📄 https://t.co/AP0mGnfUaR

📊 Scientific Judge accuracy: SciJudge-30B reaches 80.6 in-domain, surpassing GPT-5.2, GLM-5, and Gemini 3 Pro; SciJudge-4B also outperforms much larger baseline models

🧪 Data signal: built from 2.1M arXiv papers and 696,758 field- and time-matched citation-based preference pairs

🧠 Training: GRPO with DAPO loss and citation-based pairwise rewards

[Vivek Galatage @vivekgalatage]

Apple Neural Engine - the chip in every iPhone since 2017; every Mac since the M1.

The professor from Georgia Tech just reverse-engineered it - 302 pages. Hardware datapath, weight compression, & secret dispatch route that reaches it below Core ML.

https://t.co/IfHmPkMLbS