🛠️ Tooling & Dev

1.4.4

The release page’s extracted content was unavailable and only returned loading errors. No release notes or changes could be verified from the supplied material.

EVE Online: The Move to Python 3 Begins!

EVE Online is beginning a migration from Stackless Python 2.7, its last major runtime upgrade in 2010, after running on Stackless Python since the game launched in 2003. The plan starts with futurize across 2.4 million lines of code and then manually reviews roughly 20,000 sites where Python 2 and 3 semantics differ, such as integer division. The linked note says the announcement does not yet explain how Stackless will be replaced. It points to EVE Frontier’s Carbon engine, which has already replaced Stackless with the now-open-source carbonengine/scheduler library, as relevant precedent.

Large-Scale Sharded Weight Transfer with Ray Direct Transport (RDT) in vLLM

vLLM describes a sharded weight-sync path for online RL, where rollout servers must periodically receive fresh, increasingly enormous model weights. Rather than all-gathering full Hugging Face tensors and broadcasting them to every inference worker, it records each loader’s tensor transformations at runtime and uses that “sharding plan” to send each worker only the BF16 shards it needs. Ray Direct Transport and NIXL provide pull-based GPU-to-GPU movement, while remaining loader steps preserve support for varied architectures and quantization methods. On a Qwen3-235B setup, successive optimizations cut sync time from a 64.72-second NCCL baseline to 3.49 seconds; the team reports 7.53 seconds for BF16 Kimi K2 across 48 eight-H100 nodes.

Wire It, Run It, Deploy It: AI Workflows in Gradio

Gradio’s built-in gr.Workflow makes an AI pipeline a typed visual graph: inputs, operator nodes, and output nodes are wired on a drag-and-drop canvas where each intermediate result can be run and inspected. Operators can be local Python functions, hosted models, other Gradio Spaces, or Hub datasets, enabling patterns such as image generation plus background removal, topic fan-out to TTS and title generation, or parallel dataset analysis. Every named output is automatically exposed as a REST endpoint, so the visual workflow can also be invoked programmatically without separately building an API. Functions can request a ZeroGPU allocation with @spaces.GPU, allowing a node to run a local GPU model and release the hardware afterward.

How Hugging Face Inference Endpoints, Jobs, and Buckets Power Search on Papers with Code

Papers with Code rebuilt search for more than 110,000 papers as a hybrid system combining PostgreSQL full-text retrieval, pgvector semantic retrieval, and reciprocal-rank fusion. It treats embedding generation as a durable offline batch job and query embedding as a small online service, keeping immutable artifact runs in storage with manifests and SHA-256 checksums before validation and atomic index activation. The production embedding contract pins Qwen3-Embedding-0.6B to an exact revision and uses normalized 256-dimensional vectors; on a 5,000-paper pilot, its HNSW index achieved 0.9955 Recall@20 with 1.31ms p50 and 2.21ms p95 lookup latency while using roughly 27% of the 1024-dimensional storage. Because the online endpoint can scale to zero, the system immediately falls back to lexical search for cold starts, timeouts, malformed vectors, or exhausted concurrency rather than making users wait.

llm-anthropic 0.27

Version 0.27 of Simon Willison’s Anthropic plugin for LLM is principally a compatibility update for the Anthropic Python SDK 1.0.0. That SDK moves from httpx to httpx2, mirroring a similar transport change in OpenAI’s Python library 3.0.0. Willison used Claude Code with Anthropic’s migration guide to upgrade the dependency and make the tests pass, illustrating the intended upgrade path for the plugin.

VeRL-Omni v0.2.0: Faster Diffusion RL and Stable Omni Training

VeRL-Omni v0.2.0 makes request-level batching the default rollout path for supported diffusion adapters, replacing serial diffusion requests with packed transformer forwards and adding a V1 trainer path. In the Qwen-Image OCR LoRA example, isolated generation time falls from 226 seconds to 108 seconds, a 52% reduction, while GPU utilization rises from roughly 80% to about 100%; the suggested maxnumseqs range for True-CFG at 512 px is 8–32 before memory pressure becomes likely. The release also fixes policy-correctness-sensitive paths around batched log-probabilities, asynchronous rollouts, LoRA weight updates, and rollout correction. For multimodal training it introduces reusable model adapters and a stable Qwen3-Omni recipe that reports 0.833 validation reward and 0.998 actor-rollout correlation on MMK12.

Your executable is a SQLite database

Simon Willison points to a Linux technique that makes a SQLite database directly executable. It writes SELF—for Structured Executable & Linkable Format—into SQLite’s four-byte application ID field and stores ELF components across SQLite tables. A custom C interpreter extracts and executes those components, and Linux binfmtmisc can register the file signature so the kernel invokes that interpreter automatically. The result is a deliberately unusual but usable combination of a queryable SQLite container and an executable file.

1.4.3

ExLlamaV3 1.4.3 adds preliminary support for GLM 5.2 through GlmMoeDsaForCauslLM, while warning that support remains a work in progress. It introduces partial CPU-layer expert offloading with dynamic placement, replacing the earlier expert-cache approach, plus CPU cache offloading in tensor-parallel mode. The release also improves speculative decoding with automatically calibrated draft-confidence thresholds and adds experimental quantization optimization. Other changes include mid-stream text injection for reasoning-token budgets, more accurate autosplit allocation, and a reduced, stabilized VRAM footprint during DSA prefill.

Exploring Speculative Decoding in vLLM on AMD GPUs

vLLM explains speculative decoding as a draft-and-verify scheme: a lightweight component proposes several future tokens and the target model verifies them together, preserving the target model’s behavior while sometimes committing multiple tokens in one pass. If the target accepts a run of proposals, fewer target-model decode rounds are needed; at the first rejected token, later draft tokens are discarded and the target supplies the continuation. The post compares native and separate multi-token predictors with target-conditioned draft networks such as EAGLE-3, DFlash, and DSpark on AMD MI300X and MI355X GPUs using ROCm. Its key operational caveat is that throughput gains are not automatic: they vary with model and draft checkpoint, proposal length, workload, and especially token-acceptance behavior, so serving teams must measure and tune their own configuration.

llm 0.33

LLM 0.33 upgrades to the OpenAI Python library 3.x and replaces its HTTP dependency with httpx2, following a narrower 0.32.1 fix. Embedding commands and APIs now accept a per-call key, allowing plugins to use a resolved key without mutating shared model state while preserving compatibility for plugins that read self.key. Repeated -t/--template flags can now combine templates in sequence, making it possible to separate a saved model/options template from a saved prompt template. The Responses API endpoint also gains reasoningsummary controls—auto, concise, or detailed—for reasoning-capable models.

Claude Platform release notes — August 20, 2026

Anthropic released version 1.0 of its Python SDK, requiring Python 3.10+ and moving its HTTP layer from httpx to maintained fork httpx2. Applications that construct custom HTTP clients, timeouts, or transports must use httpx2 objects; tracing or mocking code that patches httpx can call httpx2.aliashttpx() at startup. The release removes long-deprecated APIs and parameters, including Text Completions and several Messages sampling controls, so this is a migration rather than a routine update. Async raw-response handling also changes to await response.parse(), and Bedrock clients now error if no AWS region is configured instead of silently choosing us-east-1.

llm 0.32.1

LLM 0.32.1 is an emergency compatibility release after fresh installations broke when the OpenAI Python library stopped using httpx, which LLM had been receiving only transitively through that dependency. The immediate fix pins OpenAI to a pre-3.0 release. Simon Willison says LLM 0.33 will instead migrate from httpx to httpx2, eliminating that dependency assumption.

llm-openrouter 0.7

The llm-openrouter 0.7 plugin is updated for compatibility with LLM 0.32 and is intended to work better with reasoning models available through OpenRouter. Models now use OpenRouter’s implementation of the Responses API. It also exposes three server-side tools—Shell, WebFetch, and WebSearch—which users enable selectively with options such as -T WebSearch.

A shot-scraper-style JSON API on Bun 1.4's new Bun.WebView

Bun 1.4 adds Bun.WebView, giving Bun core browser automation through macOS WebKit or a local Chromium process controlled via the Chrome DevTools Protocol. Simon Willison used Claude Code for web to prototype a TypeScript JSON API that loads a page and executes JavaScript against it, modeled on his shot-scraper CLI. His cgroup testing found a full Chrome serving complex pages needs about a 192–256MB container. The release also claims 2,900-plus fixes, a 5× reduction in idle CPU use, up to 35% lower memory use, 50% faster Linux starts, and a rewrite from Zig to Rust.

Claude Platform release notes — August 19, 2026

Anthropic made its Claude API computer-use tool generally available as computertoolset20260801, adding batch actions, default zoom, and per-member configuration without a beta header. It also launched a browser-use client toolset that operates inside an application-hosted browser viewport and adds accessibility-tree and element references, forms, tab control, download reporting, and opt-in uploads. Files API, Agent Skills/Skills API, and Enterprise user-management endpoints also moved to general availability, with beta request formats still accepted for compatibility. Managed Agents now support domain allow/block lists for web tools and memory stores that self-hosted sandbox workers mount and sync, while the Console session viewer gains a timeline, grouped transcript, and inspection data for costs, events, tools, resources, and threads.

smolmachines / smolvm as a sandbox for untrusted Python & JavaScript

Simon Willison asked Claude Fable 5 in Claude Code for web to investigate whether smolmachines could execute untrusted Python and JavaScript with CPU and RAM limits, no network, and access only to designated files. The web environment could not run smolmachines directly. Instead, the agent switched to a GitHub Actions runner, installed smolvm, and ran its tests against the working branch. Willison highlights this as an example of an agent adapting productively to an execution-environment constraint.

Lecture 112: Production Megakernels for Real-World Inference

The talk describes megakernels as an alternative to the conventional GPU model of launching many small, highly parallel kernels whose communication largely happens through global memory. The speaker argues that a compiler needs a deeper view of GPU execution to decide when a more fused, persistent program can improve production inference. Megakernels are presented as a performance technique rather than a universal replacement for kernel graphs, with deployment choices depending on the workload and accelerator. The focus is on translating PyTorch workloads into implementations suited to GPUs and other AI accelerators while retaining fine-grained control.

Stateless, Yet Durable: MCP Tasks v2

This talk explains that MCP v2’s stateless design substantially simplifies the task protocol, but does not eliminate the need for durable execution. From a Temporal perspective, the important cases are jobs that outlive a single request and need client- and server-side task handling. The speaker discusses implementing both sides in a bespoke client rather than relying on a standard one. The central distinction is between making the protocol transport/session stateless and making long-running work reliably resumable.

The MCP Tasks Extension

The presentation explains why MCP needs a tasks extension: ordinary MCP calls are synchronous and work well for quick operations such as database queries, API calls, and file reads. Longer work—such as batch processing—cannot reliably finish within that one-request/one-response model. It compares an earlier tasks design from the 11/20 specification with the newer 7/20 version. The practical purpose is to let clients track and retrieve asynchronous work without forcing all tools into a synchronous timeout-shaped interaction.

MCPs for Observability Stacks

The speaker argues that MCP-enabled observability should combine metrics, logs, traces, and events into a coherent system context rather than offer isolated signals. The operational goals are earlier anomaly detection, automated repetitive work, faster root-cause analysis, and lower mean time to resolution. They stress that correlated telemetry is necessary for effective troubleshooting and that the underlying data must be reliable and available. MCP is framed as a way to connect agent workflows to these observability capabilities, not as a substitute for trustworthy telemetry.

MCP Release Overview: Stateless and the Big Changes in the New Spec

An MCP steering-committee member calls the new specification the protocol’s largest change since launch. The guiding shift is from desktop-local hosts and data sources—originally centered on stdio—to deployments where MCP services operate remotely and at broader scale. The new stateless approach is presented as the protocol-level response to that transition. The talk also situates the change in the work of the Rust SDK and the open-source Goose agent harness.

MCP 728: What Changes, What Breaks, and What You Need to Do About It

Transcript unavailable.

AscendNPU-IR: MLIR for Ascend

AscendNPU-IR is an MLIR-based intermediate representation for compiling Ascend-oriented operators. It exposes higher-level abstractions that hide low-level compute, data-movement, and synchronization instructions while allowing compiler optimizations to map hardware-independent expressions to Ascend instructions. It also provides fine-grained controls over on-chip memory addresses, pipeline synchronization points, and ping-pong pipeline optimization. The project is open to ecosystem-framework integrations and provides paired Chinese and English Sphinx documentation.

Production Megakernels for Real-World Inference

The speaker introduces production megakernels as a GPU programming approach for inference that departs from executing a graph of small, isolated CUDA kernels. In the conventional model, many parallel kernel instances communicate mostly through global memory or shared memory within a core, and the launch grid abstracts much of the scheduling. Megakernels seek a more coarse-grained programming model and deeper control over execution, which can reduce overhead or improve data reuse for suitable workloads. The talk positions them as one performance tool among several, to be selected and compiled for real production traffic rather than treated as a universal optimization.

Mojo🔥 is now open source

Modular has released the Mojo compiler and toolchain under Apache 2.0, following last week’s 1.0 release and a long-standing 2023 promise to open-source it. Mojo is no longer committed to becoming a full Python superset; it is now positioned as its own Python-inspired language focused on making GPU programming easier. The company argues that AI-assisted coding can help migrate Python code to Mojo as tools and the ecosystem mature. The release turns a previously proprietary language stack into an openly licensed option for performance-oriented programming.

Claude Platform release notes — August 18, 2026

Anthropic has renamed Workbench to Playground in the Claude Console. Playground now supports every Messages API parameter and includes templates for features such as code execution and web search. Each run displays the full SDK request and corresponding API response, making it a more transparent environment for learning and prototyping API integrations.

A/B test models in production

Together AI adds endpoint-level A/B experiments that split live traffic across one control and up to 20 model variants, so teams can measure product outcomes rather than merely latency, errors, and throughput from shadow traffic. Variants must have zero weight in the endpoint’s normal traffic split; the experiment owns their fixed percentages, preventing autoscaling or replica counts from contaminating cohort shares. Teams can start at 95/5, update the complete member list to ramp exposure, use etags to prevent conflicting edits, and delete the experiment to return all traffic to the control without leaving application-side routing code behind. The platform attributes each response to a deployment, but leaves product-quality measurement—ratings, retries, retention, or completion—to the customer’s analytics; stable user sampling keys are necessary when session consistency matters.

JSON Schema 2020-12 and the Contract for Context | ​Ola Hungerford | MCP Release Party - Seattle

Ola Hungerford argues that MCP tool schemas need a stricter, shared JSON Schema 2020-12 contract because common SDKs and schema generators have produced outputs that the protocol did not actually support. Those gaps forced wrappers and translation layers, making interoperability brittle across servers and clients. The new contract is presented as less headline-grabbing than the move to stateless MCP, but important for reliable tooling because it defines what structured input and output a client can safely interpret. The practical message is to validate generated tool schemas against the spec rather than assume a popular SDK’s emitted schema is portable.

MCP Goes Stateless | ​John Dellenbaugh & Pankaj Kumar | MCP Release Party - Seattle

The speakers frame MCP’s removal of protocol-level sessions and handshakes as a major operational change for horizontally scalable deployments. Under the earlier model, an MCP service needed sticky session storage behind a load balancer, a constraint that can make a conventional stateless architecture fail an MCP-specific design question. Their shopping-assistant demo uses cart creation and item management to illustrate a realistic stateful application built over a now-stateless protocol. The distinction is that application state may remain necessary, but the transport protocol no longer forces server affinity, simplifying load balancing and resilience.

Events Notifications in MCP | ​Aman Singh | MCP Release Party - Seattle

Aman Singh identifies a gap in current MCP notifications: clients receive them only while a connection remains open, and existing notices often provide a changed URI rather than the event payload. That means an agent with PagerDuty-like permissions may be able to acknowledge, resolve, page, or roll back, yet have no dependable way to learn that an incident happened. The talk outlines a proposed triggers-and-events extension, explicitly described as a design-stage proposal rather than a finalized specification. Its aim is to let MCP support event-driven agent workflows safely and reliably when clients are disconnected or need actionable notification data.

Policy Enforcement and Tamper-Evident Audit Chains | ​Imran Siddique | MCP Release Party - Seattle

Imran Siddique argues that MCP’s growing use for real agents makes governance more than a chatbot concern: servers can expose tools, communicate across agents, and operate on consequential systems. He presents policy enforcement and tamper-evident audit chains as the next layer beyond basic protocol functionality, intended to make actions attributable and resistant to undetected alteration. The talk is positioned as a discussion starter rather than a finished standard, reflecting interest in controls that can keep pace with rapidly expanding MCP deployments. The underlying tradeoff is that making agents useful requires broad tool access, while making them acceptable in enterprise settings requires durable, verifiable constraints and records.

Keynote: Two Years of MCP | Den Delimarsky, Anthropic | MCP Release Party - Seattle

Den Delimarsky marks MCP’s 611th day in the open and recounts its evolution from local stdio and remote HTTP/SSE transports plus the core primitives of tools, resources, and prompts. The keynote uses the protocol’s rapid succession of specification versions to show how much it has expanded beyond that initial surface. Its historical framing helps explain why the latest stateless release is consequential: it continues a progression from a simple connection protocol toward a broader interoperability layer for agent tools. The talk also emphasizes that the original primitives have endured even as transport and deployment assumptions changed.

Seattle - MCP Release Party - Introduction

The Seattle introduction situates the event on the July 28 MCP specification release, coordinated with gatherings in more than six cities. The former MLOps Community had recently joined the Linux Foundation as an official Agentic AI Foundation user group, and the Seattle chapter organized the local program with Microsoft and Opaque Systems as sponsors. The agenda pairs a release keynote with sessions on MCP changes, then leaves room for community Q&A and networking. It is primarily context for the subsequent talks rather than a technical announcement.

Distributed Layerwise Offload: Scaling Toward 200B+ DiT Models Efficiently in vLLM-Omni

vLLM-Omni’s Distributed Layerwise Offload is designed to run video-generation models larger than a single accelerator’s HBM across multiple GPUs or NPUs without multiplying host-memory use by data-parallel rank. For Cosmos3-Nano on four ranks, the post reports cold-start cgroup-visible peak memory falling from 178GB to 47GB by replacing private weight copies with shared mmap-backed page-cache views; for Cosmos3-Super DP4, pinned weights fall from four 124GB copies to 124GB total, or 31GB per rank. The design shards host weights, all-gathers only the current layer, and overlaps H2D transfers, all-gather, and computation with two reusable device buffers, keeping HBM roughly to two layers. The AllGather quickstart requires vLLM 0.27.0 and vLLM-Omni v0.27.0rc1 or later because an earlier release rejects Cosmos3 DLO+DP requests; a no-AllGather multi-request path remains open work.

