Orphaned VMs aim to keep guests running while the host kernel reboots

An experimental Linux RFC from Google explores keeping virtual machines executing through a host-kernel live update, rather than stopping guests for reboot or security maintenance.

The proposed “Orphaned VM” architecture preserves vCPU state and physical CPUs, then uses a KVM Caretaker Core to handle selected VM exits while the host operating system and VMM are offline. It builds on the Live Update Orchestrator and has been tested on Intel, AMD, and Arm, but the 46-patch series is explicitly very early and not production-ready. The hard parts are exactly the ones expected: timekeeping drift, stray interrupts, guest-to-guest IPI routing, and safely crossing the management gap.

Phoronix reports 13 forum comments, but its forum endpoint was unavailable during review, so I’m not inferring a reaction consensus.

• Phoronix discussion

Linux perf is moving from embedded interpreters to standalone Python scripts

A 49-patch Linux perf series replaces embedded libpython/libperl scripting with standalone Python programs backed by a C extension, cutting one measured perf script run from about 3.75 seconds to 0.106 seconds.

The redesign avoids constructing Python dictionaries for every event, removes interpreter-lifecycle and build-dependency complications, and ports the existing profiling, syscall, scheduling, networking, Intel PT, and database-export scripts to a common perf Python module. It also enables mypy and pylint checks when installed, with opt-outs, and removes the legacy embedded scripting engine. The series is still under review; v2 was posted on September 21, 2026.

• v2 patch series

Bot-free self-hosted analytics with GoatCounter on NixOS

Vincent Bernat describes a privacy-oriented analytics deployment that cuts bot noise without cookies or stored IP addresses, then packages the whole setup as NixOS modules across five servers.

The design uses a custom GoatCounter client that records a hit only after user interaction, a CSS fallback for JavaScript-disabled readers, local proxies that buffer and batch events, systemd-nspawn containers, Colmena deployment, and Litestream backups for the SQLite database. The result counted fewer than 200 humans per day where GoAccess reported roughly 2,000 crawler-heavy visits. The trade-off is deliberate: interaction-based filtering also omits RSS readers and can be bypassed by sophisticated browsers.

The Lobsters discussion had one useful wrinkle: the author notes that EasyPrivacy blocks hosted GoatCounter, prompting the question of whether hiding the tracker endpoint is acceptable even when the analytics are privacy-friendly.

• Lobsters discussion
• NixOS configuration

Apple Silicon speaker and headset support moves toward mainline Linux

A 28-patch series adds the missing mainline audio path for Apple M1 and M2 Macs, including speaker output and headset-jack capture.

The new macaudio machine driver handles the highly variable speaker arrangements and exposes the measurements needed by the userspace speakersafetyd daemon. Because these machines lack hardware or firmware failsafes against speaker damage, the driver mutes and locks speaker controls unless that daemon is running. The series adds Device Tree support for M1/M2; M3 support is deferred because prerequisite hardware nodes are still missing. The submission is roughly 3,000 lines and remains under review.

Phoronix lists one forum comment, but the forum endpoint was unavailable during review.

• Phoronix discussion

akitaonrails/ai-memory

ai-memory is a Rust, self-hosted memory and handoff service for coding agents that lets work continue across harnesses, machines, and teammates without repeating project context.

It integrates with more than twenty agent environments through lifecycle hooks, records prompts and tool calls at a typed privacy boundary, and turns sessions into searchable handoff pages. The source of truth is a git-backed wiki of plain Markdown; the database is a rebuildable index, and capture/search/handoff work without an LLM API key. Multi-user auth, project-scoped knowledge, attribution, and an audit log are built in. It is a young project, so its broad harness support and operational claims still need independent field experience.

• README
• Rust trending page

AX – Google’s Open Agentic Orchestrator

Google’s AX is an open, Kubernetes-native runtime for running agents as durable, resumable tasks with policy-controlled execution, auditing, and observability.

The runtime is deliberately below the model and harness layer: it provides scheduling, recovery, coordination, resource limits, network egress allowlists, and protocol support for MCP and A2A while letting users bring their own model and planning logic. The trade-off is substantial operational weight—the quickstart requires Kubernetes, a registry, and the Agent Substrate control plane—and the project is early enough that its long-term scope and support are uncertain.

