Anthropic's RAG Fix, Agent Tool-Call Guardrails, and Why LLM Judges Miss What's Missing

Today's findings

1. #1 Anthropic's RAG data: keyword search + reranking beat a better embedding modeltechnique

   Anthropic's own numbers show contextual chunk summaries + keyword search + reranking cut RAG retrieval failures by 67%, with reranking alone contributing the biggest single jump.

   Retrieval · Anthropic data

   Three cheap additions cut RAG retrieval failures by 67%

   1

   Context prefix

   One-line source summary per chunk

   2

   Keyword search

   BM25 alongside vectors

   3

   Rerank

   Score the merged candidates

   Biggest single jump

   Stack these in order before reaching for a better embedding model.

   Why it matters: Most teams treat RAG failures as an embedding-model problem, but this breakdown shows plain keyword search and a cheap reranking pass close far more of the gap than a better embedding model would — a low-effort fix for the most common complaint about internal search/RAG tools.

   How to apply: Before swapping embedding models, add a generated one-sentence context prefix to each chunk describing its source (contextual retrieval), pair vector search with BM25/keyword search, and add a reranking step on the merged candidates — in that order, matching where the biggest gains showed up.

   ragretrievalanthropic

   Read more: The Chunking Change That Cut Retrieval Failures by 67%

2. #2 The structural rules that actually make Claude/OpenAI prompt caching hittechnique

   Reliable prompt-cache hits come down to three rules: deterministic prefix ordering, explicit cache_control breakpoints, and never letting dynamic content leak into the "static" prefix.

   PROMPT CACHING

   The cached prefix ends where you put the breakpoint — everything dynamic goes below it

   System prompt

   Byte-identical wording every call

   Tool definitions

   Deterministic order, never re-sorted

   Base RAG context

   Stable docs only, no per-user splices

   cache_control

   Explicit breakpoint closes the static prefix

   Per-request input

   User turn, timestamps, IDs — always below the line

   One dynamic byte above the breakpoint silently voids the hit — and the up-to-90% cost cut with it.

   Why it matters: Prompt caching can cut API costs up to 90% and slash time-to-first-token, but subtle payload-ordering mistakes silently kill the hit rate — teams building Claude-backed tools are likely leaving real savings on the table without realizing it.

   How to apply: Restructure prompts so static content (system prompt, tool defs, base RAG context) sits at a fixed prefix before any per-request content, add explicit cache_control breakpoints on those blocks for Anthropic calls, and audit your payload builder for anything that reorders or interpolates into that prefix.

   prompt-cachinganthropiccost-optimization

   Read more: How to reliably trigger Anthropic & OpenAI prompt caching without boilerplate mess

3. #3 toolwall: a fail-closed authorization gate for agent tool callstool

   toolwall is a small, dependency-free Python library that fail-closed gates every agent tool call — unknown tools, bad args, leaked secrets, and budget overruns all block by default — with a published report of 155 tests including 28/28 attacks blocked.

   toolwall · open-source Python

   Agent tool calls run only inside the gate — 28/28 attack tests blocked

   bounded capability

   Agent tool call

   scope Allow-listed tools

   scope Validated args

   monitor Secret scan

   limit Budget cap

   revoke Default deny

   monitor Verdict log

   Published report: 155 tests, 28/28 attacks blocked; anything unrecognised denies.

   Why it matters: As teams give Claude Code and other agent harnesses real tool access to databases, shells, and deploy pipelines, "the model decided not to" isn't a security boundary — a fail-closed authorization layer is the guardrail most homegrown agent setups are currently missing.

   How to apply: Drop toolwall (or the same fail-closed pattern) between your agent loop and its tool executor, explicitly allow-list callable tools/args instead of trusting the model's schema-valid output, and log every allow/deny verdict for audit.

   agentssecurityopen-source

   Read more: I built a fail-closed authorization layer for AI agent tool calls (open source), plus a free course to learn the mental model

