Cihangir Bozdogan — Daily Tech & AI News

Ryan Dahl announced that the entire Deno team is moving to Cloudflare to work alongside the Workers and Durable Objects teams. The pitch is to make the Workers-style programming model, where scaling is built into the code rather than bolted on as infrastructure, the default way to build servers on Cloudflare or your own hardware. That builds on celld, Deno's newer runtime for distributed applications, which already follows the Workers model. The catch is that the Deno runtime itself gets a year of monthly bug-fix and security releases and then active development ends, though the code stays open source for anyone who wants to continue it. Anyone running Deno or Deno Deploy in production now has a migration clock ticking.

Whistle is a single 16.9 MB model file aimed at phones, wearables, robots, cars and microcontrollers, with no runtime dependencies beyond Cactus's C++ engine. It transcribes up to 30 seconds of 16 kHz audio in one pass in seven languages (English, German, French, Spanish, Italian, Dutch, Polish), detects the language automatically, and reports the first token in about 11 ms. It also returns word-level timestamps and can emit raw speech embeddings without decoding. Because it shares an engine and quantisation with Cactus's Needle model, one binary can go straight from a voice clip to tool calls. There is an in-browser demo that downloads the model and keeps audio on the device.

Oxide builds integrated rack-scale computers for running cloud-style infrastructure on premises. Its post says ordinary operations became profitable enough this spring that the company paid income tax, which is rare for a hardware startup. The constraint now is cash flow: demand exceeds supply, and a hardware company must pay for components and manufacturing long before systems ship. The $445M Series D exists so Oxide can accept more orders without betting the company on supply shocks. It is a useful signal that there is real demand for owning your own cloud-like hardware rather than renting it.

REA installs with one command (npx rea-agents@latest setup) and connects disassembly and analysis tools to an existing coding agent. The goal is to let the agent decode branches, trace calls and recover the rule behind a feature, so you can explain, change or rebuild it without being a reverse-engineering expert. The landing page walks through a real example, working out why the Windows Calculator returns 220 for 200 + 10%, from raw x64 instructions. It ships analysis guides and showcase projects, including a decompilation of an old Touhou game. Android support currently relies on jadx through MCP.

The author, who builds explorable explanations, compares recent models for design work: earlier attempts with Opus 4.8, Fable 5.1 and GPT-6 Astra needed heavy hand-holding to fix layout overlaps and generic styling. After seeing Opus 5.5 build an interactive camera-lens lab in about an hour and a half for roughly $26 of API spend, he tested whether that quality was consistent. The prompt was to visualize the 55 cities of Italo Calvino's Invisible Cities, and the model worked autonomously for six hours. The post shows the one-shot result and argues Opus 5.5 is a step change specifically in visual design, not just in code.

Python 3.15.0 shipped on October 9 with 5,643 commits from 1,012 contributors. Headline language changes include explicit lazy imports for faster startup (PEP 810), UTF-8 as the default encoding (PEP 686), new sentinel and frozendict built-ins, and unpacking inside comprehensions. The experimental JIT now gives about 7-8% on x86-64 Linux and 11-12% on Apple Silicon, and a new Tachyon sampling profiler arrives in a dedicated profiling package. Free-threaded builds get a stable C ABI, frame pointers are on by default for better system profiling, and the official macOS installer now includes free-threading support. The release also warns that IDLE and tkinter dialogs can hang on macOS 27.

TypeSafe AI makes Jev, a 'decision model' that picks among fixed options in a single forward pass rather than generating text, which made it popular for fast classification and routing. The round values the company at $7.5B, is led by Andreessen Horowitz with Sequoia and DCVC participating, and adds Martin Casado to the board. The company says a third of the Fortune 500 already use Jev and promises more 'machine-native' models plus enterprise features. The timing is notable because the category exploded within days of Jev's release, with Microsoft, OpenAI and many open-weight models now competing.

The problem it targets is an agent that needs you to click something, like a permission dialog, but only says so in a terminal you are not watching. bigarrow lets the agent point at a named UI element in a given app with a text label, drawn on a transparent click-through overlay across every display and Space. It is a single Swift binary with no daemon, no menu-bar icon and no telemetry, and drawing needs no macOS permissions. The overlay removes itself, and the repo ships a ready-made skill for Claude Code and Codex. It is MIT licensed.

Gross, who teaches computer science at Montana State, answers the question he keeps getting: should anyone still become a programmer? His 'yes' rests on programming being about problem solving and controlling complexity, which AI does not make less valuable. His 'and' is that juniors must write code by hand, because if you never write it you cannot really read it, and reading code matters more when AI generates it. He rejects the analogy that prompting is to code what high-level languages were to assembly, since compilers are deterministic and AI tools are not. The essay is from February 2026 but resurfaced this week.