HN’s 545-point, 245-comment discussion split between people interested in secure, scalable multi-agent workloads and criticism that this is “Kubernetes for agents,” overbuilt for local development, and hard to evaluate without clearer benchmarks. Several commenters highlighted the distinction between the infra-layer runtime and application-layer workflow frameworks, plus the importance of gVisor/microVM isolation, resumability, and zero-trust permissions.

• Project site
• Source discussion
• Google/AX repository

Kubernetes 1.37 Released: Stable Metrics API and Rootless Kubelet in Beta

Kubernetes 1.37 makes the Metrics API generally available and moves rootless kubelet support to beta, while adding safer control-plane recovery and several workload-management primitives.

The release also stabilizes resilient watch-cache initialization, which bounds API-server requests instead of flooding etcd after a restart; adds pod checkpoint/restore and stable pod certificates; and introduces alpha scheduling and StatefulSet rollout options. Rootless kubelet uses Linux user namespaces to reduce the impact of container escapes. The article is a release summary, so check upstream notes before relying on feature maturity or exact gate behavior.

• Kubernetes release information
• InfoQ coverage

The Agent Harness: Control Planes, Invariants, and Approval Boundaries for Production AI Agents

Reliable production agents need stronger structure than prompt-level guardrails: explicit state ownership, serialized concurrent mutations, scoped execution authority, and validation at the user-visible edge.

OpenAI’s Vinoth Govindarajan uses production case studies to frame the harness as a control plane around the model. The emphasis is operational: make state transitions explicit, constrain what tools can do, and verify the resulting action rather than trusting an agent’s internal reasoning. The page is a conference-session summary rather than a research paper, so implementation detail is limited.

• InfoQ session summary

AWS Cannot Restore Data Held Only in Damaged Middle East Availability Zones

AWS says it cannot restore resources and data stored exclusively in the affected Bahrain region or one damaged UAE availability zone, exceeding the failure assumptions of its regional and multi-AZ services.

The incident is a sharp reminder that “multi-AZ” is not the same as an independent recovery plan: customers needed cross-region replication or migration for workloads whose durability requirements exceeded those regional boundaries. The practical lesson is to model correlated physical and geopolitical failures explicitly, validate restore paths, and treat provider redundancy claims as conditional on architecture and service configuration.

• InfoQ report

Uber Redesigns M3DB Sharding with Subclusters to Limit Failure Impact

Uber’s new M3DB placement model bounds the blast radius of node failures and maintenance by partitioning nodes into fixed-size subclusters instead of allowing shard dependencies to span most of a cluster.

Each subcluster owns a non-overlapping shard range while preserving replica isolation across racks or availability zones. Scaling uses a greedy O(S log S) sort plus O(S × N) simulation to choose shard moves that keep the donor balanced, avoiding a second rebalance pass. The trade-offs are real: equal instance weights, scale steps tied to subcluster size and replication factor, and temporary cross-subcluster sharing during expansion.

• Uber’s primary design writeup
• InfoQ coverage

Cloudflare Introduces the Agent Development Lifecycle to Replace Traditional SDLC

Cloudflare’s proposed Agent Development Lifecycle treats agent-based software factories as event-driven systems that need preview deployments, durable workflows, observability, and capability-bounded credentials—not just faster code generation.

The design uses Workflows to spawn containers, browsers, and subagents; @cloudflare/ci adds dependency caching and credential support; and tracing exposes model calls, tool executions, token use, and subagent handoffs. Its Agent Access Model issues short-lived task-bound credentials and applies a “trust ratchet” to reduce capabilities after protected-resource access. These are early product designs, not an independently evaluated standard.

• Cloudflare’s primary announcement
• InfoQ coverage

Intel Xe adds vRAM health checks and page offlining

Queued for Linux 7.4, the Intel Xe driver adds a debug-gated early-probe canary check for the last vRAM page, intended to catch BAR/CCS sizing and identity-map errors. It also adds vRAM page offlining after 21 review rounds, permanently keeping faulty pages out of future allocations and exposing bad ranges through DebugFS. The same pull adds per-engine idle status in DebugFS.

