Platforms
The services and contracts other engineers build on.
2026
A browser for agents needs more than one score
A Rust browser engine built for agents, compared with Chrome across 1,024 sites, and why text, links, pixels and scripts each need their own result.
Agent systemsEvaluationPlatforms
A deadline has to live outside the code it limits
A handler that never yields defeats timers inside the isolate, so the deadline for agent-generated JavaScript has to be a process kill from outside it.
Agent systemsPlatformsSecurity
Admitting one turn from an at-least-once queue
Why a mention needs redelivery to survive a crash, and how keeping the dedup marker in the commit that admits the turn stops a teammate answering twice.
Agent systemsPlatformsOpen source
What a component compiler owns when the server can’t run JavaScript
Compiling JSX-shaped templates to plain Rust, and dividing scoping, type checks, escaping and navigation among the compiler, rustc and the runtime.
PlatformsInterfacesSecurity
Copying code on purpose when applications can’t share a crate
When an application may link only one crate, shared code has to be copied. A canonical source tree, declared mounts, file hashes and a drift check keep the deployed copies aligned.
PlatformsVerificationSecurityPerformance
Correcting the grader without rewriting the run
A coding-agent evaluation whose first grader was wrong in both directions, and how original records, corrected verdicts and repairs stayed separate results.
SelectedEvaluationPlatformsVerification
Counting input tokens when the answering provider can change
Why one usage field means different things across model providers, and how to normalize token counts without hiding missing or contradictory data.
Agent systemsPlatformsInterfaces
The decisions a restart shouldn’t get to make twice
Which coordination decisions an agent runtime must persist before acting, which it can re-derive, and how recovery separates unstarted work from uncertain effects.
Agent systemsPlatforms
Delivering background job results to the turn that owns them
Binding background jobs to their owning turn and sandbox so that completions survive restarts, arrive at least once and report a result someone can vouch for.
Agent systemsPlatformsVerification
Following an agent failure down to the process
Tracing a completed-but-failed agent run through thread, deployment, tool call, adapter and terminal pane, and what to do when logs and status mislead.
Agent systemsPlatformsVerification
Keeping scheduled work moving after a crash
A morning pipeline built on durable, date-keyed obligations, leases and a five-minute sweep, so a crash between steps cannot silently drop the work that is owed.
Agent systemsPlatformsVerification
Making a search index prove itself at query time
A search engine that treats every posting as a lead, publishes updates by stage-then-flip, and checks each candidate against one served version before its ACL runs.
PlatformsVerificationSecurity
Merge or refuse? Choosing a conflict model for text, cards and drafts
A test for when concurrent writes should merge and when they should be refused, applied to a text CRDT, a task board and fenced draft publishing.
Agent systemsInterfacesPlatforms
Model concurrency is not machine capacity
Why admitting sub-agent sessions and admitting work to a shared machine are separate problems, handled with queues, resource preflights, leases and useful refusals.
SelectedAgent systemsPlatforms
Mutations a form can’t express: merges, legal moves and stale edits
A CRM merge, legal issue transitions and stale-edit fences: treating changes as named server operations, with history in the write and a readable state after a crash.
PlatformsInterfaces
One sign-in screen, three owners of identity
How hosted authentication, a sign-in broker and application-local accounts each vouch for a different fact, with signed browser handoffs and each one's limits.
SecurityPlatforms
Publishing a SQLite database through one compare-and-swap
How a WebAssembly SQLite adapter makes a whole database image live through one manifest swap, why deletes follow publication, and what bounded cleanup leaves behind.
PlatformsPerformance
Real files on disk, with sync running beside them
Two systems that give tools an ordinary directory and sync alongside it: echo detection without clocks, a guarded remote commit, and measured cold-restore times.
PlatformsPerformanceAgent systems
Recovering a deploy that may already be serving
How a deployment client journals an attempt before submitting, retries under one operation ID, and after a crash accepts only status bound to that operation.
PlatformsVerification
Routing sub-agents to models without risking the run
A router with a bounded judge, a fallback that keeps the child task moving, layered settings, and a record of why each sub-agent got its model and effort.
Agent systemsPlatforms
Putting a Rust server behind somebody else’s Next.js storefront
Porting Next.js Commerce onto a Rust platform with no server JavaScript: generated contracts, runtime adapters, and what the frontend assumed about its server.
PlatformsInterfaces
Shutdown can only stop what it can find
A sandbox coordinator fix that puts bootstrapping instances within reach of shutdown, and an API that says when it stopped waiting without knowing the outcome.
PlatformsInterfaces
Stock transfers and booking holds: what changes when a claim can expire
Why a warehouse transfer fits in one compare-and-swap, why a calendar hold can lapse with no write at all, and why a durable seat claim is the one that can leak.
PlatformsInterfaces
Taking Raft out of our configuration service
Replacing a home-grown Raft cluster with Valkey: which jobs moved to the store, which rules stayed in the service, and how atomic scripts keep the two together.
PlatformsSecurity
The invalidation that arrives while the loader is running
Why a cached entry must record tag epochs before its loader runs, why writers invalidate after they write, and why leases only limit duplicate loads.
PlatformsPerformance
The same scheduled occurrence, delivered twice
Giving scheduled work a stable occurrence name so redelivery can be recognised, and what that name can’t settle once work leaves the commit or reaches a provider.
Agent systemsPlatforms
Twenty-one workspaces sharing one filesystem flush
Diagnosing a 5.6× slowdown across 21 agent workspaces with a durability-matched control, and why a filesystem-wide syncfs made deployment layout part of its design.
PerformancePlatformsAgent systems
Waiting for an async host by running the program again
How a synchronous QuickJS guest in WebAssembly waits for async Rust: abort on each host call, answer it, then replay the program with the answers preloaded.
Agent systemsPlatformsSecurity
What a double-entry ledger can promise without a transaction
A double-entry ledger on a store with only conditional writes: a journal entry lands whole, account totals catch up, and retries recognise work already applied.
PlatformsVerification
What a plugin upgrade is allowed to destroy
Plugin packages, plugin data and sandbox caches have different lifetimes. How an installer applies digests, atomic renames and restore rules to each one.
PlatformsSecurityVerification
What an agent can afford to lose
Sorting an agent platform’s data into irreplaceable work and rebuildable cache, and letting that decide journal storage, migration, eviction and restores.
Agent systemsPlatformsPerformance
What an agent runtime has to write down before it says yes
What a durable agent runtime must store before acknowledging a turn, how it recovers a crash mid tool call, and what at-least-once still leaves to the tool.
Agent systemsPlatformsSecurity
What “clean locally” is allowed to mean
How a local platform emulator reproduces leases, retries and denied egress, and says where its verdict stops at the moment a check comes back clean.
PlatformsVerificationInterfaces
What “completed” means in an AI gateway
Why an AI gateway held back the terminal event until stored responses had landed, and what that release path did and did not promise about usage accounting.
PlatformsInterfacesVerification
What did the agent actually change?
How an agent platform computes a pull request from a registered base and a scoped view of the workspace, and keeps absent, unverifiable and unknown outcomes distinct.
Agent systemsPlatformsVerification
What has to commit together when a payment arrives twice
In a reference shop with hedged requests and retried webhooks: what must land in one write, and why durable intent, rediscovery and receiver idempotency are separate.
PlatformsSecurity
What TanStack Start actually asks of its server
Porting TanStack Start to a Rust host shows how much of its server contract lives behind fetch: Nitro’s rules, cache behavior and the things a port must refuse.
PlatformsInterfacesOpen source
When a usage dashboard is entitled to show zero
Treating usage replies as evidence: a browser parser that refuses inconsistent numbers, and display states that separate an observed zero from unavailable, stale or partial.
InterfacesPlatformsVerification
When the older worker finishes last
How a change-tracking pipeline fences cursor moves, repairs a stale publish across D1 and R2, and separates an empty source from an unreachable one.
PlatformsVerification
Where an agent’s URL actually connects
Following an agent's URL past the allowlist: resolving every address, pinning the connection, vetting each redirect, and why each browser backend differs.
Agent systemsSecurityPlatforms