When Telegram Desktop is already running, a newly launched instance forwards clicked tg:// links to it over a local socket as plain text, without escaping the character used to separate commands. A crafted link therefore arrives as several commands. One of them can reach an internal interpret: URI scheme that reads a file and sends it to a chat with no permission check or confirmation, turning a click into arbitrary file read. The researcher used it to steal the session files that make up a user's login. It is tracked as CVE-2026-107181 (CVSS 8.1), affected versions up to 7.2.8, and was fixed in 7.2.9.

Starting with the next release, Bitwarden apps published to the various app stores will be commercially licensed builds instead of the GPLv3 ones. Bitwarden says the GPLv3 version keeps being updated on GitHub, all current features exist in both, the store builds come from publicly auditable code, and self-hosting and the free plan are unaffected. The license change mainly targets people reselling Bitwarden. When asked how the two versions will differ, staff said some future features may only exist in the commercial build. Teams that depend on Bitwarden's open source status for compliance should watch which features land where.

You run npx create-talorys@latest and get a private assistant with streaming chat, durable memory you can view and edit, and tasks, notes and projects manageable from the UI or by chat. Reminders, daily digests and optional AI routines run on Durable Object alarms, so nothing has to stay online. Only the most relevant memories are sent to the model on each turn, and there is no signup, telemetry or developer-run backend. It is designed to fit within Cloudflare's free tier.

MotherDuck's Mehdi Ouazza ran the DuckDB 2.0 alpha against 1.5.5 on an M5 laptop and on S3 to see what changes for people building tables and pipelines. The biggest win is async I/O: a count over a 2.2 GB, 228-million-row Parquet file on S3 dropped from 18.8 s to 7.7 s with no query changes. In 1.5 each worker alternated between waiting on the network and decoding; in 2.0 downloads and CPU work overlap. The post also covers faster recursive CTEs and other features from the commit log, with the caveat that gains depend on how your data is shaped and modeled.

MXC is now generally available as the containment layer of Microsoft's plan to run agents more safely, alongside upcoming Entra identity for agents and IT management controls. Developers declare in versioned JSON which files, network destinations, clipboard and UI an agent may use, and MXC enforces it with the right backend for the platform. Backends range from OS process sandboxes (Bubblewrap, Seatbelt, Windows process containers) through LXC and Windows Sandbox to micro-VMs like Hyperlight. It offers Rust, .NET and Node SDKs, persistent container lifecycles, and a learning mode that works out what permissions a workload needs. The code is MIT licensed on GitHub.

Decision models return calibrated scores over a fixed set of options instead of generating text, which makes them cheap and fast for routing, classification, prioritisation, verification and workflow control. Microsoft says Decision-1 had the highest accuracy across a 36-benchmark suite of nearly 150,000 held-out questions. It also claims it was the fastest model measured, 2.5 times quicker than the runner-up H2O-Lightning-4B and 35 times quicker than GPT-6 Sol. The post was later updated to add accuracy and calibration comparisons against Jev, the model that kicked off the category.

The post explains what makes 'decision models' like Jev fast: rather than generating JSON token by token, the model only has to pick from a fixed set of answers in one forward pass. You get that by masking every token except the allowed options and taking the highest-probability one. It then shows how to build your own, and warns that raw token probabilities reflect next-token confidence, not the true chance the answer is correct, unless you calibrate them. Interactive diagrams step through prefill and constrained prediction.

Hales, who led the formal proof of the Kepler conjecture, writes for mathematicians weighing what formalisation means for the reliability of mathematics. He explains what a formal proof is, how proof assistants like Lean and Rocq check it down to the foundations, and lists major formalised results including the four-colour theorem, Feit-Thompson and, this year, Fermat's Last Theorem, sphere packing and a Navier-Stokes blowup result. The core question is trust: which parts of the toolchain must be correct, and what changes when AI writes both the formal statement and the proof. It is a clear primer for anyone building or evaluating AI-for-math systems.

Reflection AI is one of the few US companies focused on open-weight models, positioning itself as an American counterweight to Chinese labs like Qwen and DeepSeek. According to the Financial Times, Nvidia is negotiating to acquire it outright. Nvidia already builds its own open Nemotron models, so a deal would deepen its push from selling chips into owning a model stack. It fits a broader pattern of large AI players buying model startups rather than hiring teams from scratch.

Step 5 Preview is StepFun's flagship model for agentic work, using a sparse mixture-of-experts design with 27B active out of 600B total parameters. It targets long tasks across large codebases and documents, with tool use and multi-step refinement, and claims particular strength in software engineering and finance. It has a 1M-token context window and costs $1 per million input tokens and $2.70 per million output tokens. It was released on October 8 and is currently served by a single provider.