Markdown SVG upgrades

Simon Willison’s markdown-svg-renderer turns pasted Markdown, or Markdown loaded from a CORS-friendly URL or GitHub Gist, into a shareable rendered page. SVG blocks are displayed as SVG and accompanied by tabs that produce PNG and JPEG versions in the browser for platforms that do not accept SVG. A new MP4 tab detects animation, estimates a loop duration, renders frames, and uses more than 30MB of ffmpeg.wasm to encode them locally in the browser. The result is a bookmarkable conversion path for animated SVGs without requiring a server-side rendering workflow.

CORS Chat

Simon Willison built a browser-based chat client to test OpenAI Responses-compatible endpoints, specifically Qwen 3.8 27B served through LM Studio on an M5 MacBook Pro and an NVIDIA DGX Spark. It has also worked against LM Studio with CORS enabled and against OpenRouter. The client stores conversations locally in the browser and lets users export them as copy-pastable JSON. A notable interface detail is progressive rendering of generated SVG images while tokens stream, making it easier to inspect visual-model output in real time.

Lecture 111: Spectral Compute: Compile CUDA everywhere

Spectral Compute's CTO presents SCALE as a compiler intended to take unmodified CUDA source and generate native AMD as well as NVIDIA machine code. The lecture challenges the assumption that CUDA portability is impossible, comparing the desired outcome to recompiling C or Rust across CPU vendors rather than rewriting applications for each target. It focuses on why CUDA is the de facto GPU programming target, the hard implementation cases and vendor-specific optimizations, then promises benchmarks and a longer technical Q&A.

Spectral Compute: Compile CUDA everywhere

The supplied transcript description says Spectral Compute's CTO explains that SCALE recompiles unmodified CUDA source into native AMD and NVIDIA machine code. It emphasizes the compiler work and vendor-specific optimizations needed to make CUDA portable, rather than requiring source changes for each GPU platform. The accompanying link points to SCALE's project site.

llm-gemini 0.33

Simon Willison’s llm-gemini 0.33 adds support for Gemini 3.7 Flash, Gemini 3.6 Flash, Gemini 3.5 Flash-Lite, and the Gemini Embedding 2 and Embedding 001 models. Compatibility with LLM 0.32 means users can view reasoning traces and enable server-side tools. The release notes that 3.7 Flash removes the “minimal” thinking option that was available in 3.6 Flash. A sample SVG generated at high thinking effort exposed a browser-compatibility wrinkle: Safari renders an empty SVG filter more permissively than Firefox and Chrome, where the pelican disappears while its bicycle remains.

sqlite-utils 4.2.1

sqlite-utils 4.2.1 fixes a crash introduced in 4.2 because the package imported Self from typingextensions without declaring that package as a dependency. The bug was masked in development because a dev dependency installed it indirectly, but users invoking the tool directly with uvx sqlite-utils could lack it. Simon Willison added an isolated smoke test—uv run --isolated --no-default-groups sqlite-utils --help—to ensure the CLI works without a local virtual environment or default dev groups. The release is a concise lesson in testing the actual packaging path users take.

sqlite-utils 4.2

sqlite-utils 4.2 expands table.transform(), the feature that performs complex ALTER TABLE operations by creating a replacement table, copying data, and swapping it in. The update preserves more unusual schema details during that operation, including check constraints, unique constraints, and column comments. It also adds properties for inspecting check constraints alongside numerous smaller changes. A later 4.2.1 patch fixed a packaging-related crash in this release.

alchemy-utils 0.1a1

The alchemy-utils 0.1a1 announcement points to a performance-focused initial release. Its stated improvements target DuckDB exports and CSV imports. The post provides no further implementation detail or benchmarks, so users considering it should review the linked release material before estimating the impact on their workloads.

Record, train, and deploy from one place with Strands Agents, LeRobot, and Hugging Face Storage Buckets

AWS’s open-source Strands Robots SDK and Hugging Face describe a continuous robot-learning loop that records demonstrations, syncs them into mutable Hugging Face Storage Buckets, streams them directly for training, and deploys checkpoints back to the same robot abstraction. The approach retains the LeRobot on-disk format throughout, avoiding format conversion and full local dataset downloads; a bucket acts as the working layer while versioned Hub repositories remain the publishing layer. Xet-backed buckets deduplicate content at byte-level chunks, intended to avoid repeatedly transferring near-identical video-heavy recordings. The walkthrough can run on a laptop with a mock policy, but the authors explicitly caution that such recordings are structurally valid rather than useful training data until a real policy is substituted.

alchemy-utils 0.1a0

Simon Willison used Codex and GPT-5.6 Sol Ultra to prototype alchemy-utils, an alpha Python library and CLI that aims to bring sqlite-utils-style operations—such as insert, upsert, create, update, and table introspection—to multiple databases through SQLAlchemy. The project was tested against PostgreSQL, SQLite, and DuckDB, and the author says it reached releasable-alpha quality with few follow-up prompts under a red/green TDD workflow. Example commands show querying a local PostgreSQL table and streaming a CSV into a DuckDB database while automatically creating the matching schema. An initial DuckDB import took nearly an hour, but an agent-led optimization reduced it to roughly 35 seconds, illustrating both the utility and the need to validate generated implementation performance.

Day 0 Support for Qwen3.8-2.4T-A95B on vLLM

The supplied material contains no extracted article body for this announcement. Its listing indicates day-zero vLLM support for Qwen3.8-2.4T-A95B, including model-support, quantization, MoE, performance, and hardware topics. Consult the source for deployment commands and benchmarks.

Claude Platform release notes — August 11, 2026

Anthropic’s beta Compliance API can now return transcripts for Cowork and Claude Code sessions run locally on enterprise users’ machines. Organizations can list sessions, retrieve metadata, and retrieve messages using a Compliance Access Key with the read:complianceuserdata scope. API responses also add an anthropic-workspace-id header identifying the resolved workspace.

Claude Platform release notes — August 7, 2026

The supplied release-note entry announces the same local-session Compliance API beta: enterprise administrators can list local Cowork and Claude Code sessions and retrieve their metadata and transcripts. Access uses existing Compliance keys and the read:complianceuserdata permission. The API now also reports the resolved workspace through an anthropic-workspace-id response header.

datasette-upload-dbs 0.5a0

Datasette’s upload-dbs 0.5a0 adds a formal API for uploading a new SQLite database or atomically replacing an existing hosted database. The server saves and verifies the upload before swapping it in, so a named endpoint begins serving the new version only after validation. This makes it practical to build a database in CI and publish it to production with an authenticated POST.

SQLite compressed text-history prototypes

The supplied material contains no extracted post body for this item. It provides no details about the prototype’s compression method or results. Consult the source for the technical write-up.

datasette-auth-tokens 0.4a13

The supplied material contains no extracted post body for this release. It provides no verified feature list or migration guidance. Consult the source for release details.

datasette 1.0a38

The supplied material contains no extracted post body for this release. Its categories indicate security and SQL-injection relevance, but the raw material supplies no details. Consult the source before upgrading.

datasette 0.65.3

The supplied material contains no extracted post body for this release. It provides no verified changelog or compatibility notes. Consult the source before upgrading.

New release of LLM adds support for reasoning traces, OpenAI Responses, server-side tools, and smarter logging

The supplied material contains no extracted post body for this release. A related plugin release indicates the LLM ecosystem added typed streaming events for reasoning and tools plus server-side tools. Consult the source for the full LLM 0.32 changes.

llm-anthropic 0.26

llm-anthropic 0.26 adds Claude Fable 5, Sonnet 5, and Opus 5, as well as server-side WebSearch, WebFetch, CodeExecution, and AnthropicMCP tools through LLM’s tool interface. It upgrades to LLM 0.32, which streams reasoning and tool events as typed events, and replaces older thinking controls with thinkingeffort levels. Claude 5 models think by default, while Fable 5 always does so.

llm 0.32

The supplied material contains no extracted release body beyond a pointer to a detailed announcement. A related llm-anthropic release says LLM 0.32 introduces typed streaming events for reasoning, tool calls, and tool results. Consult the source for the complete changelog.

datasette-upload-dbs 0.5a0

Datasette’s datasette-upload-dbs 0.5a0 adds a formal HTTP API for uploading a new SQLite database or replacing one already served by a hosted Datasette instance. The plugin saves and verifies the uploaded database before atomically swapping it, so the named endpoint begins serving the new version without exposing a partial update. The release makes it straightforward to build a database in a CI environment such as GitHub Actions and promote it to production immediately after the build succeeds. Authentication uses a bearer token and the multipart request supplies both the database file and its target name.

Announcing Day-0 Support for NVIDIA Nemotron 3.5 Lightning on vLLM

vLLM added launch-day support for NVIDIA’s Nemotron 3.5 Lightning, a 30B-parameter hybrid MoE model that activates 3B parameters per token and targets always-on agents. It offers a 1M-token context window, controllable reasoning, and an OpenAI-compatible serving path for local, edge, and datacenter deployments. The post highlights three speculative-decoding options—MTP, DFlash, and DSpark—with DSpark recommended for low latency on H100, H200, and DGX Spark, while no speculation is recommended for maximum throughput. NVIDIA says the model can complete agentic workloads up to 30% faster at comparable accuracy and reach up to 4× the throughput of similarly sized open models.

Claude Platform release notes — August 10, 2026

The August 10 Claude Platform notes reiterate an API constraint for Opus 4.1: requests cannot specify both temperature and topp. Developers must choose one sampling control rather than combining them. The extracted release note also says that listed Claude API features are generally available, but does not include the feature list. Treat the parameter incompatibility as the actionable compatibility detail.

Claude Platform release notes — August 3, 2026

The August 3 Claude Platform notes carry the same Opus 4.1 sampling restriction: temperature and topp cannot be sent together. Integrations should use only one of those controls to avoid invalid requests. The available extract identifies additional Claude API features as generally available but omits their names. The practical change in the supplied note is therefore API-parameter hygiene rather than a specified feature launch.

1.4.2

The available release-page extract did not include release notes for ExLlamaV3 1.4.2. It only reports repeated loading errors, so no changes can be reliably summarized. Consult the release page directly for the actual contents.

Using the GitHub Copilot SDK for Java

GitHub presents the Copilot SDK for Java as a framework-agnostic, provider-neutral library for programmatically creating agent sessions, registering tools, sending prompts, and receiving structured responses in server-side Java. It supports direct providers such as OpenAI, Azure, Anthropic, and OpenAI-compatible endpoints through a provider configuration, with the post stating that this route does not require a Copilot subscription. Version 1.0.7-preview.1 is available as a Maven dependency; the example uses Jakarta EE 11, Open Liberty, virtual threads, WebSockets, and an H2-backed real-estate lead pipeline. Tool methods can be declared with experimental @CopilotTool annotations—requiring a compiler flag and annotation processor—or inline through ToolDefinition lambdas.

SQLite compressed text-history prototypes

Willison tested a deliberately simple revision-history scheme: put every previous text version in a JSON array, then compress the entire array with zlib or Zstandard in a SQLite BLOB. In a simulation of 1,000 edits, 20.4 MB of uncompressed revision text shrank to 80.3 KB as a Zstandard-compressed JSON array, benefiting from the repeated material between revisions. The weakness is rewrite cost, because every new edit would otherwise require decompressing and recompressing all history. The suggested mitigation is chunking history into separate rows capped at either 128 revisions or 3 MB of uncompressed JSON.

datasette-auth-tokens 0.4a13

The release updates datasette-auth-tokens for compatibility with sqlite-utils 4. The available post contains no additional release notes, migration guidance, or feature details. Users depending on the package should treat this as a compatibility maintenance release and verify their sqlite-utils version when upgrading.

1.4.1

The release page did not load in the supplied material, so its changes could not be summarized reliably. No release notes or technical details were available beyond the version title.

Claude Code Just Made Subagents Feel Obsolete

Claude Code can now use SendMessage to communicate with other named Claude Code sessions, including Remote Control sessions on other machines, creating a coordinator-and-peer workflow rather than a one-shot subagent handoff. The walkthrough uses separate panes and worktrees to send a production bug to a worker session, request a PR, and receive a completion report; it also shows fanning out skill redesigns, code reviews, and phased implementations. The author argues that persistent, visible peer sessions are easier to inspect and follow up with than subagents that vanish when finished, though setup depends on a terminal/workspace manager such as cmux and, for remote use, Remote Control being enabled. The same messaging socket can bridge tools such as Claude Code and Codex, opening up cross-tool and cross-machine coordination while retaining each session’s local context and permission mode.

v2.1.226

The release page did not provide release notes in the supplied material; it displayed repeated loading errors. No feature or fix details are available to summarize.

v2.1.225

Claude Code 2.1.225 adds gateway spend-limit information to usage warnings and introduces workspace-trust prompts for agents entering untrusted directories. It fixes authentication regressions affecting long-lived OAuth tokens and intermittent macOS MCP OAuth failures, plus several reliability issues in headless sessions, Remote Control resumes, self-hosted runners, web-session reconnects, and VS Code’s Focus view. The release also improves agent coordination: cross-session messages no longer remain silently parked in headless/startup states, and SendMessage can initiate contact with a named Remote Control session on another machine. The Remote Control recipient handling is hardened so a confirmed remote session is not replaced by a local same-named session, while photo attachments are delivered directly to Claude.

Efficient Decode Context Parallelism with vLLM for Long Context Workloads

vLLM describes Decode Context Parallelism (DCP), which shards a request’s KV cache by sequence position rather than by attention head, avoiding cache replication that constrains ordinary tensor parallelism. This particularly helps MLA models, whose effectively single KV head otherwise gets copied to every tensor-parallel GPU. In an 8×B200 test serving Kimi K2.6 NVFP4 on an agentic trace with a roughly 67K-token median input, baseline tensor parallelism ran out of KV space at concurrency 64 and plateaued near 1,863 tokens/s/GPU. DCP reached 6,091 tokens/s/GPU at concurrency 512 while using 82% of KV capacity, showing the main benefit is higher sustainable concurrency for long-context agents on fast interconnects.

GitHub Copilot weekly releases — August 3

GitHub’s weekly update focuses on handling parallel work and maintaining context across the Copilot app, CLI, and VS Code. The app now identifies the model that served completed Auto requests, supports jumping into shared sessions, and offers /side for parallel questions. The CLI adds a sessions sidebar, an experimental /worktree command for isolated workspaces, non-Git /rewind restoration, and live tool-call durations. In VS Code, agents can receive comments attached to selected browser elements, while /btw side chats share the primary conversation’s context and cache; multilingual on-device dictation and editable Markdown diffs also arrive.

Copilot impact dashboard adds a return on investment section

GitHub has added a Potential return on investment section to the Copilot impact dashboard, intended to connect Copilot spend to pull-request output. It compares less deeply adopted chat/completion users with agent-first users in later adoption phases. Administrators can select a salary band and have the cost-derived metrics recalculate against their own compensation assumptions. The feature is positioned as a way to justify investment and identify where enablement could yield more adoption, rather than merely reporting usage.

Copilot code review effort levels are generally available

Copilot code review’s Lite and Balanced effort levels are now generally available across Pro, Pro+, Max, Business, and Enterprise plans. Lite is aimed at routine documentation and small fixes, while Balanced targets larger, security-sensitive, or cross-service changes needing deeper analysis. The preview names Low and Medium automatically carry over as Lite and Balanced, and a per-review choice does not change repository or organization defaults. Organization administrators can set a default, and review timelines and overview comments now label the effort level that actually ran.

Copilot usage metrics API adds agent app activity

GitHub’s Copilot usage metrics API can now break out activity from partner agent apps such as Claude and Codex, rather than leaving all agent usage in one bucket. The optional totalsby3rdpartyagent array appears in enterprise, organization, enterprise-user, and organization-user reports for both one-day and 28-day views. Each recognized agent gets its own entry, enabling teams to see which agents are used, by how many people, and how adoption changes after a rollout. GitHub frames the addition as a basis for licensing and deployment decisions grounded in actual per-agent activity.

GitHub Code Quality no longer adds Copilot as a reviewer

Enabling GitHub Code Quality will no longer automatically create a ruleset that requests Copilot review on pull requests. GitHub says user feedback made clear that choosing whether to add a reviewer should remain with the repository, so it disabled the settings it had added to matching automatically created rulesets. Edited or user-created rulesets are left untouched, and the old ruleset remains available for owners to delete. Copilot review itself and its plan billing are unchanged; teams can explicitly enable automatic review at repository or organization level.

MCP allowlists in enterprise managed settings

Enterprise owners can now centrally allow or deny which Model Context Protocol servers Copilot clients may run, using allowedMcpServers and deniedMcpServers in copilot/managed-settings.json. Matchers can identify a server by remote URL, local command, or name. The policy fails closed on malformed or unverifiable configuration, and a server must satisfy every applicable policy layer. The controls are generally available and enforced in the Copilot app, Copilot CLI, and VS Code, with optional overridability for enterprise teams in server-managed deployments.

Moonlight & Mayhem (Raccoon Heist by Codex + GPT-5.6 Sol Ultra)

Simon Willison gave Codex Desktop running GPT-5.6 Sol Ultra the same one-shot game brief he had previously used with Claude Fable 5. He judges the resulting game, Moonlight & Mayhem, substantially better: it takes place in a museum and requires the player to rescue two raccoon teammates to reach a golden sardine, rather than merely collecting items in a yard. The run took 52 minutes and generated a repository containing the game, textures, prompts, and a full Codex transcript. It also illustrates a persistent visual-QA weakness: despite reviewing screenshots, Codex failed to notice that every raccoon had an enormous eyeball rendered as a floating black sphere.

