The launches that decide whether agents are affordable rarely get the upvotes. This batch is squarely about the middle of the stack: what an agent retrieves, where the request is routed, what the GPU is doing, and who notices when any of it wastes money.
Retrieval, in two very different shapes
SeekStorm is sub-millisecond lexical, vector and hybrid search written in Rust, and it is unusual in offering three deployment shapes from one project: embed it as an in-process library, run it as a multi-tenancy server with its own console and web UI, or expose it to agents over MCP. That last option is the one that fits the current moment - instead of stuffing retrieved documents into a prompt by hand, you hand the agent a search tool. It is Apache 2.0 and has been in production since 2020.
pg_vectorsearch stays inside the database. It is a PostgreSQL extension for high-performance approximate nearest neighbour search, built around a PRISM index designed for 100M+ vectors with hierarchical routing, RaBitQ quantization with theoretical error bounds for two-stage search, and SIMD-optimized distance computation across AVX2, AVX512 and NEON. Crucially it is pgvector compatible, so you can index existing vector and halfvec columns as-is rather than migrating data, and it supports inserts, updates and deletes with posting-list splits through a rebalance function. It is alpha and meant for testing, not production, and prerelease upgrades may require dropping and recreating the extension.
Finding the waste, then stopping it
KORA Doctor asks the question that observability dashboards do not: not what the agent ran and what it cost, but which parts of that execution should disappear. It is a small open-source CLI that analyses AUDR records and surfaces waste across tool usage, context growth, deterministic work, repeated inference, orchestration and model choice, reporting observed cost, potentially avoidable spend and an estimated optimized cost. There is no dashboard, no account and no hosted service, and it emits JSON so you can diff it.
CloudGrip is the blunt instrument for the same anxiety. It is a self-hosted AI proxy gateway and dashboard, built with Node.js, Express and SQLite, that acts as a circuit breaker: it halts requests automatically when spending reaches a configured cap. It tracks client spend, request metadata and token metrics in real time, and all logs and proxy state stay in your own instance. It exists for the specific failure where runaway agent loops and unmonitored context reloads drain a budget overnight.
Deciding where each request goes
Commit-Aware Router is an open-source proof of concept for a routing signal almost nobody models: the commercial commitments your organisation already made. Most routers choose on price, quality, latency, reliability and availability. This one also considers prepaid capacity and minimum-spend agreements, so a team does not pick the cheapest list price while forecast shows prepaid capacity going unused elsewhere. The architecture keeps contract amounts, forecasts and negotiated terms inside the customer environment - the router receives a short-lived authenticated policy signal instead of raw values - and it always enforces quality, capability, latency, residency and policy constraints before considering commercial preference.
Recursant routes on a different axis: privacy and cost per step. It sits between your agents and their models and picks a model for every request - a top model for the hard steps, a cheaper one for routine reads and test runs, and your own private model whenever personal data is involved. Every request is checked with deterministic regexes for tax file numbers, Medicare numbers, card numbers, phone numbers and email addresses before it leaves the machine, and anything matching goes to the private model, with that conversation staying private from then on. It speaks the OpenAI API, so pointing an agent at it needs no plugins or code changes, and it pools your own GPUs with paid services so private work always runs locally.
The inference and training side
Narwhal is adaptive hot-swap disaggregation for LLM inference on a role-free fleet, meaning GPUs move between prefill and decode instead of being pinned to one role. It is documentation-heavy in a good way: deploying a fleet covers discovery, installing an approved revision, validating and starting engines, qualifying the transfer fabric and attesting live engines; measuring covers the measurement contract, profiling, targets and a deployment freeze, a synthetic load trial and accepted benchmark points; operations covers engine restart, upgrade and rollback with release drills, and Grafana dashboards.
Spectra attacks the training bill from the optimizer. It is a drop-in replacement for AdamW that shifts gradient optimization to the frequency domain and factorizes second-moment variance, cutting optimizer state memory by half while keeping full 32-bit floating-point stability with no quantization collapse. The reported benchmark puts optimizer state at 4130 MB against 8256 MB for standard AdamW on a 12-layer transformer block, at a slightly lower step latency. It is one line to swap in and Apache 2.0.
Enki LLM is the small end of the same problem: a pure Rust Transformer inference engine of about 2,000 lines running Llama-3.2 1B at roughly 40 tokens per second on a Tesla T4, with no CUDA dependencies. Its party trick is live brain migration - hot-swapping execution and mirroring the KV-cache between GPU VRAM and CPU RAM mid generation without losing context - and the same binary runs on discrete Nvidia GPUs, integrated Intel graphics and multi-core CPUs unchanged.
Two structural bets
Graft is source control rebuilt for agent-scale monorepos, an independent open-source implementation of the design in Anthropic's Redesigning source control post. Git assumes every clone is a full offline-capable repository, which costs packfiles, mirrors, negotiation CPU and merge-queue contention when nearly every client is an always-online agent or CI job. Graft drops that: history, blame, diffs, merge bases, search, commits, rebases and merges happen server-side over HTTP, commits are changesets in a write-ahead log, landing is a lock-free compare-and-swap on one row, and working copies are optional and sparse.
Seahaven is the evaluation counterpart, an open-source Python framework for building synthetic worlds - working copies of your agent's tools, realistic enough that the agent cannot tell the difference. Each instance is its own SQLite database copied from a fixture in milliseconds and thrown away afterwards, fixtures freeze starting states so the same seed gives the same run, and one process hosts hundreds of world instances. The part worth copying is the grading model: every row the agent changed is logged before and after in one JSON document, so you grade on state rather than on transcripts.
Why this layer decides the outcome
Retrieval quality sets how much context you need, routing and inference set what each step costs, and evaluation is what tells you whether any of it works. The launches here are less flashy than a new agent, but they are where the unit economics live.