4. #4 How Claude Skills and MCP actually work under the hoodtip

   A harness-level writeup demystifies how Claude Skills and MCP work in practice — what gets injected into context, how tool discovery happens, and what production harnesses do to make both more reliable.

   Under the hood

   Two ways a harness tells the model what it can do

   Skills

   • Only name + description sit in context
   • Full instructions read once it fires
   • Extra files and scripts pulled on demand

   vs

   MCP

   • Tool schemas injected up front
   • Every connected tool costs context
   • Model chooses from descriptions alone

   Progressive disclosure vs eager injection — but both hinge on the description

   Write the description as the trigger, not as documentation.

   Why it matters: Most teams copy example Skill/MCP configs without understanding the mechanics; knowing how progressive disclosure and tool-schema injection actually work is what separates a skill that reliably fires from one the model ignores.

   How to apply: Read the writeup before authoring your next internal Skill or MCP server, and structure skill instructions and tool descriptions the way effective harnesses do rather than guessing from minimal docs.

   mcpagentsclaude

   Read more: How skills and MCPs actually work

5. #5 Ollama Cloud's new credit pricing is ~3x worse for heavy users than the old Pro plantip

   A 50-day usage audit shows Ollama Cloud's new $20 credit-based plan delivers roughly a third of the tokens the old flat-rate Pro plan gave for the same money.

   Ollama Cloud · repricing

   The same $20 now buys about a third of the tokens

   ~3x

   worse value for heavy users

   vs. the old flat-rate Pro plan

   $20

   Monthly price, unchanged

   ~1/3

   Of the tokens the Pro plan gave

   50 days

   Of real usage audited

   Price your own month of token volume against the credit rates before switching.

   Why it matters: If your team relies on Ollama Cloud for hosted inference, this is a quantified cost regression hiding behind a "based on feedback" repricing announcement — worth checking before anyone clicks switch.

   How to apply: Before migrating off a legacy Ollama Pro subscription, log a month of real request volume/token usage and price it against the new credit plan's published per-token rates; heavy users should stay on the old plan as long as it's offered.

   ollamapricinglocal-llm

   Read more: Value analysis of the old Ollama Pro sub model vs the new per-token model (from 50 days of real usage) · PSA: If you’re on the old Ollama Pro plan, don’t switch - ~67% LESS usage

6. #6 Auto-generate tool-call schemas straight from Python function signaturestechnique

   You can generate Anthropic/OpenAI-compatible tool-call JSON schemas directly from plain Python function signatures and docstrings, skipping both hand-written schema dicts and a full Pydantic dependency.

   Python tool calling

   Stop hand-writing tool schemas — derive them from the signature

   Hand-maintained schema

   • JSON dict written by hand
   • Pydantic pulled in for types
   • Drifts as code changes
   • Two places to edit

   → One source of truth

   Generated from the function

   • Type hints + docstring
   • No extra dependency
   • Built at import time
   • Edit the signature only

   Anthropic/OpenAI-compatible schemas, introspected from plain Python.

   Why it matters: Manually maintained tool schemas drift from actual function signatures as code changes, and pulling in Pydantic just for type introspection is heavy for a lightweight microservice or serverless tool handler.

   How to apply: For simple internal tools, generate schemas from type hints/docstrings at import time instead of hand-maintaining JSON, so a signature change automatically updates what the model sees.

   tool-callinganthropicpython

   Read more: Auto-generate Anthropic/OpenAI Tool Schemas directly from Python functions without Pydantic

7. #7 llama.cpp batch/ubatch size matters a lot once a model outgrows RAMtip

   A week-long benchmark on llama.cpp shows batch/ubatch size materially changes throughput once weights have to reload from SSD (tested with DeepSeek V4 Flash on a 128GB DGX Spark).

   Why it matters: Anyone running local models that don't comfortably fit in RAM/VRAM is leaving throughput on the table with default batch settings — this is a rare case of someone actually measuring the tradeoff instead of guessing.

   How to apply: If you're serving a large local GGUF model that spills to disk, sweep -batch/-ubatch values on your own hardware and prompt-length profile rather than trusting llama.cpp defaults; gains are hardware- and workload-specific so replicate the test rather than copying one number.

   llama.cpplocal-llmperformance

   Read more: [Benchmark] llama.cpp batch/ubatch impacts on PP and TG