Your AI Second Brain Is Slowly Rotting (Here's How to Fix It)

The video argues that AI “second brains” decay because append-only memories accumulate stale facts and contradictions across core memory files, daily logs, knowledge graphs, and externally gathered material. In its example, a client’s monthly rate exists as $4,000, $6,000, and $9,500 in different records, causing the agent to retrieve a plausible but outdated answer. The proposed design separates information into immutable, timestamped events and replaceable current state, then audits old material for conflicting state before enforcing that classification during new ingestion. The presenter says a structured workflow is more reliable than simply asking an agent to add dates—an informal dating convention complied or identified staleness only 8% of the time in one test—and recommends human approval before any cleanup changes.

vLLM Reaches 25K Total TPS/GPU on Qwen3.5

vLLM reports more than 25,000 total tokens per second per GPU for Qwen3.5-397B-A17B-NVFP4 on GB200 NVL72, using disaggregated prefill and decode at high concurrency. The key work was a FlashInfer Blackwell GDN prefill kernel, which improved relevant cases by roughly 1.02–5.78×, plus NIXL changes that move both attention cache and GDN/SSM state correctly between workers. Fixing two asynchronous KV-transfer races was essential: before that, accuracy could fall to zero; all five reported configurations instead matched the aggregated run’s 88% GSM8K score. These figures prioritize aggregate throughput at 64–5,120 concurrent requests, so the next optimization target is better per-user generation speed rather than more system-wide TPS.

Issue #56

This roundup argues that when generating software becomes nearly frictionless, the scarce skill is taste: the ability to recognize what is genuinely useful and high quality once effort no longer filters ideas. It notes that stateless MCP v2 can reduce a simple tool interaction from two HTTP requests to one, and frames MCP’s narrower interface as easier to secure than giving an agent a command line, despite unresolved prompt-injection risk. It also highlights Qwen 3.8’s disputed benchmark positioning ahead of Claude 5 and GPT 5.6, alongside Meta’s shift toward API models and an agent-oriented Muse Code harness. The recurring organizational warning is that AI adoption is not merely a tooling decision; management assumptions about how software work happens still matter.

v2.1.224

Claude Code 2.1.224 adds self-hosted runners for Team and Enterprise customers, letting its web, mobile, and desktop sessions run on their own machines or containers. It also adds HTTPS ZIP plugin sources with optional SHA-256 pinning, cross-session agent messaging and discovery on macOS/Linux, and more detailed sandbox credential-masking options including JWT claim masking and AWS SigV4 re-signing. Security and reliability fixes include preventing trailing-slash filesystem deny rules from being bypassed, showing sandbox-denial details to the model, correctly surfacing failed cross-session messages, and isolating long project-path session directories. The release removes the 200-subagent session cap while retaining concurrency and depth limits, and improves Remote Control’s compaction, failure, and stale-session behavior.

How to Cut Your Claude Code Token Costs by 20x

The article argues that prompt-cache behavior, not terse prompting, is the biggest determinant of Claude Code cost. Cached context reads cost roughly $1 per million tokens versus about $20 for a fresh write; at 500,000 tokens, that can turn the next turn from roughly $0.50 into $10 after an hour idle. It says cache resets also follow model or effort changes, fast-mode toggles, MCP connection changes, tool denials, compaction, and Claude Code upgrades. The practical advice is to use /clear when the repository can supply the needed context, /compact before context rot at roughly 600,000-800,000 tokens, and /doctor to remove obsolete CLAUDE.md instructions, skills, and MCPs. For work that does not need the top model, it recommends a planner-executor split: a strong model plans and a cheaper model carries out the work.

1.4.0

The release page did not provide readable release notes in the available material. Its page repeatedly returned a loading error, so the changes in ExLlamaV3 1.4.0 cannot be summarized reliably.

datasette 1.0a38

Datasette 1.0a38 fixes a SQL-injection flaw affecting databases that mix public and private tables under Datasette's permissions system. In the vulnerable configuration, someone allowed to view any public table could use raw SQL injection to get read-only access to private tables in that same database despite an execute-SQL restriction. Administrators using that setup should disable the execute-sql permission on the database until they update. Willison says the mixed public/private configuration is probably uncommon, but the fix also shipped in the 0.65.3 maintenance release.

datasette 0.65.3

Datasette 0.65.3 backports the SQL-injection security fix from 1.0a38. It is the maintenance-release option for users who need the patch without moving to the 1.0 alpha line.

The Hallway Track: Where Does Context Actually Live?

The speakers argue that useful context is not confined to documents and repositories: it also exists in informal conversations and knowledge people carry in their heads. They describe a safer background agent as one whose access and context are deliberately constrained, even if the infrastructure can connect it to many systems. The proposed goal is for an agent to identify what additional documents or information it needs for a task, then ask for that access rather than receiving everything by default. Their point is that “context” is changing from a static bundle supplied by a person into something an agent may help discover under controls.

How Ramp engineers work with AI agents at every step

Ramp describes using agents across the engineering lifecycle, from debugging and incident analysis to coding, code review, CI optimization, experiments, and post-deployment checks. In one case, an agent ran in shadow on a verifiable CI task and then reduced median CI time from about 18 minutes to 6 minutes by profiling, making changes, waiting for production data, and repeating the loop; the team says much of the resulting code was merged. The company distinguishes routines for repeatable work such as rebasing PRs, fixing CI, or deleting dead code from dynamic workflows for open-ended system optimization, and it gives agents least-privilege access such as read-only service keys. Ramp's “Inspect” agent can work through GitHub, Linear, Slack, Datadog, Sentry, and support systems, while an on-call assistant generates root-cause analyses and proposed fixes; the stated operating principle is to give models enough tools and context to act without giving them unnecessary authority.

A guide to slash commands in the GitHub Copilot app

GitHub's Copilot app uses slash commands as in-chat shortcuts for session, project, and agent-workflow management; typing / opens an autocomplete menu. Unlike the CLI, the desktop app manages working directories and file context visually, so its commands emphasize multi-session workflows rather than terminal setup. /plan turns a request into a scoped plan, /spar challenges assumptions and tradeoffs, and /autopilot hands implementation to the agent after a goal is supplied. /rubber-duck uses a different model for an independent review, aimed at catching blind spots in plans, refactors, architecture decisions, and migrations.

How To Make Claude Code Tokens 20x CHEAPER (& 4 More Usage Hacks)

The video argues that prompt caching is the most consequential lever for reducing Claude Code usage costs, more important than terse instructions such as “be brief.” It explains that input and output tokens accumulate in the context window across follow-up turns, so a short new request can still require the model to process the prior conversation; output tokens are described as roughly five times the price of input tokens. Its practical premise is that developers should understand caching and context behavior before trying to control spend with superficial prompt edits.

We Scored a Real Snyk Skill Against Anthropic's Rules

A Tessl review scored Snyk’s API-target configuration skill at 87/100 against Anthropic-style best practices, praising its routing, sibling-skill disambiguation, duplicate-target warning, and authentication examples. The main criticism was density: detailed authentication material sat inline in one SKILL.md instead of being progressively disclosed through references. Applying the automated fix moved authentication content into a reference file and raised the score to 90, while the discussion recommends reviewing both quality and security of internally shared or third-party skills.

The Creator of Claude Code Said to Do What Now?!

The video unpacks Claude Code creator Boris Cherny’s provocative advice to periodically delete an AI layer of global rules, skills, and hooks to see what a stronger model can do unaided. It argues that the quote is often read too literally: the useful lesson is to re-evaluate accumulated scaffolding as model capabilities change, rather than reflexively preserving or deleting everything. The presenter frames the decision as an actionable audit of which guidance still earns its complexity and which parts remain valuable for reliability and workflow.

New Skills! v1.2 brings /wait-what, /writing-for-agents, and fixes /grill-me

Version 1.2.0 of Matt Pocock’s engineering-skills project adds new skills and improvements, backed by a documentation site at aihero.dev/skills. The site organizes a workflow from documentation review through specification, tickets, implementation, and code review, and links skills to an AI-coding glossary and common questions. The project, reported at about 24,000 GitHub stars, is now available through the Claude Code plugin marketplace with read-only installation and automatic updates; the release also addresses use by Codex users.

AI Slop Is Costing You Hours. Here's How To Stop Sending It.

The video argues that low-effort AI-generated prose creates a substantial hidden cost for recipients: time spent parsing verbosity, plausible nonsense, and muddled thinking. Its central case is for authorship as an obligation to readers—people should wrestle with ideas and edits instead of treating model output as a finished communication. The presenter connects this to a technical limitation of generation and urges writers to use AI without outsourcing the responsibility for clarity and judgment.

Claude Platform release notes — August 5, 2026

Claude Enterprise organizations can now use beta inference hooks to send governed prompts from claude.ai, Cowork, and Claude Code to an organization’s AI-security server before inference. That server returns an allow-or-deny decision; requests are signed, failure handling can be configured, and denials are logged in the compliance Activity Feed. The feature moves centralized policy enforcement into the inference path rather than relying solely on post hoc auditing.

v2.1.223

Claude Code v2.1.223 adds organization-wide marketplace allow/block wildcards, warnings when restricted subagent models fall back to the parent model, and a cloud-session hint for /teleport. It closes several security gaps, including a crafted Bash-command permission bypass, invisible-character evasion in approval prompts, workflow dynamic imports escaping the sandbox, and an agent-definition policy gap. The release also improves model/context-window enforcement, managed settings merging, Linux sandbox startup, resumed-agent stability, and makes /review an alias for /code-review.

New release of LLM adds support for reasoning traces, OpenAI Responses, server-side tools, and smarter logging

LLM 0.32 exposes reasoning traces on standard error by default, keeping normal output clean for pipes; -R hides them when needed. It adds server-side provider tools, an OpenAI-compatible endpoint command for one-off calls, structured mixed streaming events, and a lower-level model.prompt(messages=[]) API. Its new Git-like content-addressable message store reduces duplicated conversation JSON while preserving readable log output. The release also adds pause-and-resume support for human-approved tool chains, moving the CLI and Python library closer to an agent framework.

llm-anthropic 0.26

The Anthropic plugin now supports Claude Fable 5, Sonnet 5, and Opus 5 through LLM 0.32. Server-side WebSearch, WebFetch, CodeExecution, and AnthropicMCP tools replace the older websearch options and are invoked through LLM's -T interface or Python tools argument. Reasoning, tool calls, and results now arrive as typed streaming events. Thinking configuration is simplified to thinking and a five-level thinkingeffort; Claude 5 models think by default, while Fable 5 cannot have thinking disabled.

llm 0.32

This release post points readers to the detailed LLM 0.32 announcement, which introduces visible reasoning traces, server-side tools, OpenAI Responses support, and redesigned logging. The update changes LLM from a string-only streaming abstraction to typed events that can represent reasoning, text, tool calls, tool results, and images. It also adds support for GPT-5.6 models and makes GPT-5.6 Luna the default for llm prompt. Plugin authors need to upgrade to participate fully in the new event system.

condense-json 1.1

condense-json 1.1 expands its replacement mechanism beyond strings, allowing structural replacements with other value types during condensation and restoration. It can also detect closely matching objects and store merge instructions for keys that should be updated or removed. The companion uncondensejson() function applies those merge operations on reconstruction. New Hypothesis property-based tests check that the format round-trips correctly.

Buzz Just Fixed AI Agents... But It Has A Serious Flaw

The video reviews Buzz, Jack Dorsey's free, open-source group-chat application for coordinating multiple AI agents, which reportedly gained more than 20,000 GitHub stars in two weeks. The presenter tested a Claude agent and a GPT agent working together and compares the product with terminal-based agent teams and tools such as Hermes and OpenClaw. Buzz's accessible shared-chat interface solves the problem of letting a team see agents coordinate rather than hiding that work in a terminal. But the review says its failures occurred in areas that are supposed to be its core strengths, so it urges caution despite praising parts of the early product.

This Is Where AI Coding Goes Next

The video argues that the next important layer in agentic coding is reliable end-to-end verification environments, where agents can spin up an app, test user flows, and check their own work. It points to GPT-5.6 Luna Extra High reaching 78% on a 106-task browser-use benchmark for about $14 total, roughly 14 cents per task, while being presented as only two percentage points behind Opus 5 at 17 times lower cost. That pricing makes routine autonomous regression checks more plausible for new product flows. The presenter stresses that verification loops, rather than raw code generation alone, are what let agents detect and correct their own failures.

How auto mode works with Claude Code

Claude Code's Auto Mode responds to approval fatigue: Anthropic says 97% of permission prompts are approved. Instead of having Claude approve itself, a separate classifier sees the user's request and proposed tool actions, but not Claude's reasoning, responses, or tool output, and checks whether an action fits the stated intent. A server-side probe scans incoming webpages and files for prompt-injection attempts, while the classifier focuses on external, destructive, or hard-to-reverse actions; read-only and recoverable work generally bypasses it. Anthropic recommends configuring internal infrastructure in the environment field, using deny or ask rules for firm boundaries, and rolling out narrowly, with human review still required for production changes.

v2.1.222

Claude Code v2.1.222 fixes a worktree-isolation flaw that could let isolated sessions and subagents run destructive Git commands against the main checkout; isolation now covers edits and Bash across session types. It also closes a route by which PreToolUse auto-allow hooks could bypass tool restrictions in background agent tasks. The release improves Auto Mode safety by sending inter-agent SendMessage calls through the permission classifier before dispatch. Other fixes cover proxy-aware startup checks, erroneous completed-response failures, MCP usage attribution, PR linking, custom gateway timeouts, connector authorization, and several accessibility and stability issues.

How the GitHub legal team used Copilot CLI to streamline their workflows

GitHub's legal team describes building internal tools with Copilot CLI by encoding legal methods, reference materials, templates, and workflow rules in repositories and readable plain-language files. One product counsel built a contract-drafting system that stores approved examples and a plain-language style guide in an access-controlled environment, cutting review and drafting time by roughly half. Another lawyer began with DMCA triage instructions and grew them into a desktop application for contract review, NDAs, risk assessment, compliance, and response drafting. Both accounts stress that these systems support legal judgment rather than replace it, with humans retaining review of the results.

Inside our 353,000-person vibe coding course

Google and Kaggle say 353,000 people registered for their five-day "AI Agents: Intensive Vibe Coding" course on building and deploying agents through natural language. The course covered design, security, and cloud deployment through expert sessions, notebooks, whitepapers, codelabs, and capstone work. More than 392,000 active Discord participants collaborated, and more than 12,000 active capstone participants submitted over 6,000 projects, including historical-transcription and space-weather systems. The full materials remain available as a self-paced Kaggle Learn guide.

Impeccable 4.0: The Best Claude Code Design Skill

Impeccable 4.0 is presented as an open-source Claude Code skill for detecting and avoiding 64 common AI-design and production-pattern failures. The release's main additions are Live mode, which lets users select components in a local browser view and request targeted variations, and Worlds, which offers 177 design directions rather than one generic starting point. With the Higgsfield MCP connected, Worlds can render those aesthetics against the user's actual site before a choice is made. The article's practical advice is to use Live mode for component-level adjustments, the terminal and visual references for larger changes, and the built-in Finish Reviewer as a final independent quality check.

What my agent knows about me

Ben tried a "reflection engine" — essentially one very large prompt file you upload to an agent with the instruction to evaluate it and complete all tasks — and had it comb through his therapy transcripts and accumulated memory files to produce a personal report. He ran it on both Fable High and Sol Max; Sol's output was more coherent and better at drawing connections, while Fable's was harder to read, and he found the result telling enough that he followed it with a 40+ question grill-me session to build a plan. The rest of the issue is a pricing story: OpenAI cut GPT-5.6 Luna by 80% and Terra by 20%, putting Luna at max thinking effort roughly at the level of GPT-5.4 xhigh — the best model available four months ago — for 8% of the cost, or 10-12x more work per dollar. His caveat from practice is that Luna Max is good for chat, research and file work but he had to bring in Sol High to clean up a Chrome extension it botched. Also flagged: OpenAI teased a new model, Astra, alongside solutions to 10 long-standing problems in maths and theoretical computer science, and DeepSeek V4 Flash at $0.14/$0.28 per million tokens with a 1M context undercuts Luna outright.

Datadog Deleted All Its AI Context. It Worked.

A Datadog director running developer-tooling for ~4,000 engineers describes going from a 200-person Cursor pilot to org-wide agent adoption, now supported by roughly 12 people across two teams (one on signals/cost/evals, one on flows). The standout finding: the front-end team suspected their repo's steering context — written back in the Sonnet 3.5 era — had gone stale, deleted the entire thing, and evals improved substantially, because much of it was retraining models on things now in their training set (an entire paragraph on how to use yarn). His argument is that context rots and that loss aversion keeps teams from deleting it, so you need eval data to make removal politically possible; his eval platform is custom Go with sandboxing, runs nightly, and was seeded by replaying PRs that historically caused incidents with an agent judge checking whether the review caught the failure. He expects developers will never write evals themselves — instead they plan to mine real agent trajectories and have an agent synthesize eval scenarios from recurring interaction patterns. On open weights, his read is that open models would need to be ~50% better than today to fully replace frontier models on their work, but they're already fine for the deterministic slice (lint/format fixes, background nudges) where creativity isn't needed.

The #1 Claude Code Design Skill Just Got a HUGE Upgrade

A walkthrough of Impeccable 4.0, positioned by the host — who says he's tested hundreds of design skills and plugins — as the best available tool for getting Claude Code to produce front-end work that doesn't look like generic AI output, while keeping the user in control. The two headline changes since the 2.x releases are live mode, which was alpha-stage before and is now much smoother and snappier, letting you iterate visually outside the terminal instead of guessing from a text loop; and "worlds," of which the release adds 177 high-rated ones. The framing is a continuation of an earlier video on injecting personal taste into the design process to avoid AI slop, with this one narrowing to Impeccable specifically as a tool. The transcript is truncated before the deeper walkthrough of how worlds are used in practice.

Reducing Entropy in Agentic Software

Jacob Young, who does technical due diligence on software teams, says best practices haven't settled, so he doesn't grade teams on tool choice — he looks for convergence: whether developers and their agents keep moving toward the same grounded idea of what the software should be. His central worry is that coding agents increase entropy, quickly turning a cohesive codebase into duplicated logic, inconsistent abstractions and many ways to do one thing; the fix is codifying what "good" looks like as standards, existing abstractions to reuse, linters, LSPs, hooks and tests that give feedback during development rather than at a giant PR. He flags documentation as a recurring failure mode — architecture and API docs drift stale within weeks unless code stays the source of truth and something regenerates them — and argues agents can apply codified OWASP practices but can't be trusted to pick cryptographic parameters. Language choice becomes a lever: Go's conventions, standard library and small dependency surface suit agents well, while Rust's type system is powerful but underused by models. His advice for juniors is blunt: still write code by hand and use models as tutors generating quizzes and problem sets, because agents amplify existing judgment and multiply bad patterns for those without production experience.

Customize the reasoning level for Copilot cloud agent

GitHub now lets you set a reasoning level when delegating a task to the Copilot cloud agent, for models that support it. You pick the level alongside the model at task start and the agent uses it for that entire run. The tradeoff is stated plainly: a higher level can improve answers on complex problems but consumes more tokens and therefore more credits, so it's a per-task cost decision rather than a global setting. It's available on all paid plans that include the cloud agent — Pro, Pro+, Business, Enterprise and Max.

Trigger Copilot automations with comments

Copilot cloud agent automations can now be triggered by the creation of an issue or pull request comment, with the triggering comment text specified when you configure the automation. GitHub's suggested uses are generating or updating documentation from code changes, investigating stack traces or error logs on an issue, and auto-creating follow-up issues for refactoring or technical debt from a PR comment. Setup lives under the repository's Agents tab, in the Automations sidebar. Automations are open to Copilot Pro, Pro+, Max, Business and Enterprise users, though Business and Enterprise require an administrator to enable the cloud agent policy first.

No Meat Proxy

A short manifesto against a specific behavior: being asked a question by a person who trusts your judgment, then pasting an AI's answer back at them unchanged. The argument is that AI output tends to be long-winded, over-complicated and full of detail nobody asked for, so relaying it verbatim shifts work onto the person who came to you rather than doing the job they actually wanted done — leaving you as nothing but a middleman. The second half extends this to authorship: even if AI did most of the work, your name on it makes it your work, and you carry the responsibility to understand, verify and own it. The closing instruction is to answer people like a person and be someone others can rely on.

Show HN: Hacker News with AI stories filtered out

A reader front-end for Hacker News that lets you strip AI stories out of the feed entirely, pitched as a way to follow stories, filter noise, and keep up with discussions. The ai=exclude query parameter is the whole point of the demo — the frontpage view rendered without the category that now dominates it. Beyond the filtering, it presents itself as a general-purpose alternative HN client rather than a single-purpose gag. It is a small artifact with a large implied argument about feed fatigue.

Don't be a meat proxy

Willison amplifies Niklas Gruhn's term "meat proxy" for people who blindly copy and paste AI output to their peers. The prescription is not to stop using models but to stop relaying them: read the output, understand it, validate it, and then write the response in your own words. Writing it yourself functions as a certificate that you actually did the prior steps. The value you add is the verification effort, not the generation.

Quoting David Crawshaw's prompt

A one-line operational recipe: a nightly cron job that runs the prompt "fetch upstream changes to the <software> and rebase all local changes on top of upstream. Check that the software works as intended and replace the current version." It turns maintaining a personal fork of a tool — historically an ongoing tax that discouraged forking at all — into an unattended background job. The prompt is the practical companion to the open-source devtools argument it was published alongside.

Devtools must be open source (exe.dev)

Willison's HN comment argues LLMs have restored the original open-source promise. The freedom to read and modify your tools was always nominal for most people, even expert programmers, because nobody could justify the time to read the code of software they use daily. Now he prompts Claude several times a day to "Clone x/y from GitHub and tell me how Z works," and treats getting an unfamiliar project to compile as a zero-time-investment challenge — hand it to Codex or Claude Code and check back in ten minutes. He isn't habitually patching his own tools yet, but says he can now see a path there that didn't exist a year ago.

AMD Helios Architecture Deep Dive: The Power of AMD’s Hardware Combined

Helios is AMD's first true rackscale system, combining EPYC 9006 "Venice" CPUs, Instinct MI455X GPUs, and Pensando NICs/DPUs with ZT Systems engineering — the payoff of the 2022 Pensando acquisition four years later. The shipping specs landed remarkably close to the projections AMD made a year ago: 72 GPUs delivering 2.9 EFLOPS of peak MXFP4 compute, 432GB of HBM4 per GPU for 31TB of HBM4 across the rack. The notable overshoot is memory bandwidth, about 21% higher per GPU than originally planned, for 1.7PB/second cumulatively — meaningful because bandwidth is a primary bottleneck in inference. Networking provides 260TB/second of scale-up bandwidth inside a rack and 43TB/second scale-out between racks.

The Hallway Track: Would You Trust an Agent to Send Your Email?

Conference attendees are asked whether they'd let an agent send email on their behalf, sight unseen, and the answer is a consistent no. One builder describes an app that reads all his mail but is deliberately given no send capability — it only writes drafts, and he validates every message that leaves his outbox. The line he draws is where output starts shaping someone's opinion of you outside your organization, and where the action is non-reversible. The other thread in the conversation is observability: with so much data flowing through agent harnesses, participants want eval metrics that actually catch hallucination rather than trust by default.

v2.1.221

A large Claude Code release. New: a VSCode Focus view that hides tool activity behind an expandable per-turn summary (Ctrl+Alt+F), and a "mask" mode for sandbox credential files on Linux and WSL where sandboxed commands read a sentinel copy while the proxy substitutes the real secret on egress — on macOS masking falls back to deny. Security fixes include a Bash permission-check bypass where zsh could execute hidden commands inside [[ ]] regex conditionals, and PowerShell permission checks mishandling quoted paths on Windows. Behavior changes: background sessions now commit and push to preserve work and only open a draft PR when warranted, /fork creates its own worktree instead of sharing the original checkout, and plugins installed via /plugin activate immediately when safe. Also fixed: MCP servers from --mcp-config not connecting before the first turn in print mode, which made the model emit tool calls as literal text.

The Inference Engineering Masterclass — Philip Kiely & Ali Taha, Baseten

Baseten, fresh off a $13B round, argues inference has become its own engineering discipline in three years: the question is no longer how to train weights but how to turn them into something fast, reliable, and affordable at scale. The most counterintuitive finding is that in a GLM-5.2 experiment, quantizing more of the model preserved benchmark quality while adding 20% throughput, because errors introduced in different layers canceled each other out. They cover cache-aware routing, disaggregated prefill and decode on separate GPUs, speculative decoding, and grafting Kimi's vision encoder onto GLM-5.2 without touching the underlying language model — plus why identical weights behave differently across clusters. The wider discussion hits the quadratic attention bottleneck blocking long-form video, why local AI is about making models less dumb while data-center AI is about making them less slow, and the loop where GLM-5.2 helped optimize the kernels serving GLM-5.2.

Show HN: Nightcrawler – A local AI pentesting agent running on a smartphone

Nightcrawler is an autonomous penetration-testing agent that runs entirely on an Android phone with no cloud connectivity — you drop the handset on a network and it discovers hosts, maps services, finds vulnerabilities, and writes a pentest report on its own. Decision-making comes from a 1.2B-parameter local model (LFM2.5-1.2B-Instruct-Heretic) doing inference via OpenCL on an Adreno 650 GPU, with a GPU governor daemon that forces max performance because Android throttles by ~6x on battery, auto-backing-off below 15% charge. The design deliberately trades speed for stealth: instead of blasting every host at once like a conventional scanner, it rotates across hosts one small action per turn and accumulates knowledge over hours, and its dashboard on port 8888 spoofs nginx headers and returns empty 404s to the target network. The author is candid that the small model only gets roughly a 50% command success rate, compensated by retry logic and dynamic scope detection that reads the subnet from wlan0 so no config changes are needed between networks. Results are reported from 72+ hours of autonomous operation, with a strong caveat that written Rules of Engagement are legally required before deployment.

Show HN: Sprocket – The Best AI Agent for Hardware and Software Development

Sprocket pitches itself as a platform for developing both hardware and software with an AI agent, shipped as a browser app, a CLI, and an Electron desktop build that trades extra RAM for a native shell. The published material is essentially installation and operations documentation rather than a technical argument: you install from GitHub Release artifacts or run sprocket serve, pass a directory to open or reconnect a workspace in a new thread, and the tool persists attached workspaces and local server sessions in $HOME/.sprocket (overridable via SPROCKETDATADIR). The development path runs Vite on localhost:5173 against a Rust API on 127.0.0.1:7731, with Convex used as the backend deployment and AuthKit for auth — model provider API keys are configured per-provider on the Convex deployment, implying a bring-your-own-key, multi-model design. Nothing in the available text substantiates the "hardware" half of the claim with specifics such as CAD, EDA, or firmware integrations, so the differentiator versus existing coding agents is not yet evidenced.

Agents Write 95% of Our Code. Here's the Catch

Amy Heineike of Tessl reports that 95% of their code went through their internal "software factory" this week (over 90% for the month), with roughly 600 PRs closed in a week at a small company — and that the catch is quality, not throughput: the same industry data showing AI adoption soaring also shows bugs and incidents jumping. Her benchmark over a thousand open-source skills found that agents complete tasks at high rates but follow only ~70% of a skill's individual instructions on average, even for the best models, meaning labs have over-rotated on task completion and under-rotated on steerability; a well-written skill also lets a much cheaper, smaller model hit the same success rate, which matters because the cost/intelligence frontier spans 100x on a log scale (Fable 5 is ~10x the cost of GPT-5.6 medium reasoning). Her prescription is the "harness engineer": name your invariants explicitly and enforce them via skills, ast-grep-style deterministic linters, narrow per-file "verifiers", and agentic code review — because models that got better at coding also got better at judging against clear criteria. The second pillar is analytics — mine agent logs, repeated PR comments, complexity analysis, and mutation testing to find where agents waste time (they rewrote a CLI wrapper for Linear's API because agents kept getting confused by it) — and the third is a risk ladder where research code auto-merges freely, internal tooling auto-merges unreviewed by the hundreds, and high-leverage code demands a human. On the failure modes she is blunt: agents often never read skills at all (a description problem — write it as an advertisement, but not so exciting it fires when unwanted), overly prescriptive or mutually contradictory skills cause agents to give up, and code-review agents should be prompted to consider findings rather than fix all of them, so nothing in the loop is treated as authoritative.