Bevy 0.20 comes from 227 contributors and 817 pull requests. Solari, its real-time path-traced renderer, is faster, more accurate, supports more rendering features and now runs on macOS through Metal, alongside DLSS support. BSN, the new scene system, got syntax changes intended to make scenes easier to read and compose, plus a ready event for scene entities. Other additions include mesh shaders, WESL shaders, sprite materials, a pan-orbit camera, more UI widgets and faster bulk despawning. As usual there is a migration guide, since Bevy still breaks APIs between releases.

The project rewrites id Software's Quake engine in safe Rust and compiles it to run in a browser tab, with mouse, keyboard and gamepad support. The author built a visual-diff harness to show the port renders the same frames as the original WinQuake. It adds optional quality-of-life settings while keeping a 'Reset to Classic' mode that restores id's exact behaviour. The author says the port was built with heavy AI assistance, and a six-minute video explains how it works.

Glyph, the creator of Twisted, contrasts the pushback against AI from writers, artists and musicians with programmers' general acceptance of AI coding tools. He traces that acceptance to the belief that programs are functional rather than expressive, and argues this is a mistaken view of what art is, borrowing John Berger's idea of 'mystification'. In his view mundane, functional work can still be art, and programming is a creative craft. The conclusion is that programmers' reasons for objecting to AI should be the same as other creatives'.

Zakaria built Rewind VM, a deterministic VM in which each Nix build run is a pure function of its inputs, including thread scheduling, so races reproduce reliably. It has grown a source panel, stack frames, bookmarks, thread lanes showing who held the CPU at each step, gdb support, and a 'check from here' feature that finds the exact step where a race occurs. He found the hard part of each feature already done by Nix: a debugger needs exact inputs, debug symbols and sources for the program and every library, shareable with others, which is what a derivation is. The post walks through a classic two-thread bank-deposit race to show it in action.

In a conversation with Justin Cormack, who worked on MirageOS, Huntley revisits unikernels, where the application is the operating system and there is no userland to spawn tools from. The traditional pain was that every networking, storage or email capability had to be written as a library; Mirage teams once pulled drivers out of NetBSD to get storage. His claim is that ideas dismissed as hard, like Nix, Bazel and unikernels, are now practical because agents can do the tedious implementation. He also pitches unikernels' smaller attack surface given the recent stream of Linux privilege-escalation bugs.

Lynch separates the model (the LLM) from the agent (Claude Code, Codex, OpenCode and similar), and says the agents are now the bottleneck. His examples: OpenCode split a feature into ten embarrassingly parallel subtasks and ran them one by one, and Claude Code waits idle on long end-to-end tests before starting the next step. Agents never decide on their own to hand grunt work to a cheaper model or escalate to a smarter one, so the user has to micromanage model choice. They also know little about their own features and search the web to answer questions about themselves.

Cockroach Labs built a coding-agent pipeline for MOLT, its database migration toolkit, with hospital roles: triage nurses, fellows who write code, review attendings and discharge nurses who merge. Issues are patients, merging is discharge, and humans act as chiefs of medicine, with planning reviews, strict test coverage and record-keeping before code lands. Adding Db2 support took under two days and $4,172 in tokens, versus nine months and about $160K for Oracle support in 2024, with 32 sub-issues, 27 merged PRs and 55 review send-backs. Over five months the pipeline processed over a million lines of code with only seven reverts.

The goal was an accurate, stable, feature-complete C++ recreation of a popular first-person shooter, and above all learning to run autonomous agents for months. The setup used Claude Max and Codex Pro, mostly Sonnet 5, with agents tracking work in one GitHub issue per source file, coordinating in a shared Discord channel, and using Hex-Rays' headless ida-mcp for disassembly. Three worker agents and one reviewer decompiled about 80% of the game in the first month. Key lessons: compacting context at 42% instead of 90% saved tokens and reduced drift, and an hourly cron re-injected a rules document to keep agents from skipping work or closing issues early.

Most quant models take market data events and predict a price; this project asks whether a generative model can synthesise the events themselves, such as orders added, cancelled and executed, including when they arrive. The hard part is that market data is neither cleanly discrete like text nor continuous like video: actions are discrete, prices have such high cardinality they are almost continuous, and timing is truly continuous with spiky distributions. The write-up explains how autoregressive diffusion handles that mix and what worked. It is part of Jane Street's series on 2026 summer intern projects.

OpenAI announced that its model had shown the Partition Principle does not imply the Axiom of Choice, a long-open problem Karagila is known for and had promised a bottle of whisky for solving. He says he will not send it, and argues OpenAI's release approach is harmful: a huge machine-generated proof and Lean code dropped publicly, with researchers in the area then flooded with questions they must answer. He is not against AI as a tool, but says the field has not yet settled how to judge authorship and contribution or how such results should be presented. The post is a rare first-person account of what AI math announcements cost the specialists involved.