8. #8 PromptGuard Multilingual: an open classifier for prompt injection and jailbreakstool

   CiberIA released an open, multilingual (Catalan/Spanish/English) prompt-injection and jailbreak classifier on Hugging Face, hitting 94.87% accuracy and 100% attack recall on its held-out test set.

   Why it matters: A free, drop-in classifier for prompt-injection detection is a cheap first line of defense for any agent ingesting untrusted web or document content — a real gap for teams working outside English-only deployments.

   How to apply: Run untrusted input (retrieved docs, tool outputs, user uploads) through the classifier before it reaches your agent's context, and treat flagged content as needing extra scrutiny or sandboxing rather than blind trust.

   prompt-injectionsecurityopen-source

   Read more: PromptGuard Multilingual v1

9. #9 A hallucination-resistant successor to Automated-AI-Web-Researcher-Ollamarepo

   The author of the 3k-star Automated-AI-Web-Researcher-Ollama shipped Academic-AI-Literature-Reviewer-Ollama, which grounds a local model's research in actual scientific literature instead of the open web.

   Why it matters: Local-model web research tools inherit the web's own unreliability; grounding retrieval in the literature instead is a concrete, reusable pattern for building an internal research/summarization agent whose citations actually hold up.

   How to apply: Point the Ollama-backed tool at a research question needing literature grounding, and borrow its literature-vs-web retrieval split for any internal research agent you build that needs to avoid confidently-cited nonsense.

   ollamaagentsopen-source

   Read more: I made an Automated Academic AI researcher which is hallucination proof. · I made an Automated Academic AI researcher which is hallucination proof.

10. #10 Harness Arena: a blind benchmark for Claude Code vs. other agent harnessestool

    Harness Arena is a new open-source, MIT-licensed blind benchmark that runs Claude Code, Codex, and other agent harnesses on identical tasks with anonymized judging.

    Why it matters: Picking an agent harness is currently mostly vibes and marketing; a blind, task-based comparison methodology is a more honest way to evaluate Claude Code against alternatives for your team's actual workload.

    How to apply: Run your own representative coding tasks through Harness Arena's methodology (or fork it) to get an apples-to-apples read on Claude Code vs. other harnesses before standardizing tooling across the team.

    agentsbenchmarkopen-source

    Read more: I built an open-source blind benchmark for AI agent harnesses - how would you make the comparison fair? · Harness Arena - open-source blind benchmark for agent harnesses

11. #11 MiniMax-H3's 8-step LoRA runs full local video gen on an AMD iGPUtechnique

    MiniMax-H3's official 8-step PDD acceleration LoRA runs entirely locally on an AMD Radeon 8060S integrated GPU, producing a 5-second video with synced stereo audio and no CFG needed.

    Why it matters: Open-weight video generation running acceptably on integrated, non-discrete graphics substantially lowers the hardware bar for teams wanting to prototype local video-gen features without a dedicated GPU rig.

    How to apply: If evaluating local video generation, start with MiniMax-H3 plus the official 8-step PDD LoRA rather than full-step inference — it's the fastest path to a usable local baseline on modest hardware.

    video-generationcomfyuilocal

    Read more: I ran MiniMax-H3 PDD locally on a Radeon 8060S iGPU (gfx1151): 5.17 s video + native stereo audio, 8 steps, no CFG

12. #12 LLM judges catch wrong content but miss what's silently missingpaper

    A new paper finds LLM-as-judge setups reliably flag incorrect content but systematically fail to notice when required content is simply absent — "omission blindness," tested on AI-generated clinical notes.

    Why it matters: Anyone using an LLM judge to grade agent outputs, RAG answers, or generated docs should assume it's blind to missing information by default — a false sense of eval coverage is worse than no eval at all.

    How to apply: If you run an LLM-as-judge eval pipeline, add an explicit completeness/checklist pass (did the output include every required element?) instead of relying on the judge to notice omissions on its own.

    evaluationllm-judgepaper

    Read more: LLM Judges Verify Presence, Not Absence: Omission Blindness in AI Clinical Notes