Today: Cloudflare has a busy week, MongoDB keeps its shared storage from reading your data, and factory robots keep the AI part small.
Picked from 43 new articles across 23 sources · arrow keys for other days
Today in 30 seconds
30s left
MongoDB Atlas Infinite splits compute from storage using two logs, and encrypts data before it reaches the shared storage tier, so storage can't read it. story 1 ↓
Standard Bots uses a learned model only to find parts. Ordinary code moves the arm, and a few dozen corrections fix an edge case. story 2 ↓
Cloudflare is buying Deno for celld, its open-source take on Durable Objects. The Deno runtime gets one final year of monthly fixes. story 3 ↓
Cloudflare's 46 Birthday Week launches include a plan to issue post-quantum certificates, a Kafka-style stream built on object storage, and sub-2ms key-value reads. story 4 ↓
Cloudflare now runs the decryption and key handling for Oblivious HTTP, so sites behind it can accept requests that hide users' IP addresses. story 5 ↓
1/5Murat Demirbas (Metadata)· Murat· Oct 11
MongoDB separates compute from storage while keeping storage unable to read data
MongoDB's Atlas Infinite, in public preview, moves data off database servers onto a shared storage service. Unlike the standard design, that storage gets only encrypted bytes, and the database engine keeps batching its writes.
Why it matters · It shows how to separate compute from storage without making the storage layer able to read customer data, which most cloud databases built this way can do.
Know this first
Context from the editor, not the article · 41 sec
1 · Shared-nothing vs disaggregated
In a shared-nothing database, every server has its own disk holding a full copy of the data. Adding a replica or restoring a backup means copying everything. A disaggregated design moves data to a shared storage service, so the compute servers that run queries hold only caches. Each side can then grow without the other.
Systems such as Amazon Aurora send every page change from the compute server as a physical redo log. A replicated log service stores that log. Page servers replay it to rebuild any data page as of any moment. To do that, storage has to understand, and so be able to read, the data.
3 · Pages and checkpoints
Storage engines keep data in fixed-size blocks called pages. Some engines write each page to disk only at periodic checkpoints. Between checkpoints, a page can absorb many edits in memory and is then written once. This saves a lot of disk work, but nothing records each individual page change.
Atlas Infinite's layout: compute nodes above a shared Log Service, Page Service and object storage.1 / 2
MongoDB released 1 Infinite in public preview on September 29, with MongoDB 9.0. Atlas is MongoDB's managed cloud database. Infinite separates compute (the servers that run queries) from storage, which becomes a shared service. Murat Demirbas summarizes the design from a post by Abhishek Chauhan, who led it. The core design choice is that the storage layer is deliberately "blind": it never needs to read customer data.
Why change
Today each Atlas cluster is a three-node 2: three servers, each holding a full copy of the data on its own disk. Adding a replica, growing storage or restoring a backup means copying everything, which takes hours on large clusters. Compute and storage also come bundled, so customers pay for both even when they need only one. AI-agent workflows add a newer need: cheap snapshots and branches of production data. Demirbas argues MongoDB could wait this long because 3, which splits data across many nodes, already let it scale out.
Why the standard design didn't fit
Usually the compute server ships a 4 of every page change. Page servers replay that log to rebuild any page, so storage must be able to read the data. That clashed with 5, MongoDB's storage engine, in two ways. First, WiredTiger batches its work: a page absorbs many edits in memory and is written once, at a 6. Logging every change would undo that saving. Second, two WiredTiger nodes holding the same data store different bytes, so there is no single correct page to replicate. MongoDB also didn't want shared, multi-customer storage able to read anyone's data.
How it works
Two logs. A write is durable once the 7, MongoDB's log of logical operations, is on a majority of Log Service replicas across three availability zones. Separately, at each checkpoint, WiredTiger sends a of physical page deltas, which page servers sort by page. Only the oplog sits on the commit path, and pages are written once per checkpoint.
The storage layer is written in Rust and isolated into cells. Every cluster has a 10 ready to take over. The article gives no benchmarks; follow-up posts are promised.
MongoDB released 1 Infinite in public preview on September 29, alongside MongoDB 9.0. Atlas is MongoDB's managed cloud database service. Infinite changes how it stores data: database servers no longer keep their own full copy of it. Instead, compute and storage are split ("disaggregated"), and storage becomes a shared service. Murat Demirbas summarizes the design from a MongoDB Engineering post by Abhishek Chauhan, who led the work. The core design choice is that the storage layer is made "blind". It never needs to understand, or even be able to read, the data it holds.
Why MongoDB waited
Many databases moved to disaggregation once their workloads outgrew a single machine. MongoDB had less pressure to do so because it has long offered 2: data is split across many nodes, and chunks move automatically to balance load. Demirbas, writing as part of the MongoDB side ("that bought us time"), argues this let the company take its time and avoid giving up performance or security.
The case for disaggregating now comes from what the article calls storage gravity. Atlas currently runs each cluster as a three-node 3, meaning three servers that each hold a full copy of the data on their own disk. Growing storage, adding a replica or restoring a backup all mean copying the whole dataset. On large clusters that takes hours, and customers expect minutes. Because compute and storage are bundled, needing more of one means paying for both. The article also points to a newer need: agentic development workflows, where AI agents work against data and want cheap snapshots, clones and branches of production data.
The standard design, and why it didn't fit
In the usual recipe, the compute server holds no durable state. It ships a physical 4, a record of every change to every page, to a log service. That service is replicated by quorum, meaning a write counts once most replicas have it. Page servers replay the log to build any page as of any point in time. Object storage, such as Amazon S3, sits underneath as the long-term copy.
The article gives three reasons this clashed with 5, MongoDB's storage engine:
Checkpoint batching. WiredTiger doesn't log each page change. Writes pile up in memory, and a page that takes many updates is written to disk once, at a 6. Logging every page change would remove that saving. Demirbas notes that modern engines are converging on this style of design: copy-on-write (a changed page is written to a new location rather than overwritten), multi-version and checkpointed.
No single correct page image. WiredTiger is lock-free and parallel, and it evicts pages from memory speculatively. So two nodes holding the same logical data have different bytes on disk. "Replicate the pages" has no single correct target.
Because MongoDB builds the engine, the server and the cloud service, it could change all three together.
The architecture
Compute consists of a primary, a 7 (a warm backup ready to take over) and optional read replicas. These nodes run queries and transactions and keep only caches and recent changes, all of which can be rebuilt from storage. The shared storage layer is written in Rust and has three parts:
A Log Service whose only job is reaching agreement (consensus) on the order of the log.
A Page Service that spreads each customer's pages across many servers in every availability zone. Components called page materializers feed it from the log.
Object storage for long-term durability, organized by an Object Index Service.
Difference 1: two logs
A write is durable once the 8, MongoDB's logical log of operations such as "insert this document", is stored on a majority of Log Service replicas across three zones. That is the only thing on the commit path. Separately, at each checkpoint, WiredTiger emits a 9 ("physiological" log): physical page changes, mostly deltas. The phylog also travels through the Log Service, and page servers sort it by page. Pages are written once per checkpoint, not once per change, so durability and page building are fully separate.
A made-up example: if a counter document is updated 1,000 times between checkpoints, the oplog records 1,000 small operations, which is what makes each update durable. The phylog then carries a single delta for that page at checkpoint time.
Difference 2: storage sees only ciphertext
Data is encrypted on the compute node before any byte leaves it, and it is decrypted only there. That happens inside the customer's network, with keys the customer can hold and revoke. Storage cannot see documents, collection names, indexes or even where one tenant ends and another begins. According to the article, an attacker with root access to the entire storage fleet would get only opaque bytes. This works because storage never has to interpret pages. It just files deltas that compute produced.
Difference 3: fresh replicas without per-change page logging
The catch is that shared pages only move forward at checkpoints. A replica reading only those pages could be seconds behind. MongoDB's fix is to have the standby and read replicas also apply the oplog, as it arrives from the Log Service, to a local "ingest table". A read merges the checkpoint-consistent page from storage with the newer changes in the ingest table. The article says this keeps 10 at milliseconds while keeping checkpoint batching.
Availability
Every cluster has a hot standby, so a failed primary means a quick handoff rather than starting a new node. Data exists in three forms at once: the replicated log, the page servers and object storage. The storage fleet is split into isolated cells so a fault in one can't spread to others. Recovery is spread across many machines rather than falling on one.
What's left open
This is an overview, and Chauhan's parts 2 and 3 are still to come. The article gives no benchmarks: no write latency, no recovery times, and no cost of the extra encryption and merge work. Several questions go unanswered. How big can ingest tables get? How do snapshots and branches work on top of blind storage? How does the system compact deltas it cannot read? The article also doesn't say how page servers apply phylog deltas they can't decrypt. Presumably they store and index encrypted deltas rather than merging them, but the article doesn't say.
Remember
Separating durability (the oplog) from page building (the phylog) lets a checkpointing engine work with shared storage without per-change logging.
Encrypting data on the compute node means a compromised storage fleet yields only ciphertext, unlike designs where storage rebuilds pages.
Replicas stay fresh by merging checkpointed pages with a local table of recent oplog changes.
How Standard Bots keeps factory-robot AI small, focused and running on-site
Standard Bots, which makes industrial robot arms, gives its AI models one narrow job, like spotting parts, and leaves the motion to ordinary code. Models run inside the factory and learn from human corrections.
Why it matters · The same pattern applies to software agents: let the model handle the fuzzy step, write the rest as deterministic code, and fix failures with a few targeted examples.
Know this first
Context from the editor, not the article · 38 sec
1 · Industrial robot arms
Most factory robots are not humanoids. They are fixed arms doing repetitive jobs like welding, assembly, or machine tending: loading raw parts into a machine such as a lathe and unloading the finished ones. Factories judge them on cycle time (seconds per repetition) and on reliability over thousands of runs.
2 · Learned vs programmed behavior
Classic robots follow hand-written programs, like moving to point A and closing the gripper. They are predictable, but they break when parts, lighting or positions change. Learned models, trained on images or demonstrations, cope with that variation, but they are harder to predict and need data from real or simulated work.
3 · Training vs inference
Training a model means adjusting its parameters on large datasets, usually on cloud GPU clusters. Inference means running the finished model to make decisions. A robot needs inference continuously and quickly, so where it runs, in the cloud or on local hardware, shapes latency and uptime.
ClickFind: a user marks which parts the perception model should find for a task.1 / 3
Standard Bots makes industrial robot arms, the kind that weld, assemble, and tend machines (load raw parts into a lathe and take finished ones out). Its customers include NASA, Amazon and Lockheed Martin. In a Latent Space interview, CEO Evan Beard and Head of AI Leif Jentoft explained where they use machine learning and where they deliberately don't.
The constraint: reliability
Factories care about 1, meaning seconds per repetition, and reliability across thousands of runs. So Standard Bots keeps tasks short-horizon, meaning short sequences of actions, and uses conventional code for anything that doesn't need learned behavior. Its largest model has only "low billions" of parameters. Customers adapt a shared base model through demonstrations and 2, which means extra training on a small task-specific dataset.
What the model does
Latent Space interviewed two leaders at Standard Bots: co-founder and CEO Evan Beard, and Head of AI Leif Jentoft. Standard Bots makes industrial robot arms and calls itself "America's largest AI-native industrial robot manufacturer." Its customers include NASA, Amazon and Lockheed Martin. The interview is less about any one breakthrough than about how a company running robots in real factories decides where machine learning belongs and where it doesn't.
The problem: reliability on a production line
Humanoid robots get most of the attention. The article argues that in 2026, plain industrial arms doing 1, welding and assembly matter more. A factory cares about two numbers above all. The first is 2, meaning how many seconds each repetition takes. The second is reliability, meaning how rarely the robot fails across thousands of repetitions. A model that is impressive 95% of the time can still stop a production line.
Earlier Latent Space episodes made a related point about "Physical AI," meaning AI that acts in the physical world rather than on a screen. Guests from Applied Intuition, a company that builds software for autonomous vehicles, said model intelligence isn't the main constraint. The hard part is deploying models onto real hardware within limits on safety, latency, power, cost and reliability.
Remember
The learned model only handles perception (finding parts); hand-written code handles motion and sequencing, which keeps behavior predictable.
Inference runs locally on edge GPUs because factory internet is unreliable and uptime decides customer acceptance.
The company claims a few dozen on-the-line corrections can fix an edge case, but the article publishes no numbers.
Cloudflare acquires Deno, and will end the Deno runtime within a year
Cloudflare is buying Deno, the company behind a JavaScript runtime that competes with Node.js. Cloudflare wants Deno's new project, celld, to make self-hosted Workers apps practical. The Deno runtime itself stops development after one year.
Why it matters · A well-known JavaScript runtime is being wound down by its own creator, who says matching Node.js no longer solves big problems and that new server abstractions are the better bet.
Know this first
Context from the editor, not the article · 37 sec
1 · JavaScript runtimes
A runtime is the program that runs JavaScript outside a browser. Node.js, created by Ryan Dahl in 2009, dominates. Dahl started Deno in 2018 to fix what he regretted about Node: built-in TypeScript, modern APIs and security by default. Both run on V8, Google's JavaScript engine.
2 · Cloudflare Workers and workerd
Cloudflare Workers runs small JavaScript functions on Cloudflare's servers worldwide, without users managing machines. In 2022 Cloudflare open-sourced workerd, the runtime underneath Workers. In principle anyone can run it on their own hardware, but much of the platform around it remained Cloudflare-only.
3 · Durable Objects
A Durable Object is a Workers feature: a uniquely named object that exists as exactly one instance at a time, with its own private storage. Because every request for that name reaches the same instance, it is a simple way to coordinate shared state, such as a chat room or a counter.
Cloudflare is acquiring 1, the company behind the Deno JavaScript runtime. Deno is a program that runs JavaScript and TypeScript outside the browser, much like 2. Cloudflare isn't buying it to keep that runtime going. It wants the team and a new project called 3.
What celld does
The news
On 9 October 2026, Cloudflare announced it is acquiring 1, the company behind the Deno JavaScript runtime. Simon Willison covered the deal in a short link post. It is unusual for one reason: Cloudflare is not buying Deno to keep the Deno runtime going. It is buying the team and a two-month-old project called 2. The runtime that gave the company its name will be wound down.
What celld is
Remember
Cloudflare bought Deno for celld, not the runtime; celld aims to make self-hosted Workers apps practical, including their stateful parts.
Dahl argues that keeping compatible with Node turned Deno into a re-implementation of Node, with gains too small to justify switching.
Node's permission model is now stable but still lacks Deno's ability to allow-list individual network hosts.
Cloudflare made 46 announcements in one week. Most target AI agents as users. Highlights include a planned post-quantum certificate authority, an open-source CLI generator, durable event streams, and a faster global key-value store.
Why it matters · Underneath the marketing are several real infrastructure changes: post-quantum certificates, event streams without brokers, and agent-friendly CLIs. Each could change how you build or secure services on the edge.
Know this first
Context from the editor, not the article · 37 sec
1 · What Cloudflare runs
Cloudflare sits between websites and their visitors, handling security, caching and traffic in more than 300 cities. It also sells a developer platform: Workers (small serverless programs that run in its data centers), R2 (file and object storage), and Durable Objects (stateful coordination). Birthday Week is its yearly batch of product launches.
2 · The post-quantum problem
A large enough quantum computer could break the public-key cryptography that HTTPS uses today. New standardized algorithms such as ML-KEM (key exchange) and ML-DSA (signatures) resist that attack, but their keys and signatures are much larger. Larger certificates make every connection setup slower.
3 · Agents as web users
AI agents are programs that call websites and APIs on a user's behalf. The post says automated traffic has now overtaken human traffic. Most of this week's launches assume an agent, not a person, is the one reading output, running commands or paying for content.
Image: Cloudflare
Cloudflare, which sits in front of a large share of websites to handle security, caching and traffic, made 46 announcements during its 16th-birthday week. The recap gives each one a single sentence, so details are thin. The post's framing claim is that automated traffic has now passed human traffic, and most launches treat an AI agent as the main user.
Tools built for agents
cf is a new command-line tool that covers the whole Cloudflare API. It outputs structured JSON so agents can parse it reliably. It is generated by 1, an open-source pipeline that builds SDKs (client libraries), CLIs and docs from a single API definition, so they stay in sync. EmDash, an open-source WordPress alternative, runs each plugin in an isolated sandbox. A plugin gets only the permissions it is explicitly granted, which targets WordPress's long-running plugin-security problem.
Post-quantum security
Cloudflare, the company that sits in front of a large share of the web to handle security, caching and traffic, celebrated its 16th birthday with 46 announcements over five days. The wrap-up post by Carlos Armada gives each launch one sentence and leaves the details to separate posts. That limits how far this summary can go: it can say what each piece is and roughly how it works, but in most cases it can't give performance numbers or design detail. The post frames the week around one claim: for the first time, automated traffic on the Internet exceeded human traffic. Most launches assume an AI agent is the user.
Below are the launches most relevant to engineers, grouped by theme.
Tooling generated from the API itself
cf is a new command-line tool that mirrors the full Cloudflare API. Output is JSON-first (structured data instead of human-formatted text) and configuration is typed. Both make it easier for a coding agent to call the tool and parse the result reliably. It is generated by 1, an open-source pipeline that runs in CI (continuous integration, the automated build system) and turns API definitions into SDKs (client libraries), CLIs and documentation. The idea is that every interface is produced from one source of truth, so none of them falls behind when the API changes.
Remember
Merkle Tree Certificates swap a large signature on every connection for one batch signature plus a short proof.
K2 provides ordered, Kafka-style event streams on object storage without broker servers to run.
The recap's only hard performance numbers are the sub-2ms p99 KV reads and the 74% speed claim.
Cloudflare launches a managed gateway for Oblivious HTTP privacy traffic
Cloudflare opened a closed beta of a hosted Oblivious HTTP gateway. Oblivious HTTP is a standard that keeps app servers from seeing users' IP addresses. The gateway decrypts requests that arrive through a separately run relay and passes them on as ordinary web requests.
Why it matters · Hiding users' IP addresses from AI inference and health apps is turning into standard architecture, and this cuts the cost of running the cryptographic half yourself.
Know this first
Context from the editor, not the article · 41 sec
1 · What servers learn about you
Every web request carries the client's IP address, which roughly reveals location. A server can also identify a client by its TLS fingerprint, the particular mix of encryption versions and options it offers. Put together, these signals let a server tie many separate requests back to one person, even if no login is involved.
2 · Proxies and separation of trust
A proxy forwards your traffic, so the destination sees the proxy's address and not yours. But the proxy itself sees who you are and, unless traffic is encrypted end to end, what you send. Strong privacy designs split the work between two parties that don't share data, so neither one can see both identity and content.
3 · Cloudflare's place in the network
Cloudflare runs a global edge network. Its CDN (content delivery network) sits in front of customers' servers, and its Workers platform runs customer code on Cloudflare's machines. A 'zone' is a customer's domain configured on Cloudflare. In 2022 Cloudflare launched an OHTTP relay product called Privacy Gateway.
Before: with Cloudflare's relay, customers had to run their own gateway to keep trust separated.1 / 2
Cloudflare has opened a closed beta of the Cloudflare OHTTP Gateway. It is a paid add-on that lets a customer's domain accept Oblivious HTTP traffic once it is switched on in the dashboard. 1 is a standard from the 2, the body that sets internet protocols. It lets app servers receive requests without seeing users' IP addresses. Cloudflare is also renaming its 2022 3 product, Privacy Gateway, to .
The news
Cloudflare has opened a closed beta of the Cloudflare OHTTP Gateway, a paid add-on that lets a customer's domain receive Oblivious HTTP traffic once it is switched on in the dashboard. 1 is a standard from the 2, the Internet Engineering Task Force, the body that publishes internet protocols. It lets an app's backend receive web requests without ever learning the user's IP address. To keep its two products apart, Cloudflare is also renaming its 2022 product, Privacy Gateway, to . General availability is planned for this fall, and there is a waitlist.
Remember
OHTTP's privacy holds only if the relay and gateway operators don't collude; the cryptography can't enforce that.
Cloudflare's gateway refuses traffic arriving from its own Workers or proxied hosts, so it can't end up on both sides.
OHTTP hides network metadata, not content. Identifiers in the request body defeat it entirely.
Encryption at the source. Data is encrypted on the compute node, with keys the customer can hold and revoke. Storage can't see documents, collection names, indexes or tenant boundaries. Even root access to the storage fleet yields only opaque bytes, according to the article.
Fresh replicas. Shared pages update only at checkpoints, which could leave replicas seconds behind. So replicas also apply the oplog to a local "ingest table" and merge it with the shared pages when reading. The article says this gives millisecond 9.
Security. If storage rebuilds pages from a log, it must be able to read them. Protection then depends on operational controls. MongoDB's position is to treat unencrypted user data as "toxic" and keep it encrypted as long as possible. That matters most when many customers share the storage, because one mistake can then reach other tenants.
In 3, a 4 perception model (one that can recognize parts it wasn't specifically trained on) finds and identifies parts after a user marks them in a tool called 5. Hand-written code handles the arm's motion and the surrounding sequence of steps. The model's image-processing backbone was trained on more than a billion images, which Jentoft says lets it cope with changes in lighting, material and background.
Running inside the factory
Models are trained in the cloud but run on-site. Wrist cameras feed raw pixels over internal Ethernet to GPUs at the edge, meaning on the robot side rather than in a data center. The GPUs produce "6," short batches of planned motions, and stream them to the low-level controller. Jentoft says the reason is simple: most factories don't have reliable internet, and uptime decides whether customers keep the robots.
The company also controls the whole stack: arm, gripper, control system and AI. Jentoft argues "no model today is truly hardware-agnostic." Skild, a startup building general-purpose robot intelligence that works across hardware, is betting otherwise.
Learning from failures
Simulators struggle with liquids, suction and cutting flexible material, so real-world data matters. The company captures failures and human corrections from deployed robots. Jentoft claims "in-situ interventions can fix an edge case with a few dozen examples." Air-gapped defense customers, whose networks have no outside connection, send nothing back. Most others agree to share data for 7, where corrections improve a shared model, because their own robots get better.
A developer platform, 8, lets outside teams plug in their own models, such as NVIDIA's Cosmos world models. For now, that takes custom integration code.
The caveat
This is an interview, so the claims are the company's own. It gives no failure rates or cycle times, and no evidence for the few-dozen-examples figure. The article's lesson, which it says applies to software agents too, is to keep the model's role narrow and fix edge cases with targeted data.
What the model actually does
Standard Bots runs several models. Customers adapt a shared base model for their own task by showing it demonstrations and 3 it, which means extra training on a small task-specific dataset. The largest model is in the "low billions" of parameters, small next to frontier language models.
The clearest example is machine tending for high-mix manufacturing, where a factory runs many different parts in small batches. Jentoft describes a 4 perception system: "zero-shot" means it can recognize parts it wasn't specifically trained on once a user points them out. A tool called 5 lets the user mark which parts to look for. The model then locates and identifies those parts. Everything else is conventional programming: the arm's motion and the "cell logic," meaning the sequencing of the robot, the machine and its doors and fixtures. The perception backbone, the core image-processing network, was trained on more than a billion images. Jentoft says that is what lets it separate an object from its background and handle different lighting and materials.
Here is how the split might work, as an illustration. A machine shop switches from aluminum brackets to steel brackets. Nobody rewrites the program. The operator clicks the new part, the model finds it in the camera image, and the same hand-written routine picks it up, loads the lathe and closes the door. The learned part handles the variation, and the programmed part handles the steps that must never change.
Beard says the company deliberately sticks to short-horizon tasks, meaning short sequences of actions, to meet cycle-time and reliability requirements. It uses ordinary code wherever learned behavior isn't needed.
Full stack and on-premises inference
Standard Bots builds the arm, the end effector (the gripper or tool at the end of the arm), the control system and the AI. Jentoft argues this lets the company co-optimize models and control policies, the rules that turn goals into motor commands. "Despite claims elsewhere, no model today is truly hardware-agnostic," he says. The article notes that Skild, which is building "general purpose robotic intelligence," is betting on the opposite: models that generalize across different robot hardware.
Models are trained in the cloud, but inference runs in the factory. Jentoft describes the data path. Wrist cameras and other sensors send raw pixels and signals over internal gigabit Ethernet to GPUs at the edge, meaning on the robot side rather than in a data center. Those GPUs produce "6," short batches of planned motions, which stream to the low-level controller. Producing several steps at once instead of one per model call is a common way to keep motion smooth when the model is slower than the control loop. The article doesn't give latencies or chunk sizes.
The reason for running on-site is practical. "Most factories and warehouses don't have reliable internet," Jentoft says, and mobile robots have it worse. "Uptime is crucial to customer acceptance, so we keep the loop local."
Learning from failures
Simulation helps, but Beard says some tasks are hard to reproduce in current simulators, including liquids, suction and cutting flexible material. So real-world data matters. Operators can teach the robot by demonstration with a handheld touch device. When a deployed robot fails, the company captures the failure signals and the human corrections.
Jentoft's central data claim: "In-situ interventions can fix an edge case with a few dozen examples." In-situ means corrections made on the real production line. He argues that data quality matters more than volume, and that access to real deployments gives the company "the highest value data." Whether that data flows back depends on the customer. Defense customers often work in 7 environments, networks with no outside connection, so "nothing comes back." Other customers usually agree to contribute data to 8, where corrections from many deployed robots improve a shared model, because their own robots get better in return.
9 for outside developers
Standard Bots also offers StandardOS, a set of APIs and SDKs (software development kits) that lets developers use any part of its stack, including their own models. Beard gives 10 as an example: an open family of "world models," which predict how a physical scene will change, built for robotics. Version 3 came out in late May. For now, developers write their own integration code. The company says it plans to make data collection, training and deployment onto its robots easier.
What to take from it, and what's missing
The article's lesson for engineers is about scope. Keep the model's job narrow, surround it with deterministic code, and fix edge cases with targeted corrections from real use. The author says this applies to software agents too, and cites a similar point from Diogo Almeida, creator of Jev, that the right task and data can matter more than compute.
Much is left unanswered. There are no failure rates, cycle times, or before-and-after numbers for the "few dozen examples" claim. There's no detail on how corrections are validated before reaching other customers' robots, and no comparison with the cross-hardware approach Standard Bots dismisses. This is an interview, so the claims are the company's own.
In August the Deno team released celld, an open-source implementation of 4. Durable Objects is a feature of 5, Cloudflare's service for running small JavaScript functions on its servers worldwide. A Durable Object has a unique name, runs as exactly one instance at a time, and has its own storage. Every request for chat-room-42 goes to that one instance, so shared state stays consistent without locks or a separate database.
Making sure only one copy of each object exists across many machines is a hard distributed-systems problem. Until now, only Cloudflare's own infrastructure solved it. Ryan Dahl, who created both Node.js and Deno, says celld has worked "remarkably well" while depending "only on 6 for coordination and persistence." Object storage means simple S3-style file buckets. The article doesn't explain how that coordination works.
Cloudflare says it will use celld to make self-hosting 7, its open-source Workers runtime, "a first-class supported way" to run Workers-style apps. In practice, code written for Workers could run on your own servers, including the stateful parts.
Deno winds down
The Deno runtime will get monthly bug-fix and security releases for one more year. After that, development stops. The code stays open source for anyone who wants to fork it.
Dahl backs the decision. On Hacker News he wrote that Deno "has been sucked into the gravity well of node compatibility." Real-world code depends on Node's behaviour, so Deno ended up re-implementing Node. "Why reimplement Node? It works. Marginal performance or UX or security benefits are not enough." He sees celld as "an entirely new model for server development."
What's lost
Simon Willison regrets losing Deno's 8. Scripts get no file or network access unless granted, down to specific folders and hostnames. Node added a similar model in v20 (2023) and made it stable in v22.13 (January 2025). Node still can't allow-list individual network hosts, though: networking is either fully on or fully off.
The article gives no benchmarks or failure data for celld. "Works remarkably well" is its creator's own judgement.
In August 2026 the Deno team released the first version of celld, an open-source implementation of the 3 pattern from 4.
Some background first. Cloudflare Workers is a serverless platform, meaning developers upload small JavaScript functions and Cloudflare runs them on its servers around the world, so nobody manages machines. Plain Workers are stateless: any copy of a function can serve any request, and nothing is remembered between requests. A Durable Object adds state. Each object has a unique name, exactly one live instance exists at a time, and it has storage attached. Every request for, say, chat-room-42 goes to that single instance, which sees all messages in order. Coordination problems that would normally need locks or a separate database become ordinary code on one object.
The difficulty is guaranteeing "exactly one instance, with durable state" across many machines. That is a distributed-systems problem: something has to decide which machine currently owns each object, and what happens when that machine fails. On Cloudflare's network, Cloudflare's own infrastructure handles this. Outside Cloudflare there was no standard way to do it.
Ryan Dahl, who created both 5 and Deno, describes celld's approach in one line: it has been "depending only on 6 for coordination and persistence." Object storage means S3-style services (Amazon S3 or something compatible) that store files by key. If celld really needs nothing else, then running Durable Objects yourself would require only a runtime plus a storage bucket, with no consensus cluster or dedicated database. The article doesn't explain how celld uses object storage for coordination, for example how it makes sure only one instance owns an object, so treat that as an open question.
What Cloudflare wants
According to the Cloudflare blog post the article cites, the aim is to build on celld to "make 7 self-hosting a first-class supported way to build and run apps using the Workers programming model." workerd is the open-source runtime under Workers, released in 2022. You could already run workerd on your own servers, but stateful features like Durable Objects depended on Cloudflare's platform. celld could fill that gap. That would make "write it for Workers" less of a commitment to a single vendor, which is presumably the appeal for Cloudflare.
The cost: Deno the runtime ends
Deno's announcement is blunt: "We will support the Deno runtime for another year with monthly releases containing bug fixes and security updates. After that year we will end our development of the Deno runtime." The code stays open source, and others are welcome to fork it and carry on.
In a Hacker News comment, Dahl said this was a joint decision he agrees with. His reasoning:
Deno is "well engineered" but "ultimately is not solving big problems."
It "has been sucked into the gravity well of node compatibility." Most real JavaScript code depends on Node's APIs and the npm package ecosystem, so to be usable Deno had to behave exactly like Node.
"Why reimplement Node? It works. Marginal performance or UX or security benefits are not enough."
celld, by contrast, is "not just a slightly different API to interact with the file system or network — it's an entirely new model for server development."
Coming from the person who wrote both runtimes, this is a frank admission: a better-engineered rival to an entrenched platform tends to turn into a copy of it, and a copy rarely justifies switching.
What gets lost: the permissions model
Willison's favourite Deno feature is its 8. A Deno script gets no file, network or environment access unless you grant it. You can name exact paths and hosts, for example allowing reads only from ./data and network access only to api.example.com. That limits the damage a compromised dependency can do.
Node has since copied much of this. A permission model arrived in Node v20.0.0 (April 2023) and became stable in v22.13.0 (January 2025). Willison notes one gap: Node can't yet allow-list specific network hosts. Networking is all or nothing. Once Deno is gone, the finer-grained version goes with it unless Node adds it or a fork keeps it.
Open questions
Users: Deno projects get roughly a year of security fixes. Whether a community fork survives is unknown.
celld's correctness: "Remarkably well" is the creator's own assessment. The article gives no benchmarks, failure-mode analysis or production data. How to guarantee a single owner per object using only object storage is the key detail, and it isn't covered here.
Deno's other products: the article doesn't say what happens to Deno's hosted services.
Cloudflare plans to become a 2, an organization browsers trust to confirm who owns a domain. It would issue free 3. The recap doesn't explain them, but the problem they address is that post-quantum signatures are large: roughly 2.4 KB compared with 64 bytes today. Under the proposal, a CA signs one "root" covering a big batch of certificates. Each server then sends a short proof that its certificate is in that batch, instead of carrying large signatures on every connection.
Other security launches:
An AI tool, CryptoLabe, maps cryptography across Cloudflare's code ahead of a 2029 migration target.
A standards fix stops attackers from forcing VPN tunnels back onto weaker, pre-quantum encryption.
Cloudflare tested its own web application firewall against frontier AI models and found detection gaps in six attack categories.
Getting paid by agents
Monetization Gateway lets sites charge agents per request using 4 "Payment Required", a status code reserved long ago and rarely used. Auto Router sends each AI request to a cheaper model when that model is good enough for the task.
Storage and data
K2: durable, ordered event streams stored on 5, Cloudflare's object storage. It works like Kafka but without broker servers to run.
6 KV Instant: a key-value store with reads under 2 ms for 99% of requests, replicated across 300+ locations.
Basin: a serverless analytics platform built on the open 7 table format.
The catch
Cloudflare says it is the fastest provider in 74% of the top 1,000 networks, but it changed how it measures this year. Beyond that figure and the KV latency, the recap has no benchmarks or consistency guarantees. Read it as an index to the individual posts.
EmDash is an open-source content management system built on Astro (a web framework) and billed as a successor to WordPress. It targets WordPress's biggest weakness: plugins run with full access to everything. EmDash runs each plugin in its own isolated Worker sandbox, and a plugin can do only what it has been explicitly granted, much as a phone app has to ask before it can use your camera (an analogy). Vinext 1.0 runs Next.js apps (a popular React framework) on Vite, a fast JavaScript build tool, rather than Next.js's own toolchain, so the apps aren't tied to a single host. The post says Vinext started as an AI-built experiment. Experimental Rust support via an Emscripten target for wasm-bindgen (tooling that compiles Rust to WebAssembly) lets more native Rust libraries run on 2, with progress toward supporting Tokio, Rust's main async runtime.
Cryptography and security
Cloudflare plans to become a public 3, an organization browsers trust to vouch for which server owns which domain. Today Let's Encrypt dominates free, automated certificates. A second free issuer would make that system more resilient if one provider fails.
The planned CA would issue 4. The recap doesn't explain them, but the general idea from the IETF proposal works like this. Post-quantum signatures are large: an ML-DSA signature is about 2.4 KB, against 64 bytes for today's common ECDSA signatures. Rather than signing every certificate separately, the CA collects a batch of certificates into a Merkle tree. In that structure each parent is a hash of its children, so one signature over the root vouches for every leaf. A server then presents its certificate plus a short "inclusion proof", a handful of hashes showing its certificate sits under a root the browser already trusts. The connection setup carries one compact proof instead of a chain of large signatures.
Related launches:
CryptoLabe uses AI to find and classify cryptography in Cloudflare's own code. The company is aiming to finish its post-quantum migration by 2029.
An IETF extension for IKEv2, the handshake that sets up IPsec VPN tunnels, authenticates the entire handshake transcript. Without it, an attacker in the middle could strip the post-quantum options and quietly force both sides back onto weaker classical cryptography. This is called a downgrade attack.
Logs and analytics now show whether each request used post-quantum key exchange.
Workers gains native ML-KEM and ML-DSA support in Web Crypto, the standard browser-style cryptography API.
Cloudflare also aimed frontier AI models at its own WAF (web application firewall, which filters malicious HTTP requests). An adaptive red-team system found detection gaps in six attack categories. Fixes went into normalization, the step that converts encoded or obfuscated input into a standard form before rules check it, and into managed rules.
Paying for agent traffic
Monetization Gateway (beta) lets sites charge agents per request using 5. That status code was reserved decades ago as "Payment Required" and has rarely been used. It works alongside x402, a protocol for machine payments carried over HTTP. Pay Per Use reports, bills and pays publishers when verified AI buyers use their content. On the cost side, AI Gateway's Auto Router classifies each request and sends it to a suitable, cheaper model, while User Insights flags where a team is using a bigger model than the task needs.
Data and storage
K2 provides durable, ordered event streams on 6 object storage. It does the job of Kafka-style systems, separating the producers that write events from the consumers that read them, without a cluster of broker servers to run.
Basin, now generally available, is a serverless analytics platform on 7 (an open table format that lets many query engines read the same files in object storage) and R2.
Workers KV Instant offers sub-2-millisecond reads at the 99th percentile (8: 99% of reads finish within that time) and fast replication across 300+ locations. It is built on Quicksilver, Cloudflare's internal replicated key-value store. The existing Workers KV is eventually consistent and can take a while to spread writes. The recap doesn't give exact replication times or consistency guarantees.
Containers was rebuilt with faster startup and filesystem snapshots so agent sandboxes can keep their workspace between sessions.
Clef and Clef-flash are open-source "decision models" for fast classification, released with a reinforcement-learning fine-tuning platform.
Operations
Cloudflare Traces follows each request through security rules, cache, Workers and the origin server without requiring an SDK. Issues groups Workers errors and sends stack traces, logs and traces to a coding agent or webhook. On network speed, using what it calls an expanded real-user measurement method, Cloudflare says it is the fastest provider in 74% of the top 1,000 networks. Because the method changed, that figure can't be compared directly with earlier years.
What's left open
This is a launch index, not an engineering write-up. It has almost no benchmarks: the only hard performance numbers are the KV p99 and the 74% figure. It doesn't cover consistency semantics for KV Instant or K2, the timeline for the CA, or how well Auto Router keeps "response quality". Those answers, if they exist, are in the individual posts.
Cloudflare OHTTP Relay
How OHTTP works
Normally a server sees each client's IP address and can fingerprint it from the 4 (encryption) settings it offers. That is enough to link many requests to one person. OHTTP splits the path between two independent operators:
A relay sees the client's identity, strips it, and forwards an encrypted blob it can't read.
A 5 decrypts the blob and passes plain HTTP to the app server. The client encrypted it with 6 (Hybrid Public Key Encryption, which seals a message to the gateway's public key). The gateway then encrypts the response for the return trip.
The relay knows who is asking. The gateway knows what was asked. Cloudflare calls this "double-blind". It only holds if the two operators don't collude. Flo Health's Anonymous Mode and Apple's Private Cloud Compute both use OHTTP.
Why a gateway now
Customers whose servers already sit behind Cloudflare's CDN or run on its 7 platform couldn't use Cloudflare's relay. Cloudflare would have held both halves and broken the model. Now they can have Cloudflare run the gateway and get a relay from another party. Cloudflare also says self-run gateways add real latency. Its gateway runs on every edge server via 8, a routing method that sends traffic to the nearest location. For CDN customers, decryption and the app's own processing can happen on the same machines.
What the gateway does
Accepts requests at /.well-known/ohttp-gateway on the customer's domain. Ordinary traffic skips it.
Supports 9, which lets it process a request piece by piece.
Only forwards to the customer's own subdomains, so it can't be abused as an open proxy.
Manages the encryption keys and serves the public key on request.
Runs 10 before decryption, so only approved relays get through, for example via 11.
Refuses traffic that comes from Cloudflare Workers or Cloudflare-proxied hosts, so Cloudflare never ends up on both sides by accident.
Caveats
You still need your own OHTTP client and an independent relay. Cloudflare notes the hard part of a relay is credibly promising users you won't match its logs against decrypted requests. OHTTP hides network metadata only, so putting an email address in the request body defeats it. The post gives no latency numbers, pricing or dates.
3
Cloudflare OHTTP Relay
The problem OHTTP solves
In a normal exchange the app server sees the client's IP address. That is the "from" label on every packet. The server can also fingerprint the client from the 4 versions and cipher suites it supports. With these signals a server can link many requests to one user, whether it wants to or not. Cloudflare's framing is that this visibility can be a burden for developers, and that users currently shoulder privacy themselves through VPNs, cookie blocking and adblockers.
OHTTP splits the path into two hops run by different organizations:
The relay receives the client's request and sees its IP address and TLS fingerprint. It strips those identifiers and forwards the request. To the app server, every request looks like it came from the relay. If many users share one relay, their requests blend together.
The 5 sits in front of the app server and handles the cryptography. The client encrypts each request with 6 (Hybrid Public Key Encryption, a standard scheme that wraps a message for one recipient's public key). Only the gateway can unwrap it. The gateway turns the result back into plain HTTP for the app server, then encrypts the response for the trip back.
The relay therefore forwards ciphertext it can't read, and the gateway reads content without knowing who sent it. Cloudflare calls this "double-blind": the relay sees only identity, the gateway and app server see only content, and nobody sees both. That guarantee holds only if the relay operator and the gateway/app operator don't collude.
A worked example (illustrative). A user in Berlin opens a health app's anonymous mode and asks for cycle data. Her phone fetches the gateway's public key and encrypts the request "GET /cycle-data". It sends the sealed blob to a relay run by Company A. Company A sees a Berlin IP address and an unreadable blob, and forwards the blob. The gateway decrypts the request and hands "GET /cycle-data" to the app server, which sees only Company A's address. Flo Health uses OHTTP this way for its Anonymous Mode. Apple's Private Cloud Compute uses it to keep AI inference requests from being linked to user identities.
Why Cloudflare needed a second product
Cloudflare's existing product was a relay, which left a gap. If a customer's servers already sit behind Cloudflare's CDN or run on 7, Cloudflare would act as both relay and gateway. It would see client identities and decrypted content, which breaks the model. Those customers needed Cloudflare on the gateway side, with someone else running the relay.
Cloudflare gives two other reasons. Developers want privacy infrastructure that is easy to adopt. And running a gateway yourself adds latency, because there are extra network hops plus the cost of decrypting requests and encrypting responses. Cloudflare says the gateway runs on every server in its edge network using 8, a routing method where one address is announced from many locations so traffic reaches the nearest one. That shortens the relay-to-gateway hop. For CDN customers, decryption and origin handling can happen on the same Cloudflare machines, which removes the gateway-to-origin hop.
How the gateway works
Endpoint. Clients send OHTTP requests to https://your-zone.com/.well-known/ohttp-gateway. The gateway decrypts each one, issues a subrequest to the customer's server, and returns an encrypted response. Ordinary HTTP traffic skips the gateway entirely, so a site can serve both kinds. Cloudflare scales capacity automatically.
Chunked OHTTP. The gateway supports both standard and 9. Cloudflare recommends chunked, because the gateway can process a request piece by piece instead of waiting for the whole message.
Scoping. The gateway is tied to the customer's zone. A request to example.com's gateway may target foo.example.com but not wikipedia.com. This stops someone from using your gateway as an open proxy to attack other sites.
Key management. Cloudflare generates and rotates the HPKE keys. It serves the public key configuration in response to a GET request on the same endpoint. For extra privacy, clients can fetch keys from a different IP address than the one they use for requests.
Relay authentication. The gateway knows almost nothing about clients, so it has to trust that relays behave. 10, the company's zero-trust access product, runs before decryption. Customers can admit only approved relays using 11 (both sides present certificates), static service credentials, or custom external logic.
Misconfiguration guard. The gateway refuses to decrypt requests that come from Cloudflare Workers or from hosts proxied through Cloudflare. That way Cloudflare never ends up on both sides by accident.
Which product to pick
Use the Relay if your servers are hosted off Cloudflare and you can run your own gateway. Use the Gateway if your servers are behind Cloudflare, if you accept OHTTP from a third-party client and relay (Apple's LiveCallerID SDK is the example given), or if you want a managed, low-latency gateway.
Caveats and open questions
You still have to build two pieces yourself. One is an OHTTP client; Cloudflare points to ohttp.info and a sample library. The other is a relay from a separate party. Cloudflare notes that relays are technically simple. The hard part is credibly promising users that you won't inspect relay logs and match them against decrypted requests. That is the reason to use an independent relay provider rather than run one yourself.
OHTTP also protects only network metadata. If the encrypted body contains an email address or username, the privacy is gone. Cloudflare warns about this explicitly.
The post gives no latency figures, pricing or beta dates, so the performance claims can't yet be checked. The whole guarantee also rests on the non-collusion assumption, which users can only take on trust.