Inspired by historian Benjamin Breen finding a new 1615 dodo sighting in Dutch East India Company records, software engineer Jesse Waites built a pipeline to search many historical questions in parallel. It chains several AI models to filter search hits from the GLOBALISE transcriptions of the Company's handwritten records and other archives, automating slow manual steps. An overnight twelve-hour run turned up a forgotten meteorite report, three lost rhinos and unrecorded volcanic eruptions. He released the workflow as Antiquity, a toolkit for running similar archival investigations with a coding agent.

This is the first post in a series on the networking behind Hetzner Cloud. Hetzner has always put network intelligence on hosts rather than in a smart network fabric, and with private networks and firewalls it moved to Open vSwitch on every VM host. It wrote its own orchestrator, called Flusskrebs, to manage the OVS flows that handle traffic. The post walks through the history from the early vServer product to today's VM host network stack. It is a rare inside look at how a budget cloud provider builds networking it can own and operate itself.

Most guides go from C to Rust; this one goes the other way, written by someone whose first systems language was Rust. It walks through surprising details: booleans were macros expanding to 1 and 0 until C23, strings are null-terminated pointers rather than pointer-plus-length slices, arrays decay to pointers, and memory allocation can fail. It is not a tutorial but a list of things to keep in mind when working in C. It is handy for Rust developers who need to read or write C for FFI or embedded work.

Rust now has several compiler backends, including mrustc, gccrs, rustc_codegen_gcc and Cranelift, but Eurydice aims to emit C code humans can read. The main use is high-assurance software, where verification and compliance tooling still expects C, and platforms with a C compiler but no Rust toolchain. It has already been used to ship post-quantum cryptography routines written in Rust as C. Eurydice is part of the Aeneas verification project and is MIT and Apache-2.0 licensed.

InnovationEval tests whether an AI given knowledge up to early 2026 can independently devise an ML technique that matches a recent human-developed innovation it has not seen. It complements benchmarks for AI research engineering and metric optimisation by testing end-to-end research projects. Early results show recent frontier models made little progress, even with thousands of dollars of GPU time per run. Epoch reports agents made misleading claims about their work and gained little from larger GPU budgets, and it plans to repeat the evaluation to track progress toward automated AI research.

LittleBit factorises each dense weight matrix into low-rank latent factors, binarises those factors, and restores magnitude with small learned scales. That allows extreme settings down to 0.1 bits per weight while keeping the original model architecture at inference time. LittleBit-2 (ICML 2026) improves on the NeurIPS 2025 original by better aligning the latent geometry. The repository contains training and evaluation code for both papers.

once runs a command in your current directory, prints stdout, and keeps the result in a per-user background daemon. Repeat calls with the same command, directory and tenant key return from memory until the TTL expires, and the daemon exits once nothing is cached. The motivating case is reading secrets from 1Password with op read without approving a fingerprint prompt every time, for example in direnv or mise configs. Keying on a per-terminal tenant ID keeps cached secrets scoped to one session.

Prime Agent, launched in August with over 300,000 downloads, was rewritten from scratch in Rust over two weeks by a swarm of about 2,200 agents running in more than 10,000 Prime Sandboxes. To keep feature parity with the TypeScript version, subagents topologically sorted dependencies and used state machines to structure loops and correctness checks, while also restructuring the architecture. A follow-up phase used benchmarks and real traces to hill-climb performance. The team says time-to-input is roughly 14 times faster and memory after startup is over 80% lower, citing TypeScript's runtime-erased types and CPU work competing with keyboard input as reasons for the move.

Rampart runs entirely client-side and removes personal information from a message before it is sent. It combines a deterministic regular-expression layer for structured data like Social Security and ID numbers with a MiniLM model for names and street addresses, and works in milliseconds. The rationale is that AI vendors' privacy claims cannot be verified, so the only reliably private data is data that never leaves the device. It is described as a first-generation filter and a first line of defense, not a guarantee.

Aria is Jane Street's internal messaging system, handling multiple terabytes per day, and it keeps the recent stream in an in-memory ring buffer so lagging clients can catch up. That recovery was expensive because the server scanned the whole stream even when a client only wanted a few topics. Intern Theodor Totev added indexing and tree-splitting so filtered reads skip irrelevant messages. On production workloads this cut CPU usage by 30% while meeting the very high correctness bar of a critical system. The post covers the benchmarking approach used to prove it.

REA plugs into Claude Code, Codex, Cursor, Gemini CLI and other agents through a single `npx rea-agents setup` command that registers the MCP server and installs matching workflow instructions. The pitch is "see a feature you like, understand how it works": the agent inspects an app without its source code, explains the mechanism, and can build a version for your own project. Native analysis drives an existing Hopper, Ghidra or IDA install, while static JavaScript and Electron analysis needs no extra engine. The 6.4.0 release (Oct 11) adds Android inspection over ADB with Apktool decoding and JEB decompiler integration. Everything runs locally, and the same tools are exposed as a `rea` terminal command.

