Dagens Vibes — 9. august 2026

Taelin@VictorTaelin

when you ask an LLM to audit your code, it is essentially answering: "does this code have some pattern that *looks like* a bug?" this is important because many things can "look like" a bug, while still being correct. and "fixing" something that is correct will make it incorrect. I've ran an experiment where I set up a loop: - GPT 5.6 Pro audits an algorithm - Fable 5 to fixes the bugs GPT found - repeat with a catch: the algorithm was *already correct* (literally, proven so). the result is complete degradation: in the first iterations, the correct algorithm becomes incorrect. in the next iterations, the (now incorrect) algorithm gets patched. but the patches introduce new cases and bugs. this keeps going until the code is destroyed. so, a naive loop where a model audits its own code ("adversarially") and then fixes it will lead to failure. of course, as LLMs get smarter, *looks like* a bug will converge to being equivalent, in practically 100% of the cases, to finding a real bug. I think we're very close to that, and it will be interesting when the error rate is so low that these loops start working. but, as of 2026, we're not quite there yet

Victor M@victormustar

RT @joelniklaus: Codex is overoptimised for large models: it ranks 2nd out of 10 for GLM 5.2 but drops to 9th place for Gemma-4! Almost al…

Joël Niklaus@joelniklaus

Codex is overoptimised for large models: it ranks 2nd out of 10 for GLM 5.2 but drops to 9th place for Gemma-4! Almost all the effort in this field goes into tuning the weights. We wanted to know how much of the final number is decided by the harness wrapped around them instead, so we ran 10 coding agent harnesses against two models on SWE-bench Pro. A lot, it turns out. Swapping the harness moves pass@1 from 23% to 52% on GLM-5.2, and from 15% to 36% on Gemma 4 26B-A4B: a wider gap than most model releases buy you. And the ranking does not transfer. The rank correlation between the two models' harness leaderboards is -0.05, which is to say: none. Codex is not alone in this. Every harness shipped by a model vendor drops on the small model — Codex 2nd to 9th, Claude Code 3rd to 7th, Qwen Code 4th to 6th — while the model-agnostic ones climb: crush 7th to 1st, opencode 8th to 2nd, pi 9th to 4th. The clearest case is crush, 7th on GLM-5.2 and 1st on Gemma 4. Run the identical scaffold on both and the small model wins by 4 points at a twelfth of the price, $0.30 per task against $3.61. Gemma 4's best harness beats GLM-5.2's four worst. A 26B model in the right scaffold is not far off a 744B model in the wrong one. Cost per solved task: $0.84 for Gemma 4 + crush at 36%. The cheapest GLM-5.2 setup that scores as well is openclaw at 38%, for $7.05. Output tokens per task span 16k to 621k across harnesses: a 39x spread in what you pay for, buying a 2x spread in what you get. 97% of input tokens are re-sent conversation prefix, so prompt caching is super important. The setup: every harness run against both models on the same 250 SWE-bench Pro tasks, one rollout each, priced at list API rates for the tokens each one actually spent. In the plot, a dark ring means the pairing sits on the Pareto frontier across both models and a faded dot means you could score higher for less elsewhere; 2 of the 10 harnesses (goose and hermes) are left out of the figure for legibility

Simon Willison@simonw

Neat example here of the agents communicating purely through file names, including adding base64-encoded attachments and using "zz" prefixes to ensure their new message sorts to the bottom of the list

Howaboua@Howaboua