https://www.phoronix.com/news/Intel-Xe-vRAM-Health-Check

Primary patch discussion: https://lore.kernel.org/all/20260902124117.918018-12-matthew.auld@intel.com/

Notion’s production CRDT for collaborative rich text

Notion describes the CRDT/data-model redesign it deployed in July 2025 for concurrent editing and Offline Mode: an RGA-derived sequence structure with stable session/Lamport IDs, tombstones, Peritext-style rich-text annotations, and a text-slice/tree model that preserves edits across concurrent block splits. A search-label index limits the number of blocks fetched when a text instance has been split repeatedly. Notion says the system processes millions of CRDT operations per minute.

https://www.notion.com/blog/how-notion-handles-concurrent-editing-with-crdts

Gzip 1.15 fixes decades-old correctness and safety bugs

Gzip 1.15 (September 20, 2026) includes more than 100 commits, largely bug fixes accumulated over the past 18 months. The release fixes a race that could remove the wrong file after an ancestor rename, uninitialized-memory use, an LZH decompression buffer overflow, multiple LZH corruption cases, streamed ZIP handling, temporary-file races on limited platforms, and locale handling for diagnostics. It also drops several obsolete platform targets.

https://www.phoronix.com/news/Gzip-1.15-Released

Linux 7.4 may make read-only file opens ~39% faster

A VFS patch queued for Linux 7.4 lets do_dentry_open() consume an already-held terminal dentry reference instead of taking and dropping redundant references during pathname lookup. The five-revision series reports a 39% increase in read-only open() operations in will-it-scale on a 20-core VM.

That is a focused microbenchmark, not an end-to-end application result, but the change is unusually small and targets a hot path after more than two years of iteration.

Phoronix report

Btrfs, ZFS, and bcachefs under real workloads

A new benchmark suite compares multi-device CoW filesystems across core I/O, responsiveness, metadata work, and integrity—not just synthetic throughput. Its current cohort shows bcachefs scoring strongly on the aggregate workload mix, while Btrfs and ZFS vary substantially by layout.

Important caveat: the automated runs use loop devices on shared ephemeral VMs, so the author says to compare ratios rather than absolute MB/s; real-hardware runs are still being added. The benchmark sources and run history are public.

Benchmark · HN discussion

Wild vs. Mold: why linker benchmarks disagree

David Lattimore reproduced Mold’s recent linker results and traced the difference from Wild’s earlier numbers to benchmark setup: whether the output file already exists, tmpfs versus ext4, and whether startup uses fork or --no-fork. Under matched conditions, the linkers are much closer than the headline comparison suggests.

The post also identifies concrete follow-up work: Wild needs the same filesystem-specific optimizations Mold uses, including preallocation and huge-page mapping. It is a useful example of how benchmark methodology can dominate systems-tool comparisons.

Benchmark analysis

Linux 7.3-rc4 fixes two Btrfs regressions

The upcoming kernel release restores stable Btrfs filesystem IDs after a Linux 7.2 change made f_fsid vary across upgrades and reboots. That broke userspace expecting a stable ID—including NetworkManager OpenConnect users whose VPN key handling stopped working after upgrading.

The same fix batch repairs /dev/root detection for Btrfs root filesystems on initramfs-less GRUB2 boots. Both regressions are user-visible compatibility failures, not just cleanup.

Phoronix report

What Zig felt like, coming from Rust

A Rust developer with seven years of experience reimplemented an existing Rust JSONPath library in Zig, using the project to compare the languages in a non-toy but bounded setting. The report covers Zig’s sparse IDE support, build.zig as a compact test/compliance driver, the shift back toward CLI tooling, and the friction of carrying Rust habits into Zig. It is useful less as a language verdict than as a concrete account of the first serious port.

The Hacker News thread had 171 points and 209 comments when checked. Discussion pushed back on treating one project as representative, and several commenters highlighted Zig’s current stability and ecosystem tradeoffs for long-lived or archival code. The author also explicitly labels the experience as an early, potentially naive introduction to Zig.