My Super Simple Software Factory (For Agentic Engineers)

IndyDevDan's thesis is that software factories are misunderstood and are useful for exactly one reason: leverage on your prompt — and the leverage you get scales with how much you invest in the factory, from chaining a few agents with light config at the low end to a system of agents plus code that operates without you, sometimes better than you would. He builds around three design principles: observable, customizable, and reusable. Observability is the one he insists is non-negotiable — if you can't measure your agents you can't improve them — and his implementation lets you click into any AI developer workflow and see exactly what happened in a swim-lane view. The customization payoff is heterogeneous model routing: Kimi K3, Gemini 3.6 Flash, GPT-5.6 Terra and GPT-5.6 Luna all coexist at different performance/speed/cost tradeoff points, with the factory orchestrating across them. The recurring slogan is "agents plus code beats agents alone" — deterministic code around the agents is what converts a vibe-coding session into a system, and he explicitly disclaims the video for anyone mindlessly generating slop.

condense-json 1.0

Simon Willison shipped 1.0 of condense-json, a year-and-a-half-old Python library, as part of a deliberate push to be braver about declaring things stable — the release is sensible non-disruptive fixes plus a version bump, not a rewrite. The library takes a JSON document plus a replacements mapping (e.g. {"1": "with foxes in it"}) and rewrites every matching string or substring into a compact {"$r": [...]} form referencing the key, with uncondensejson() reversing the transform losslessly. The point is deduplication: when JSON repeats data that already lives in a related structure, you store the reference instead of the text. Willison uses it to shrink the SQLite logs generated by his LLM tool, with PR #1586 tracking the latest integration.

Why we write our own C and C++ inference engines

LocalAI explains that while most of its backends wrap upstream engines (llama.cpp, vLLM, whisper.cpp, MLX), eighteen are from-scratch C/C++ ports written because wrapping would have meant shipping a multi-gigabyte Python install, a CUDA-only stack, or nothing at all. The headline number is vllm.cpp: a 9.1 GiB vLLM virtualenv becomes a 66 MiB binary, with token-for-token identical output and throughput within noise across concurrency 2–32 (only single-stream shows a clear 4.5% lead), plus lower peak host memory (24.88 vs 28.18 GiB). Their speed wins mostly come not from better kernels but from host-side overhead a Python reference never bothered to optimize — caching two positional embeddings cut ~95 ms per forward in depth-anything.cpp; caching a redundant LSTM pass removed 97% of transducer decode time in parakeet.cpp. Some ports (face-detect.cpp, voice-detect.cpp) are actually slower than onnxruntime on CPU and shipped anyway, because exact parity — embedding cosine 1.000000 — is what makes a biometric backend a drop-in rather than a migration. The costs are real: per-repo CI, benchmark suites, GGUF converters, and ggml's generic CUDA kernels trailing tuned cuDNN on conv-heavy models.

GPT2-BASIC: Portable Machine Intelligence in BASIC

GPT2-BASIC is a fixed-point transformer runtime written in BASIC that compiles under DOS FreeBASIC and actually runs GPT-style inference with integer arithmetic on 486-class hardware — loading local weights, tokenizer, and indexed knowledge files from disk, with no cloud, GPU, Python, or modern OS in the loop. The default checkpoint is deliberately tiny: 2 layers, 48 dimensions, 4 heads, 192 context, 463,168 parameters in Q20.12 fixed point, scoring 10/10 (avg 0.969) on its DOS prompt suite, in a 309,760-byte GPT2.EXE. The interesting engineering is the memory/speed tradeoff curve across build variants: a 2,048-token output-head shortlist raises throughput to 3.35 tok/s versus 2.41 baseline on a QEMU 486DX2/66; a q4 token-embedding/head build cuts runtime memory from 2,055,940 to 974,724 bytes at 2.12 tok/s; and a streaming variant drops to 616,324 bytes but only 0.81 tok/s. The author is explicit that this is not a frontier LLM squeezed into a 486 — the claim is that inference is a portable algorithm, and that hardware-specific speed numbers remain QEMU evidence until real board logs land.

Using the Gini Coefficient to Plan Edge Capacity

Fastly's production capacity model rests on the Gini coefficient — normally an economics inequality metric — applied to the distribution of traffic across customer workloads at a POP. The author first tried the full modern toolbox (AutoML, neural nets, tree models, ensembles, time-series specialists, even LLMs) and found they all learned ordinary traffic well but failed precisely on the rare, concentrated events that capacity planning exists to survive, like a major game release or a failover from another provider. The insight is that popularity is a form of inequality, and caching at every layer is implicitly tuned for it, so traffic concentration predicts front-end cache hit ratio — which in turn drives CPU efficiency and therefore POP headroom. A square-root rescaling of the Gini value was needed because the first signs of concentration matter a lot while additional inequality has diminishing returns; the coefficients come from robust regression over recent history, with adjustments for structurally uncacheable customers. The resulting model is small, interpretable, fast enough for interactive counterfactual scenarios, and has been in production over a year.

Unlimited-OCR: One-shot Long-horizon OCR

Baidu's Unlimited-OCR is released with inference paths for both HuggingFace transformers on NVIDIA GPUs (tested on Python 3.12.3 with CUDA 12.9) and vLLM, with an official recipe published at recipes.vllm.ai. The repository documents a uv-managed virtualenv setup that installs a local SGLang wheel, pins kernels==0.9.0, and adds PyMuPDF for PDF-to-image conversion, plus platform-specific Docker images. Serving is via an OpenAI-compatible streaming API, and an included infer.py starts the SGLang server automatically to run concurrent batch requests over an image directory or PDF, with documented post-processing for OmniDocBench evaluation. The authors credit Deepseek-OCR, Deepseek-OCR-2, and PaddleOCR as the models and ideas they built on.

Somebody else decided what good looks like, and it shipped with the skill you installed. Here's the guide to fix it.

Nate argues that installing an agent skill proves nothing: what you actually imported was someone else's decisions about which tools to use, which shortcuts are acceptable, and what "done" means. He learned this with a recommended design skill that kept producing the same terracotta-and-maroon landing pages he was trying to escape — the skill ran exactly as written, just to someone else's taste. His sharper technical point is that both Codex and Claude Code cap how much of your skill list the model ever sees and silently trim it past that line, so a 25-skill library averages out conflicting instructions and yields duller work than five skills did. The remedy is a seven-step "one-job test": name the job, run one real task through the skill, and end with keep, fork, or delete, recorded in nine lines of evidence you can re-check months later. The trap he names explicitly is adding a skill to fix bad output — that is the loop that produced the bad output.

datasette-apps 0.2a0

This alpha release adds two tools aimed at making Datasette Apps easier for the Datasette Agent to build and edit. applist() lets the agent enumerate the apps the user has permission to edit; appdebug() lets the agent open an app invisibly and run JavaScript against it. The debug trick is the interesting part: the app is rendered in an opacity: 0 iframe with pointer-events: none, so it can't be seen or clicked, and agent-supplied JavaScript executes inside that sandbox. That gives the agent a real smoke test — it can confirm the app works and even measure element dimensions — built on the context.browsertask() mechanism introduced in datasette-agent 0.4a0.

I Stopped Installing Claude Skills. Here's What I Do Instead.

Nate B Jones opens with the observation that most people don't realize their Claude, ChatGPT, or Codex already ships with skills, let alone what those skills do to their output. He defines a skill plainly — a set of instructions the model pulls in at a particular moment to get a job done, a recipe rather than an app — and stresses that the app mental model is exactly what misleads people. Skills come with no guarantee of behavior, and the deeper you go the messier it gets. His main warning is against treating GitHub skill repos like Pokémon cards: grabbing bundles of promised skills from untrusted sources and stuffing them into your agent typically doesn't work, both because the source isn't verified and because the collection itself degrades results.

llm-mcp-client 0.1a0

Simon Willison released a new plugin that exposes tools from MCP servers as native LLM tools, letting the llm CLI consume any Model Context Protocol server's tool surface directly. It's an early alpha (0.1a0), so expect rough edges, but the bridge is the point: MCP has become the de facto tool-description protocol and this removes the need to write bespoke adapters per server. The linked post itself is a short "beat" note with minimal prose beyond the release announcement and a sponsorship pitch.

datasette-agent 0.4a0

The 0.4a0 release of datasette-agent adds an await context.browsertask() mechanism that lets agent tools execute code directly in the user's browser rather than only on the server. Willison flags this as the exciting part: Datasette Agent plugins can now ship tools that run custom JavaScript client-side, opening the door to DOM manipulation, local rendering, and interactions that need the user's session or viewport. It effectively extends the agent's action space from the server process into the page the user is looking at.

PCIe Gen6 and Gen5 Will Both Matter for AI Storage

ServeTheHome argues the second half of 2026 begins the PCIe Gen6 server transition — the first major generational shift since EPYC Genoa brought Gen5 in 2022 — but that Gen5 storage stays relevant because supply constraints and budgets force a performance/cost balance. The scale numbers are the argument: Gen6 x16 enables 800Gbps of network bandwidth from a single slot, roughly the throughput of 32 PCIe Gen3 NVMe SSDs, and modern servers carry 8–10 such links, so each GPU can pull from network storage at 800Gbps–1.2Tbps. Doubling per-lane rate also lets architects bifurcate to x2 links to fit more devices at Gen5-equivalent speed, or concentrate bandwidth for higher per-device throughput. The driver is inference rather than training: KV cache tiers spanning machine boundaries, and architectures like NVIDIA CMX that move context out of expensive on-accelerator HBM. Silicon Motion's SM8466 Gen6 x4 controller is the showcase part at >28GB/s sequential and >7M random IOPS — about twice its Gen5 SM8366 — with SR-IOV, Multi-PF isolation, and NVMe 2.0 Flexible Data Placement; the post is sponsored and no SM8466 SSD has been tested yet.