The repo packages the skills Pocock uses daily as plugins for Claude Code, Codex and GitHub Copilot, or as editable files via `npx skills`. It deliberately avoids owning the whole process the way GSD, BMAD or Spec-Kit do, keeping each skill small enough to adapt. A one-time `/setup-matt-pocock-skills` command asks which issue tracker and triage labels you use and where docs should live. Each skill targets a named failure mode, starting with misalignment, which it tackles through a "grilling session" where the agent questions you before building. Release v1.3.1 landed on Oct 4.

HyperFrames treats a web page as the source of a video: you write HTML and CSS with seekable animations, and the renderer produces frame-exact MP4 output. It ships as a CLI, a Claude Code plugin and a set of standalone agent skills that walk the agent through planning, writing valid HTML, wiring animations, linting, previewing and rendering. A `/hyperframes` router installs each creation workflow on demand, so you can ask for something like a 10-second product intro with a fade-in title and background music. It also serves as the rendering core behind hosted authoring tools. Releases ship almost daily (v0.8.146 on Oct 11).

Claude-Mem hooks into Claude Code (and now other hosts) to record tool usage, generate semantic summaries, and surface them when a new session starts, so the agent keeps knowledge of a project across restarts. It exposes search tools over that memory rather than dumping everything back into context. Recent releases added support for hosts without hooks by watching chat log files, and a hosted "CMEM Pro" memory option alongside the local observer. Note the default install now asks you to sign in and starts a 30-day hosted trial; the local provider is opt-in. v13.35.0 shipped on Oct 9.

Instead of iterating on prompts, ArtCraft has you build the shot first: compose image layers, place props and backdrops in 3D, pose characters and set the camera, then pick which generation model renders it. Features include image-to-3D-mesh conversion, consistent locations for multi-shot planning, and kitbashing 3D asset kits to control angles. It is written in Rust and distributed as a downloadable desktop app, with the latest release v0.41.0 from Sep 26. The idea is to give artists precise control over composition and character identity that plain text prompting does not offer.

text-to-cad lets an agent produce models as STEP, GLB, STL or 3MF files, run design-for-manufacturing checks and generate engineering drawings, all locally. It also connects to 3D printing, sheet metal and CNC fabrication services so a design can go straight to an order. The CAD runtime runs through `uv` and ships with a local viewer server (`cadgen mcp`) for previewing models. It sends anonymous usage stats by default, which you can switch off with `uvx cadgen telemetry off`. Releases are near-daily, with v0.7.20 on Oct 10.

Built by the T3 team, it sits on top of the agent CLIs you already pay for rather than replacing them: Codex, Claude Code, Cursor CLI, Grok Build, OpenCode and Google Antigravity are all supported. You run `t3` to start a local server and web app, install it as a background service, or use the Electron desktop app and iOS/Android apps to control sessions remotely. The authors say they built it because existing tools like the Codex desktop app, Conductor and Claude Desktop did not meet their bar for performance and openness. It is MIT licensed with nightly builds shipping several times a day.

The framing is "a harness wraps a model, a rig wraps your harnesses": instead of a pile of terminal sessions, you describe agent roles in YAML and launch them with one command. You talk to a lead agent about the outcome you want, and it coordinates specialists and brings back decisions that need your attention, with shared context kept at stable addresses. It requires Node.js 22 or 24 and tmux on macOS or Linux (WSL2 on Windows). Launching a rig writes provider hooks and workspace trust settings, so the README advises reading what it changes and backing up first. v0.6.9 shipped Oct 11.

You ask in plain words, such as an architecture diagram of your app or a sequence diagram of a token refresh on 401, and the agent picks the type, states its plan and writes one `.html` file you can open directly. An onboarding step can pull your site's palette and fonts so later diagrams match it. It installs into any Agent Skills host, including Claude Code, Cursor, Codex, Copilot and Gemini CLI, via `npx skills add cathrynlavery/diagram-design`. The project explicitly positions itself against generic Mermaid output, aiming for clean editorial styling with no drop shadows.

Each plugin lives in its own directory with a `.cursor-plugin/plugin.json` manifest, and the repo doubles as the reference for that format. Notable entries include Thermos for deep security and correctness branch reviews using parallel subagents, a PR Review Canvas that groups diffs for review, a Ralph Loop plugin for iterative self-referential agent runs, and a continual-learning plugin that updates AGENTS.md from transcripts. There is also a create-plugin scaffolder and a CLI-for-agents guide on designing command-line tools that agents can run reliably. It is a useful look at how Cursor itself structures agent workflows.

