Purview is a weekly review of blog posts I find on the web and how they relate to my work. It is also a way to shout out interesting work, even when it sits outside my comfort zone.
Brice Bulgarelli built Seam, a deterministic tool that follows call stacks across languages, and measured it on Keycloak with Claude Code. Seam cut tool calls by about 36% and still raised the bill by about 1.4x compared to grep. Even an idealized tool replaying perfect answers cost 1.13x to 1.26x when it replaced search, and 0.91x when the agent kept grep beside it. A tool that returns only the answer, about 500 tokens, cost 0.45x grep. The agent kept verifying for about ten more calls after it had the answer, which he calls the verification floor. This is one task on one repository, five rounds per arm, and on Sonnet the floor was smaller.
He also published a short French version, Pourquoi un outil d’agent peut coûter plus cher.
Link: https://blog.bulgarelli.dev/papers/cout-outil-structurel/
How Should Agents See Code?, a York University study, looks at five structured views of a repository (AST, call graph, dependencies, docs, hybrid), exposed to Claude Code with Haiku 4.5 as MCP servers. They help most when finding the code is the bottleneck, as in fault localization, where tokens dropped 25% to 39%. They fade when the hard part is writing the patch or the test.
Link: https://arxiv.org/html/2611.07286v1
The York study finds structured views save tokens when locating code is the hard part. It counts total tokens. An earlier study that Brice builds on (Token Reduction Is Not Cost Reduction, by Weinberger and Hozez, arXiv 2607.12161) showed that fewer tokens is not a smaller bill, because cache writes cost more. What Brice adds is the verification floor, and a way to price a perfect tool before building one. The two answer different questions, and together they say what to measure: the bill, not the token count.
My next step: build a large application from scratch, over several iterations, and test whether bb.py reproduces the results of these two studies.
Opinion is also bubbling up about using alternative code representations to help agents work on code, as in Jason Davenport’s Why Git Needs Help: Moving from Files to Systems for Source Control.
A benchmark of 69 tasks and 574 dependent steps across 9 languages, asking whether coding agents can keep building on their own code. The strongest of 9 models solves 18.5% of tasks, and 38 tasks are solved by no model.
Link: https://multistepswe.com/
Storey names two debts next to technical debt: cognitive debt, when no one on the team can explain how the system works anymore, and intent debt, when the goals and rationale are missing. Her prototype lets humans write curated tours through needs, decisions, code and tests, while AI only audits them. The friction of writing a tour is the point. There is no evaluation yet.
Link: https://arxiv.org/abs/2611.08456
The authors propose PAAI (Power, Access, Adequacy, Independence) to ask who controls the infrastructure behind an AI evaluation. Applied to twelve African AI evaluation projects, it shows African actors supplying data, language expertise and task design while others keep the infrastructure. Taking part is not the same as having authority.
Link: https://arxiv.org/abs/2611.08134
Mojeek, one of the few search engines running its own independent index, published a small controlled experiment on 5 November. They self-distilled Qwen2.5-7B on invented facts about films, directors and studios, then checked whether the model could answer in the reverse direction. It learned the facts in the direction they were given and almost nothing else, so distillation inherits the reversal curse. Their remedy: have the model write each fact from every cue a later question could start from, and test reversed and multi-step questions, not just recall.
Why it matters to me:
Link: https://blog.mojeek.com/2026/11/self-distillation-inherits-the-reversal-curse.html
A shout-out to Let Over Lambda—50 Years of Lisp by Doug Hoyte, a book about macros and the advanced features of Common Lisp, first published in 2008. Its 2026 update says the entire book is now free to read online, in HTML and PDF. The print edition runs about 380 pages, and that is a lot of effort to put into a book on macros.
I prefer fexprs and Kernel, and I don’t know Common Lisp. I will probably read it after SICP!
Link: https://letoverlambda.com/
Three search APIs now sell by the query, with no account and no API key. The agent sends a request and gets back HTTP 402 with a price. It signs a USDC payment, retries, and receives the results with a receipt. It runs on x402, an open protocol. Brave joined on 12 November.
From the lowest price per query to the highest: Mojeek asks £0.002 to £0.003 for raw results from its own index, with no x402 and at most 10 results per request on the cheapest plan. Exa starts at $0.004, but only in its lightest mode, and its deep modes reach $0.015. Brave is at $0.005, paid in USDC on Base only for now. Tavily is at $0.01 on the same rail, twice Brave’s price. Kagi is at $0.012 and still needs an account and an API key. Bing is at $0.014 and no longer sells raw results: it returns summarized grounding, only inside Azure. The trade-off runs in one direction. The cheaper offers give you raw results you can build on, and ask you to accept a smaller index or a crypto wallet. The more expensive ones give you ranking quality or an answer, and tie you to an account or a cloud.
Links:
A token added to an agent’s context has to save about 20 tokens of re-reading to pay for itself, because writing to the prompt cache costs 20 times more than reading from it. I learned it from Brice Bulgarelli’s study above.