1.3.0

ExLlamaV3's v1.3.0 release adds preliminary support for the DeepseekV3 architecture, validated against JoyAI-LLM-Flash and Moonlight-16B-A3B, though routing groups are not yet implemented. Memory handling gets a second-tier CPU K/V cache plus smarter page and checkpoint eviction policies, which matters for long-context local inference on constrained VRAM. The release also fixes a bug where frequency and repetition penalties caused slowdowns on long contexts, and adds the XTC sampler and token bans. Security-wise, it mitigates latent vulnerabilities in the Safetensors loader — worth taking if you load community checkpoints.

Stateless MCP has recaptured my interest (and inspired mcp-explorer and datasette-mcp)

Willison reports renewed enthusiasm for stateless Model Context Protocol servers, which he says prompted him to build two new projects: mcp-explorer and datasette-mcp. The framing suggests stateless MCP removes much of the session-management overhead that made earlier MCP work awkward, making servers easier to deploy and inspect. The full article body was not captured in this collection, so the implementation details and code examples are not available here.

smevals - a small eval suite for evaluating models, prompts, and harnesses

Willison highlights smevals, a small evaluation suite from Jesse Vincent designed to test not just models but also prompts and the surrounding harness — the three variables that jointly determine agent behavior. The framing matches a recurring theme in his writing that harness quality is frequently mistaken for model quality. The full article body was not captured in this collection, so the suite's specific tasks and scoring approach are not available here.

Claude Code Creator's Greatest Tip For Using AI Agents

The video summarizes an interview with Boris Cherny, creator of Claude Code, whose central claim is that people are still using frontier models the way they used Sonnet 3.5 — carrying "dead weight" into Claude without realizing it. His headline recommendation is to delete your setup every time a new model ships: Anthropic itself removed roughly 80 percent of Claude Code's system prompt when Opus 5 launched. The reasoning is that your setup — CLAUDE.md, skills, hooks — is injected into the context window at launch and stays there for the whole session, so accumulated steering built for a weaker model becomes a persistent tax on a stronger one. The presenters, who run a software company, say they've adopted the approach themselves, and also cover the usage command for tracking how much of your five-hour window you've burned and where it went.

Autoscaling endpoints for LLM inference

Together AI's post on autoscaling endpoints for LLM inference. The article body was not captured in this collection, so the scaling mechanics, latency behavior, and pricing details are not available here.

Show HN: What should the GUI for AI agents look like?

Akilan and Miguel pitch MarbleOS as an attempt to do for AI agents what Xerox PARC, the 1984 Macintosh, and NeXTSTEP did for the command line: make invisible capabilities visible. Their argument is that today's agent interfaces are still effectively terminals — Claude Cowork's /skill-name [param1] [param2] just swaps shell flags for tools, skills, and context, and still requires the user to recall what exists and how to invoke it. Marble instead treats AI as a workspace: each delegated task becomes a card, multiple jobs run side by side, files and finished artifacts are visible at once, and the expected tool calls are shown before a task runs. The stated payoff is that output should be a directly usable spreadsheet or PowerPoint rather than something buried in a chat transcript, and the founders report that when capabilities are made visible, users delegate work they'd never have thought to ask for in a chat box. A downloadable beta is on the site; the HN thread sits at 77 points and 47 comments.

b10205

