Ten agent builds from Sep 26–Oct 2: per-action routing, a compiler gate, and a 0.8B judge
Ten runnable indie agent builds from September 26 to October 2: a router that prices every action, tools that trim or delete the agent loop, and two ways to shrink the judge to something a laptop can run.
Ten Show HN posts in the seven days to October 2 put a number on the same thing. Weave Router 2.0 reports matching a frontier model on Terminal-Bench at 52% of its cost, on the vendor's own paired runs. A CLI called compress reports cutting the tokens Codex sends back to the model by 29.6%. D-Engine reports 2,552 tokens for an edit that an ordinary agent loop spends 34,600 on. Jevstiller reports answering like its remote teacher 98% of the time from a few hundred kilobytes of local model. Gutsy put a decision model in 775 MB and ran it on a CPU.
Every one of those numbers is about the same question: what a single step is worth paying for.
The week split three ways. One group priced the turn and kept the loop — route it to a cheaper model, trim what goes back into the context, or hand the agent interfaces where it used to get whole files. A second group deleted the loop and let a mechanical check decide, with a compiler, a rule algebra, a YAML gate, or a parser standing where the model used to. A third group shrank the decider itself, down to something that fits on a laptop. Ten builds below, then seven smaller releases and one trend from GitHub's weekly board.
Route the turn, don't upgrade the model
Weave Router 2.0 puts a price on each action
Weave's router, on Show HN on September 30 at 105 points, is a drop-in proxy for the Anthropic, OpenAI and Gemini APIs. You point Claude Code, Codex, or Cursor at
localhost:8080, and it picks a model for every upstream request from the providers you have enabled, including open-weight models through OpenRouter. 1The submitter, adchurch, describes the change from the first version. A hidden Markov model traces the session state, a classifier then maps the session to a bucket of similar models, and the bucket narrows the choice before the router picks. A separate subsystem prices the cost of switching models against the cost of refilling a new cache. An escalation classifier sends a stalled or looping task back up to a frontier model, and flat-rate subscriptions you already pay for get drained before per-token credit is spent. 2
The published comparison ran the same Codex harness, two attempts per task, against GPT-6 Astra on the same day and package. On Terminal-Bench 4.0, 66 tasks, the router solved 62.1% against Astra's 60.6%, in 20.5 minutes per trial against 44.1, at $5.22 against $10.03. On SWE-Atlas, 124 tasks, it solved 62.1% against Astra's 66.1%, in 6.8 minutes against 16.7, at $2.31 against $5.04. OpenRouter's own auto router, run separately on the same tasks, solved 54.0% on SWE-Atlas. 3
Those are the vendor's runs, on the vendor's task pairings, with the harness published in the repository so you can rerun them. The site's own estimate puts a $12,000 monthly token bill about 53% lower after routing. The numbers to hold onto are the per-trial costs, because they are the ones your own traffic will move. Start with
npx @weave-os/router, and log which model each action gets for a day before you believe any of it.compress trims the tool output on the way back
Yolanda and Spencer built a compressor for their own Codex bills, after "maxing out sub and burning $700/day per person on api". It wraps Codex with a proxy and a fine-tuned Qwen model that strips tool-call results before they return to the model, which is where an agent loop's input tokens mostly live. Their reported cut is 29.6%, and they claim it holds the KV cache intact because the trimming happens on results rather than on the prompt. 4
The CLI is
compress, posted on Show HN on September 30 at 11 points and installed from the Everest installer. codex --uncompressed turns it off for a run. The repository is public; the compression model and the service behind it are not. That service is the part to read the privacy paragraph about: eligible tool output, the associated tool arguments, a short focus description, and up to 4,000 characters of your latest user message go to Everest for compression. The repository says the service does not store session content, that your terminal keeps the original output, and that savings are estimates. 5This is the smallest tool in the issue and the one with the most direct trade. If your agent's cost is dominated by tool output flowing back into the context, 30% is a real number. If your code sits under an NDA that forbids sending it to a third party, run
everest savings on a throwaway repository first.Ctxfw sends interfaces where whole files used to go
Ctxfw, on Show HN on September 29 at 5 points, is an MCP server that parses a codebase with tree-sitter and replaces the dependencies around the file you are editing with their signatures, type definitions and stubs. The file under edit stays intact; the modules one and two hops away arrive as interface shapes instead of full implementations. 6
The method is the most testable idea in this cluster, and the numbers around it are the least settled. The repository's abstract claims 72.4% fewer tokens; the Show HN title says 67%; the repository's own case study on its CLI's dependency graph reports 49,096 tokens reduced to 20,014, which is 59.5%; and its multi-repository table reports aggregate savings between 24% and 57%. The framing is heavy — a badge reading "ACI-1.0000 VERIFIED", an "empirical validation trilogy" — and none of it has been rerun outside the author's own machines. 7
What survives the marketing is a mechanism you can check in an afternoon. Run
pip install ctxfw against one repository, then diff the token counts of the context bundle before and after. The 59.5% case study figure is the one to test against, and the claim that the file under edit is preserved byte for byte is the one to verify first.Take the model out of the gate
OpenAPPA decides by algebra instead of by a second model
The industry's answer to approval fatigue has been a second model that judges every tool call. OpenAPPA, on Show HN on September 28 at 25 points, starts from the observation that a classifier watching tool calls cannot follow data across them, and that a classifier is itself prompt-injectable. The engine runs outside the agent's prompt and execution loop, so the model can neither see nor negotiate with it. 8
The configuration describes data sources, audiences, trust levels and authorities rather than allowed and blocked tools. Each trajectory carries a label, audience times trust, that only ever gets more restrictive — reading a private repository narrows the audience, reading an unvetted page lowers trust — and the engine derives each decision from that label. Because the policy is declarative, you can validate in CI that your whole tool graph is covered. 9
OpenAPPA's own benchmark puts task completion at 89%, against 90% for Claude Code's auto mode and 41% for Microsoft's FIDES, with successful attacks at 0%, 10% and 31% respectively; the comparison figures for the other two systems are those vendors' published numbers. The mechanism that lifts utility is a remedy plan: the engine answers a forbidden action with the legal ways forward, including sanitizers that mask the payload, an authority that approves one action without lifting the session's restrictions, and a subagent that isolates an untrusted read. The paper is behind a NeurIPS acceptance. 10
That benchmark is OpenAPPA's own, run on its scenarios. The part that transfers is that you write one policy file and hook it into one place in your loop.
D-Engine deletes the loop and lets the compiler decide
D-Engine, on Show HN on October 2 at 2 points, is Sergio Corruchaga's attempt to stop paying for the agentic loop. You describe a change, a file selector picks the targets by token budget, the model returns
SEARCH/REPLACE blocks and nothing else, a four-strategy cascade applies them inside a shadow git worktree, and tsc --noEmit decides whether anything merges. A compile that is not green leaves your branch untouched. 11The token comparison is the whole argument. On the same task with the same literal prompt and the same model, D-Engine v0.2.2 spent 2,552 tokens against 34,600 for a minimal single-shell-tool agent and 107,000 for that agent at its default thinking level. A ten-task benchmark, one attempt each, tied quality at 48 out of 50 while averaging about 2,100 tokens per task against the loop's 93,000, and produced zero broken commits on main against one. 12
Two limits matter before you use it for anything real. It cannot create new files yet, and the fuzzy matching step, at a 0.85 threshold, is the author's own named weak link — a patch applied through it has not been located exactly. The file selector is not deterministic, and the project was at one GitHub star when I looked. Treat the benchmark as a careful description of what the bounded-edit case costs, and try it on a change you already know how to make.
Stepgate writes the procedure down where the model cannot edit it
Stepgate takes the plan out of the prompt. You write a YAML stepfile that declares its inputs, the remote APIs and MCP servers it may call, and an ordered list of steps, each with the output it must produce and the gates that check it. Stepgate, posted on Show HN on September 28 at 5 points, runs the file as an MCP server: the client's agent sees one step at a time and never the later ones, so it cannot skip ahead. 13
The gate is what decides a step is done. A step passes when its output satisfies JSON Schema, JSONLogic or an HTTP verifier, and the check can run against what the APIs actually returned, which is how a fabricated value fails. The server makes every tool call and attaches the credentials itself, so the model never holds a key and a host the stepfile did not declare is refused. A hash-chained ledger records every step, tool call, gate verdict and retry, and
stepgate --verify detects an edit to that ledger after the fact. 14Writes wait for a person: an approve gate asks for confirmation through the MCP client before a later mechanical step writes. The model still does the judgement inside each step, which is the part to design carefully. A gate can check that a field exists and matches a schema.
Perspica reads the diff by parsing it
Perspica, on Show HN on October 1 at 14 points, is a local Rust binary that answers the question a raw diff leaves open. It parses both sides of a change with tree-sitter, tracks the calls between them, and reports what actually moved: renames including ones where the body also changed, new required against new optional parameters, extractions into new functions, dependency changes per module. Formatting, comment-only edits and generated files get folded away. 15
It also surfaces what a diff hides: a renamed or removed name still used somewhere in the repository, calls to a changed function that were not updated, code the change left unused. It gives a reading order from the entry points down to the changed functions, and marks which of them the changed tests reach. It covers TypeScript, JavaScript, Python, Rust, Go, Java, Scala and C, answers in a few hundred milliseconds on a typical pull request, and produces the same answer every time. 16
The tool was built for work that came out of a coding agent. When the change came from a Claude Code or Codex session, perspica shows your own prompts from that session, and its optional LLM pass marks each group of changes as one you asked for, with a quote checked against your prompt, or as the agent's own call. That LLM layer is the only part that needs a key or a local Ollama model; everything above runs without one. Files in other languages fall back to ordinary line diffs.
Shrink the judge to something you can run
Jevstiller answers like Jev 98% of the time and shows its work
Jevstiller, on Show HN on September 29 at 66 points, sits in front of a paid classification call, learns a small local model from that teacher's answers, and lets the local model take the requests it is sure about. The local part is a frozen sentence encoder and a single logistic regression head — a few hundred kilobytes, trained in seconds and retrained every 2,000 new teacher answers. Confident, in-distribution requests come back in about 15 milliseconds on a CPU; the rest go to the teacher at its usual ~300 ms. 17
The interesting part is the contract rather than the model. You set one number, say 98%, and the system promises that the label it returns is the one the teacher would have returned on at least that share of requests. The author, whose writeup carries the full method, gets there with an exact Clopper-Pearson bound on the calibration set, a fixed grid of thresholds tested strictest first, and a permanent audit slice of 2% of all requests that goes to the teacher regardless. The naive alternative — sweep thresholds and keep the loosest one that looks under budget — broke the 2% budget in 6 to 12 of 20 random splits per task. The bound broke it once in 100. 18
Coverage is the price. At a 98% target the local model answered 74.9% of Banking77 intents, 78.9% of CLINC150 and 86.5% of AG News, and the guarantee gave up four to eight points of coverage against the naive rule. In a 24-hour soak, a stand-in teacher silently changed every answer at hour twelve; the audit caught it, local share fell from 90% to 9% inside four minutes, and recovered to 90% in 49. The guarantee measures agreement with the teacher, so a teacher that is wrong makes the local model wrong the same way. It also holds only while your calibration rows resemble the traffic you route.
Gutsy puts a decision model in 775 MB on your CPU
Gutsy, on Show HN on October 1 at 8 points, is a full fine-tune of Qwen3.5-0.8B that answers the same Jev-style Decisions API. Send a state and typed questions — yes or no, choose one of these, score on this rubric — and get a calibrated probability for every option. It generates no text, makes no network call and charges nothing per call, and it is served as a 775 MB GGUF through llama.cpp on an ordinary CPU. 19
Its author is unusually careful with the evidence. On JevBench's public items, 231 of them, Gutsy scored 167, or 0.723, against Jev's reported 0.866 on the same set, and the calibration error is 0.021 before any scaling. Options can be shuffled without changing the answer 94% to 99% of the time, lists up to 255 options are handled by shortlisting, and the state is encoded once so follow-up questions about it cost only their own tokens. 20
The weaknesses are listed in the same place as the results, which is the reason to trust the rest. Date and number arithmetic sits near chance, because a 0.8B model cannot do multi-step calculation in one forward pass. New multi-step rulebooks scored 0.42. It abstained on all seven ambiguity cases where it should have asked. Long states on CPU took 4.2 seconds at the median and 23 at the 95th percentile, and it is English only. Gate a risky action on a threshold you measured on your own labeled rows, and compute the dates in code.
Mingbird argues the harness was the problem
Mingbird, on Show HN on September 30 at 5 points, is a local-first harness for 2–9B models on Ollama, aimed at the laptop you already own rather than a discrete GPU. Its author, who posts as Gustor, makes a larger claim than a tool release: the cliff you see when a small model stalls in a cloud-shaped framework is a harness defect rather than a model defect. 21
The evidence is a 288-cell benchmark — four harnesses, four open models from 2B to 35B, 18 real tasks, deterministic artifact scoring, every cell published as CSV with the runners. The same 2B model that scores 0.017 to 0.271 in the three comparison harnesses scores 0.821 here, and the cliff reproduces on a second 2B model at 0.779 against 0.017, 0.096 and 0.239. A separate probe pinned one frontier model and swapped only the harness: 0.997, 0.989, 0.925 and 0.478. 22
Read that probe narrowly, as the author does — among intact harnesses the model is still the bigger lever. The benchmark is his own, which is why the tasks, the scorer and the raw cells are public and a single cell takes about 30 minutes to reproduce. The application is Apache-2.0, runs on Windows 10 and 11 with Linux and macOS builds marked experimental, and ships a one-click offline mode that keeps web tools out of the prompt entirely. A 2B model will not rewrite your codebase in one shot; it fails loudly instead, which is the property worth testing.
Also shipping
Seven smaller releases from the same window, each with the one thing worth knowing:
- Kern Sandbox (getkern/kern): a rootless container sandbox for model-written code, with no daemon and no VM. Its result carries a
fault.type, so a loop can tell a timeout from an OOM kill from the code's own exception, which exit 137 alone cannot. It refuses mounts over 17 named credential directories, andnetwork=Trueincludes the host's loopback — a test read the host's SSH banner off127.0.0.1:22. 23 - Recalld (recalld.ai): a hosted memory layer with three primitives. Its curated
recallreturned 243 tokens per query against its rawsearch's 1,627, at 88.7% and 88.2% accuracy on LoCoMo — measured on a benchmark harness written by another memory company, run by Recalld with the prompt and judge untouched. 24 - ironbee-express (ironbee-ai/ironbee-express): a browser agent whose every step is one Jev choice over the page's controls, at about 300 ms with no screenshot sent and no text generated. On the authors' e-shop demo it completed nine actions in 6.7 seconds for $0.00054, and a passing run replays with no decisions at all. Elastic License 2.0, and access is waitlisted. 25
- Ferry (dlhck/ferry): keeps remote Linux agent boxes in the same shape as your own machine, publishing skills,
AGENTS.md, subagents, hooks and MCP configuration to a private git snapshot that each box pulls and links over SSH or Tailscale. It installs the CLIs and starts logins on the box, and it leaves your login credentials behind. 26 - Motif (motif-Labs/motif): an experience graph that records what agents tried, what happened, and what a person corrected, then reuses that as memory and exports it as a decision dataset for evaluation. Self-hosted, with the human correction as a first-class object rather than an afterthought. 27
- Graphene (graphene-data/graphene): an analytics framework built for coding agents as the primary user, with a semantic layer for accurate queries and a dashboard file type for consistent output, driven entirely through the CLI with all its documentation inside an agent skill. 28
- Raven (EverMind-AI/Raven): a "harness of harnesses" with four built-in agents and an Evolver that rewrites each agent's memory, planning, capability and action modules against benchmarks from outside, so the agent under test is never the thing editing itself. The technical report is on arXiv. 29
One trend from GitHub's weekly board. The largest weekly gainer was vectorize-io/hindsight, a memory layer that learns, at 17,403 stars added to reach 44,522. Paperclip calls itself the open-source app everyone uses to manage agents at work, and added 14,335 to reach 96,080. Also climbing: google/ax, an open agentic orchestration runtime in Go, at 2,919; pbakaus/impeccable, a design language for AI harnesses, at 2,704; and heygen-com/hyperframes, which renders video from HTML for agents, at 2,667. Those repositories carry no launch date inside this window, so read the numbers as attention rather than as releases. 30
Where to start this weekend
Pick by the friction you already have, and try one thing rather than five:
- Your bill is the constraint and you cannot tell which actions need a frontier model. Put
npx @weave-os/routerin front of one repository for a day and log the model each action got. Their paired benchmark says 48% to 54% off per trial; your own log will say what your mix does. - Your context is mostly tool output. Run
everest savingson a throwaway repository and read the privacy paragraph before it touches client work. If that is too much, install Ctxfw on one repository and count the token difference yourself instead of quoting the badge. - A step in a procedure keeps getting skipped or invented. Write one Stepgate stepfile for that procedure with a JSON Schema gate on the step you care about, and read the ledger afterwards to see what actually ran.
- Review is where your agent's output piles up. Run
perspicaon the last agent-authored pull request you merged. If its mechanical list of stale references and unreached code comes back empty, the LLM pass is optional for that change. - You want a small model to do the deciding. Set Jevstiller's dial at 98% and measure coverage on your own labeled rows, or pull Gutsy's 775 MB GGUF and check the date and number questions your workflow actually asks before you automate on it.
References
- 1Show HN: Open-source model routing for coding agents at Astra-level performance
news.ycombinator.com
- 2weave-os/router repository
github.com
- 3Weave Router benchmarks
weaveos.com
- 4Show HN: Token compression CLI to save Codex/Astra costs
news.ycombinator.com
- 5spenmcke/compress repository
github.com
- 6Show HN: Ctxfw – AST context firewall that cuts agent prompt tokens by 67%
news.ycombinator.com
- 7heuristicolab/ctxfw repository
github.com
- 8Show HN: OpenAPPA – open-source deterministic guardrails that don't break agents
news.ycombinator.com
- 9OpenAPPA
openappa.com
- 10OpenAPPA benchmark results
openappa.com
- 11Show HN: D-Engine – deterministic LLM code edits, 42× fewer tokens than an agent
news.ycombinator.com
- 12corruchaga/D-Engine repository
github.com
- 13Show HN: Stepgate – AI agents that can't skip steps, in one portable file
news.ycombinator.com
- 14Chaarangan/Stepgate repository
github.com
- 15Show HN: Perspica – A semantic diff for reviewing code
news.ycombinator.com
- 16sshah03/perspica repository
github.com
- 17Show HN: Jevstiller – Distill Jev into a local model, with a disagreement bound
news.ycombinator.com
- 18A local model that answers like Jev 98% of the time
jevstiller.pages.dev
- 19Show HN: Gutsy, a 0.8B Jev-compatible decision model that runs on your CPU
news.ycombinator.com
- 20kouhxp/gutsy repository
github.com
- 21Show HN: Mingbird – an agent harness that makes a 2B model finish real tasks
news.ycombinator.com
- 22Mingbird/Mingbird-agent repository
github.com
- 23Show HN: Kern Sandbox, run LLM-generated code locally, no cloud, no daemon
news.ycombinator.com
- 24Show HN: Recalld – A memory layer for AI agents that returns only relevant facts
news.ycombinator.com
- 25Show HN: Fast browser agent (using Jev) with deep reasoning as needed
news.ycombinator.com
- 26Show HN: Ferry – Sync your coding agent setup to remote Linux boxes
news.ycombinator.com
- 27Show HN: I turned my team's coding-agent history into a knowledge graph
news.ycombinator.com
- 28Show HN: Graphene – Data analysis toolkit for your coding agent
news.ycombinator.com
- 29Show HN: Raven – The harness of harnesses, built for RSI
news.ycombinator.com
- 30GitHub Trending
github.com
This story was produced automatically by a channel. One sentence is all it takes for Neodrop to keep producing for you.