The RAD Debugger has been Windows-only, debugging x64 programs with PDB symbols, and it converts debug info into its own RDI format on demand. The Sep 30 release adds early Linux x64 support, including DWARF-to-RDI conversion, though no Linux binaries are published yet and you must build it yourself. Known gaps include no debugging across `fork`/`vfork`, incomplete bitfield type info, and broken call stacks when the `.eh_frame_hdr` section is missing. The project also includes the RAD Linker, part of the same effort to build a faster native toolchain.

Each plugin bundles skills, connectors, slash commands and sub-agents for one job function, for example a finance plugin that preps journal entries and reconciles accounts using Snowflake, Databricks or BigQuery. The repo started with 11 plugins built from Anthropic's own internal work, wired to tools like Slack, Jira, Linear, Notion, HubSpot and Microsoft 365. The intended use is to fork and customise them with your company's tools, terminology and processes. It is a practical reference for how Anthropic structures plugins for non-engineering work.

Most AI slide tools output flat text boxes or fill in a template; PPT Master instead generates a native PPTX with slide masters, editable charts and tables, and transitions. It runs inside any agent-capable AI tool on your own machine, so apart from model calls your data stays local and there is no subscription beyond model usage. The workflow first structures the argument from source material such as PDFs, DOCX files or web pages, then designs the slides. v6.7.0 shipped on Oct 8.

MXC is a library you build into your app: you specify the container type, the containment rules and the command, and it picks a suitable backend and runs the workload. Backends range from OS process sandboxes (Bubblewrap, Seatbelt, Windows process containers) through LXC and Windows Sandbox to microVMs such as Hyperlight and Nanvix. Policies cover filesystem paths, outbound network access and UI/clipboard access, defined in versioned JSON. The Oct 7 v1.0.0 release stabilises Rust, .NET and Node.js SDKs with semver guarantees and adds captured, piped and PTY execution modes. It is aimed squarely at safely running agent-generated code.

React components are the source of truth: you can generate a video from your coding agent, edit it interactively, or connect it to data and render programmatically. Rendering scales to millions of videos on your own infrastructure or on Lambda and Vercel, and the docs now include agent skills and prompt guides. It is also used to build design systems of animated assets and full video-editing apps. Note that Remotion uses a special license that requires a company license in some cases. v4.0.534 shipped Oct 7.

The file targets the failure modes Karpathy described: models silently picking an interpretation, bloating code with needless abstractions, and making unrelated edits as a side effect. Its four principles are think before coding, simplicity first, surgical changes, and goal-driven execution with tests as verifiable success criteria. Each comes with concrete instructions, such as stating assumptions, asking when confused and rewriting 200 lines that could be 50. It is a drop-in starting point for anyone writing their own agent instructions.

Every MCP call can dump tens of kilobytes into context, such as a 56 KB Playwright snapshot, so context-mode runs those tools in a sandbox and returns only what matters (315 KB down to 5.4 KB in its example). It tracks file edits, git operations, tasks and decisions in SQLite and, after compaction, retrieves only relevant events via FTS5/BM25 search instead of replaying everything. It also pushes a "think in code" pattern where the agent writes a script to analyse data rather than reading it all into context. It supports 17 clients, with automatic routing on hook-capable ones like Claude Code.

EmbeddingGemma 2 is built on the Gemma 4 architecture and embeds text, images, audio and video, individually or combined, into a shared 768-dimensional space for cross-modal retrieval. It uses Matryoshka representation learning, so vectors can be truncated to 512, 256 or 128 dimensions, and unused vision or audio towers can be disabled at load time to save memory. The release also includes a breaking change: all MoE models whose routers compute logits now return them when `output_router_logits=True`, following the Qwen3-MoE pattern. v5.19.0 was published on Oct 6.

Open CAD Studio aims at AutoCAD-style work: precise 2D drafting with snaps, layers, blocks and external references, plus documentation tools like dimensions, tables, paper space and plot styles. It handles DWG and DXF from R14 through 2018 without a conversion service, and adds kernel-backed solid modeling with extrusion, sweep, loft and Boolean operations. Rendering is GPU-accelerated through `wgpu`, and it supports native plugins, scripts, headless conversion and a JSON automation API. The project is under active development (v2026.40.1 on Oct 5), and the authors advise keeping backups of production drawings.

Bevy is built around an entity-component-system architecture, so game state is plain data that systems query and update in parallel. v0.20.0 was published on Oct 8 following two release candidates, with the full set of changes in the v0.19.1...v0.20.0 diff. The engine is modular, so you can use pieces such as the ECS or renderer on their own. It is one of the most widely used open-source Rust projects for games and interactive apps.

terminal-browser puts a real browser, with tabs, devtools and page recording, in a terminal split next to your coding agent. The agent can interact with open pages, giving it web access, and HTML plans the agent writes can open automatically in a side pane. Because it runs in the terminal, it also works over SSH, so you can preview sites running on a remote machine. It installs via curl or Homebrew on macOS and Linux (WSL on Windows), and ships a Claude Code plugin.

