Today: realistic limits on what AI automation will do, a GPU scheduler people stopped gaming, and Cloudflare making Workers easier to profile and to run on your own servers.
Picked from 28 new articles across 23 sources · arrow keys for other days
Today in 30 seconds
30s left
Nathan Lambert predicts AI could automate pretraining research within 2–3 years but won't reach general superintelligence. The gains come from measurable infrastructure work. story 1 ↓
Ai2 replaced GPU priority labels with budgets and time-limited job protection. Teams got 98% of the hours they were owed, and debug jobs now wait 30 seconds instead of two hours. story 2 ↓
Cloudflare Workers can now be CPU- and memory-profiled under live traffic. Internal teams made a JSON helper 2.7x faster and got one Worker under its 128 MB limit. story 3 ↓
Deno's Ryan Dahl and Bert Belder are joining Cloudflare to merge celld into workerd and add scalable Durable Objects for self-hosted Workers. story 4 ↓
DeepMind's Pushmeet Kohli says AlphaFold learned from lab-solved structures and didn't solve protein folding. He argues scaling laws and the right data matter more than extra compute. story 5 ↓
1/5Interconnects (Nathan Lambert)· Nathan Lambert· Oct 9
Lambert: AI will automate AI engineering, but not reach general superintelligence
AI researcher Nathan Lambert argues that coding agents will soon do much of the engineering behind AI, making models far cheaper to train and run. He doesn't expect that to make models fundamentally smarter.
Why it matters · It gives engineers a grounded way to judge "AI will replace researchers" claims: the near-term gains come from measurable infrastructure work, not from a breakthrough in reasoning.
Know this first
Context from the editor, not the article · 45 sec
Nathan Lambert is a researcher who works on post-training, the stage after a model's initial training where it is refined. He writes the Interconnects newsletter.
Training and serving a large language model (LLM) is mostly an engineering problem. Thousands of GPUs, the chips that do the math, have to be kept busy. Data has to move efficiently between them, and every answer the model gives has a compute cost. Over the past decade, the best AI researchers have been judged largely on whether they could implement and scale their ideas on this kind of infrastructure.
Coding agents are AI systems that write, run and debug code with little human help, and in 2025–26 they became capable enough to take on much of this work. That has fed talk of "recursive self-improvement": AI that improves AI, which then improves AI faster, possibly leading to superintelligence. Ilya Sutskever, an OpenAI co-founder, has argued that the field is moving from an "age of scaling" back to an "age of research." Lambert's essay responds to both ideas.
Image: Interconnects (Nathan Lambert)
2/5Hugging Face· Oct 9
Ai2 replaces GPU priority queues with budgets and time-limited job protection
Ai2 swapped its priority-based GPU scheduler for manager-set time budgets, week-long fair-share accounting and a promise of uninterrupted runtime. Clusters stayed 98% busy, waits fell sharply and hands-on repairs dropped 74%.
Why it matters · It shows how a scheduler's rules shape user behavior, and how attaching a cost to every claim stopped the gaming that priority labels had encouraged.
Know this first
Context from the editor, not the article · 49 sec
A cluster scheduler decides which submitted jobs ("workloads") get which machines, and when. On shared GPU clusters used for AI training, demand usually exceeds supply, so the scheduler is really deciding whose research moves forward.
Two classic ideas matter here. Preemption means stopping a running job to free hardware for another one. A job is "resumable" if it saves checkpoints and can restart where it left off. Fair-share scheduling gives each group a target share of the machines and favors whichever group has recently received less than its share. Hierarchical versions follow an organization chart, so shares are split by program, then by project, then by person. Well-known implementations include the Hadoop Fair Scheduler (2009), SLURM's Fair Tree and YARN's Fair Scheduler.
Ai2, the Allen Institute for AI, is a nonprofit research lab that trains open models. Its infrastructure team describes compute as a pyramid of four layers. From the bottom up: availability (the hardware is healthy), occupancy (available time is assigned to a job), impact (the most valuable jobs get chosen) and utilization (jobs actually keep the GPUs busy). This post is about the impact layer.
Preemption
Stopping a running job early so its hardware can go to another job.
3/5Cloudflare· Dominik Picheta· Oct 9
Cloudflare Workers can now be CPU- and memory-profiled live in production
Cloudflare now lets developers capture CPU and memory profiles of their serverless code while it handles real traffic, shown as flamegraphs. Its own teams used it to find wasted work and a memory leak.
Why it matters · Profiling under real production traffic shows performance problems that local testing misses, and the internal case studies show what kinds of bugs it finds.
Know this first
Context from the editor, not the article · 43 sec
Cloudflare Workers is a serverless platform. You upload JavaScript or TypeScript, and Cloudflare runs it in data centers around the world, close to whoever sends each request. Instead of giving each program its own container, Workers run inside V8 isolates. V8 is the JavaScript engine used in Chrome, and an isolate is a lightweight sandbox inside it, so many customers' code can share one process safely. Each isolate gets a 128 MB memory limit.
A profiler samples a running program many times per second and records which function is executing (CPU profiling) or which function allocated memory (memory or heap profiling). The usual way to show the results is a flamegraph: stacked boxes where each box is a function, the boxes above it are the functions it called, and a box's width shows its share of CPU time or memory.
Until now, Workers could only be profiled locally with Chrome DevTools. Local test traffic rarely looks like real production traffic in either volume or variety.
Example flamegraph. Box width shows each function's share of CPU time or memory.1 / 4
4/5Cloudflare· Kenton Varda· Oct 9
Deno's founders join Cloudflare to make self-hosted Workers production-ready
Deno's team, led by Node.js creator Ryan Dahl, is joining Cloudflare. They will fold their open-source clone of Cloudflare Workers, called celld, into Cloudflare's own open-source runtime so apps can run outside Cloudflare.
Why it matters · Whether you can leave a serverless platform is a real architecture decision. This move aims to make Cloudflare's programming model portable to your own servers.
Know this first
Context from the editor, not the article · 41 sec
Cloudflare Workers is a serverless platform. You upload JavaScript, and Cloudflare runs it in hundreds of data centers close to users. Each app runs in a lightweight sandbox inside one shared JavaScript engine instead of in its own container. That is part of why Workers is cheap to run.
Durable Objects are a Workers feature for state. Each object is a single named instance that owns its own storage. Every request for that name is routed to the one place it lives. This makes coordination tasks like chat rooms or collaborative editing simple, because one object sees all the traffic for one thing.
The catch is that apps built this way don't fit ordinary hosting, which is usually web servers plus a shared database. Critics call this "lock-in." In 2022 Cloudflare open-sourced its runtime as workerd.
Node.js (2009) made server-side JavaScript popular. Its creator, Ryan Dahl, later built Deno, a newer JavaScript/TypeScript runtime, through his company Deno Land.
Image: Cloudflare
5/5Latent Space· Oct 10
DeepMind's Kohli: AlphaFold copied lab structures, it didn't solve protein folding
Google DeepMind's Pushmeet Kohli and Biohub's Sal Candido argued on a panel that scaling up AI won't solve biology by itself. Biology needs better data, built-in scientific knowledge, and models whose confidence scores can be trusted.
Why it matters · Two people who build some of the best-known AI-for-science models explain where "just scale it" works, where it fails, and why trusting a model can matter more than understanding it.
Know this first
Context from the editor, not the article · 44 sec
Proteins are chains of amino acids, the building units of proteins. Each chain folds into a 3D shape, and that shape largely decides what the protein does. Measuring a shape in the lab takes months, so predicting shape from sequence was a goal for 50 years. AlphaFold 2 (DeepMind, 2020) predicted many shapes about as accurately as lab experiments. That result helped win the 2024 Nobel Prize in Chemistry, and many headlines called protein folding "solved."
AlphaFold learned from the Protein Data Bank (PDB), a public archive of protein structures measured in labs over decades. Its design built in a lot of biology knowledge by hand.
That clashes with Rich Sutton's "Bitter Lesson" (2019), an influential essay arguing that general methods which scale with compute beat hand-built domain knowledge in the long run. The panel tests that idea against biology. It was moderated by Brandon Anderson at an event where a new biology data effort was announced. The transcript calls it "the BBI" and doesn't explain it further.
Lambert opens with a puzzle. Top industry researchers tell him AI will be better than them at their jobs within a few years, and he doubted it without knowing why. His answer is that they are watching models get dramatically better at infrastructure and engineering. He agrees the models will become "superhuman distributed 1 engineers," meaning better than people at running work across many chips. But he argues that this makes experiments easier to run. It does not make the models different in kind.
Why engineering is the part that falls first
Lambert's central argument is that much of the AI stack is verifiable: success can be scored with a number. Training speed is measured in 2 (word-pieces) processed per second per GPU. 3, the work of answering a prompt, is measured in tokens per prompt, 4 (floating-point operations, a unit of compute) per token, or simply cost per answer. A clear score plus well-known sub-problems is exactly the setup in which AI agents can grind out improvements.
He points out that labs already cut serving costs by 10–30% after launching a model at a fixed price. He expects agents to push inference close to the hardware's theoretical maximum within a few years. As a result, the cost of model intelligence should fall "near-exponentially," possibly faster than recent trends. After that, the longer-term step is co-design: building chips and models together, which he says could add further orders of magnitude in efficiency. His specific prediction is that 5 research, meaning model architecture and data selection for today's class of models, could be automated in 2–3 years.
He prefers to call this "parallelized, AI-assisted language modeling" rather than 6 (recursive self-improvement). In his view the bottleneck in AI shifts from execution back to ideas, as it was before deep learning took off.
What follows
More demand, not less. Cheaper intelligence should trigger the 7: when a resource gets more efficient to use, total use rises. Lambert thinks the real constraint is figuring out how to package and deliver agents. He cites Meta's Muse agent as an early example, though the excerpt doesn't describe what it does.
Science by connection. In biology and chemistry, he expects models to find links between small sub-fields whose researchers rarely talk to each other. He says it is unclear whether that amounts to a new era of discovery or just speeds up the path science was already on.
Better 8. These are the simulated tasks used to train models by reinforcement learning (RL), where the model learns from trial and reward. Companies selling them have passed $100M and even $1B in revenue. Lambert says researchers widely regard much of what they buy as "crap," yet labs still see a clear return from buying it. He calls the quality problem "clearly fixable."
Caveat
The available text cuts off at a paywall. Lambert's fuller case for what this acceleration won't fix is not included.
Remember
Lambert expects fast AI progress wherever the work can be scored with a number, such as speed or cost per answer.
He predicts pretraining research on architecture and data selection could be automated within 2–3 years.
He argues cheaper intelligence will increase demand, and that how agents are delivered is now the bottleneck.
Ai2's pyramid of GPU metrics: availability, occupancy, impact and utilization. This work targets impact.1 / 4
The problem: free priority gets gamed
Ai2 runs thousands of NVIDIA H100, B200 and B300 GPUs in clusters of 88 to 1,024 GPUs, shared by about 150 researchers. Jobs request 2–3x more GPUs than the clusters have at any given moment.
The old scheduler let users label jobs by priority and opt out of preemption, up to a per-team cap on GPUs. This went wrong in three ways:
Priority inflation: eventually 100% of jobs were marked HIGH, so lower priority levels got no GPU time at all.
Squatting: debug jobs started too slowly to be useful, so researchers parked idle jobs on GPUs to hold them for later.
On-call toil: before a faulty machine could be repaired, engineers had to negotiate shutting down the non-preemptible jobs running on it.
The team calls this a 1: each person acting in their own interest wore down a shared resource. Their first fix was to give important teams exclusive GPUs. That left hardware idle whenever those teams had nothing ready to run.
Budgets instead of schedules
Ai2 now hands out shares of GPU time instead of GPUs. Managers divide time down a tree: across programs, then projects, then researchers. In the article's diagram, project A1 gets 35% of total capacity. Any job that wants protection from preemption must charge a budget, so a squatting job spends its own team's time.
A 2 enforces the budgets. It looks back over a 7-day window and ranks jobs from under-served allocations ahead of jobs from over-served ones. Jobs that charge no budget can still use idle GPUs, but any budgeted job can preempt them. One researcher said this "feels like we have an extra 30% compute," because a team's unused time can now be made up later in a burst.
The scheduling contract
Every job declares a 3, capped at 8 hours. During that period it can't be preempted. After it, the scheduler may stop the job and automatically put 4 jobs back in the queue. A minimum of zero means the job runs free and can be preempted at any time. Unhealthy machines now empty out as their jobs reach minimum runtime, which cut repairs needing a human by 74%.
Before rollout, a simulator replayed past job submissions plus hand-built scenarios. Through it, the team tuned settings such as the 8-hour cap.
Results (30 days after a rollout starting in late July)
Teams received 98% of the GPU hours owed to them. "Owed" means the allocation, capped hour by hour at what the team actually requested. 13 of 15 teams got at least 95%, and the worst got 90%.
5 stayed at 98%. 18% of delivered time came from jobs charging no budget.
6 wait for debug jobs fell from 2 hours to 30 seconds. The simulator had predicted 6 hours to 5 minutes. The authors note the baseline sample was small.
On the largest H100 cluster, median wait fell from 5 minutes to 24 seconds, and p90 fell from 2.8 to 1.8 hours.
Caveats
Researchers struggled at first, and documentation didn't fix it. Live Q&A sessions and dashboards did. Interactive sessions that once lasted a week now risk preemption after 8 hours and lose their in-memory state. Ai2 plans a CPU-only cluster for these sessions and sessions that can be restored after preemption. The team also suspects 7: with fewer jobs open to interruption at once, the largest jobs may wait longer for enough free GPUs.
Remember
If claiming priority costs nothing, everyone claims it. Charging every protected job to a budget made gaming the scheduler cost more than asking for budget.
Guaranteeing a job a bounded minimum runtime makes preemption routine, which also let faulty machines empty out on their own for repair.
The scheduling algorithm wasn't new. What changed was its inputs: weights come from strategic budgets set by managers.
Cloudflare has added on-demand CPU and memory profiling for Workers and 1. Durable Objects are Workers that keep state and have a unique name. From the dashboard's Observability tab, or from the cf command-line tool, a developer picks a Worker version and a duration, clicks Capture Profile, and gets an interactive flamegraph. There is also a table view sorted by sample count and a downloadable profile file. TypeScript projects need 2, which link compiled code back to the original source, or function names will show up mangled.
What it found at Cloudflare
CPU case. The team profiled the Worker behind the 3 binding (R2 is Cloudflare's object storage) for 50 seconds. The widest boxes, decryption and byte copying, were expected. The table view, though, showed that genericR2JsonReplacer took over 5% of CPU time and called itself recursively. A "replacer" is a callback that JSON.stringify already runs on every node of the object it serializes. This replacer also walked the tree on its own, so a value nested five levels deep was processed five times. Removing the duplicate traversal made the function 2.7x faster. A second fix removed a repeated metrics call that cost about 1% of CPU on its own.
Memory case. Another internal Worker's 4 memory was about 133 MB. P999 is the level that 99.9% of measurements fall below, and 133 MB is over the 128 MB limit, so the Worker kept being evicted with "Exceeded Memory" errors. A heap profile, opened in 5 (Google's profile viewer), showed that 6 metrics code caused about 66.7% of allocations. That code was believed to be disabled but was only partly turned off. Removing it changed memory as follows:
Percentile
Before (MB)
After (MB)
P50
70
54
P90
94
79
P99
113
97
P999
133
118
How the profiler reaches a live 7
A Worker may run in many data centers and in several copies on one physical server. Before profiling, the system has to find a data center where the requested version ran recently, confirm the isolate is still loaded, and check that it belongs only to the requesting account. Cloudflare does not start a fresh isolate for profiling, so a Worker with little traffic may be hard to profile. Durable Objects are addressed by name, so the request is sent to the exact server that hosts that object.
Only one thread can run JavaScript in an isolate at a time, which is enforced by a lock. The runtime holds that lock only briefly. It takes the lock, starts V8's CPU profiler sampling every 1 ms, and releases the lock so requests keep running. When the duration ends, it takes the lock again to stop the profiler, then converts the results outside the lock.
Limits
You have to start each session by hand, so short-lived incidents can be missed. The memory profiler sees only allocations made during the profiling window, so memory allocated at startup won't appear. Cloudflare says it is working on continuous, always-on profiling.
Remember
Production traffic exposed problems local profiling missed, including 'disabled' metrics code still causing 66.7% of memory allocations.
The profiler holds the isolate's lock only to start and stop, so requests keep running while it samples every 1 ms.
A Worker with little traffic is hard to profile because no fresh isolate is started for profiling.
Cloudflare announced that the Deno team, including Ryan Dahl and Bert Belder, is joining the company. In the post, Cloudflare engineer Kenton Varda says they will lead an effort to make self-hosting 1 (the open-source Workers runtime) a "first-class supported" way to run apps. That means merging code and ideas from 2 into workerd. Deno released celld in August as an open-source reimplementation of Workers and Durable Objects.
Why Cloudflare welcomed a clone
On the surface, celld looks like a threat: it lets Workers apps move to other providers. Varda argues the opposite. He says Workers is built differently because the design is better, not to trap customers. His examples:
It is cheap to run one app in hundreds of locations.
3, a system where the platform hands your code ready-made connections to databases and other services, make access both easier and more secure.
Durable Objects make real-time and distributed apps practical in a way that a classic 4 (browser, app server, database) struggles with.
He also says lock-in hurts business. When Cloudflare pitched 5, a product that lets companies run their own customers' code on Workers, to Shopify in 2022, Shopify refused to sign unless the runtime was open source. So Cloudflare released workerd. Varda stresses it is the same code Cloudflare runs in production, not a separate copy. Some customers have since left using it, and he calls that acceptable.
The gap: Durable Objects don't scale off Cloudflare
Varda admits few people run workerd in production. Cloudflare released the runtime but never built the surrounding tools and services needed to deploy it.
The bigger technical gap is Durable Objects. Workerd supports them only as a 6: everything runs in one process. That works for local testing but can't spread load across machines. The hard part is 7: making sure every request for a given object reaches the one machine that holds it, across a whole cluster.
Cloudflare's own routing system is, in Varda's words, "a beast." It was built for hundreds of locations and depends on outside services run by 8 (operations staff who keep production systems running). No self-hoster would want it. TODO comments promising a fix go back to workerd's first release. Varda says his own attempt last spring "didn't work."
According to Varda, celld fills exactly this hole. It is compatible with Cloudflare's model and designed to be self-hostable and to scale. The post doesn't explain how celld routes objects or what limits it has.
Caveats
This is a company announcement, so it has no benchmarks, timelines or architecture details. The post promises more announcements "in the coming months." Both celld and workerd can be self-hosted today. Varda mentions running "Cloudflare OS" at home but doesn't explain what it is.
Remember
Workerd is Cloudflare's actual production runtime, open-sourced. Shopify required that before building on Workers.
Self-hosted Durable Objects never scaled beyond one process. Routing requests across machines was the unsolved piece.
No technical details or timeline yet. Treat this as intent until the merged code ships.
Sal Candido of Biohub, a nonprofit research group whose stated mission is to cure all disease, rejects the idea that 1 are everywhere. A scaling law is a predictable rule that adding data or compute makes a model better. "A lot of the work is actually finding that scaling law," he said. Once you find one, improving the model "becomes an engineering problem." You can only find one if your data actually contains the information the task needs.
His example cuts against the usual focus on clean data. He trained 2 (models trained on protein sequences the way chatbots are trained on text) on 3 data. That is DNA sequenced in bulk from environmental samples, and much of it, he says, isn't even a complete, real protein. It still made the models better at designing working proteins. The risk is going too far the other way and scaling whatever data is cheap to produce, rather than asking what data the problem needs.
Hand-built knowledge vs. scale
Pushmeet Kohli of Google DeepMind reads the Bitter Lesson as "the problem comes first." Teams shouldn't commit in advance to building better models or to generating more data. For AlphaFold, DeepMind couldn't add much to the PDB, so it put its effort into the model. It built in the biology fact that each amino acid in the chain is influenced by others. That 4 (an assumption built into a model's design) made the model "much more data-efficient." DeepMind tried the same approach on 5, measurements of which genes are active in individual cells, aimed at a "virtual cell" that simulates a whole cell. It concluded the data isn't good enough yet.
Candido adds that inductive bias helps most when data is scarce. As data grows, a wrong assumption can hold the model back. Transformers, the architecture behind today's language models, aren't being replaced, he says, but they are being adapted for specific uses.
What AlphaFold actually did
Kohli says AlphaFold learned to reproduce the single structure someone had deposited in the PDB. It did not learn the range of shapes a protein actually takes. Real proteins move, change shape with their surroundings, and are often partly floppy and unstructured ("disordered"). He would rather train directly on 6 micrographs, the raw electron-microscope images that structures are built from. He thinks those images contain information about motion that the finished structures throw away. He tried this, but says it needs more work.
Trust over interpretability
AlphaFold 2 scored about 90 on 7, a 0–100 measure of how close a prediction is to the measured structure. Kohli argues that 95 would be worthless if 8, the model's confidence score for each part of a prediction, were not calibrated. A model can be confidently wrong, and a scientist could waste a year on that prediction. In his view, knowing how a model behaves matters more than understanding its internals. Candido disagrees in part. He says his team's interpretability work found information about protein function and motion hidden inside protein language models.
Remember
Scaling laws have to be found; messy metagenomic data still improved protein language models.
Built-in domain knowledge helps most when data is scarce and may hold models back as data grows.
Kohli: AlphaFold reproduces one stored structure per protein, not the range of shapes real proteins take.