Encoders, Basins and Git for Agents · Morning Gist
Monday, October 55 stories · 11 min
Encoders, Basins and Git for Agents
Measured tradeoffs for small classifier models, a wave of Cloudflare launches for agent and data workloads, and two arguments about what matters when agents write code.
Picked from 20 new articles across 23 sources · arrow keys for other days
Today in 30 seconds
30s left
Marc Brooker's 2.6B T5Gemma encoder halves median latency against the Qwen-based strands-decider with similar accuracy, but slows more on long prompts. story 1 ↓
Cloudflare Artifacts, a Git-speaking versioned filesystem for agents, opens beta with deploys, events and forks. Billing starts October 15. story 2 ↓
Cloudflare's Iceberg-on-R2 stack is now GA as Basin: 3GB/s ingest per stream, automatic table maintenance, serverless SQL with joins, zero egress. story 3 ↓
Martin Fowler argues code stays the source of truth when agents write it, citing Sam Ruby's 60K-versus-4M token comparison. story 4 ↓
MIT's Alex Zhang says coding harnesses are nearly interchangeable, and that Recursive Language Models' code-only design helps skills transfer across tasks. story 5 ↓
Cloudflare AI Search is GA, with image search by pixel embeddings, OCR for scanned PDFs and support for any chat model.
Brooker Tests Encoders Against strands-decider's Decoder: Faster, Not Clearly Better
A 2.6B T5Gemma encoder halves median latency compared with the Qwen3.5-based 2B decider and roughly matches its accuracy. It scales worse on long prompts, and the unmasked version generalizes worse.
Why it matters · Choosing between a small encoder classifier and a repurposed decoder is a real design decision for LLM-routing and judgment components. Here are measured tradeoffs, including how layer type changes the latency curve.
After strands-decider-2B launched last week, people asked Marc Brooker why it is a modified LLM rather than a BERT-style encoder. The usual reasoning is that bidirectional attention, where each token sees what comes before and after it, should beat causal attention for classification. Brooker concedes that strands-decider is, in a sense, "abusing a decoder as an encoder." He also notes up front that he is not a model-development expert.
The candidates
v19: the shipped design, built on Qwen3.5 with about 2B parameters.
b1 / b2: T5Gemma 2 encoder-decoder models at 1B+1B and 4B+4B. The LM head is removed and replaced with strands-decider's pointer head.
e1a: the encoder half of the original T5Gemma, at 2.6B parameters.
e1b: e1a plus a masked state cache. The state attends bidirectionally to itself, and each question attends to the state and to itself. This lets several questions run in parallel without interfering, and lets the cached state be reused, much like a decoder's KV and prefix cache.
Frozen ModernBERT and ettin-encoder-1b did worse than T5Gemma at the same parameter count, so he did not train them.
Results
Accuracy. b2 beats v19 on JevBench accuracy and Brier score, and on JF100 Brier score at equal accuracy. But it has roughly 8B parameters against v19's 2B, so the comparison isn't fair. The closer matchup is e1b vs v19:
On JevBench, e1b is slightly more accurate (within v19's run-to-run variance) but slightly worse calibrated.
2/5Cloudflare· Dina Kozlov· Oct 1
Cloudflare Artifacts adds deploys, events and bindings as Git-for-agents beta opens
Cloudflare's Git-speaking versioned filesystem is now in open beta, with billing from October 15 and a contest to build an agent-native GitHub.
Why it matters · If you're thinking about running many coding agents against one codebase, Artifacts offers one concrete set of building blocks: a repo per agent, programmatic forks, and push events you can hook automation to. Pricing and lock-in still need checking.
Diagram of Artifacts as programmable Git primitives that developers build products and workflows on top of.1 / 3
Cloudflare's Artifacts, a versioned filesystem that speaks Git and is designed to scale to millions of repositories, is now in open beta for Workers Paid customers. The post, by Dina Kozlov, is partly a feature update and partly an invitation to a competition. The company is asking developers to build "the next Git platform" for a world where hundreds or thousands of agents work on the same codebase at once.
The premise is that GitHub's model of branches, PRs and issues was built for humans. With many agents working at once, Kozlov asks open questions: how agents know what others are doing, how conflicting changes get resolved, how all that output gets reviewed, and how to record why a change was made. Cloudflare doesn't answer these itself. It is pitching Artifacts as the low-level layer and leaving coordination, review and merge semantics to builders.
What's new since launch
3/5Cloudflare· Marc Selwan· Oct 1
Cloudflare's Iceberg-on-R2 data platform goes GA, renamed Basin
Pipelines, Catalog and SQL now handle 3GB/s ingest per stream, automatic table maintenance, and joins and window functions in a serverless engine.
Why it matters · This gives you a serverless Iceberg lakehouse with zero egress fees, so DuckDB, Spark or Snowflake can read the same tables. For small or spiky analytics workloads, it could replace an S3-plus-Athena setup.
Image: Cloudflare
Cloudflare has made its Data Platform, announced in beta during Birthday Week 2025, generally available and renamed it Basin. It is built on Apache Iceberg tables stored in R2 and has three parts. Basin Pipelines (formerly Cloudflare Pipelines) handles ingestion. Basin Catalog (formerly R2 Data Catalog) is a managed Iceberg REST catalog. Basin SQL (formerly R2 SQL) is a serverless distributed query engine. Existing configurations keep working under the old names.
The argument for it, according to author Marc Selwan, rests on two trends. Iceberg has become the standard open table format, and R2's lack of egress fees makes it practical to query the same data from any engine, including PyIceberg, DuckDB, Snowflake and Spark. Pricing is usage-only: you pay for ingestion, processing and queries, with no hourly or cluster charges.
What changed since beta
Pipelines accepts events over HTTP, Workers bindings or Logpush. It transforms them with SQL and writes Iceberg tables, or JSON or Parquet files, to R2. Each stream now ingests up to 3GB/s, and users have created tens of thousands of pipelines. Other additions:
Worker bindings are schema-aware: wrangler types generates TypeScript types from a stream's schema.
Dropped events are reported by cause: missing field, type mismatch, parse failure or null.
Terraform covers the whole path: catalog, stream, sink and the SQL that connects them.
Catalog started with automatic compaction and now also handles:
4/5Martin Fowler· Martin Fowler· Oct 5
Fowler: Code still matters as the source of truth when agents write it
Fowler's latest fragments: Sam Ruby's 60K-vs-4M token comparison, "nurturing" rather than building software, and Gemini 4 Argon's 15% hallucination rate.
Why it matters · If agents write most code, someone still has to decide which representation is the source of truth. Ruby's token numbers give a concrete reason to keep it high-level, whether or not humans read it.
Image: Martin Fowler
Martin Fowler's latest fragments post is a mixed bag. The most useful thread for working engineers is about what code is for once LLMs write most of it.
Keep the notation at the top
The thread starts with Geoffrey Huntley, who says code no longer needs to be readable by humans. Fowler points out that Huntley's own example has an LLM explain a Haskell function by translating it into Python. To Fowler, that shows code still has a role. The form a model stores code in just doesn't have to match the form it shows a reader. He compares this to projectional editing, where the representation you edit is separate from the one that gets stored.
Sam Ruby picks up on a claim DHH made at Rails World: agents will keep "drilling" down from Rust and C++ to assembler and then microcode. Ruby asks what sits at the top of that drill, meaning what we keep, edit and trust as the source of truth. He measured it. A Rails application takes about 60,000 tokens in Ruby and about 4,000,000 tokens once compiled to C. A 67x jump strains the context window. Even if the code fits, the model has a harder time knowing where to focus. Ruby concludes that a high-level, conventional notation is worth keeping even if no human ever reads it: "Let the drill go as deep as it can. Just keep the notation at the top."
Fowler ties this to Unmesh Joshi's argument that code does two jobs. It gives instructions to a machine, and it holds a conceptual model of the domain. As generating code gets cheaper, Joshi argues, the second job matters more: making the model explicit and refining its vocabulary through iteration and feedback. "The act of writing code is itself part of our thinking."
5/5Latent Space· Oct 2
Alex Zhang on Recursive Language Models and why harness design shapes generalization
The MIT PhD student argues coding harnesses are nearly interchangeable, and that RLMs' code-only design lets a skill learned on one task transfer to others.
Why it matters · If Zhang is right, the scaffold around a model affects what it learns to generalize, not just its tool access. That challenges the current habit of treating Claude Code, Codex and Pi as meaningfully different products.
Post announcing RLMs: models treat their own prompt as an object in an external environment.1 / 2
Latent Space's yearly "emerging PhD" episode features Alex Zhang of MIT, known for KernelBench, GPU Mode and Recursive Language Models (RLMs). The conversation is long and wide-ranging. These are the parts that carry substance.
What an RLM actually is
Zhang defines an RLM as a harness whose only tool is code. The model runs inside a Python or Bash REPL. Every other tool, including calling itself as a subagent, is exposed as a function in that environment. Its context lives in memory or on disk rather than in the prompt. The point is that the model can always go back to its original context, even after compaction.
He contrasts this with what he calls "trajectory as a prompt": the loop shared by Claude Code, Codex and Pi, which keeps appending the rollout to context. Zhang argues these harnesses are "all the same" in their design choices. He cites a recent "harness tax" paper finding that most harness choices don't matter. Prime Agent sits partway between the two designs: it offloads context to disk and its only tool is IPython, but it keeps the compaction loop.
RLMs began as a fix for long context. Zhang now frames them around composition. Ordinary tool calls happen one turn at a time with no shared state. An RLM gives the model a central context that it manipulates with code.
Harnesses as compositional generalizers
Zhang's main claim is that harness design changes generalization. When an RLM is trained on a short retrieval task, it learns a high-level program, such as "spawn subagents, then loop over and check the results." That program carries over to tasks 8–30x longer, and to tasks in different domains, like math versus writing. The subagents handle the parts that differ. Standard harnesses, he says, make similar problems look different to the model. Because the setup is recursive, he argues the same reasoning applies at every level of subagents. He adds that there is "no magic here."
On JF100, the two tie on calibration and e1b is slightly less accurate.
Latency. The encoder-only models have a median latency of about 35ms, against 65ms for v19. The encoder-decoders are slowest. e1b's advantage shrinks as prompts get longer. e1b uses 26 full-attention layers, whose compute cost grows quadratically with length. In v19, 75% of layers are Gated DeltaNet, which costs more per call but grows only linearly. Both benchmarks lean toward short prompts, which flatters e1b. Whether it wins in practice depends on the mix of prompt lengths.
Generalization. On the nine eval sets, the unmasked e1a beats v19 on seven, for example MuSiQue at 0.948 vs 0.882 and BoardgameQA at 0.884 vs 0.820. It trails slightly on ContractNLI and on v16's generated set. Yet it scores clearly lower on JevBench (153 vs 168) and a little lower on JF100 (158 vs 162). Brooker suggests that letting the question and the state attend to each other may actually hurt generalization, which the masked e1b avoids.
Brooker calls the experiment "hopelessly confounded." Architecture, base model, and instruction-tuned vs base weights all changed at once. His conclusion is that neither design clearly wins at this size. The encoder code is in a separate branch and is not yet worth merging.
Remember
The masked 2.6B encoder roughly matches the 2B decoder on accuracy, at about 35ms median latency versus 65ms.
The decoder's Gated DeltaNet layers (75% of layers) cost more on short prompts but scale linearly, so they win on long ones.
Without masking, the encoder did better on 7 of 9 eval sets but generalized worse to JevBench (153 vs 168).
Workers Builds integration. You can connect a repo to a Worker. A push to the production branch builds and deploys it. Pushes to other branches create or update Workers Previews, which are isolated, shareable deployments.
Artifacts binding in Workers. Code running in a Worker can create or fork repos, inspect files and commits, and issue repo-scoped Git tokens. The intended pattern: when a task arrives, fork the project for an agent, read its AGENTS.md for context, and hand the agent a scoped repo to push to.
Event subscriptions. Events fire on create, import, fork, delete, push, clone and fetch. One example: a push event triggers a Worker, which starts a Workflow and passes it the repo, branch and commit so a review agent can inspect the change.
Data jurisdiction. You can set US or EU at the namespace level, and every repo in that namespace inherits it.
Metrics. Each repo shows total operations, pulls, pushes, errors and error rate, in the dashboard or through queries.
Early uses include vibe-coding platforms storing user projects, agent sessions saving their code and context, and isolated forks that let several agents start from the same point so their results can be compared or merged.
Pricing and the contest
Billing is based on repository operations and stored data, and starts October 15, 2026. The post gives no rates.
Contest entries must show, at minimum, multiple agents making changes concurrently. Cloudflare explicitly doesn't want "GitHub with agents added on top." A submission needs a 5–10 minute video, source code under MIT, Apache or BSD, and run instructions. The deadline is October 14, 2026. The top three teams get trips to Cloudflare Connect, and the winner gets $25,000 in Cloudflare credits.
Remember
Workers can now fork repos, read files, and issue repo-scoped Git tokens through an Artifacts binding.
Push events can trigger CI, review agents, or deploys; non-production branches get automatic Workers Previews.
Billing starts October 15, 2026, but the post gives no per-operation or storage rates.
per-table compaction policies with target file sizes
snapshot expiration with a guaranteed minimum of retained snapshots
cleanup of unreferenced data files, with no separate Spark maintenance job
consolidation of fragmented manifests by partition, which cuts metadata I/O during query planning
It also generates statistics, which Basin SQL uses to split a query into smaller tasks spread across Workers. At beta, SQL was mostly for filtering event and time-series tables. It now supports inner, outer, semi and anti joins, subqueries, CTEs, window functions with QUALIFY, grouping sets, rollups and cubes, set operations, EXPLAIN, and more than 190 scalar and aggregate functions. A built-in dashboard editor shows query plans and statistics.
Users and roadmap
Cloudflare's own billing and infrastructure teams use Basin. Anomaly says it replaced an S3 and Athena pipeline with it, and Bobsled uses it to distribute data products across clouds. The post gives no benchmarks or latency figures.
Planned work includes:
Iceberg V3, including the VARIANT and geospatial types
custom partitioning and schema migrations in Pipelines
stateful streaming: aggregations, joins and incrementally updated materialized views
sort and cluster compaction
full DDL in Basin SQL
adaptive query scheduling
jurisdiction controls for data sovereignty
Remember
Basin bundles Pipelines, Catalog and SQL on Iceberg and R2; zero egress lets any Iceberg engine read the data.
Ingestion now scales to 3GB/s per stream; Catalog handles compaction, snapshot expiry and orphan-file cleanup.
Basin SQL now runs joins, window functions and cubes; no performance benchmarks were published.
Fowler argues that "building" assumes determinism, while LLM systems are closer to something we nurture. When a deterministic system has a bug, you can usually fix it or switch off the component. With an inferential model, neither is simple. Separately, Ruby frames the practical question about agents like this: for this week's task, where will the information come from, and what will check the result?
Hallucination vs. accuracy
Fowler quotes a post on Artificial Analysis results. Gemini 4 Argon hallucinates 15% of the time, against Grok 4.7 at 29%, GPT-6 Astra at 45%, Opus 5.5 at 59% and Fable 5.1 at 69%. Argon gets fewer answers right than Opus 5.5 on max: 50% versus 66%. The difference is that it declines when it doesn't know. According to the post, the only models with lower hallucination rates rarely answer and get no more than 15% right. Fowler says he prefers that trade-off.
The post also covers Thoughtworks alumnus Ola Bini's deportation from Ecuador, which rested on a secret security report, and a DDD Europe video interview with Eric Evans.
Remember
Sam Ruby: a Rails app takes about 60K tokens in Ruby and about 4M in C. That's a reason to keep high-level source.
Joshi argues code is also a conceptual model of the domain, and that role matters more as generation gets cheaper.
Gemini 4 Argon hallucinates 15% vs Opus 5.5's 59%, but answers fewer questions correctly (50% vs 66%).
He reports that frontier models are only "okay" inside RLMs today because they were trained on trajectory-style harnesses. Internal results that he did not share showed Fable doing best, which he puts down to its trained-in dynamic workflows.
Other points
Kernels have a verification gap. Almost all top GPU Mode leaderboard entries are now AI-generated. Yet the one expert-steered kernel in the top 10 was the only one stable in end-to-end systems. Zhang says reward hacking has been a problem since KernelBench. In his view, one piece of expert insight can make a trillion-token search unnecessary.
Megakernels: he expects compilers over higher-level ops, not LLMs, to handle fusion.
Jev: he praises it for changing the output space instead of using a full autoregressive decoder, for example when a binary classification would otherwise cost "400X." He sees this as a way to speed up slow multi-call systems like RLMs.
Research taste: Zhang argues academics should make bets that look trivial at first, as SWE-bench, ReAct and RLMs did.
Remember
An RLM is a harness with code as its only tool, context offloaded to the environment, and the model callable as a subagent.
Zhang reports RLMs trained on short tasks generalize to tasks 8–30x longer and across domains, because the learned strategy is the same.
AI-written kernels top leaderboards, but in one case only the expert-steered kernel was stable end-to-end.