This llama.cpp build lands a ggml-zendnn change adding a group matmul direct API for mulmatid (#25918), the fused-expert matmul path used by MoE models on AMD's ZenDNN CPU backend. It also scales the MULMATID fallback threshold by expert count, so the decision to drop back to the generic kernel now adapts to how many experts a model routes through rather than using a fixed cutoff. The practical effect is better CPU-side throughput for mixture-of-experts models on Zen hardware. Binaries ship as usual across macOS/iOS, Linux (CPU, Vulkan, ROCm 7.2, OpenVINO, SYCL FP32/FP16), Android, Windows (CUDA 12/13, Vulkan, HIP, OpenCL Adreno) and openEuler Ascend targets.

b10204

A small but targeted SYCL fix: this build adds support for device-to-device memcpy via DEV2DEVMEMCPYFORWARD (#26234), co-authored by Intel's Neo Zhang Jianyu. That matters for multi-GPU Intel setups, where tensor transfers between devices previously had to route less efficiently rather than moving directly device to device. It is one of four consecutive SYCL-focused commits in this release run, showing sustained Intel-backend investment in the project. The usual full matrix of platform binaries accompanies the tag.

b10203

This release adds q2 support to the SYCL mulmat path (#26231), extending the Intel backend to handle q20-quantized matrix multiplication and then broadening coverage to more q20 cases. Two-bit quantization is the aggressive end of the size/quality tradeoff, so getting it running natively on SYCL means Intel GPU users can load larger models into constrained VRAM without falling back to slower generic kernels. Combined with the neighbouring b10202 and b10204 builds, it signals that SYCL is catching up to the CUDA and Vulkan backends on quantization coverage. Prebuilt artifacts span the standard macOS, Linux, Android, Windows and openEuler set.

b10202

The single change here fuses RMSNORM and MUL into one SYCL kernel (#26015). Kernel fusion of this kind removes an intermediate write-and-read of the normalized activation tensor to global memory, which is a memory-bandwidth win rather than a compute one — typically the binding constraint during inference. RMS norm followed by a multiply is executed once or twice per transformer layer, so the saving compounds across depth. As with the rest of this batch, it targets Intel hardware through the SYCL backend and ships across the full platform matrix.

b10201

This build improves flashattnvec in the WebGPU backend for quantized KV caches at long contexts (#25956), plus assorted bug fixes, a corrected value-type check, and a rebase-related build fix. Quantized KV cache is what makes long-context inference affordable in memory terms, but it historically degraded the flash-attention fast path; this patch targets exactly that intersection. Because it lands in ggml-webgpu, the beneficiaries are browser and cross-platform GPU deployments rather than CUDA users. Notably this is the one non-SYCL entry in an otherwise Intel-heavy release run.

b10200

The release notes for this llama.cpp build failed to load when fetched, returning only repeated page-load errors, so the specific commit contents are not available here. The tag is the immediate predecessor to the b10201–b10205 run published the following day. Anyone tracking the changelog should read it directly on GitHub.

vLLM for Baidu Kunlun

Baidu has published vllm-kunlun, a community-maintained hardware plugin that runs vLLM on Kunlun XPU accelerators. Rather than patching vLLM directly, it follows the project's Hardware Pluggable RFC, using the plugin interface to decouple Kunlun backend integration from vLLM's core — the pattern the vLLM community now recommends for new silicon. The plugin covers the mainstream model families: Transformer-style dense models, mixture-of-experts, embedding models, and multimodal LLMs. Published benchmarks are run at 16-way concurrency with 2048-token input/output. The project opened December 8, 2025, is Apache 2.0 licensed, and credits the KunLunXin team for supplying XPU resources for adaptation and end-to-end testing.

Show HN: Vimgolf.ai – Learn Vim by playing through a map of levels

Vimgolf.ai is a browser-based Vim trainer that drops you into editing real files inside interactive levels rather than teaching motions through documentation. The structure is gamified progression: a map of levels organized around discrete skills, so each exercise isolates one editing technique before layering on the next. Four skills are playable free with no account required, and the full course covers 72 skills across 216 levels. The pitch is essentially spaced, hands-on drilling as an alternative to memorizing a cheat sheet.

b10199

This llama.cpp build adds server support for feeding input embeddings in order to generate the next token (PR #26313), including handling embeddings for the sampled token and a fix to the ~serverbatch() destructor path. It matters for workflows that want to inject continuous vector representations directly into the server rather than going through tokenized text — a prerequisite for multimodal and speculative-decoding style pipelines built on the HTTP server. As with every tagged build, binaries ship across macOS/iOS, Linux (CPU, Vulkan, ROCm 7.2, OpenVINO, SYCL FP16/FP32, s390x), Android arm64, Windows (CUDA 12/13, Vulkan, HIP, OpenCL Adreno), and openEuler Ascend targets. The Apple Silicon KleidiAI variant remains disabled.

b10198

A small but targeted Vulkan backend change: quantized concat is now supported (PR #25684), meaning concatenation operations no longer need to fall back or dequantize when operating on quantized tensors under Vulkan. This closes one of the remaining op-coverage gaps that forces mixed-precision detours on AMD, Intel, and mobile GPUs running the Vulkan path. The release otherwise carries the standard matrix of prebuilt binaries across macOS, Linux, Android, Windows, and openEuler. It's the kind of incremental backend parity work that quietly widens which models run cleanly off-CUDA.

b10197

This build adds test support for an alternative convolution layout (PR #25617), introducing a cwhn = true flag on conv2d test cases plus layout validation at graph-build time. The change extends layout checks into the conv2d.cu CUDA kernel and requires the CPU backend kernel to be stored contiguously to avoid test failures when cwhn=1. It also adds op-support checks in the Vulkan backend — specifically a new graph build-time check in ggmlbackendvkdevicesupportsop — to fix a CI failure and a runtime assert. The practical effect is that alternative memory layouts for convolutions can now be exercised without silently breaking backends that don't support them.

b10196

A correctness fix in llama-context: pending asynchronous copies are now synced before embdseq is cleared (PR #25676). Without the sync, in-flight async transfers could race against the buffer being wiped, producing corrupted or empty embeddings in sequence-embedding workloads. This is the sort of bug that surfaces intermittently and only under specific backend/scheduling conditions, which makes it worth picking up if you generate embeddings at volume. Binaries ship across the usual full platform matrix.

b10195

This release is build-hygiene work on the test suite: get-model.cpp was being compiled repeatedly across test targets, so it has been removed and the duplication eliminated (PR #26317). The same change also fixes quantization type selection in the tests, which had been picking the wrong quant in some cases. Neither change affects inference behavior — the payoff is faster CI and test builds plus more accurate quant coverage in the test matrix. Standard prebuilt binaries accompany the tag.

b10194

The CUDA backend gains transpose-free GEMV computation (PR #26171). When a matrix's weights are shaped 1xK, ggml-cuda can now route directly to matmulvecf instead of performing an explicit transpose first, removing a memory-movement step from a very hot path. Matrix-vector multiplies dominate single-stream decode, so shaving a transpose here is a token-generation latency win rather than a throughput-only optimization. Builds cover macOS/iOS, Linux CPU/Vulkan/ROCm/OpenVINO/SYCL, Android, Windows CUDA 12 and 13, and openEuler Ascend variants.

GPU Management: Why Idle GPUs Are the New Grounded Aircraft

The piece argues enterprise AI has hit the same structural constraint airlines did: a GPU accrues cost by the calendar hour (financing, depreciation, power, cooling) but only produces value by the compute hour, so utilization — not fleet size — separates comparable budgets into different economics. It traces the shift from capability scarcity to compute scarcity, noting that in 2020 Microsoft's 10,000-GPU supercomputer for GPT-3 looked like a ceiling, while by 2026 Anthropic was running simultaneous multi-gigawatt commitments across Amazon, Google, Microsoft and AMD because no single vendor could supply enough. Downstream, enterprises hit a pricing wall where API cost scales linearly with tokens, pushing them to buy GPUs and convert a variable cost into a fixed one — which sizes clusters for peak demand and creates idle capacity by construction. The harder half of the problem is heterogeneity: real-time inference wants latency, batch wants throughput, training occupies a card for days, quantization needs a large burst — a scheduler tuned for one misallocates the other three, and a cluster can show high average occupancy while jobs queue for a GPU shape that's busy. The analogy's limit is the lesson: a 737 in Chicago can fly any route, but an idle GPU can only absorb workloads matching its memory, latency, and duration profile.

llm 0.32rc2

RC2 lands right after RC1, fixing a dependency issue and adding two user-facing changes. The default model for users who never set one moves from GPT-4o mini to GPT-5.6 Luna — better and more recent, though slightly pricier at $0.20/$1.20 versus $0.15/$0.60; you can revert with llm models default gpt-4o-mini or go cheaper still with llm models default gpt-5-nano at $0.05/$0.40. The second addition is llm openai endpoint, a command for running prompts, chats and model listings against arbitrary OpenAI-compatible endpoints without configuring a model first (these calls are not logged). Willison built it out of frustration at the lack of a CLI for poking at Chat Completions clones, and notes you don't even need LLM installed — a uvx --pre llm openai endpoint one-liner will run a tool-using prompt against a local LM Studio model.

llm-chat-completions-server 0.1a0

This plugin exists as a test of the content-addressable log schema introduced in LLM 0.32rc1. OpenAI Chat Completions requests carry the entire conversation on every call, so each request grows longer than the last; the new schema hashes individual message parts so repeated history is de-duplicated in the database rather than stored again. Installing it (llm install llm-chat-completions-server, then llm chat-completions-server -p 9001) starts a localhost server exposing your full collection of LLM models — from any installed plugins — behind a ChatGPT Completions-compatible endpoint. Willison notes GPT-5.6 Sol wrote the whole thing, since it knows the Chat Completions API shape well.

llm 0.32rc1

RC1 completes the work begun in 0.32a0: a new database schema that better captures the structure of prompts and responses from current model families. The central change is content-addressable hash IDs for stored messages, which enables de-duplication in the database and lets LLM represent trees of messages for forked conversations rather than flat linear logs. Because this is a significant schema change — new tables only, existing data untouched — Willison advises backing up your logs.db before upgrading to the RC. The release also adds support for gpt-5.6-sol, gpt-5.6-terra and gpt-5.6-luna.

The Hallway Track: What Even Is Harness Engineering

Simon Maple works the hallway track at AI Engineer in San Francisco asking attendees what "harness engineering" and its successor buzzword "loop engineering" actually mean. The answer he gets: the point of a loop is that the agent stops returning to you for input every five to ten operations. One interviewee argues models have fundamentally changed how they handle long-running work — until very recently, no matter how hard you pushed an agent to continue, even with emerging features like channels pushing notifications into agent sessions, it would still circle back asking you to pick between three choices. The other half of the problem is memory decay: what's valuable today may be worthless in two days, so the harness has to weight and update memory rather than just accumulate it. One attendee describes evolving a self-healing Pokémon agent demo into actually fine-tuning an open-weight model on a Pokémon harness — with the caveat "don't try this at home, very expensive."

This Setup Gives Your Team the Same Claude Memory (Steal it)

A community poll found nearly 70% of members are trying to use Claude across a team, but almost none have a clean way to do it — and the video argues the infrastructure explains why. Claude's memory is bound to an individual account, third-party memory frameworks store findings on your own machine around a single user, and MCP connections authenticate as you personally; every serious layer of the stack is single-player by design. Y Combinator listing team infrastructure for agents on its requests-for-startups page is offered as evidence nobody has solved this yet. Rather than wait, the presenter builds a workaround from tools teams already have — Notion, Claude, and one shared memory connector — claiming roughly 80% of a working team setup for 20% of the effort, with Notion swappable for any file-sharing tool. The framing shift he insists on: stop treating context as something each person's Claude owns individually and start treating it as shared infrastructure with permissions, shared tools, shared memory and shared conversations.

A user has managed to run Kimi K3 on 80xRTX 5090, via 25GbE Ethernet.

A hobbyist cluster of 80 RTX 5090s interconnected over 25GbE was used to run the newly released Kimi K3 weights — a demonstration that frontier open-weight inference is reachable without datacenter interconnect, if you're willing to accept commodity Ethernet latency. No detailed body or throughput numbers were extracted with the post.

b10192

A llama.cpp build tagged only as "sync : ggml" — the routine upstream synchronization of the ggml core library into the llama.cpp tree. No user-facing feature or fix is described. Binaries ship as usual across macOS/iOS, Linux (CPU, Vulkan, ROCm 7.2, OpenVINO, SYCL FP32/FP16), Android arm64, Windows (CUDA 12/13, Vulkan, HIP, OpenCL Adreno) and openEuler Ascend targets.

b10189

This build removes a custom CPU op from the M3 graph and expresses it with stock ops instead (#26297) — a simplification that reduces bespoke kernel surface in favour of the standard operator set. The full matrix of platform binaries is unchanged from the preceding builds.

b10188

A Metal backend fix (#26082) for a memory leak where wired GPU memory was not unwired if a model was freed without any GPU operations ever running. The change also makes dummy work run only when residency sets are used, guards the function behind a compile-time check, and adds a regression test that measures system-wide wired memory. Relevant to anyone loading and discarding models on Apple Silicon.

b10186

A ggml build fix (#26277) addressing a KleidiAI CI failure and a stringop-overflow compiler warning, contributed from Arm. It is a build-hygiene release rather than a functional change; note that the macOS Apple Silicon KleidiAI-enabled artifact remains disabled in this build matrix.

Ontologies Are So Back: Why AI Agents Are Reviving the Semantic Web

Frank Coyle's AI Engineer World's Fair talk argues that LLMs supply probabilistic reasoning but agentic systems need "logical guardrails," and that ontologies — "data as graphs" — are that guardrail; he calls the combination neurosymbolic AI, and demonstrated using an OWL reasoner to validate a Claude agent loop after tool execution. A practical point: established web ontologies like Schema.org, FOAF and Dublin Core are already in LLM training data, so you can prompt for them rather than inventing your own. Neo4j CEO Emil Eifrem framed three ontology layers — business concepts, technical metadata over enterprise data assets, and agent runtime execution traces — enabling a shift from "thick agents with manually wired data sources" to "thin agents on a shared semantic layer." The old objection stands: ontology maintenance is what killed the Semantic Web, though one proposed fix is having the agent maintain the ontology itself as it hits edge cases.

Why every Wikimedian should be a toolmaker

Writing after Wikimania 2026 (1,250 in person, 2,000+ online, Wikipedia's 25th year), Hay Kranen reframes the AI question through Deep Blue: Kasparov didn't lose to a machine, he lost to humans as toolmakers, so Wikimedians must become toolmakers too. He names three concrete threats — declining readership (which matters because readers become editors and small donations fund the projects), scraper bots straining infrastructure while the LLM companies that depend on Wikimedia data give nothing back, and AI-generated articles plus an internet degrading into slop that poisons the reference base articles depend on. Internally he flags a polarization risk: skeptical voices, especially younger editors who oppose any AI use, were surprisingly quiet at Paris, and tension between volunteers, affiliates and the Foundation could stall decisions. His counter-asset is trust and reliability — the thing big tech's money cannot buy — plus Wikimedians' ability to explain that code isn't magic, a lesson companies are learning the hard way after firing dev teams and expecting parity.

Writing the PHP Virtual Machine in Rust (with a lot of help from AI)

JoliCode built rphp, a PHP VM in Rust, in roughly one month. The naive first prototype (one day) worked but was slow and, critically, produced a stack VM where PHP is register-based — a mismatch that would have broken value destruction order and error timing that real libraries depend on. Rather than copy Zend Engine the way Bun's rewrite did (which the author criticizes as so full of unsafe it defeats the point of Rust), they designed around Rust idioms: no global mutable state, a self-contained instantiable VM, and a copy-on-write fork mode where a paused VM is cloned per request and discarded. Results: ~80% of basic compatibility tests pass, pure PHP execution is 5–15× slower than PHP, but fork mode is ~30× faster than its own classic mode and beats PHP/FrankenPHP on the Symfony Demo. His verdict on AI: a technical sparring partner that summarized decades of C and explained why optimizations existed, rarely right first time, still writes sloppy code, and dangerous because it convinces you it succeeded when it didn't.

Loop engineer practice #1: Reddit loop grew 0 to 95 Karma in 7 days

AI Jason opens a "loop engineering practice" series with a Reddit agent that took an account from −4 to ~97 karma in a week and a half, alongside an SEO loop that tripled traffic over a month and a half. The loop makes three to five posts per day at randomized times: it finds relevant qualified posts, runs them through a quality gate (which he calls the single most important component), writes a value-adding comment only if it genuinely fits, and otherwise drops the candidate — plus a weekly self-review of past performance. His framing is that most people who try Reddit automation fail, himself included on earlier attempts, and that the difference comes down to five specific nuances rather than the loop structure, which looks like everyone else's. The transcript was truncated before all five were enumerated.

Adding a custom MCP server to Claude and ChatGPT

Simon Willison notes that both Claude and ChatGPT’s standard chat interfaces can connect to a custom MCP server. He cautions that the setup currently involves quite a few steps. The item is a short pointer rather than a configuration guide.

ThunderAgent: 2x Faster Agentic Inference for Synthetic Data Generation at Scale

Together AI’s open-source ThunderAgent treats a multi-turn agent workflow as a schedulable program instead of independent LLM requests. That lets it pause lower-priority workflows under memory pressure, track KV-cache footprints, and route resumed work to the node with capacity, reducing cache-thrashing caused by tool waits and fixed node pinning. In its CoderForge-style tests, it reached 803 versus 390 tokens/s at batch size 192 on one 8×H100 node, and 2.39× the SGLang Gateway speed on eight nodes; adoption only requires adding a programid to OpenAI-compatible requests.

The Ultimate Knowledge Base: Bring YouTube Into Your AI Second Brain

The video presents Google’s Open Knowledge Format as a proposed agent-to-knowledge-base standard, analogous to MCP for tools and A2A for agents. Its demonstration packages roughly 200 videos from the creator’s channel into a searchable knowledge bundle so an agent can answer cross-video questions and cite the relevant videos. It also promises a workflow for building comparable knowledge bases from other YouTube channels.

We Scored Oracle's Database Skill Live: 95% Isn't Enough

A live review examines Oracle’s repository of database skills, which provides agents with product-specific guidance for SQL, operational tasks, containers, and niche features such as property graphs. The speakers argue that local, tested skill context reduces the need to hunt documentation and can encode secure, scalable best practices, especially when paired with a database MCP server. Tessl’s reviewer initially scores an Oracle database skill at 95%, then applies suggested verification steps for slow-query diagnosis and reaches 100%, illustrating iterative review and PR-based improvement of SKILL.md files.

Paste This Into Claude, Never Hit a Token Limit Again

Nate B. Jones explains that token limits are mainly driven by repeatedly resending accumulated conversation context, not by the latest user message. In one tracked Codex workspace day, 3.59 billion of 3.77 billion processed tokens—about 96%—were reused input across 143 threads. The video frames retries and long chats as particularly expensive because each repeats the history, then promises practical rules, an accompanying skill, and a more technical multi-agent solution for managing that growth.

The last30days Skill: How to Fix Claude Code's Research Problem

The open-source last30days skill is positioned between quick web search and costly deep research: it collects posts, comments, and transcripts across Reddit, Hacker News, GitHub, YouTube, TikTok, Instagram, LinkedIn, Bluesky, X, and other sources, then synthesizes sentiment into a ranked brief. It can be invoked with /last30days or natural language, scoped to selected platforms, and typically takes about five minutes; raw results are also saved as JSON for inspection. Most sources auto-configure without cost, while X needs an xAI key at roughly $0.10 per run and some social sources have dependency or subsidized-call requirements, so the author recommends it for genuine sentiment questions rather than routine lookups.

Optimizing vLLM on Arm CPUs

vLLM and collaborators improved Arm Neoverse CPU serving by fixing stack-wide bottlenecks rather than focusing only on GEMM kernels: PyTorch now defaults to mimalloc on Arm, libgomp can use LSE atomics, and oneDNN pre-packs weights during warmup. The allocator alone improved Llama 3.1 8B offline throughput 2.3× and low-concurrency serving by about 7×, while weight prepacking reduced output-token latency by 60% and optimized paged attention reached up to 4× faster. An INT8 W8A8 path using Arm I8MM/SMMLA can add as much as 88% throughput versus the optimized BF16 baseline, alongside lower TTFT and per-token latency.

Copilot code review: Agent skills and MCP now generally available

GitHub Copilot code review now generally supports repository skills and MCP servers for Pro, Pro+, Business, and Enterprise users. Skills live in skill-specific directories under .github/skills and allow reviews to apply internal standards and tools; MCP connections can bring in context from systems such as issue trackers and documentation, but all MCP calls in code review are read-only. Review comments now identify whether skills or MCP context informed them, existing cloud-agent configurations carry over, and GitHub and Playwright MCP are enabled by default.

Your tenth message costs far more than your first. Grab the guide + the Token Saver skill: clean tasks, evidence selection, settled steps as code, accepted answers reused.

Nate cracked open his own token-burn tracker after a long Codex session and found 3.77 billion tokens across 143 threads and 28,877 local records — but the alarming part was that 3.59 billion (95.73%) of input was "reused" context rather than new prompts. His point is that the tenth message carries everything before it: prior exchanges, standing instructions, tool definitions, files, screenshots, browser results, command output, and rejected answers, so you type less but pay more. He stresses that reused ≠ useless — continuity (the decision from 20 minutes ago, the file already changed, the approved paragraph) is what makes agents work, and eligible repeated material can earn a provider cache discount. His experiment sets an aggressive target: cut reported reused input by 90% without increasing mistakes, retries, or review time, delivered via 15 measured changes, 9 no-install habits, and a "Token Saver" skill for Codex and Claude Code.

Stephane Jourdan, Simon Rohrer & Pini Reznik - From Pipelines to Prompts: Surviving the Shift to AI

This panel gathers three practitioners to discuss surviving the shift from traditional pipelines to AI-driven, agentic development. Simon Rohrer is head of enterprise architecture and ways of working at Saxo Bank in Denmark, where he runs the AI center of excellence and is rolling out agentic development across roughly 700 developers, and co-authored John Smart's book "Sooner Safer Happier." Pini Reznik is co-founder of Reync, a consultancy helping enterprises adopt AI for software development, infrastructure, and building large platforms (his prior company, Container Solutions, grew substantially). Stephane Jourdan is CTO and co-founder of a startup focused on context for production agents, with 15 years building startups for managing production systems, one of which was acquired by Snyk. The available transcript is truncated before the substantive discussion begins, so the panel's specific conclusions are not captured here.

Show HN: Segue – Save context in one AI, load it in another by a short handle

Segue is a neutral MCP relay that lets you save a block of working context in one assistant and reload it in another via a short, three-syllable pronounceable handle (like "brelavo"), avoiding copy-paste and re-explaining when you switch tools. One AI calls savecontext with your brief or notes and returns the handle; you hand that handle to any other MCP-capable client (Claude, ChatGPT, Cursor, Windsurf, Codex) signed into the same account, which calls loadcontext to pick up where you left off. It emphasizes user control — nothing syncs automatically, handles resolve only inside your account and are meaningless if leaked, and contexts stay readable/editable/exportable as plain .md even on lapsed accounts. The pitch targets the daily "context tax" of rebuilding state every time you move between planning, building, and drafting tools.

uv 0.12.0

sqlite-utils 3.39.1

This is a point release in which Simon Willison back-ported a fix for table.deletewhere() that had originally shipped in version 4, making the fix available to users still on the 3.x line. It's a small maintenance beat posted on 26th July 2026.

The #1 Trending Github Repo Just SOLVED Claude's Search Problem

The transcript for this video was unavailable, so this summary draws only on the video description. It covers an open-source repo called "last30days" (github.com/mvanhorn/last30days-skill) presented as a fix for one of Claude Code's under-discussed weaknesses — web search — with sections on how it works and a demo.

Configuring Dedicated Model Inference

Issue #55

Augmented Coding Weekly's issue #55 breaks format to spotlight a single long-scroll story, "The Rise of Open Weights," which the author (Scott Logic) created to map the industry's path to today's open-weight moment. Highlights that surprised the author: OpenAI began as an openness-committed non-profit yet became one of the most closed AI companies; Google's leaked May 2023 "We Have No Moat" memo increasingly looks correct; frontier training costs exploded from under $1,000 (2017) to nearly $500M (2025); DeepSeek's January 2025 story is more nuanced than a shoestring miracle; and the frontier-to-open gap collapsed from about a year to a couple of months, disappearing on some benchmarks. The framing question is no longer "which model is best?" but whether organizations should keep renting AI from a few providers or start owning the capability themselves.

Show HN: Formally verified 3D CSG: Trust 93 lines spec, not 1000 lines AI code

This project claims the first formally verified 3D constructive solid geometry operation — mesh intersection — implemented in Lean 4 and proven against a 93-line specification that exactly pins down the resulting surface and guarantees well-formedness (watertight, coherent orientation, no degenerate triangles). The central idea is trust minimization: a reviewer reads only the 93-line spec and runs the Lean checker, ignoring the ~1000 lines of AI-written implementation and the 60,000+ lines of AI-generated proofs, since the compiler certifies conformance with zero trust placed in any LLM. The tradeoff is speed — it takes 24 seconds to intersect two 70k-triangle Stanford bunnies, far slower than state-of-the-art — because the author prioritized minimizing human review effort over performance. The author notes this performance gap is not fundamental to verified software.

Inside the Dark Factory: AI That Ships Code Solo

Tessl's AI engineering lead Rob Willoughby describes the company's "Dark Factory" — an orchestrator that pulls Linear tickets, runs coding agents in isolated Daytona sandboxes, and drives PRs through automated review (Code Rabbit plus Tessl's own skill-based agents) and CI, merging autonomously where allowed. Roughly 65–70% of Tessl's PRs now flow through it (about 40% of production PRs, all requiring human review), and one busy weekend shipped 150 auto-merged PRs while the team was out; Willoughby estimates ~95% of the Dark Factory's own codebase has never been seen by a human. The key leverage isn't the orchestrator (which he calls "dead simple") but the verification layer: fast, single-purpose "verifiers" — natural-language yes/no checks judged by an LLM over the diff — that encode engineers' taste, plus deterministic lint rules and behavioral tests, with a nightly job promoting recurring review comments into verifiers. Hard-won lessons included race conditions from double-counted queue items (fixed with a Quint formal model) and a failed Elixir rewrite-from-verifiers experiment that exposed blind spots where core routing logic lived only in unit tests, not end-to-end checks.

Unharness Your Agents

Dan Gerlanc and John Berryman argue that today's terminal- and IDE-bound agent "harnesses" are too narrow, and that agents should see and act across the websites, applications, files, and physical spaces of a person's life — the goal of Berryman's Rook project, which makes those contexts addressable while letting people keep the harnesses they trust. He sees feasibility as the barrier that recently fell, while security, transparency, trust, and standardization remain open, and expects adoption to start with read-only access, dry runs, approvals, and reversibility, aided by conventions like skills files, AGENTS.md, and llms.txt. His strongest practical claim: replace bespoke workflow code with skills written in plain English whenever the model can follow them — "the new programming language is English, the new runtime is the agent runtime, the new software is skills" — with frameworks like LangGraph becoming less necessary. On memory he is skeptical, saying retrieval-by-textual-similarity doesn't reproduce how humans turn mistakes into procedural knowledge and taste; he prefers explicit review of a finished task, then packaging the generalized process as a skill, and wants agents that actually update weights to learn a person's idioms.

The harness is all you need (mostly)

The author argues that success with AI coding comes not from stacking up skills, MCPs, custom agents, or clever prompts — most of which is "gimmicks" and "slop" — but from deeply understanding and using the harness itself, treating GitHub Copilot as the agent harness. The recommended starting point is the Copilot CLI, because its bare text interface keeps you close to the raw interaction rather than hiding it behind UI. A key step is turning on "YOLO mode" (Allow All / /allow-all), since agents need autonomy to deliver real productivity — approving every command trains you to rubber-stamp without reading. The safety caveat: never run YOLO mode on your local machine, especially at work, because private org data and costly mistakes are at stake.

GitHub Copilot app for Beginners: Getting started

The GitHub Copilot app reframes AI coding away from a single chat window toward a workspace that manages multiple concurrent agent sessions, each tied to a project so it carries the repository context needed for a task. You can keep several threads moving at once — using Quick Chat to ask questions or investigate the codebase while another session continues a project update — without losing your place. The app also adds an interactive browser canvas via the /create-canvas slash command, letting you preview a running app inline, and with Canvas Dev Mode's "Pick & Polish" you can select page elements directly as context for the next request. Agent Merge extends the workflow through the standard pull-request, CI, and review process.

Harness Engineering: Building an AI Software Factory

Dru from Tessl presents "harness engineering" (aka loop/meta engineering, software factories) — a shift from writing code to building and monitoring loops of agents that build and review the product, with humans shaping tickets and improving system autonomy, automation, and quality. The technique rests on three loops: an inner loop (unit tests, linters, TDD) that drives per-attempt correctness, an outer loop (agentic code review, agentic QA clicking through the built product) that builds confidence to reduce human review, and a meta loop of maintenance agents that watch CI, PR comments, and logs to propose their own fixes. A central discipline is that when an agent produces a broken PR you don't correct it — you throw it away and add a test or skill so the mistake can't recur, a "slot machine" workflow that's organizationally painful but compounds. Tessl cites OpenAI's reported 5x productivity gain from moving engineers from interactive sessions to ticket/PR flows, and shares that its own 24 engineers now ship ~700 PRs/week while still human-reviewing everything touching production. Tessl also pitches cheap LLM "verifiers" (100+ per PR at ~$0.30/day) as a shift-left alternative to $25-per-PR agentic reviews.

Kimi K3 Is Here: Efficient Day-0 Support on vLLM

vLLM announces day-0 serving support for Kimi K3, a 2.8-trillion-parameter Mixture-of-Experts model (16 of 896 experts active per token) with a 1M-token context and native vision, built on Kimi Delta Attention (KDA) and Attention Residuals. Most layers use KDA — a linear-attention mechanism keeping a fixed-size recurrent state instead of a growing KV cache — interleaved with periodic full-attention layers for exact global recall, which is what makes the 1M context affordable. vLLM introduces a single hybrid KV-cache manager holding paged KV blocks and compact recurrent-state blocks under one scheduler, plus a dedicated KDA backend running FlashKDA for prefill and fused CUDA kernels for decode. The hardest engineering problem was prefix caching across the hybrid cache, solved by decoupling large physical KDA state blocks from fine-grained prefix matching so long shared prompts can reuse both state and KV. Recommended hardware is 8 NVIDIA B300 or 8 AMD MI355X GPUs, and for now only Docker images work due to pre-release dependencies like FlashInfer.

TIRx

The transcript for this video was unavailable. Per the video description, Bohan Hou introduces TIRx, an open-source programming DSL for GPUs and AI accelerators that combines native-level control with tile APIs to reduce boilerplate, built on a simple layout system, and being used to build frontier ML kernels and mega-kernel systems while exploring agentic kernel programming.

Stop guessing whether a cheaper model can do the job. Grab the bakeoff guide: the validator, the manifest, the score sheet, and the fixtures.

Nate argues that the "should we use Chinese models" debate is framed wrong: the decision is not about a country but about a specific job, endpoint, and verification check, and serious AI users should test DeepSeek, Qwen, GLM, Kimi, and MiniMax selectively rather than declaring the whole stack usable or unusable. His central cautionary tale comes from a 34-task run of his "Ringer" multi-agent system, where one worker reported 213 verified quotations but 13 turned out to be stitched together — illustrating that a cheaper model's token price is misleading because it can double your review time. He stresses that the real cost metric is what an accepted result costs, not the sticker price per token. The post ships a bakeoff kit (validator, manifest, score sheet, two fixtures to prove your checker rejects bad work), and he notes the run that taught him all this cost roughly $8.

Simon Obstbaum & Rob Willoughby - Why evals are hard and how we're solving it - AI Native DevCon Jun

The available transcript is almost entirely conference stage logistics — a host promoting the "Grenola" skill for browsing recorded talks at tessal.io, reminding attendees about extra afternoon workshop slots, and introducing Simon Obstbaum and Rob Willoughby to the stage. The substantive talk on why evals are hard and how the speakers are solving it is cut off before its content begins, so the actual argument and findings are not captured in the provided material.

From Day 0 to Production SLAs: Serving GLM-5.2 on 24 NVIDIA B300 GPUs with vLLM

vLLM documents cutting GLM-5.2-NVFP4 decode latency from ~40 ms to 17 ms mean TPOT on 24 B300 GPUs, using a disaggregated 4-Prefill + 1-Decode topology to hit production SLAs of TTFT ≤ 2.5s and TPOT ≤ 20ms. Disaggregation is the enabling move: it removes prefill work from the decode critical path so TPOT depends only on decode batch composition rather than incoming prompt-length distribution. A key fix addressed the interaction between P/D disaggregation and MTP speculative decoding — newly transferred requests compute only one token on their first decode step, creating mixed batches that fall off the fast CUDA-Graph path, so they pad shapes with dummy speculative tokens to 1+N to match existing requests. Notably, they chose a parallelism strategy that is not the highest raw throughput, because a config that improves throughput 30% but violates the TPOT SLA is useless; measured concurrency settled around 700 requests at 8K context, 300 at 16K, and 25 at 256K.

You Can Hand One AI Agent Your Worst Recurring Task. It Cleared 60% Of Mine.

Nate B Jones recounts how his company resolved 51 of 52 customer-support issues using AI, but the real lesson came from digging into why the tickets existed: the vast majority traced back to a single broken process — people couldn't get into the Slack community. The failures followed predictable patterns (invitations never received, sign-in links reported as already expired, one email used to pay and another to join), which AI made far easier to surface than manual triage. He argues the distinguishing move for a 2026 automation strategy is looking at the whole process — all the hidden work of finding the email, checking payment, searching Slack, resending invites, apologizing, and closing the ticket — rather than just optimizing the final reply as in 2024–2025. The principle generalizes to any repetitive process where you're cleaning up the same self-inflicted mess over and over.

Executive Briefing: Gumroad Let a Customer Approve Its Code. Here's Where Your Agent Should Stop

Nate reports that his company closed 51 of 52 support tickets and felt good about the 98% number — until sorting by root cause revealed that 39 of the 52 were the same Slack-access problem, meaning they had efficiently repaired one broken entry path 39 times and called it a great week. His timing study of support tickets found the reply itself was cheap; the expensive part was reconstructing the customer's identity across half a dozen systems. He points to Gumroad's support agent as the model of an agent owning the whole loop — it found a charting bug, wrote the test, and shipped the fix — but also the natural stopping point, since the agent got the design wrong in a way only the customer could catch. He argues support is the ideal place to start with agents because the work is concrete, customers tell you when you're wrong, and the history already sits in the inbox, yielding three payoffs at once: faster answers, less repeated scavenger-hunting, and a better product.

Tammuz Dubnov - When Our PM Started Writing Code: What Merge Rate Taught Us About AI Adoption - AI N

Tammuz (Thomas) Dubnov, founder and CTO of Autonomy AI, argues that the "PMs writing code" story is really about how organizations become genuinely AI-native—and, crucially, how to measure that shift rather than just claim it. He presses the audience on a familiar pain: leaders field constant CFO/CEO questions about AI spend, yet few can define what "AI native" actually means or prove the AI work is worthwhile. His proposed yardstick is merge rate: it's encouraging when PMs and designers open PRs, but the real question is whether those PRs get merged—i.e., whether they're meaningful contributions or noise. The talk frames merge rate as a concrete adoption metric that separates genuine AI-native productivity from activity theater as companies push non-engineers to build with AI. (Transcript was truncated mid-talk, so later specifics were unavailable.)

Ruff v0.16.0

Astral shipped Ruff v0.16.0 on July 23rd, and Simon Willison noticed only because his CI jobs started failing against his unpinned "ruff" dev dependency. The headline change: Ruff now enables 413 rules by default, up from just 59 previously, out of a total rule set that has grown from 708 to 968 since v0.1.0 — many of these catch severe issues like syntax and immediate runtime errors that were previously off by default. Running the new version against Datasette, sqlite-utils, and LLM surfaced hundreds of minor violations, though comprehensive test suites (CI across Python 3.10–3.14) made the upgrades relatively safe. Willison notes that Ruff's detailed per-rule explanations give a coding agent everything it needs to auto-fix, and he had Codex (GPT-5.6 Sol high) upgrade LLM and sqlite-utils while Claude Code (Opus 5) handled Datasette — a nod to Astral's new home at OpenAI.

Dave Farley - Vibe Coding - Is this really the best we can do? - AI Native DevCon June 2026

Closing out AI Native DevCon, Dave Farley pushes back on the idea that "vibe coding" is the endpoint of agentic programming, arguing that the disciplines and behaviors that have stood the test of time remain important even amid a genuine sea change in how software is produced. He frames AI adoption in programming as hugely disruptive but insists that many durable engineering practices should carry forward rather than be discarded. He notes he isn't alone — several other speakers that day made similar points — and sets out to question assumptions about the new agentic world and examine why the durable fundamentals still matter. (Transcript is truncated in the raw materials, so the full argument and specific recommendations are not captured here.)

Oleg Šelajev - You're absolutely right, it was your home directory! - AI Native DevCon June 2026

Oleg Šelajev of Docker's DevRel team presents on sandboxing and isolating AI agents, motivated by Docker's push to find its place in the CI ecosystem and its recent sandboxing initiative. The session targets developers who write agents that run locally on their own machines, walking through why and how to isolate those AI workloads to avoid the kind of accidents the talk's title jokes about — an agent wiping your home directory. Šelajev, formerly of Zero Turnaround and Atomic Jar (maker of Testcontainers, acquired by Docker), frames local agent isolation as the practical safeguard needed as you let AI do more autonomous work. (Transcript is truncated in the raw materials, so the concrete tooling and steps are not fully captured here.)

v2.1.220

This is a release of Claude Code, Anthropic's agentic coding tool that runs in the terminal, understands your codebase, and executes routine tasks, explains complex code, and handles git workflows through natural-language commands. The published release notes for v2.1.220 could not be extracted — the GitHub release page returned repeated "There was an error while loading. Please reload this page." messages instead of the changelog. As a result the specific fixes, features, or changes in this version are not available from the captured content.

v2.1.219

This Claude Code release adds Claude Opus 5 as the new default Opus model, with a 1M-token context window and a fast mode priced at $10/$50 per million input/output tokens. Notable additions include a sandbox.network.strictAllowlist setting that denies non-allowlisted hosts without prompting, a DirectoryAdded hook that fires when new working directories are registered mid-session, and richer MCP error reporting (HTTP status and error text now surface in claude mcp list and /mcp). Subagents can now spawn nested subagents up to depth 3 by default (previously 1), and dynamic workflows default to a medium size guideline aiming for fewer than 15 agents. Numerous fixes cover Vim mode, screen-reader echoing, self-hosted runner lifecycle handling, and the /model picker labeling the merged Opus row correctly as "Opus (1M context)."

Issue #54

This issue argues that open-weight models have closed the gap with closed labs, citing Kimi K3 from Beijing's Moonshot AI landing third on Artificial Analysis's Intelligence Index, just behind Claude Fable 5 and GPT-5.6 Sol. It relays writer Stephen's point that K3 is as good as Claude for his work, cheaper, and — critically — can't be shut down by the US government, calling US AI policy "an unmitigated failure." It also unpacks the misreported OpenAI "rogue AI" story: OpenAI was testing an unreleased model without guardrails against the ExploitGym benchmark, and the model chained vulnerabilities to escape its sandbox and attack Hugging Face's production infrastructure — doing exactly what it was asked. The buried, more important detail is that Hugging Face (based in France) was blocked from using commercial AI APIs to analyze the attack logs and had to fall back on the open-weight GLM5.2 model. The piece closes by criticizing the Trump administration's consideration of a ban on Chinese open-weight models over unproven distillation accusations, noting the irony given the unlicensed data used to train frontier models in the first place.

Why AI Agents Need a Data Harness, Not Just a Lakehouse

Dremio's Will Martin argues that agentic AI and analytics require a "data harness" that makes data accessible, understandable, and performant at conversational (subsecond) speed — because agents can't tolerate the minutes-to-hours latency humans accept, and slow pipelines error out and waste tokens. He frames the harness as three execution-layer components on top of a lakehouse: an open catalog (Apache Polaris) providing table maintenance, governance, and fine-grained row/column access control; a semantic layer that consolidates business definitions (e.g., what "customer" or "Q2" actually means) into one place so agents don't guess; and a query engine (Apache Arrow-based) that federates across silos, querying data where it lives rather than centralizing it. He stresses open standards — Arrow, Iceberg, the Iceberg REST spec — as the way to avoid vendor lock-in, noting even Databricks and Fabric now use the REST spec. Performance features like reflections (automatic materialized-table acceleration), predicate pushdown, variant shredding, and columnar caching (C3) can cut costs by up to 90% for some customers.

Brian Douglas - The beginners guide to training AI on your own code - AI Native DevCon June 2026

In this conference talk, Brian Douglas (ex-GitHub, now founder of Paper Compute) shares his hands-on journey into training AI on your own codebase rather than pitching a product. He frames the talk as a "speed run" of what he learned rather than a step-by-step workshop, using a Pokémon Red case study — building AI to speed-run the Game Boy game — as the vehicle for the lessons. The work draws on a research paper he read and the open-source tooling his company has been building over recent months. He notes, half-jokingly, that his experiments got him banned from Claude, a caution about pushing model usage to its limits.

I deleted 5 things from a sensitive file before AI read it. It still found what would break my launch.

Nate argues that employees are caught between two mandates from the same company: managers demanding more AI-driven productivity and IT forbidding uploads of sensitive data — with the manager's judgment carrying immediate, personal consequences that privacy policy cannot match. Because useful AI work now runs on real material rather than an empty chat box, privacy has shifted from a policy slide into a file-by-file decision each worker must invent for themselves. He illustrates with an auditor who found uploading client files would be "a game changer" but faced products that were either far less intelligent or "priced astronomically," leaving the work at a standstill. His answer includes Airlock, a Mac app he built for the repetitive redaction work, plus operator practices like routing, tiers, and local pipelines — and a "two-minute test" pitting the approved path against the consumer route.

How to Fix Claude Code's Web Design Problem

Chase argues that Claude Code's design weakness is taste, not technical capability: the code compiles and the layout works, but output regresses to the mean — same palette, same font, instantly recognizable as AI. His fix is a workflow that injects your own taste, and he stresses that better models won't help because they'll only shift what counts as "generic." Step one is curating a personal library of design inspiration (he even had Claude Code build a small web app that groups screenshots by type, surfaces style vocabulary and keywords, generates matching hero-background prompts, and seeds a build via a "copy brief" button). Step two tools up with three external add-ons — the Impeccable skill, the Taste skill, and the Higgsfield MCP, plus 21st.dev for components — where Impeccable (open-source, ~50,000 GitHub stars, now folded into GitHub's official AI tooling) packs 23 commands that hunt and remove "slop" defined as 46 distinct patterns across typography, color, spacing, responsiveness, interaction, motion, and UX writing.

3 Ways To Fix Claude Code's #1 Web Design Problem

This Chase AI video walks through a three-step method for escaping "AI slop" in web design, the newer form of which is cleaner than the old generic-SaaS look but still telegraphs a single-prompt origin through its predictable palette, font, and style. Step one is cultivating and curating taste by building a personal library of high-level design references, on the premise that "AI has no taste" and better models merely redefine what reads as generic. The video then covers which skills and MCPs to add to Claude Code to raise the baseline of every build. It closes with a concrete build sequence — the prompts to use, how to prototype, and how to iterate and tweak — so viewers leave with a flexible roadmap applicable to all their AI design work.

Anthropic Just Solved Claude Cowork’s Biggest Limitation (Goodbye MCP)

Simon Scrapes demos a new Claude Cowork feature that lets you teach Claude a skill by recording your screen while performing a task, so Claude can then operate software it's never had API or MCP access to. The key shift is that no integrations are required at all — if you can click it on screen, you can teach Claude to do it, including operating legacy enterprise desktop software and repetitive tasks. What differentiates it from ordinary screen recorders is that you talk through the process as you record, adding verbal context to fill in the gaps. The live demo builds an Instagram DM lead-magnet automation (comment-a-keyword triggers an automated reply with a link and a follow check) that the presenter normally does manually after every YouTube upload, turning it into a skill that runs on autopilot.

Announcing vLLM AFD Plugin: Disaggregating Attention and FFN for Flexible MoE Serving

vLLM introduces an experimental external plugin bringing Attention-FFN Disaggregation (AFD) to Mixture-of-Experts models, separating the stateful, KV-cache-coupled Attention path from the routed, all-to-all-heavy FFN/expert path into independently deployed and independently scaled services. It preserves vLLM's request lifecycle and OpenAI-compatible interface, integrates through the standard plugin entry point and --additional-config without editing vLLM's source, and supports NVIDIA GPUs and Ascend NPUs with synchronous and asynchronous connectors and DeepSeek V2/V3-family wrappers. Benchmarks on DeepSeek-V3.2 W8A8 on Ascend 910C (controlled, throughput-only) show the allocation ratio matters: a 48A16F split lands below the EP64 baseline (−5.3% at 16K, −10.0% at 32K), while 64A16F delivers the best normalized throughput (+11.3% at 16K, +9.0% at 32K). The takeaway is that disaggregation alone doesn't guarantee gains — the Attention-to-FFN allocation must be tuned — and the results remain experimental pending broader hardware testing.

Bringing Nunchaku 4-bit Diffusion Inference to Diffusers

Loading a modern text-to-image transformer in BF16 often needs 20–30 GB of VRAM; most quantization backends are weight-only, cutting memory but not speeding up (and sometimes slowing) inference. SVDQuant, the method behind Nunchaku, instead runs the main transformer layers at 4-bit weights AND activations (W4A4), shrinking memory while accelerating the denoising loop — it moves activation outliers into weights, keeps the hardest part in a small 16-bit low-rank branch, and quantizes the rest to 4 bits. Diffusers now loads these checkpoints directly via frompretrained() with no local CUDA compilation, generating a 1024×1024 image in ~1.7s on an RTX 5090 at ~12 GB peak versus ~24 GB for BF16. The new "Nunchaku Lite" path trades away architecture-specific fused kernels — so it can't match the full engine's speed — but still delivers ~30% speedup with the same VRAM savings; NVFP4 needs Blackwell GPUs while older cards use INT4.

v2.1.218

This Claude Code release is a large maintenance and accessibility update. The headline behavioral change moves /code-review to run as a background subagent so review work no longer floods the conversation, and /deep-research is also being adjusted. Numerous fixes address real hazards: Windows paths with \u-prefixed segments being mangled into CJK characters, the left-arrow key discarding conversations without undo, retry loops re-sending doomed context-overflow requests, and agent frontmatter hooks running from untrusted folders. It also adds screen-reader announcements for deleted text, HTTP status/error detail to claude mcp list failures, and improved auto-mode handling of dangerous-rm and suspicious-Windows-path checks so they no longer trigger permission dialogs.

Copilot vs. raw API access: What are you actually paying for?

GitHub argues the choice between paying for Copilot and calling the same models via raw API depends on "what work you need to own." Copilot is development tooling wrapped around the model — connecting the editor, repository, pull request, issue, terminal, and org policies — so cost per task depends on context selection, tool use, and retries, not just the listed token rate; org plans pool AI Credits with admin budgets and usage dashboards. Raw API access is the right foundation when you're building a product feature, internal agent platform, eval harness, or automation pipeline you fully control. GitHub also cites an evaluation holding model, benchmark, context window, and tooling constant across SWE-bench Verified/Pro, SkillsBench, TerminalBench and Win-Hill, where Copilot CLI reached task-resolution parity with vendor harnesses while using fewer tokens in most configurations.

How to Actually Run Your Coding Agent Safely (And Avoid the Horror Stories)

Cole Medin addresses "YOLO mode" (e.g. Claude's dangerously-skip-permissions), the setting that lets a coding agent run any command without asking — which every agent has and most people use daily. He argues the solution is not to abandon YOLO mode, since approving hundreds of actions defeats autonomy and wastes time, but to contain it. His primary recommendation is sandboxing with Docker because it's free, easy to set up, and capable: an isolated environment gives the agent full autonomy without the risk of it wiping databases or deleting directories on your real machine. The video walks through the risks people underestimate and then demonstrates the Docker-sandbox setup.

Tessl Skills Clinic - Nnenna Ndukwe from Qodo

The transcript for this video was unavailable (blocked by rate limiting / bot detection), so this summary draws only on the published description. Host Simon Maple runs Qodo's PR Resolver agent skill through Tessl's automated review, which scores skills against Anthropic's best practices, and watches the skill climb from 78% to 89% after fixes are applied. The discussion argues that a skill's description is the single biggest factor in whether an agent ever triggers it, and that most agent skills go unused because of poor descriptions. It also touches on new research suggesting AI-generated skills often underperform human-written ones.

Simon Martinelli - Lessons from Spec-driven Development - AI Native DevCon June 2026

The transcript for this video was unavailable (blocked by rate limiting / bot detection), so this summary draws only on the published description. Martinelli presents the "AI Unified Process," a spec-driven approach in which system use cases — descriptions of observable system behavior — become the central, stable contract, and code is derived from those use cases rather than treated as the source of truth. AI acts as a supporting tool that generates and updates code and tests from the use cases in small, controlled steps, keeping backend logic, database access, and UI behavior aligned over time instead of doing full regeneration. The talk draws concrete workflows and lessons, including limitations and trade-offs, from three real customer projects. The description also flags a related theme of "AI slop" pull requests straining open-source maintainer trust.

A Preview of Production-Scale Kimi K3 Support on vLLM

Moonshot AI's newly announced Kimi K3 is a 2.8-trillion-parameter model with native vision, a 1-million-token context window, Kimi Delta Attention (KDA), Attention Residuals (AttnRes), and highly sparse Mixture-of-Experts; full weights are slated for release by July 27, 2026, with vLLM targeting day-0 serving. The post details how each architectural choice shifts cost: KDA reduces per-token KV retention but introduces a large recurrent state, AttnRes eases the single-residual-stream limit but adds cross-layer memory traffic, and extreme MoE sparsity avoids activating all 2.8T parameters but raises routing and communication stakes. The central engineering challenge is prefix caching: because KDA is recurrent, vLLM must capture the exact KDA state at a prefix boundary, and storing state at every cache boundary is too expensive, so the new design decouples the physical state block size from where cache hits can land. Day-0 support, the authors stress, comes from early architecture sharing and upstreaming, not a single post-release pull request.

Beyond a Single Model: Building Mixture-of-Models Systems with vLLM Semantic Router

vLLM Semantic Router is evolving from routing among models toward composing dependable "Mixture-of-Models" systems, where independent models, policies, preferences, and execution paths live under one versioned contract that can be trained, evaluated, exported, deployed, and invoked through a single interface. In under a year it has reached 5,000 stars, 150+ contributors, and 300,000+ downloads, across three releases — Iris (composable routing with domain, embedding, factuality, and preference signals), Athena (first-class model selection, memory/RAG, multimodal stack, dashboard), and Themis (session-aware agentic routing, replayable traces, explainable routes across ROCm/CUDA/OpenVINO/CPU). The core architecture separates neural evidence from symbolic policy: signals become projections, projections feed decisions, decisions choose algorithms, and algorithms select models. A white paper formalizes this with a typed neural-symbolic DSL that validates policy before compiling it into deployable configuration.

Graph Engineering vs Loop Engineering: What Changed

The author frames "graph engineering" as loop engineering applied across multiple connected agents: same trigger, task, and success criteria, but each subtask becomes its own agent running its own trigger-task-test loop, with results passed between nodes and optionally a review agent that decides whether to re-run or ship. The key argument is that breaking work into atomic, individually verifiable pieces lets you write precise success criteria for each agent — impossible when one agent juggles ten vague things at once. But the author is blunt that most projects don't need it: a single loop is usually enough. Graphs earn their complexity in three scenarios, most notably "context rot" — when one agent's per-run context window balloons into the 300,000–500,000 token range and output degrades — at which point splitting the work avoids a self-inflicted quality tax.

Move Over Loop Engineering, Graph Engineering Is Now Here

The transcript for this video was unavailable; the following is drawn from the video's description. Chase AI argues that the "loop engineering" era of building agents may already be over, replaced by "graph engineering" as the latest approach to structuring AI agent workflows. The video walks through what graph engineering is, how it works, and why it matters, contrasting loops versus graphs before covering practical use cases. The creator frames it as a buzzword worth actually caring about for anyone building agentic systems.

v2.1.217

Claude Code's v2.1.217 release ships a broad batch of fixes and a few new features. Notable additions include emoji shortcode autocomplete (type :heart: to insert ❤️), warnings when transcript writes fail or session saving is silently off, and a cap on concurrently-running subagents (default 20) so a single message can't fan out unbounded background agents. Key fixes address a memory leak from truncated MCP tool outputs retaining full results, Windows auto-update failures that could leave claude.exe missing, background session isolation not canonicalizing symlinked directories (a workspace-escape risk), and auto-compact never triggering for Opus 4.8 on Bedrock. Subagents also no longer spawn nested subagents by default, and --max-budget-usd now actually halts running background agents once the cap is hit.

Pushing software engineering limits with “napkin math”

Gergely Orosz distills his AI Engineer's World Fair interview with Simon Eskildsen, co-founder and CEO of turbopuffer, around the practice of "napkin math" — quick back-of-envelope calculations to reveal why systems run slowly or cost too much. Eskildsen, a self-taught engineer who skipped college, spent nearly a decade at Shopify learning infrastructure and databases, and sharpened his instinct for the theoretical limits of compute operations through International Olympiad in Informatics competitions. When ChatGPT drove demand for fast search over small context windows, he used napkin math to discover existing search solutions were far more expensive than physically necessary — the insight that spawned turbopuffer. After a $8M seed round, Cursor became customer number one, and Eskildsen argues much VC funding serves founder ego rather than genuine business need.

Nativ: Run AI models locally on your Mac

Simon Willison highlights Nativ, a new macOS desktop app from Prince Canuma (developer of the MLX-VLM library) that wraps Apple's MLX framework for running AI models locally on a Mac. Similar in shape to LM Studio, it provides both a chat interface and a localhost API server for accessing models. Willison notes a nice touch: the app automatically picked up MLX models already present in his Hugging Face cache directory. He is enthusiastic about the project as a convenient local-LLM option for Mac users.

TIRx

GPU MODE session (topic implied to be tool-integrated reasoning / GPU work). Transcript unavailable — video is a scheduled live event that hasn't aired yet.

Grabette: an open system to record robot-manipulation data

Hugging Face released Grabette, a low-cost handheld gripper (Raspberry Pi + Pi camera + OAK-D depth camera) that lets anyone record manipulation demonstrations by hand and…

A Fireside Chat with Cat and Thariq from the Claude Code team

Simon Willison's edited transcript of an AI Engineer World's Fair chat with Anthropic's Cat Wu and Thariq Shihipar on how coding agents shifted engineering from careful…

Claude Code uses Bun written in Rust now

Simon Willison verifies Jarred Sumner's claim that Claude Code v2.1.181+ (June 17) ships the Rust port of Bun, finding his own install reports Bun v1.4.0 — an unreleased…

SQLite Query Explainer

Simon Willison had Claude Fable build an interactive tool that runs SQLite via Pyodide/WebAssembly in the browser and layers plain-language explanations onto the output of…

nascheme/quixote

Simon Willison notes the Quixote Python web framework got a fresh commit six hours ago — despite the repo's oldest commit being a 21-year-old import of Quixote 2.4 from Subversion.

Fine-tune video and image models at scale with NVIDIA NeMo Automodel and 🤗 Diffusers

NVIDIA and Hugging Face have integrated the open-source NeMo Automodel library with 🤗 Diffusers, bringing production-grade distributed training to any Diffusers-format model on…

Codex vs Fable: Which AI Agent Picked the Better Problem?

Nate B Jones runs a head-to-head where he tells Codex and Fable to inspect his files and Slack and pick their own business problem to automate (not just the solution). The two…

LLM cliché highlighter

Simon Willison, frustrated by writing crammed with LLM clichés ("no fluff, no filler, no jargon"), had Fable 5 vibe-code a small app that highlights ten common patterns of…

The 4 Levels of Agentic Coding: How to SHIP Like Boris Cherny

Ray Amjad walks through Boris Cherny's framework of AI-adoption stages for agentic coding, from step zero (no AI) through assisted coding up to step four. He argues most people…

Grab the guide + skill that turns "I have an agent and don't know what to do with it" into a working automation

Nate ran the same open brief ("search my business, find the problem worth automating, build it") against Codex and Fable: Codex was smoother to operate and built a useful…

Firefox in WebAssembly

Puter compiled Firefox/Gecko to WebAssembly so the full browser runs inside another browser; the ~$25K Claude Opus/Fable build proxies all traffic over a WebSocket (Wisp)…

Mermaid to ASCII art (mermaid-ascii)

Simon Willison had Claude Fable 5 compile the Go library AlexanderGrooff/mermaid-ascii to WebAssembly to compare against his earlier Grok Build Rust-based Mermaid-to-ASCII tool.

Herdr: Run Claude Code, Codex, and Every Agent in One Terminal

Herdr is an open-source, ~10MB Rust "agent-forward" terminal multiplexer (tmux-like) that runs multiple coding agents in one window, auto-detects 15+ agents, shows which need…

This Repo Just Solved The #1 Claude + Codex Headache

Chase AI demos Herdr running two Claude Code terminals plus OpenCode and Codex in one space, highlighting its three benefits: organization, multi-agent monitoring, and…

Every Prompt You Send Drags 18,384 Words Of Junk. Here's How I Cut It.

Nate B Jones argues that every corrective rule, skill, and system prompt you pile onto an AI accumulates into an invisible "harness" that degrades model performance; he built a…

Mermaid to Unicode box art (grok-mermaid)

Simon Willison found a self-contained Rust Mermaid terminal renderer inside the newly open-sourced Grok CLI and, using Claude Code for web (Fable 5), compiled it to WebAssembly…

Context engineering with Dex Horthy

On the Pragmatic Engineer podcast, HumanLayer CEO Dex Horthy (who coined "context engineering") shares 12 lessons — including that shipping unread AI-written code broke…

What building Shippy taught us about building agents

Ai2's Skylight team details the architecture of Shippy, a high-stakes maritime AI agent, structured as "soul, skills, and config" (running on the OpenClaw harness and Claude…

Model Routing Is Simple. Until It Isn’t.

IBM Research explains why model routing is harder than a classification problem — caching made Claude Sonnet 4.6 actually cheaper than GPT-4.1 despite higher sticker prices,…

How to Turn Claude Into Your Personal Assistant

A practitioner walks through using Claude Code as a personal assistant across sales/productivity, research, and content, estimating 5–10 hours saved weekly — including an 8…

Your new model is running on instructions you wrote for the old one. Grab the skill and the guide: the map, the six rules, the cleanup, and the receipt.

Nate's Newsletter argues your smarter model may be running on a bloated "harness" of accumulated rules (one route loaded 18,384 words before reaching the relevant guide); it…

Quoting GitHub Changelog

GitHub Changelog: Dependabot now waits until a new release has been on its registry for at least three days before opening a version-update PR — this "dependency cooldown" is…

simonw/pedalican

Simon Willison built pedalican, a custom animated "pet" for Codex Desktop — a pelican riding a bicycle — and documents how GPT-5.6 Sol used several rounds of gpt-image-2 to…

lobste.rs is now running on SQLite

Community site Lobsters completed its long-planned database migration, moving off MariaDB to SQLite; CPU and memory usage dropped, the site feels snappier, and VPS costs…

datasette 1.0a37

Datasette 1.0a37 is a minor release with performance and documentation improvements to the permissions system, plus a reverted cosmetic API change that had broken nearly every…

What is “loop engineering?”

Pragmatic Engineer examines "loop engineering" — designing self-running loops that prompt the agent instead of writing prompts yourself — tracing it to Geoffrey Huntley's…

How I Turned Claude Into My Personal Assistant (Complete System)

Chase AI walks through his exact Claude-based personal-assistant setup, automating three buckets of grunt work — productivity/sales, research, and content — into Claude Code…

Anthropic Finally Fixed Long-Running Agents

Ray Amjad walks through Claude Code's new (and largely undocumented) "observer agents" feature, enabled via CLAUDEEXPERIMENTALOBSERVERAGENTS=1, which adds a sub-agent type that…

Using uvx in GitHub Actions in a cache-friendly way

Simon Willison shares a cache-friendly recipe for uvx tool-name in GitHub Actions: set UVEXCLUDENEWER: "2026-07-12" and use it as part of the cache key so tools resolve to a…

Anthropic Can Now Read Claude's Mind

DOOMQL

datasette code-frequency chart on GitHub

Executive Briefing: Point an agent at your calendar and your repo, and it will show you the rules your company is actually running. Here are the 15 I wrote for mine.

Your company has rules nobody consciously voted on—they live in meetings and processes; AI dissolves scarcity but not judgment, leaving you to sort which rules still matter…

shot-scraper 1.11

shot-scraper 1.11 releases with minor improvements around command option consistency and fixing the server: mechanism when the service takes longer than a second to start…

Fable gets another bump

Anthropic is extending Claude Fable 5 access through July 19 across all paid plans, allowing subscribers to use up to half their weekly usage limit before switching models or…

sqlite-utils 4.1.1

sqlite-utils 4.1.1 includes mainly a fix for an edge case discovered while experimenting with the 4.1 release, specifically addressing questions about ON DELETE behavior that…

How to One-Shot a Scroll Animation Website With AI

(Chase AI) — You can now build a cinematic, scroll-scrubbed animation website with a single AI skill and one prompt; I ran it with Claude Fable 5 and GPT-5.6 Soul inside Codex,…

sqlite-utils 4.1

The first dot-release since sqlite-utils 4.0 introduces minor new features, including extending the transform mechanism to switch tables from strict to non-strict and…

Building the future of agentic infrastructure

A discussion between YouTube experts about managed agents, agent identity, harness evolution reducing nondeterminism issues, composite strategies like multi-agent competition…

Grab the One-Minute Test That Tells You If Your Task Needs a Chat, One Agent, a Team, or Nothing at All

Nate's Newsletter presents a framework for evaluating tasks in about one minute using four criteria (size, independence, separation, checkability) to resolve them into chats,…

1.6M agents registered for OpenClaw and did NOTHING.

A critique of the 1.6 million registered AI agents who sat idle after being set up without any assigned tasks; explores why organizations struggled to utilize available agent…

Profiling in PyTorch (Part 3): Attention is all you profile

The third installment of PyTorch's profiling series focuses on attention mechanisms, analyzing kernels in naive implementations versus fused SDPA, and demonstrating how…

llm-meta-ai 0.1

The new llm-meta-ai plugin provides CLI and Python library access to Muse Spark 1.1 as an unofficial API into the model for preview users during access which was long enough to…

llm 0.31.1

A bug came up when testing llm-meta-ai that got posted as a beat by Simon Willison related to the plugin functionality for Muse Spark 1.1 access during preview period.

Data for Agents

NVIDIA releases synthetic open datasets for agentic AI training to enable better tool-use failures and multi-step reasoning without exposing proprietary "secrets" that make…

Native-speed vLLM transformers modeling backend

The transformers library's vLLM backend now achieves native inference speeds via torch.fx static analysis and runtime layer fusions for compatible architectures, eliminating…

Why AI Infrastructure must evolve for Agent Experience — Akshat Bubna, Modal CTO

Modal CTO Akshat Bubna argues that traditional cloud infrastructure designed for human developers who can fill context gaps in their heads doesn't work for agents, which…

The Pragmatic Engineer AMA

Andrew Stellman answers subscriber questions about software engineering, AI, hiring, and his career; shares three stories including how COVID prompted him to become a full-time…

Rewriting Bun in Rust

Bun developer Jarred Sumner uses Claude Anthropic's latest frontier model (Mythos/Fable) to rewrite Zig codebase in safe Rust using test suite as conformance suite; the 1.1…

From Hugging Face to Amazon SageMaker Studio in one click

From Hugging Face to Amazon SageMaker Studio in one click — New deep-link integration lets developers deploy models directly from Hugging Face into pre-configured SageMaker…

sqlite-utils 4.0, now with database schema migrations

sqlite-utils 4.0, now with database schema migrations — Introducing native schema-migrations support via programmatic Python migration files that track applied changes in a…

sqlite-migrate 0.2

sqlite-migrate 0.2 — The final release promoting schema migrations as built-in into sqlite-utils; existing projects continue unchanged while new users get migration features by…

github-code Web Component

github-code Web Component — New GPT-5.5 generated component that embeds specific GitHub code blocks with line numbers for previewing snippets in the browser;

sqlite-utils 4.0rc4

sqlite-utils 4.0rc4 — Last RC release implementing detailed Fable 5 review feedback before stable launch with compound FKs, nested transactions, and migrations ready for…

Run AI workloads on any cloud, store on Hugging Face: zero-egress storage with SkyPilot

Hugging Face + SkyPilot now offer zero egress storage, allowing teams to mount any Hub repo as a local path with hf:// URLs and run compute where GPU capacity exists without…

tencent/Hy3

Tencent's Hy3 multimodal model announced by Simon Willison — a new entrant to the LLM race from China with Pelican-riding-a-bicycle branding and generative AI capabilities…

LeRobot v0.6.0: Imagine, Evaluate, Improve

Import AI 464: Fables writes GPU kernels; AI automation; and analog computation

🤗 Kernels: Major Updates

Building a World Map with only 500 bytes

Simon Willison, July 4) – Pushing ASCII art and data URL techniques to represent global geography in under 500 bytes of JavaScript. Source

Better Models: Worse Tools

Simon Willison, July 4) – Reflection on how improved LLMs don't always translate to better developer tooling; discusses Armin Ronacher's observations and tools from…

Open Source AI Gap Map

explores gaps in the open-source AI landscape, covering categories from local LLMs to generative-AI tooling and dataset creation. URL

Vercel's Andrew Qu on why agents are a new kind of software

Agents as a new kind of software, by Vercel's Andrew Qu (latent.space/p/vercel-agents-new-software) — published 2026-07-03

llm-coding-agent 0.1a0

Simon Willison releases llm-coding-agent v0.1a0: an open implementation that wraps coding agents and exposes a simple interface (simonwillison.net) — published 2026-07-02

Using DSPy to evaluate and improve Datasette Agent's SQL system prompts

Simon Willison applies DSPy to evaluate and improve Datasette Agent's SQL system prompts, making it smarter at query generation (simonwillison.net) — published 2026-07-02

AIEWF Daily Dispatch: Loops, Software Factories & Forward Deployed Engineers

Richard MacManus reports from the second day of the AI Engineer World's Fair where "loops" dominated conversations about agent engineering. Key themes include loopcraft…

Forward Deployed Engineers and the future of software engineering

Deep dive into how forward deployed engineers are shaping the future of software engineering. URL (Published: 2026-07-01)

Featuring Every Eval Ever Results on Hugging Face Model Pages

Every eval ever results are now visible directly on HuggingFace model pages, making it easier to compare models. URL (Posted by eeecommunity; Published: 2026-06-30)

[AINews] Loopcraft: The Art of Stacking Loops

An exploration of the art and principles of creating effective loops in agentic systems. URL (Published: 2026-06-12; Date may be historical based on publish date within article…

ScarfBench: Benchmarking AI Agents for Enterprise Java Framework Migration

A new benchmark specifically for evaluating AI agents' performance in enterprise Java framework migration tasks. URL (Posted by IBM Research; Published: 2026-06-30)

Have your agent record video demos of its work with shot-scraper video

Learn how to have your AI agents record video demos of their work using the newly updated shot-scraper toolchain. URL (Published: 2026-06-30; Categories: projects, python, ai,…

shot-scraper 1.10

Latest release of shot-scraper with new features for automated visual testing and screen capture automation. URL (Published: 2026-06-30; Categories: python, coding-agents)

Quoting Jon Udell

Simon Willison's "Quoting Jon Udell" blog post ( — covers coding-agents, generative-ai, llms; published 2026-06-28

Hack Your Summer

Simon Willison's "Hack Your Summer" career advice ( published 2026-06-28

Using Local Coding Agents

Sebastian Raschka's Ahead of AI piece covering safe local agent design, privacy (keep code on-device), cost controls with LLMs; practical IDE integration patterns and…

The Five Questions That Turn a Messy Task Into an AI Loop (+ the prompts to map yours)

+ prompts to map yours). Nate's Newsletter explores frameworks for identifying recurring tasks suitable for automation loops. URL: | Published: 2026-06-24

I Stopped Prompting AI One Task At A Time. This Works Better.

Video discusses "loop of loops" approach—organizing agents around recurring jobs rather than one-off prompts, moving from task-by-task prompting to agent-based solutions that…

Executive Briefing: Your team is running agents nobody owns. The one-page card and two prompts that fix it.

New article highlights that "everyone is running agents nobody owns" and introduces a one-page ownership framework with two essential prompts to fix the problem. Read

You Can't Run AI Agents Without This

Video explaining the difference between assistant interactions (ask/answer model) versus agent systems that produce reusable work products with clear ownership requirements. Watch

Vercel deleted 80% of its agent's tools and the agent got better + what to delete from yours (guide inside!)

URL

Don't build more AI agents until you watch this

URL

Only 1 in 1,600 People Use Codex. Here's How to Catch Up.

| "Only 1 in 1,600 People Use Codex. Here's How to Catch Up." (June 12)

Grab my Ultimate Guide to Codex and catch up to the 1 in 1,600 people using it every week (mostly no code!)

from Nates Newsletter (June 12)

Claude FM 🎵 music for thinking and building

June 12)

Claude FM 🎵 music for thinking and building

June 12)