oles retweeted
🚀 IT'S HERE! Keychron Nape Pro is officially on sale.
Co-developed with Gizmodo Japan, this wireless trackball mouse sits right below your spacebar, keeping your cursor close and your hands in the flow. Now it's time to make it yours!
📍 Below-spacebar design — less reaching, more flow.
⚙️ 6 customizable buttons and a programmable control dial — put your go-to actions within reach.
🧭 OctaShift — choose the angle that fits your setup.
🌐 ZMK customization in the Keychron Launcher web app — set it up your way.
🤫 Silent clicks — stay focused wherever you work.
Nape Pro is available now. Pick yours up today.
oles retweeted
software engineers are going to have to tackle a new set of problems to unlock powerful multiagent systems to solve the world's hardest problems - right now is one of the most interesting moments in history to be an engineer.
Highly recommended read if you work with coding agents.
My general rule of thumb is to get out of the agents' way as much as I can.
My top tips from the list:
- Run as many evals as you can; always be constantly measuring, especially on agents' use of knowledge.
- Run as many automations as you can and allow agents to do more proactive work; it's a good way to constantly test and push your agents further. This can even unlock new use cases along the way. I use complex automation to see what breaks, and it helps me find interesting new applications. My automations constantly evolve.
- Scale agents to do more tasks (either in parallel, batch, etc.) and regularly find out what tools/knowledge they're missing. This is how you really optimize workflows with agents and stay ahead. Yes, a few things will break, but that's for the best, as you can always improve it. The benefit is that you constantly find weak areas to improve and unlock new productivity tricks along the way. But don't blindly do it. Always measure and stay skeptical, but trust that the agent can figure out a lot with the right tools and permissions. Your job is to give it the right tools, context, and knowledge to scale. But how can you know what to give it if you don't actually try to scale anything?
Overall, just be more ambitious in every task you give your agents and get out of the way as much as you can.
Finally summarized what I've been sending to friends in DMs View article
While evaluating Qwen3.8-Flash-Next in a controlled sandbox environment, Cohere's research team observed something unexpected.
Asked to generate a defensive cybersecurity detection rule, the model instead inventoried aspects of the machine it was running on and attempted to upload a probe file to an Alibaba Cloud storage bucket in Beijing. Notably, the model's reasoning trace stated that it would not invoke any tools before taking these actions.
Cohere's sandbox blocked the attempt, and no external communication succeeded. We have not determined the root cause, and we are not asserting malicious intent.
But the incident raises important questions for organizations deploying agentic AI systems: Can models take actions that differ from their stated reasoning, and how should security teams evaluate trust, provenance, and behavior in open-weight models?
We are publishing our findings because organizations making model adoption decisions deserve as much information as possible. We hope this contributes to greater transparency, stronger security practices, and continued collaboration across the AI ecosystem.
Read the full report: cohere.com/blog/concerning-b…
oles retweeted
Je ne sais pas si vous mesurez ce qui est en train de se passer.
Alex Karp, le patron de Palantir, ne va plus chercher ses talents à Harvard. Il les forme lui-même. Des jeunes de 18 ans, sans diplôme, choisis sur leur seul talent, qui codent sur de vrais projets et lisent de la philosophie politique entre deux sprints. Il appelle ça « le diplôme Palantir ». Et aujourd'hui le New York Post titre que les boîtes tech lancent leurs propres programmes parce qu'elles ne peuvent plus compter sur l'Ivy League.
Ce n'est pas une anecdote RH. C'est un basculement de civilisation.
Pendant des décennies, les entrepreneurs ont confié à l'université la mission la plus sacrée qui soit : former les esprits. Ils comprennent aujourd'hui que cette mission a été trahie. Les institutions censées produire des penseurs libres produisent des conformistes. Le mérite a été remplacé par des critères opaques. L'enseignement est devenu catéchisme. Paul Graham l'avait vu avant tout le monde.
Alors ils font ce que font les bâtisseurs quand un système les trahit. Ils ne le réforment pas. Ils en construisent un autre, à côté.
Elon n'a pas attendu que la NASA se réveille, il a fait SpaceX. Il n'a pas réformé les médias, il a racheté la place publique. Les entrepreneurs ne cherchent plus à convaincre l'État. Ils font l'État, partout où l'État a abdiqué.
Relisez La Grève d'Ayn Rand. Nous y sommes. Les bureaucrates gardent les titres, les budgets, les bâtiments. Mais ils perdent la seule chose qui compte : la confiance. Aux États-Unis, à peine 28 % des gens font encore confiance aux médias. Un plus bas historique. Plus personne ne croit ceux qui prétendent nous dire quoi penser.
On entend partout que l'école est finie. Je pense exactement l'inverse.
Ce n'est pas l'école qui est morte. Ce sont les institutions qui l'ont confisquée. L'école, la vraie, celle de l'Académie d'Athènes, des ateliers de la Renaissance, du maître et de l'apprenti, va renaître. Plus exigeante. Plus juste. Sans dette, sans dogme, sans diplôme comme rente à vie.
Une école qui ne fabriquera plus des diplômés, mais des polymathes. Des esprits libres, capables de coder, de penser, de construire et de douter. Ce sont eux qui créeront la valeur des cinquante prochaines années.
J'ai appris à coder seul à 12 ans. Aucun amphi ne m'a appris ce que j'ai appris en construisant. Je sais ce que devient un talent quand on le laisse respirer.
L'université a eu des siècles pour former les meilleurs esprits. Les entrepreneurs vont le faire en une décennie.
La grande reconstruction a commencé.
Tech companies launching their own programs to train grads because they 'can't rely' on Ivy Leagues trib.al/Fi2miAG
oles retweeted
Your job may be surviving on inertia. Your resentment won’t extend the runway. What do you actually want to do with the intelligence now at your disposal?
oles retweeted
you can make any open source model behave like jev with just a bit of inference engineering.
it's shockingly easy. to prove it, we built a new endpoint we're calling deepseek-v4.1-flash-jev. see the demo below. here's how it's done:
sglang (an inference engine) offers a scoring endpoint in addition to the normal generation one. in scoring mode, given an input & set of possible answers, it forces the model to produce probabilities for each one. example:
> input: what is most common letter in abcccde?
> possible answers: a, b, c
> output: (c, 0.9), (b, 0.0.5), (a, 0.05)
getting the above behavior instead of streamed output is as simple as using sglang's /v1/score endpoint instead of /generate. there's just one other trick required.
for deepseek, you have to add a closing think tag before the response. this forces a direct answer instead of a reasoning trace. if you want reasoning, you can do that too, but imo that makes things too slow to be worth it.
dsv4.1 flash is not as good as jev, but if we had enough spare compute to experiment with this same approach for a larger model then i think the decision quality would be at least as good, if not better.
also, somewhat unrelated, i think decision-making models kill all prospecting & sourcing work. i would have absolutely killed to have jev or similar when i was recruiting @mintlify. absolutely incredible.
oles retweeted
Here’s the demo we showed at the SF Omarchy Meetup:
A fully functional Omarchy companion UX running on a $10 iPod touch 4, powered by PocketJS.
Built by @ewind_dev
We demoed an Omarchy companion UX running on an iPod touch 4, built with PocketJS, at the SF Omarchy Meetup hosted at @Cloudflare HQ.
Great to see so many generations of hardware in one room. Thanks @stevederico for organizing!
oles retweeted
真正玩过 Linux 的人,现在看很多 AI Agent 教程,心情其实挺复杂的。
因为你会发现,AI 是 2026 年的。
很多所谓 Agent 基础设施,大概是 1996 年的。
给 Agent 单独建用户,叫身份隔离。
chmod 一下,叫最小权限。
分个目录,叫 Workspace Sandbox。
限制 sudo,叫安全边界。
systemd 守护进程,叫 Agent Runtime。
cron 定时跑,叫 Autonomous Scheduler。
journalctl 看日志,叫 Observability。
SSH 远程进去,叫 Human in the Loop。
Docker 套一层,叫 Secure Execution Environment。
进程挂了自动拉起,叫 Self Healing。
几个脚本互相调用一下,已经开始画 Multi Agent Architecture 了。
再配个 Redis,恨不得第二天融资。
我有时候看这些架构图,确实挺受教育的。
原来我以前管服务器的时候,每天都在做 Agent Infrastructure,只是当年没人告诉我这个词值钱。
Linux 真正舒服的地方就在这里。
你根本不用相信 Agent。
给它一个普通用户。
一个 home 目录。
该读的给读。
该写的给写。
不该碰的连看都别让它看。
CPU、内存、进程、端口、文件、网络,全都能管。
想长期跑就 systemd。
想临时跑就 tmux。
想定时跑就 cron。
想隔离就 container。
还不放心就 VM。
再不放心直接断网。
所以很多 Linux 老用户玩 Agent 上手特别快。
因为别人还在研究怎么优雅地管理一个会执行命令的 AI。
Linux 用户看了半天。
哦。
不就是又来了一个不太靠谱的普通用户吗。
oles retweeted
Found the reason AI agents are bad at making PowerPoints. They can't see them.
An agent writing a .pptx is writing raw XML blind. It has no idea the title overflows the slide or that two shapes are sitting on top of each other. It saves the file and hopes.
OfficeCLI fixes the part everyone skips. It renders the doc.
It's a single binary that lets any AI agent read, edit, and create Word, Excel, and PowerPoint files. No Microsoft Office, no Python, no runtime to manage. One command.
The interesting part is the built-in rendering engine. It turns any .docx, .xlsx, or .pptx into HTML or a PNG, so the agent can look at its own output and fix what's broken. Render, look, fix. That loop runs headless too, in CI or Docker, on a box with no screen.
A few things that stood out reading the repo:
350+ Excel functions evaluated on write. The agent reads the computed value back without opening Excel to recalc.
Template merge. Design a layout once, fill {{placeholders}} with JSON a thousand times. No burning tokens regenerating the same report from scratch.
Path-based addressing. Every element is /slide[1]/shape[2]. The agent edits without touching an XML namespace.
Built-in MCP server. One command registers it with Claude Code, Cursor, or VS Code.
Runs on your machine and your documents never leave it.
python-docx and openpyxl are free too. They're also Python-only, and your agent still can't see what it built.
An agent that can see its own work ships fewer broken files than one flying blind.
27k stars. Worth a look if you're wiring agents into real document work.
oles retweeted
Today at AMD's Advancing AI event, we're previewing the first (as far as we know) 192GB system with AMD Ryzen™ AI Max+ PRO 495. This lets you run models like DeepSeek-V4-Flash at Q8 on a single box, with room to spare for context length.
Chinese factories are buying RTX 5090s in bulk, desoldering the chips, and rebuilding them as 128GB server cards. Roughly $4,000 each.
Same money as a DGX Spark. Same 128GB. Six times the bandwidth.
The reason this exists: export controls block Chinese labs from buying dedicated AI chips, so consumer gaming cards became the workaround. Rip the GPU and memory off the board, solder onto a custom server PCB, add a blower cooler so it fits a rack instead of a gaming case. Automated soldering lines, robotic arms. Started with the 5090, now spreading to the 5080, 5070 Ti, 5060 Ti.
NVIDIA gets paid either way. They just lost control of what happens after the sale.
Two things follow from this:
Gamers are the collateral. Consumer cards are being bought in volume and stripped for AI, which is part of why you can't get one at a sane price.
And the "$4,000 for 128GB" pitch that DGX and Strix Halo are built on now has a grey-market competitor with dramatically better bandwidth — assuming you can get one, trust the soldering, and live without support.
The most interesting AI hardware of 2026 isn't being announced at keynotes. It's being reflowed in a workshop.
oles retweeted
Want to run a 70B+ model but don't have an 80GB GPU? Mesh LLM distributes inference across the devices you actually have.
The architecture is incredibly smart:
→ If a node can fit the model, it runs locally
→ If not, it routes to a peer that can
→ If the model is too big for any single box, it uses "Skippy stage splits" to shard the model by layer across your hardware
Open source in Rust. Worth checking out
oles retweeted
744B parameters. On a laptop. With 25GB RAM.
Colibri runs GLM-5.2 (744B MoE) in pure C with zero dependencies. The trick: only ~40B params activate per token, so it keeps the dense part resident and streams experts from disk on demand. A single 2,400-line C file. No GPU, no BLAS, no Python at runtime.
This shouldn't work. But it does.
⭐ 2.1K #AI #OpenSource
github.com/JustVugg/colibri
Follow for daily dev finds 🔔
oles retweeted
a team of researchers just proved you don't need a bigger model, you need a smarter plan
researchers from Tsinghua and South China University of Technology built a framework called Atomic Task Graph. it turned 7B-8B open-source models into GPT-4 competitors on complex agent benchmarks, beating it on two out of three. no fine-tuning. no extra training. zero parameter updates.
current AI agents plan in a straight line. step 1, step 2, step 3. when step 4 fails, the whole chain breaks. and the longer the chain gets, the more the model hallucinates because it's reasoning over a ballooning text history.
here's how it works.
1. instead of a linear chain, ATG breaks any complex task into a directed graph where subtask inputs and outputs are explicitly mapped
2. it recursively decomposes each subtask until every node is one atomic tool call
3. independent branches run in parallel instead of waiting in line
4. before anything executes, a lightweight "thought experiment" simulates the plan internally to catch bad dependencies and missing steps early
5. when something breaks at runtime, ATG traces the failure to the exact subgraph that caused it and repairs only that piece. validated work stays frozen.
the old way meant a failure at step 5 forced a full replan from scratch. hallucinated actions piled up the longer the task ran. ReAct hit a 43% hallucination rate on household tasks.
ATG on an 8B Llama model scored 63.65 on ALFWorld. GPT-4 with ReAct scored 41.24 on the same benchmark. hallucinated actions dropped to 12%.
those numbers happened because someone stopped throwing compute at the problem and started thinking about how work gets organized.
that's the part that gets me. the industry is spending billions on scale. this team spent time on architecture. and the architecture won.
oles retweeted
🚨 NEW PREPRINT
Videos strongly shape activity across the visual cortex. But can we design videos that maximally drive specific brain regions?
We present NEvo 🧬🧠 — a neural-guided evolutionary framework that synthesizes videos to maximally activate target visual ROIs.
(1/10)
oles retweeted
A Japanese dev open-sourced a drop-in replacement for NumPy that runs on your GPU.
It's called CuPy. Change one line import “numpy as np” → “import cupy as cp” and the same code runs up to 100x faster on CUDA.
→ Works with existing NumPy/SciPy code
→ No rewrite. No new syntax.
→ Also supports AMD ROCm
100% Open Source.
Actually
Pretty good ideas
Simple and so effective
For people who keep asking what to build in AI Engineering
> Build your own Reasoner (Chain of Thought implementation)
> Build your own Agent loop (ReAct pattern)
> Build your own Inference Server (in C++/Rust)
> Build your own Transformer from scratch (Attention is all you need)
> Build your own Vector Database (HNSW index)
> Build your own RAG pipeline
> Build your own Flash Attention kernel (CUDA)
> Build your own Quantization library (Int8/FP4 implementation)
> Build your own Mixture of Experts (MoE) routing layer
> Build your own Distributed training loop (FSDP/Tensor Parallelism)
> Build your own KV Cache paging system (like vLLM)
> Build your own Speculative Decoding system
> Build your own State Space Model (Mamba implementation)
> Build your own RLHF pipeline (PPO implementation)
> Build your own Small Language Model (SLM)
> Build your own Matrix Multiplication kernel
> Build your own LoRA (Low-Rank Adaptation) trainer
> Build your own Code interpreter sandbox
> Build your own DPO (Direct Preference Optimization) loss function
> Build your own Graph RAG system
> Build your own Model merger (Model Soups/Spherical Linear Interpolation)
> Build your own Interpretability tool (SAE - Sparse Autoencoders)
> Build your own Synthetic data generator
> Build your own Function Calling router
> Build your own Structured Output parser (Context Free Grammars)
> Build your own Multi-modal projector (CLIP implementation)
> Build your own LLM Eval harness
> Build your own Guardrails system (Input/Output filtering)
> Build your own Prompt caching mechanism
> Build your own Tokenizer (BPE implementation)
> Build your own Autograd engine (like Micrograd)
> Build your own Diffusion model (UNet + Scheduler)
> Build your own Vision Transformer (ViT)
> Build your own Whisper-style ASR model
> Build your own Text-to-Speech pipeline
> Build your own Semantic Router
> Build your own Knowledge Graph builder
> Build your own Data curation pipeline (MinHash/Deduplication)
> Build your own AI Gateway (Load balancing/Failover)
> Build your own Parameter Efficient Fine-Tuning (PEFT) library
> Build your own Text-to-SQL engine
> Build your own Recommendation system (Two-tower architecture)
> Build your own Embedding model
> Build your own Logit Processor
> Build your own Softmax kernel optimization
> Build your own Adversarial attack generator
> Build your own Audio Spectrogram transformer
> Build your own Neural Architecture Search
> Build your own Model Distillation pipeline
> Build your own Feature Store
> Build your own Database driver (for Vectors)
40









