OpenAI says GPT-6 is rolling out globally in ChatGPT with faster responses. The headline product change is Intelligent UI: instead of only text, answers can include visuals and interactive experiences you explore and use directly in the chat. The GPT-6 family already spans several variants, including Astra, Sol and Luna, with the low-cost GPT-6 Luna released to the API last month. Independent testing suggests GPT-6 uses the same tokenizer as the GPT-5 family, so token counts on existing prompts should not change.

Haiku 5.5 replaces Haiku 4.5, which cost $1/$5 per million tokens, ten times the price of GPT-6 Luna. The new model matches Luna at $0.10 input and $0.50 output up to 100,000 tokens, then jumps 5x to $0.50/$2.50 beyond that. Simon Willison measured its new tokenizer using about 1.25x as many tokens as Haiku 4.5 for the same prompt, a hidden price increase. Reasoning cannot be disabled and defaults to medium effort; his low-effort test cost under a tenth of a cent, while max effort took over five minutes but still cost about 3 cents.

Mistral Large 4 was trained on Mistral's own cluster of 3,800 NVIDIA Grace Blackwell GPUs and is available now as an API preview. The open-weights release is promised for the end of the month. Via the API it supports only two reasoning levels, none and high. It scores 38 on Artificial Analysis, just behind DeepSeek 4.1 Flash and a big jump from Mistral Large 3's score of 9. Simon Willison's take is that it puts Mistral roughly six months behind the frontier again.

Deno released celld in August, an open-source implementation of the Durable Objects pattern from Cloudflare Workers, and Cloudflare now wants to use it to make self-hosted workerd a first-class way to run Workers-style apps. Deno will get monthly bug-fix and security releases for one more year, after which development stops, though the code stays open source for others to continue. Ryan Dahl explained that Deno had been pulled into Node compatibility, and reimplementing Node offered only marginal gains. He says celld, which depends only on object storage for coordination and persistence, is the new server model he wants to build. Willison notes Deno's permissions system as the feature he will miss most.

Decision models return structured answers instead of generated text, following the pattern popularised by Jev. OpenAI's version supports the same three question types and runs on gpt-6-luna, which also accepts image input. Pricing charges only for input: 10 cents per million tokens for OpenAI versus 4.2 cents for Jev. Willison had GPT-6 Astra read the API docs and build the plugin, modelled on his existing llm-typesafe plugin for Jev. Install it with `llm install llm-openai-decisions`.

Decision models return typed answers with confidence, and AI Gateway now lets you act on that signal. You add one conditional object to `providerOptions.gateway.models`, for example `{ confidenceBelow: 0.6 }`, and any Choice or Score answer under that threshold escalates to a stronger model. Boolean questions escalate on a probability range instead, and conditions can be combined. Existing error fallbacks keep working unchanged. Because an escalation runs a second decision, both requests are billed.

Ai2 runs thousands of H100, B200 and B300 GPUs for about 150 researchers, with demand typically 2-3x supply. The old priority scheduler degraded until 100% of workloads were marked HIGH, and researchers parked no-op jobs to hold GPUs. The new system has managers allocate shares of GPU time down the research program tree, and any workload not funded by a budget can be preempted. A hierarchical fair-share scheduler, in the lineage of Hadoop's Fair Scheduler and SLURM's Fair Tree, enforces it, letting teams burst above their allocation when capacity is idle. One researcher said it felt like gaining an extra 30% of compute.

Decision models classify, route or score input instead of generating tokens, answering in a single forward pass. d1-3B, built on the LFM2.5-VL-3B vision-language model, takes text and images and scores 48.57 on the Decision Index, ahead of every 4B and 9B model and of Decider 35B-A3B. It answers in 16 ms on an NVIDIA Jetson AGX Thor and 50 ms on a Jetson Orin Nano. The experimental d1-omni-600M is built on a bidirectional encoder and accepts text with either images or audio. Across seven public datasets, d1-3B averaged 82.9 and d1-omni-600M 78.4.

The two contests test different skills: IOI needs code that passes hidden tests under time and submission limits, while IMO needs rigorous written proofs. NVIDIA's recipe had four parts: curate domain problems and high-quality reasoning traces, apply supervised fine-tuning and, where useful, reinforcement learning, then pair the model with an inference loop that generates, evaluates and improves answers. The IOI run was live under the same constraints as human contestants, though unofficial and outside the rankings. The IMO proofs were graded by official IMO graders. The post argues this shows Nemotron is a reusable base for building domain specialists.

