KV Residency Planner
shippedAn in-browser simulator of how an LLM-serving scheduler decides what stays resident in fast KV cache versus what gets evicted or prefetched, driven by a real placement algorithm you can push with your own memory limits and request patterns.
Approach
A client-side simulation implements a simplified version of the block-based KV-cache scheduler real serving engines use (vLLM-style PagedAttention): fixed-size token blocks belong to active request sequences across three tiers — GPU (fast, capacity-limited), CPU (swap, larger but slower), and Evicted (fully dropped, must recompute from scratch). A seeded trace of about 25 realistic requests (short chat queries, long document-summarization prompts, multi-turn agent tool-call loops) arrives over a simulated timeline; each tick the scheduler admits new arrivals, advances decoding for running sequences, and when GPU capacity is exceeded evicts the least-recently-touched sequence's blocks to the CPU tier using real LRU accounting, cascading to full eviction when the CPU tier also fills, and proactively prefetches the most-recently-touched swapped sequence back to GPU the moment space frees. The simulation autoplays on load so the tier grids, running event log, and request timeline are already animating with real scheduler decisions before any click; capacity sliders, play/pause, and a step button let a visitor re-run the identical algorithm against their own memory limits and timing. Pure vanilla HTML/CSS/JS in a single file — no bundler, since the whole scheduler is a few hundred lines of plain JS driving DOM block elements, and a toolchain would add build risk for zero benefit on an hour-scoped project.
The source post
https://x.com/lgrodev/status/2116229395933167850
Scoring
Pick
| surprise | 4 |
|---|---|
| demonstrability | 4 |
| self_containedness | 5 |
| honesty | 5 |
AgentForge's one interesting claim is a web preview that lets you see how a compiler plans KV residency, prefetch and placement for an agent program against an explicit machine model. That reshapes cleanly into a single static artifact: implement the real placement/eviction cost model in client-side JS, let a visitor set cache size and a request trace, and watch the actual algorithm's decisions animate across memory tiers — no model weights, no API key, no third-party fetch at build or runtime, so nothing about the demo is faked or pending a network call that this sandbox can't make. It's also the rare idea in tonight's batch that isn't a browser-map, browser-canvas-editor or evolving-agents demo, genres this series (and the wider web) has already seen many times over, which gives it the surprise the others lack. Every other candidate either names no concrete mechanic, needs a binary/model pulled in during an offline build, needs a real backend service, or has no browser form factor at all.
Review
| shipped | 5 |
|---|---|
| honest | 5 |
| worth_it | 4 |
| efficient | 5 |
No change: the gate passed on the first attempt, NOTES.md names no struggle or recurring friction, and the only candidate failure mode worth watching for (the 522 on first curl) was propagation lag that resolved on its own rather than anything the build, pick, or routing stages did wrong.
Cost
| total | $0.2443 |
|---|---|
| xai | $0.2443 |
What it looked at
RustGIS v0.5.0**: Pure-Rust open-source GIS toolkit with full web-browser version for mapping, queries, overlays, symbols and analysis; interesting because it runs entirely client-side with no installs or external models.
OpenTakeoff**: Free open-source browser-only AI project with live demo and full source; interesting as a zero-setup, standalone web app for immediate experimentation.
Higgsfield Canvas (open-sourced)**: Infinite canvas + video editor for AI image/video work with in-browser MP4 export and MCP agent integration; interesting for fully local, browser-renderable creative workflows agents can drive.
AgentForge research preview**: Open-source compiler/runtime for AI agents that plans KV residency, prefetch and placement against an explicit machine model; interesting because the web preview lets you explore the agent program view directly in-browser.
The Trinity (open-sourced)**: Agents that recursively self-improve inside self-built simulation environments then generalize to real robot tasks, with video demo and GitHub code; interesting for a fully demonstrable closed-loop self-improvement loop you can inspect and run locally in a contained setup.
JetSpec++ (fully open-sourced)**: Models, code and inference engine released together; interesting as a complete, self-contained release package with paper + runnable artifacts for immediate hands-on use.
claimnov (open-sourced)**: Science agent that runs persistent Python/R kernels and logs every step for re-checkable results; interesting because the open code + data lets you reproduce and extend a verifiable idea-judging workflow without external dependencies.
libargus (open-sourced)**: MIT-licensed library to run AI models directly inside Java apps with no separate server; interesting for embedding lightweight model execution in a portable, non-native-desktop form that could be wrapped into a browser context.
Gate
| pass | project directory exists — /Users/artax/code/builds/2026-11-01/project |
|---|---|
| pass | no build step needed — static project |
| pass | build output with index.html — /Users/artax/code/builds/2026-11-01/project |
| pass | index.html is a document — 18158 bytes |
| pass | local asset references resolve |
| pass | page loads without console errors |
Stages
| scout | grok · ok · 58.2s |
|---|---|
| pick | claude · ok · 65.0s |
| plan | claude · ok · 63.9s |
| build | codex · ok · 186.5s |
| gate | local · ok · 2.8s |
| publish | local · ok · 10.9s |
| review | claude · ok · 74.0s |
Notes
Omitted for lack of
None. The artifact needs no external service or generated imagery.