---
name: The System Design
tagline: An Engineering Newspaper Curated By Adarsh Kumar
curator: Adarsh Kumar
curator_url: https://adsingh-portfolio1.vercel.app/
date: 2026-10-02
edition_label: "Friday, October 2, 2026"
canonical_url: https://tsdn.vercel.app/2026-10-02/
---

# The System Design — Friday, October 2, 2026

> An Engineering Newspaper curated by [Adarsh Kumar](https://adsingh-portfolio1.vercel.app/)

--------------------------------------------------------------------------------

## [Row-Level Security Performance in PostgreSQL, Measured](https://now-next.nl/en/insights/row-level-security-performance-postgresql/)

**Why read:** See how policy expressions, function volatility, indexes, and parallel safety can change PostgreSQL row-level security from near-zero overhead to a full-table scan.  
**Discussion:** [HN Thread](https://news.ycombinator.com/item?id=49949946)  

A benchmark on PostgreSQL 17.10 and nearly two million invoices shows that a direct tenant policy using current_setting() can perform about as well as an explicit tenant filter when the right index is available. The cost depends on how the policy obtains the tenant and whether its expression can use the index.

The report measured a volatile PL/pgSQL helper at roughly 1.9 seconds where a simple indexed lookup took fractions of a millisecond, because the helper prevented the planner from using the tenant index. Declaring an appropriate helper STABLE, and considering parallel safety, restored efficient plans. The results underline that RLS policies need query-plan testing with realistic tenant sizes and connection-pool behavior.

---

## [Homa: Rethinking TCP for Low-Latency AI Clusters](https://www.theregister.com/networks/2026/10/01/stanford-prof-is-beating-the-drum-for-a-new-protocol-to-replace-tcp/5300629)

**Why read:** Understand a message-oriented datacenter transport that lets receivers schedule traffic and prioritize short RPC-like messages instead of treating all traffic as one TCP byte stream.  
**Discussion:** [HN Thread](https://news.ycombinator.com/item?id=49953983)  

Homa is a message-based transport proposal aimed at datacenter workloads where short RPCs can be delayed behind large transfers. Unlike TCP?s byte-stream model, receivers learn the expected message size and schedule incoming traffic, using shortest-remaining-processing-time behavior to favor shorter messages.

The Register reports benchmark figures presented by John Ousterhout: at 100 Gbps and 80% utilization, short-message p99 latency was reported as 92 microseconds for Homa versus 1.2 milliseconds for TCP. The protocol is intended to coexist with TCP during gradual adoption; standardization and upstreaming work remain in progress.

---

## [Deterministic Simulation Testing in Celld](https://celld.dev/blog/deterministic-simulation-testing/)

**Why read:** Learn how reproducible event scheduling and injected storage/network faults expose race conditions that ordinary integration tests may rarely reproduce.  
**Discussion:** [HN Thread](https://news.ycombinator.com/item?id=49957355)  

Celld describes a deterministic simulator that runs the system?s production event-handling code while controlling request delivery, task scheduling, simulated time, and object-storage outcomes. Tests can delay or fail writes and explore different event interleavings without waiting for real time.

A fixed random seed reproduces the same execution, allowing a failing schedule to be replayed and inspected. After each action, invariant checks verify system state. The article describes using this approach to find and reproduce a previously unknown alarm-related race in the runtime.

---

## [The Agent Said It Was Done. The Database Disagreed.](https://huggingface.co/blog/microsoft/thinkingbox)

**Why read:** A stateful agent benchmark checks whether workflows leave correct backend records and side effects, not merely whether an agent made plausible tool calls.  
**Discussion:** [HN Thread](https://news.ycombinator.com/item?id=49952030)  

Microsoft and Hugging Face introduce ThinkingBox, which evaluates agents against the terminal state and side effects they leave in a backend. A workflow can contain well-formed tool calls and still be wrong?for example, closing a customer ticket when the required state is to leave it on hold.

The benchmark runs 507 stateful workflows repeatedly from clean backends and reports single-attempt success, whether a task succeeds at least once, and observed consistency across 20 attempts. Its central systems lesson is that tool-call traces are not a substitute for checking durable application state.

---

## [Untyped: Model-Checking Agent Tool Protocols](https://github.com/untyped-ai/untyped)

**Why read:** A concrete example of formally checking retries, approval gates, and tool-call budgets in side-effecting agent workflows.  
**Discussion:** [HN Thread](https://news.ycombinator.com/item?id=49953789)  

Untyped models the protocol around an agent and its side-effecting tools, rather than trying to model the language model itself. Its TLA+ specification checks properties such as at-most-once effects, approval before destructive actions, and a call budget that remains bounded across retries.

The examples demonstrate how a lost acknowledgement can lead to duplicate effects when an idempotency key is scoped to an individual attempt instead of a logical step. The project also checks recorded event traces against the same protocol, connecting design-time model checking with observed runtime behavior.

---

## [Stateful Linux MicroVMs for Coding Agents](https://github.com/mariobm/agent-house)

**Why read:** Explore a self-hosted sandbox design that gives coding agents persistent Linux machines, snapshots, and isolated workspaces instead of disposable containers alone.  
**Discussion:** [HN Thread](https://news.ycombinator.com/item?id=49955804)  

Agent House presents AHVM, a client and server setup for running persistent Linux microVMs on hardware the operator controls. Each VM provides an interactive shell, files, networking, and snapshots; the project uses a libkrun-based runtime and supports workflows such as pausing, resuming, and restoring a checkpoint.

The repository labels the project early release and explicitly says it is not qualified for hostile multi-tenant workloads. That distinction matters when evaluating isolation boundaries: a convenient agent sandbox is not automatically a hardened multi-tenant execution service.

---

## [How a ttrpc-Rust Concurrency Bug Dropped the Final RPC Frame](https://notes.shvbsle.in/ttrpc-data-loss/)

**Why read:** A concrete example of how out-of-order asynchronous frame handling can silently lose data, and why a naive fix can introduce head-of-line blocking.  
**Discussion:** [HN Thread](https://news.ycombinator.com/item?id=49951655)  

An intermittent container log stream ended before its final message. The investigation traced the loss to ttrpc-rust, a lightweight RPC protocol used between components such as containerd and its shims. The client spawned a task per incoming frame, so a close frame could remove a stream before the task handling the preceding data frame looked it up.

Processing frames inline preserves their read order, but the article notes that this naive fix can create connection-wide head-of-line blocking. The case illustrates why protocol fixes must preserve ordering without allowing one slow stream to stall unrelated requests.

---

## [Hacking the Go Compiler to Efficiently Map IPv4 to IPv6](https://vincent.bernat.ch/en/blog/2026-go-netip-addrto6)

**By:** Vincent Bernat  
**Why read:** A focused example of how compiler optimization decisions affect a tiny hot-path operation in Go?s net/netip address representation.  
**Discussion:** [HN Thread](https://news.ycombinator.com/item?id=49954375)  

The article examines mapping an IPv4 netip.Addr to its IPv4-mapped IPv6 form. The standard-library-friendly AddrFrom16(ip.As16()) sequence is simple, but the author?s benchmark on Go 1.27.1 measured it at about 7.14 ns per operation, compared with about 0.88 ns for a native implementation.

It walks through standard-library, helper-function, and unsafe-layout approaches, including the generated assembly. The practical takeaway is to benchmark the actual hot path and weigh unsafe representation tricks against maintainability and compatibility rather than assuming the compiler will optimize equivalent-looking code.

---

## [System Design in Depth: An Interactive Learning Platform](https://vedgupta.in/blog/system-design-in-depth/)

**Why read:** A newly shared curriculum pairs system-design concepts with simulators, implementation exercises, and operational trade-offs.  
**Discussion:** [HN Thread](https://news.ycombinator.com/item?id=49954222)  

System Design in Depth is an open learning platform focused on the mechanisms behind familiar architecture components. Its curriculum spans workload modeling, storage engines, consensus, queues, production resilience, and architecture evolution.

Rather than relying only on diagrams, it includes interactive simulators for concepts such as Raft, consistent hashing, cache stampedes, and rate limiting, along with from-scratch implementation exercises. The platform’s design reflects a useful teaching principle: make consistency, failure handling, and operational trade-offs visible instead of treating components as interchangeable boxes.

---

## [Page Table Memory Consumption](https://frn.sh/pagetables/)

**Why read:** Learn why page tables can consume substantial memory when many processes map the same shared regions.  
**Discussion:** [HN Thread](https://news.ycombinator.com/item?id=49951390)  

Linux page tables are often a small fraction of mapped memory, but that estimate changes when many address spaces map the same physical pages. Each process generally needs its own page-table entries, even when the underlying data pages are shared.

The article traces this cost through examples involving shared-memory workloads, including database clients mapping a large shared global area. In extreme cases, per-process page tables can consume enough memory to contribute to out-of-memory failures. It explains why page-table accounting and possible mechanisms for sharing page tables matter when designing systems with large numbers of processes and shared mappings.

---

## [Kyber Remote Streaming Solution Architecture](https://kyber-27201e.gitlab.io/docs/Architecture/General/)

**Why read:** See how a remote-streaming system separates media, input, USB forwarding, authentication, and network transport into supervised components.  
**Discussion:** [HN Thread](https://news.ycombinator.com/item?id=49952543)  

Kyber?s documented target architecture splits server responsibilities among a media streamer, input server, USB service, network multiplexer, and controller. The controller authenticates clients, launches and supervises the required processes, and propagates authorization decisions.

The design uses shared client/server components where possible and describes QUIC-based communication for its data plane. Separating media capture and encoding from control and device forwarding provides clearer fault and responsibility boundaries, while also allowing multiple screens and users to be managed.

---

## [TurboPython: A Python-to-C++ Compiler](https://tpy-lang.org/)

**Why read:** See how a Python-like language changes its type and ownership rules to support ahead-of-time compilation without garbage collection.  
**Discussion:** [HN Thread](https://news.ycombinator.com/item?id=49954875)  

TurboPython describes a Python-syntax language with required function and field types, a strict ownership model, and compilation to C++. It removes dynamic runtime features such as monkey-patching and garbage collection, while making ownership transfers and copies explicit through its type system.

That design trades compatibility with the broader CPython package ecosystem for more predictable object lifetimes and compiled execution. The project is an early language implementation, so its current standard-library and third-party-package support should be considered before evaluating it for production use.

---

## [Latency Implications of Virtual Memory](https://rigtorp.se/virtual-memory/)

**Why read:** Understand how page faults, TLB misses, and page-table changes can create latency spikes in real-time and high-frequency systems.  
**Discussion:** [HN Thread](https://news.ycombinator.com/item?id=49953642)  

This guide explains how the virtual-memory abstraction affects latency on Linux systems. First-touch page faults, TLB misses, TLB shootdowns, and file-backed page-cache activity can introduce stalls that are difficult to see in average-latency measurements.

For latency-sensitive workloads, the guide discusses pre-faulting and pre-allocating memory, limiting the working set, considering huge pages, and measuring fault and TLB events with performance tools. The right choices depend on the workload and machine, so these techniques should be benchmarked rather than applied blindly.

---

## [Pve-agents: Coding Agents on Existing Proxmox Infrastructure](https://pve-agents.sh)

**Why read:** A current self-hosting project explores running coding-agent environments on an operator?s existing Proxmox infrastructure.  
**Discussion:** [HN Thread](https://news.ycombinator.com/item?id=49954905)  

Pve-agents is a self-hosted project inspired by cloud coding-agent environments. Its author describes using an existing Proxmox installation to provide personal development environments, bringing agent workspaces closer to infrastructure the developer already operates.

The system-design angle is the placement of ephemeral or agent-managed compute inside a home-lab or private virtualization boundary. Operators still need to evaluate lifecycle cleanup, credential handling, network segmentation, and resource limits before exposing such environments to untrusted workloads.

---

## [CTWM: Heavy-Tailed Memory Traces in Long-Horizon Agents](https://redreamality.com/blog/ctwm-heavy-tailed-memory-traces-long-horizon-agents/)

**Why read:** Explore how memory-access concentration can affect retrieval coverage and how an explicit budget policy can expose that trade-off.  
**Discussion:** [HN Thread](https://news.ycombinator.com/item?id=49955466)  

The article examines the shape of memory access in long-horizon language agents, arguing that task success and token cost alone do not show which memories repeatedly receive attention or which rare states are being dropped.

It describes Core-Tail World Model (CTWM), a proposed budget-allocation approach that ranks memory items, adjusts concentration with a parameter, and summarizes rather than simply discards the tail. The discussion presents this as an auditable design hypothesis and distinguishes heavy-tailed observations from stronger claims about criticality.

---

## [RepoGuard: Architecture Guardrails for Coding Agents via MCP](https://github.com/taylormatematica-beep/repoguard)

**Why read:** A newly shared tool applies repository architecture constraints through an agent-facing MCP interface, raising questions about making architectural rules executable.  
**Discussion:** [HN Thread](https://news.ycombinator.com/item?id=49955746)  

RepoGuard is presented as a fast architecture-guardrail tool for coding assistants such as Claude and Cursor, exposed through MCP. The project?s approach places repository constraints in a form an agent can consult while working, rather than relying only on prose instructions.

For teams evaluating this pattern, the important design questions are how rules are represented, whether checks are deterministic and repeatable, and whether enforcement also runs in CI. An agent-facing guardrail is most useful when it complements?not replaces?authoritative repository checks.

---

## [Writing Evals for Agentic Systems as a Four-Step Loop](https://sgaud.com/texts/ai-evals)

**Why read:** A practical workflow for turning reproducible agent traces and expert feedback into progressively more automated evaluations.  
**Discussion:** [HN Thread](https://news.ycombinator.com/item?id=49956391)  

This guide recommends preserving each agent run as a reproducible snapshot, including prompts, files, tools, and external responses. It then has subject-matter experts label runs, builds a dataset from those judgments, and derives a rubric from recurring failure modes.

Only after the checks and examples exist does the workflow introduce an LLM judge, whose decisions should be validated against human evaluations. Deterministic code checks—such as validating schemas, tool usage, and resulting database state—should remain preferred wherever they can express the requirement.

---

## [MentaAgent: A Self-Hosted Analyst for Company Files](https://github.com/DanielKim03/mentaagent)

**Why read:** Review a self-hosted assistant architecture that combines persistent document data, model-provider choices, and source-linked answers.  
**Discussion:** [HN Thread](https://news.ycombinator.com/item?id=49952810)  

MentaAgent is a self-hosted business analyst that ingests company documents and spreadsheets, answers questions with references to source files, and retains information across conversations. The project runs through Docker Compose and supports configurable hosted providers as well as a local-model option.

Its deployment notes make important system boundaries explicit: files remain on the operator’s machine, but content sent to a selected hosted model provider leaves that boundary. The project also distinguishes keyword search from embedding-based semantic search, illustrating how provider capabilities shape the retrieval architecture.

---

## [Someone Got Doom Running in an SQL Database](https://arstechnica.com/gaming/2026/10/can-it-run-doom-sql-database-edition/)

**Why read:** A playful database story that asks how far SQL-based data systems can be pushed beyond their conventional transactional and analytical workloads.  
**Discussion:** [HN Thread](https://news.ycombinator.com/item?id=49956404)  

Ars Technica reports on an implementation of Doom running in an SQL database. The unusual project turns the familiar ?Can it run Doom?? challenge into a database-engineering experiment: using a system primarily built to store and query data as the host for an interactive game.

The system-design interest is in the boundary between a database?s intended workload and general computation. It is a reminder that SQL engines provide powerful execution and state-management machinery, while also raising practical questions about fit, performance, and operational complexity. This is an exploratory demonstration, not a recommendation to run production game or application logic inside a database.

---

## [Vinix: A Modern Operating System Written in V](https://github.com/vlang/vinix)

**Why read:** Follow an experimental operating-system project exploring real-hardware support, multiple architectures, and Linux source compatibility.  
**Discussion:** [HN Thread](https://news.ycombinator.com/item?id=49957388)  

Vinix is an experimental effort to build a modern operating system in the V programming language. Its stated goals include running on real hardware, targeting modern AMD64 and ARM systems, supporting multiple cores, and maintaining enough source-level compatibility with Linux to ease porting.

The repository describes the project as pre-alpha and not intended for daily or production use. Its value today is as a systems experiment: bare-metal constraints can expose language and compiler gaps, while hardware support and compatibility goals make the project’s scope and trade-offs concrete.

---