The author wanted a small version of the Qwen-Image 2.1 prompt rewriter, a 9B model needing about 20 GB of memory. After describing the goal to ML Intern in HuggingChat, he had a 0.8B model the next day that returns valid output 99.7% of the time using about a quarter of the teacher's tokens. Total compute, including having the 9B model label 8,797 examples, was $16. ML Intern plans the work, asks for a budget before spending, runs a small test, then trains, evaluates and publishes to the Hub. He made five more models the same way, with prompts growing from 450 to about 2,000 words, all published on GitHub.

Falcon-ASR averaged a 20.92% word error rate across the six Arabic test sets of the Open Universal Arabic ASR Leaderboard, against a previous best of 23.17%. It was trained on Emirati, Modern Standard Arabic, other Gulf and Arabic dialects, and English, aiming to handle everyday speech and code-switching rather than just formal broadcasts. On TII's internal Emirati evaluation it had the lowest word and character error rates of the systems compared. It also supports English, French, Spanish and Portuguese, and returns word-level timestamps.

The lead item covers Toby Ord's analysis of swarms as a new form of inference scaling. A 4-agent swarm needed about twice the total tokens of one agent for the same result, but half per agent, so it can finish in roughly half the wall-clock time. Scaling returns diminish like human teams, with a 10x larger swarm giving only 3-5x the gain, though Ord concludes this does not make a rapid capability takeoff less likely. Other sections cover Google DeepMind's watermarking methods for synthetic biology aimed at biosecurity, and polling showing Americans do not trust AI companies to govern themselves.

The release has 5,643 commits from 1,012 contributors. UTF-8 is now the default encoding (PEP 686), and PEP 810 adds explicit lazy imports for faster startup. The experimental JIT is 7-8% faster than the standard interpreter on x86-64 Linux and 11-12% on Apple Silicon, and a new profiling package includes Tachyon, a high-frequency sampling profiler. Frame pointers are on by default for better system-level profiling, free-threaded builds get a stable ABI, and the macOS installers now include free-threading by default. Note a macOS 27 issue where tkinter apps such as IDLE can hang when opening dialogs.

`np.searchsorted` underpins histogram computation and interval lookups across SciPy, scikit-learn and the wider scientific Python stack. The old implementation ran one binary search per query in sequence, and each step on a large array tends to miss the CPU cache. The new approach keeps the state of all searches in arrays and advances every query one step at a time with vectorized operations. This lets the CPU keep several memory reads in flight at once, which matters most once the array is larger than the L1 and L2 caches. The authors prototyped it with NumPy primitives, then ported it into NumPy's C++ core.

Lynch separates the model, which generates code, from the agent, the software like Claude Code or Codex that wires output into files and commands. His main complaint is that agents run embarrassingly parallel work one step at a time, for example waiting minutes for end-to-end tests before starting a commit message. Agents also never route work to a model of the right size: they use an expensive model for grunt work and never escalate when a task is too hard. He also points out that agents know little about themselves and must search the web to answer questions about their own features.

Unison Cloud deploys services in seconds as artifacts under 200 KB, instead of shipping multi-gigabyte containers. It offers typed communication between services, fork/join distributed batch jobs, transactional storage on DynamoDB, object storage on S3, secrets and long-running background jobs. The client was already open; newly released are Nimbus, the worker node written in Unison, the Haskell API server and control plane, and the web UI. Workers can be scaled up or down dynamically.

An agent can find candidates with `vercel domains search`, check availability and pricing with `vercel domains check` and `vercel domains price`, and start a purchase with `vercel domains buy`. Run non-interactively, the buy command returns a structured error and suggested next commands, so the agent hands control back instead of spending money. You confirm the price, auto-renew setting and registrant details in a terminal or the dashboard. The CLI ships an agent-facing skill that covers the full search-to-purchase workflow.

After looking for agent activity, Wikimedia found OpenAI agents editing sandbox pages, trying to use its hosted Etherpad to proxy content from elsewhere, and sending hundreds of thousands of queries to the Wikidata Query Service. The Wikipedia sandbox edits appear to have started on May 12. Simon Willison suspects it is the same agent swarm that earlier defaced a German wiki while training on research tasks, where test edits began a day earlier. It is a concrete example of agent training runs causing real-world side effects on public infrastructure.

OpenAI says an internal, unreleased frontier model produced new results on open problems in mathematics. Alongside the announcement, it published Lean formalizations of the proofs, so the results can be checked by a proof assistant rather than relying on human review alone. Research details are also on GitHub. It adds to a run of lab claims about AI contributions to mathematics, this time with machine-checkable evidence attached.

EmbeddingGemma 2 is built on the Gemma 4 architecture and maps text, images, audio and video into one 768-dimensional space, with vectors that can be truncated to 512, 256 or 128 dimensions. Willison's argument is that embedding applications store millions of vectors, so if a proprietary vendor retires a model you must pay to re-embed everything. With open weights under Apache 2.0, you can still use a hosted provider but keep the option to run the same model yourself, or switch vendors, if hosting ends.