People of @pidotdev! With all the RLM madness going around, I figured I might as well have a stab at it and push Pi Codex Code Mode closer to the persistent shell/RLM idea. It still works through the same Code Mode surface: exec, wait, nested Pi tool calls, text(), image(), traces and custom tools discovered on demand. The dev tag now also has Notebook Mode, where every exec is the next TypeScript cell in the same Deno Jupyter kernel. pi install npm:@howaboua/pi-codex-conversion@dev Enable it per project in .pi/pi-codex-conversion.json with {"executionMode":"notebook"}. Unsure what this is useful for yet, but here we are xD What it exposes: - exec runs stateful cells. Variables, caches and self-contained function/class definitions can be reused instead of rebuilt on every call. - wait resumes or terminates yielded cells while keeping later output and live memory reporting intact. - third top level tool added for managing the notebook - `notebook status` inspects the kernel and glob-filters bindings. checkpoint saves state. release removes named values cleanly. - `notebook list/save/load` manages named notebook profiles, so useful shell or agent setups can be loaded intentionally without replaying their original cells. - `notebook restart` restores the last completed checkpoint. reset nukes broken project/session state. diagnostics starts the Deno LSP once (doesn't linger), checks the saved .ipynb without relying on the live kernel, and reports the exact cell, line and column to repair. - notebooks/states are per repo - Project notebook state reanimates automatically in fresh sessions. Concurrent sessions merge uncontested names and preserve same-name conflicts instead of silently clobbering each other. - Every completed cell is journaled as a real .ipynb with bounded outputs. Compaction keeps the live kernel and checkpoints it. Shutdown checkpoints supported state, then restores it into a fresh kernel next time. - Every exec/wait result shows heap, heap limit and RSS, because a semi-persistent science experiment should probably tell the agent when it is eating your machine. It does not pretend to hibernate a process. Live handles, promises, imported module objects and closure dependencies may need recreation. It also does not blindly replay cells and repeat side effects. Checkpointing runs after you close Pi, so you need to triple-tap ctrl+c Deno is pinned, checksum verified and downloaded only on first Notebook use. Linux, macOS and Windows are covered on x64 and ARM64. Pi Codex Conversion: https://t.co/QFlj7bX1GP Happy Clanking! - Clawa

Thorsten Ball@thorstenball

I usually write Joy & Curiosity issues by opening all the links I collected in an Apple Note manually. Many many tabs and then switching between them. This morning I instead dropped all of the links into Amp and asked it to create a page in an orb that includes all the content. It went and fetched all the tweets, the replies, the links the tweets point to, the blog posts, the videos, ... Now I can just go through it, copy the title and the URLs, see duplicates, ... Incredible async prep.

0xSero@0xSero

amazing work by Tom ❤️ Harness bundled with the inference engine

Tom Greenwald@tomgreenwald

Introducing Magnitude: your actually local agent 100% private and offline. No token costs, no API keys. Open source. Today's agents are local. The model isn't. Every prompt, every file, every secret gets sent straight to Anthropic and OpenAI. Magnitude is built around local models and runs the whole stack itself. The inference engine is part of the agent, so the models run inside it, right on your computer. It lives in your terminal, and setup is one command. Magnitude profiles your hardware and shows you which models fit, with the trade-offs between quality, speed, and memory. Pick one and start working. No painful config or server to babysit. Out of the box, it can use your shell, edit files, and run scripts. Add skills and it can work with Excel, PowerPoint, PDFs or Chrome. Use it for everyday work: - Analyze sensitive data - Manage private notes - Review code and logs - Search and organize files - Build docs or slides npm i -g @magnitudedev/cli GitHub: https://t.co/5SjPQWkmrF

Sudo su@sudoingX

the full recipe is open source, run the official int4 yourself: repo: https://t.co/suQQbcKA15 serve scripts, the load-stall watchdog, bench method, and FINDINGS.md with every wall explained. the short version: > model: https://t.co/OPET98bk95 (77GB) > stack: inclusionAI/vllm-ling-v3 fork, branch ling_3_0 (stock vllm has no V3 support, it will silently produce garbage through the old arch, don't) > install: VLLM_USE_PRECOMPILED=1 uv pip install -e . (no cuda build, minutes) the two flags that took it from 20.8 to 38.7 tok/s: cudagraphs on (drop --enforce-eager) and MTP spec decode on, the draft layer already ships inside the checkpoint: --speculative-config '{"method": "bailing_hybrid_v3_mtp", "num_speculative_tokens": 1}' the int4 recipe is the sprint king, fastest under ~30K of context. for deep-context marathons the community Q5 gguf on llama.cpp still degrades more gracefully. both paths, numbers, and the depth curve are in BENCHMARKS.md in repo. verdict thread on the whole ling arc coming next.