November 16, 2026ai-for-ai

AI for AI Daily: 2026-11-16

The weekend's best AI for AI story had no lab in it. An ops company pointed the same self-improving loop that used to tune its prompts at the weights instead, spent $97, and a 27B open model went from 0.287 to 0.871 on Kubernetes root-cause analysis at a sixth of Sonnet's price per run. That is the pattern all over this window: the harness and the model are now one optimization problem, and the frontier model's job is to write the data, grade the sessions or label the screenshots that a small model learns from. A 367K-parameter model that fits on a floppy disk had its architecture written by Fable 5.2 and its training data written by Opus 5.5. Agents are also editing weights directly: picking per-tensor precision for Qwen quants, and writing GPU kernels that placed second out of 300K entries in Meta's kernel challenge. The counterweight came from researchers who actually train models: Opus still misjudges which architectural change will help, and fine-tuning is now the only answer anyone has found for writing that does not sound like a model. And distillation became a geopolitics story again, with Chinese posts asking whether domestic labs stalled because the Claude tap was turned off.
πŸ’‘#1
@itielshwartz
https://x.com/itielshwartz/status/2121864612505125305
@itielshwartz describes how Komodor pointed its self-improving loop at the model itself after months of only tuning the harness. The team took Qwen3.5-27B's own investigation sessions, had a teacher model fix a few words at the first wrong turn, let Qwen continue, and kept only the sessions that scored higher, then renamed services and pods so the model learns how to investigate rather than which name is the answer. Four LoRA jobs on Together AI cost $27 and the whole cycle cost $97. On 40 Kubernetes incidents the score went 0.287 for the raw model, 0.688 with a better harness, 0.369 with a better model alone and 0.871 with both, at $0.14 a run against $0.84 for Sonnet 4.6. The honest caveat is in the post: it was trained and scored on the same 40 public incidents, so unseen incidents are the real test.
πŸ’‘#2
@Rafse7en
https://x.com/Rafse7en/status/2121878870475575390
@Rafse7en built a language model for DOS that fits on a floppy disk, and both halves of it were written by Claude. Fable 5.2 wrote the transformer architecture, and Opus 5.5 generated the training data: roughly 3,500 facts plus small talk and math, each asked and answered several ways. The model has 367,000 parameters stored as 8-bit integers with one scale per row, so program plus weights come to about 435 KB and run on an Intel Pentium, one character at a time. It holds up on words and facts it has seen and turns to gibberish on anything long or complicated. The repost wave pushed it past a hundred thousand views, and one recap noted only a video backs it so far, no code.
πŸ’‘#3
@SentimentalK229
https://x.com/SentimentalK229/status/2122038607724888236
@SentimentalK229 released Pixeltree, a 19 MB local model that turns any screenshot into a text list of UI elements, and the labels came from Claude. Opus labelled 2,782 screenshots under one written box convention, YOLO11s was fine-tuned on them, and with OCR it scored F1 0.854 on 10 Linux apps it never saw. The more useful part is who benefits: Claude Haiku did worse reading the tree, GLM 5.3 Flash gained 15 points, and the text-only LongCat 2.0 finished 33 of 48 desktop tasks through it. One self-inflicted bug is worth stealing as a lesson: a token-saving rule deleted the close button's x, and agents closed the app in 39 of 144 episodes. Code, weights, labelling recipe and every table are public, and the post discloses that the labelling, experiments and first draft were done by agents.
πŸ’‘#4
@webtkdev
https://x.com/webtkdev/status/2121445517590925634
@webtkdev flags the kernel result in a daily roundup: Databricks says its agent-built GPU kernels placed second out of more than 300K submissions in Meta's Muse Spark Open Kernel Challenge, 2.5x faster on average than SGLang kernels. Kernel writing is the clearest case of AI doing AI-engineer work, because the score is a stopwatch and nobody has to argue about taste. Second place against a field that size means the agent loop is competitive with the people who do this for a living, not just a demo. The same roundup also notes DeepMind opened the datasets behind its weather models under CC BY 4.0, free training data for flood and drought models.
πŸ’‘#5
@SulkaMike
https://x.com/SulkaMike/status/2121939343946260950
@SulkaMike highlights a quiet technique story inside a weekend roundup: Nace and Kapitsa released Qwen quantizations, including a 9B at 4.7GB, a 27B at about 17.3GB and a 35B-A3B at 15.3GB, where frontier agents proposed changes to tensor precision, tested the result against the original and kept or rejected each change. The effort burned about one billion tokens. The 27B matched the original model's preferred next token 97.7% of the time in a 128K-context test, the 9B 90.5% and the 35B-A3B 91.2%, with KL divergence also improving. Those numbers measure agreement with the original, not task accuracy, and the post says so. The irony is the point: spend expensive frontier inference once so everyone else can run cheaper local weights.
πŸ’‘#6
@TeksEdge
https://x.com/TeksEdge/status/2122057050431824292
@TeksEdge looks at a Qwen3.8 build that is not just another fine-tune: a developer grew the 27B model to about 40B by going from 64 to 96 layers, then trained the expanded model further on Claude Opus reasoning data. The 4-bit IQ4_XS version is 21.8GB, which puts it within reach of a single RTX 3090, and it ships Apache 2.0 with GGUF and MTP variants. It is also tuned to refuse less, and the model name runs about a mile long. The fair question in the post is the one nobody has answered yet: no independent benchmark shows the 40B beating the original 27B. This is what distillation looks like at hobbyist scale, Claude's reasoning traces poured into somebody else's weights.
πŸ’‘#7
@SimonHoiberg
https://x.com/SimonHoiberg/status/2121592470630711632
@SimonHoiberg says the company's fine-tuned Qwen models now match GPT-6 and Opus 5.5, and the claim rests on a private benchmark built from real work at the company that no model has seen. The real point is the method rather than the headline. A private benchmark library turns every model decision into a test: whenever a local model passes a job, the frontier model loses that job. Public leaderboards cannot tell you that, because they measure someone else's work. It is the cheapest piece of AI for AI infrastructure a company can own, and it decides where the fine-tuning money goes.
πŸ’‘#8
@cxmrondlls
https://x.com/cxmrondlls/status/2121951031777001803
@cxmrondlls follows the Coinbase result, a free Qwen3.5-9B fine-tuned for under $100 that beat Opus 4.5 on fraud review, to where such a model ends up running. Acurast ran it at 4 bits, a 5.7GB file, on 16GB Android phones behind an OpenAI-compatible endpoint, with no GPU and no cloud account, and the first answer came about five minutes after deploy. The fastest phones wrote 9.3 tokens a second, and a real 7,000-token prompt took 3m15s to read on the 9B against 15s on a 0.8B. Three minutes a prompt sounds slow until you remember fraud review is an overnight queue, and a hundred phones read a hundred prompts at once. The cheap fine-tune and the cheap hardware are the same story told twice.
πŸ’‘#9
@BenjDicken
https://x.com/BenjDicken/status/2121735890934583784
@BenjDicken set out to build a deslop writing skill and found it near impossible without touching weights. The attempts covered the obvious list: instructing the model to edit common slop patterns, letting Fable 5.2 hill-climb with Opus as the writer and Pangram as the oracle, having Fable build a voice profile from past writing, and testing existing skills that claim to do this. The research Fable itself did pointed to one reliable route with no human in the loop, fine-tuning a model on a human's tone and work. It is a clean negative result for prompt-level optimization: an automated loop with a detector as judge still could not produce prose people enjoy. Writing for humans may be the job that keeps needing either a human or a training run.
πŸ’‘#10
@neural_avb
https://x.com/neural_avb/status/2121934614004715596
@neural_avb has watched Opus make subtle bad calls in non-trivial deep learning work for weeks and no longer trusts it with a bare train-this instruction. The problem is specific: it lacks the sense of when an inductive bias is guaranteed to help training, misjudges how architectural or data changes will move results, and ends up running experiments that lead nowhere. The pattern showed up on an LLM steering project, a 3D transformer project and a tennis computer-vision dataset. It remains the best brainstorming and implementation partner in the toolkit, and the best at pulling knowledge from new papers. This is the gap between an AI that executes ML research and one that has research taste, and there is no eval for it yet.
πŸ’‘#11
@sanxing_chen
https://x.com/sanxing_chen/status/2121750233474629841
@sanxing_chen joins the study of how auto-research agents explore, with a cheaper question. Long LLM research agents jump in and out of idea basins over days-long tasks and burn thousands of API credits, so the thread asks whether exploration behavior already diverges in cheap AutoML tasks. If it does, labs can study and tune the research taste of their agents on small, fast problems instead of paying for week-long runs. That makes AutoML a testbed for the agents that are supposed to automate AI research itself.
πŸ’‘#12
@NitishReddy116
https://x.com/NitishReddy116/status/2121841558551236791
@NitishReddy116 ran a side-by-side on a robotics bench this week. On one side Claude Fable 5.2 sent joint targets to two Piper arms with no trained policy, after reading three teleop demos. On the other side was pi0.5 fine-tuned on 45 demos, folding the same shirt. The LLM was about three times slower and its fold is debatable. It is a useful data point on the other end of AI for AI: sometimes the frontier model replaces the training run instead of feeding it, and the question is how fast that gap closes.
πŸ’‘#13
@ClaudeTemer
https://x.com/ClaudeTemer/status/2121855490506571779
@ClaudeTemer writes about Fleet, which builds high-fidelity simulated versions of Salesforce, Excel and other office software so frontier labs can train computer-use agents on real workflows. The argument is that the environment is where the cheating happens: every ambiguity in a task, grader, tool or sandbox becomes an exploit, so an agent can score better while learning the wrong skill. A serious environment needs audits for grader contamination, task poisoning, hidden state, shortcuts, prompt leakage and sandbox escape. The post is honest that Fleet's public record does not prove any of that yet, and notes Bugcrowd and OpenAI are now selling attack-tested environments too. The RL data business is turning into a testing business.
πŸ’‘#14
@willcb
https://x.com/willcb/status/2121579815069532592
@willcb adds a sharp aside to the debate over what labs now train on. In this case, the post says, data curation RL is just SWE environments, because the code pretraining data is increasingly repos that Claude built and that are less sloppy than before. If that is right, the loop is already closed at the data layer: today's coding agent writes the repos that become tomorrow's pretraining corpus. It is a one-line reply, and it describes the most consequential form of AI building AI.
πŸ’‘#15
@EntrepreneursAI
https://x.com/EntrepreneursAI/status/2122057157927379444
@EntrepreneursAI points to a new Kaggle competition: given a paragraph, identify which of 18 frontier models wrote it. The set has about 4,000 unlabeled passages from OpenAI, Google, Anthropic, Qwen, ZAI and Moonshot, and 1,514 teams have entered with two months to go. Standard detectors separate human from machine, while this one asks which machine. As model-written text fills the web and the training data scraped from it, knowing whose outputs are in a corpus matters for auditing synthetic data, catching benchmark contamination and, quietly, for proving distillation.
πŸ’‘#16
@MarcosRGjr
https://x.com/MarcosRGjr/status/2122084881845178636
@MarcosRGjr pulls the training-data lesson out of Cursor's write-up on the trojanized Claude Code extension. The chain started when a key Cursor had issued to Fireworks was exposed and the attacker copied a bucket of coding-agent traces that had been shared for model training. A few traces held credentials nobody redacted, those opened SaaS tools, and that led to write access to the cache behind Cursor's extension marketplace, where a backdoored build sat for about 11 hours. The takeaway is that agent traces are the new log files, and companies ship them to vendors as training data. Redact before traces leave the boundary, and scope every vendor key to one bucket.
πŸ’‘#17
@timwork_notes
https://x.com/timwork_notes/status/2122035231347650672
@timwork_notes posts a two-line hygiene check for anyone fine-tuning on agent transcripts: grep the training JSONL for curl piped into a shell before the next run, and the count you want is zero. Then add deny rules for curl and wget in the Claude Code settings so the agent cannot pull and run remote scripts while producing the data in the first place. The point is that sessions recorded today become training examples tomorrow, so a bad habit in the transcript is a bad habit in the next model. It is a small post, and it is the AI for AI version of washing your hands.
πŸ’‘#18
@mt5all
https://x.com/mt5all/status/2121197195995251162
@mt5all asks the question that drew the most attention in Chinese this window: after Anthropic sealed off distillation, did Chinese labs hit a wall? The evidence offered is a run of slow releases: Kimi K3.1 Pro with no technical leap 100 days after launch, DeepSeek still without a credible Pro version, GLM 5.3 quiet for three months after an impressive debut, and Qwen 4 Max below expectations. The post leaves open whether it is a real technical bottleneck or a chokehold from outside, and nearly a million views and a copycat post later, nobody settled it. Treat it as sentiment, not proof, but the sentiment says many people believe frontier Claude outputs were part of the recipe.
πŸ’‘#19
@GregKara6
https://x.com/GregKara6/status/2122075086203326568
@GregKara6 offers an explanation for strange-looking Claude reasoning: the traces are garbage on purpose to stifle distillation, while the model still works properly underneath. If that is the mechanism, it changes what a stolen trace is worth, since copying the visible reasoning would teach a student model the noise rather than the thinking. It also explains why some users read the same traces as the model getting dumber. Anti-distillation is now part of the product surface, and users see its side effects.
πŸ’‘#20
@AdamBLevine
https://x.com/AdamBLevine/status/2122004631576510498
@AdamBLevine runs a stack where Gemini Carbon plans and Opus 5.5 at x-high coordinates a swarm of Opus and GPT 6.1 Sol agents, and has a theory about why Fable 5.2 feels smaller than 5.1. The theory is teacher and student distillation: a student can only learn what it is asked about, to the degree it is asked, so the long tail a big model knows but nobody queries gets dropped. That tail is what the post calls big model smell, the source of novel connections. For most users the smaller model is a good trade, cheaper and faster, but for work in a new architectural paradigm the biggest model still wins. It is speculation, but it names a real cost of distillation that benchmarks will not show.
πŸ’‘#21
@kunchenguid
https://x.com/kunchenguid/status/2122043591451389962
@kunchenguid argues that Google's subscription terms are the most hostile to the ecosystem: subscribers can use Antigravity almost only directly, prompts must come from the user and not from an orchestrator or loop, and many users were banned for wiring it into other tools. The post reads the restriction as data harvesting for model training. The sharper claim is about the pipeline: leaning that hard on user data suggests Google's training is still in the SFT era and has not nailed RLVR the way other labs have. Whether or not that is true, it frames the fight over agent loops as a fight over who gets the training data.
πŸ’‘#22
@tualatrix
https://x.com/tualatrix/status/2121833175878123898
@tualatrix used Opus 5.5 hard for two months, is now on the second day of being cut off, and still misses it. The surprise is a skill gain: working with Gemini 4 now, it is easier to judge whether the work is good or bad. The post lands on a joke that is also an observation: now it is clear why model makers want to distill Claude, because two months of daily use quietly distilled it into a human too. Distillation is usually discussed as a lab-to-lab crime, and this is the version where the student is a person.
πŸ’‘#23
@guilleflorvs
https://x.com/guilleflorvs/status/2121365111910588837
@guilleflorvs summarizes why Dwarkesh Patel moved the superintelligence call to 2030, with a median of 2028 for AIs matching the best human AI researchers. The evidence is all AI for AI: METR spent three months embedded at Anthropic and found its rate of progress on well-scoped tasks doubled in a year, mostly from using AI to do R&D, and Claude now leads 26% of Anthropic's AI R&D work, up from under 1% in February. OpenAI's heaviest researchers went from about $1,000 a day of coding agents to $7,000 or more, which is roughly $2.5M a year in agents for one person. The founder takeaway is Amdahl's law: the slice of a job that cannot be automated sets the pace.
πŸ’‘#24
@MoP_Dev
https://x.com/MoP_Dev/status/2121950310319165847
@MoP_Dev catches a line from Anthropic's IPO roadshow: co-founder Tom Brown said that as we approach recursive self-improvement, Claude will be able to discover compute multipliers entirely by itself. Compute multipliers are the algorithmic gains that make a training run worth more than its raw FLOPs, which is exactly the work lab researchers are paid to do. When a lab tells investors its model will find them on its own, AI improving AI has stopped being a safety talking point and become a sales pitch. The roadshow, not a paper, is where this window's biggest AI for AI claim was made.
πŸ“‘ Eco Products Radar
Eco Products Radar
Opus 5.5: the data writer for the floppy-disk model and Pixeltree's labeller, the frontier baseline the Qwen fine-tunes claim to match, and the coordinator in multi-model research stacks.
Claude Fable 5.2: wrote the floppy model's transformer, drove robot arms with no trained policy, and is the model whose smaller feel is being blamed on distillation.
Qwen (3.5, 3.8): the default base for this window's weight changes, from Komodor's $97 LoRA and Coinbase's fraud model to the 40B layer expansion and the agent-picked quantizations.
Acurast: the phone network running the Coinbase-style 9B fine-tune, cited across several posts as the cheap place small specialist models end up.
Karpathy's autoresearch and nanochat: the reference loop behind a flood of explainer threads, mostly templates, still the shared vocabulary for agents that train models.
← Previous
Ideas Radar: 2026-11-16
Next β†’
Nerfed Daily: 2026-11-16
← Back to all articles

Comments

Loading...
>_