MCP Servers Get Serious, Claude Code Gets Cheaper: Today's Open-Source AI Digest

Today's findings

1. #1 A concrete pattern for securing MCP servers with FastMCPtechnique

   A production-grade MCP server recipe: JWT auth, per-user-group tool visibility, audit logging, and S3 signed URLs for file access.

   MCP SERVER SECURITY

   Four-piece security recipe for FastMCP

   JWT Auth Gate tool discovery

   Group Visibility Per-user tool filtering

   Audit Logging Log every call

   S3 Signed URLs Stream files via signed links

   Authentication Authorization Audit Data Access

   Adopt all four for a production-grade MCP server security baseline.

   Why it matters: Most MCP server examples skip auth and access control entirely; this gives teams exposing internal tools to Claude or other clients a concrete, copyable security baseline instead of rolling their own.

   How to apply: If you're standing up an MCP server for shared/internal use, adopt the four pieces directly: gate tool discovery behind JWT auth, filter which tools a caller can even see by group, log every call for audit, and never stream files through the model — hand back signed URLs instead.

   mcpsecurityclaude

   Read more: Building and securing MCP servers with FastMCP · coles.codes · Building and securing MCP servers with FastMCP · coles.codes · Building and securing MCP servers with FastMCP · coles.codes

2. #2 Lever cuts Claude Code tool-result tokens 47% with deterministic hookstool

   An open-source Claude Code plugin replaces token-hungry "transport" work (fetches, re-reads, quoting) with content-addressed pointers via ordinary hooks.

   Claude Code Plugin

   Lever cuts tool-result tokens 47%

   Before: Raw Transport

   • Fetch pages
   • Re-read files
   • Quote blobs

   → 47% fewer tokens

   After: Content-Addressed Pointers

   • Content-addressed store
   • Reference pointer
   • Free context

   Deterministic hooks replace token-hungry transport with pointers.

   Why it matters: A large share of agent token spend isn't reasoning, it's re-transporting the same fetched pages or file reads back through the model; automating that transport with deterministic code instead of LLM calls is a direct cost and context-window win.

   How to apply: Install the Lever hooks (github.com/Clear-Sights/Lever) so large fetch/command output lands in a local content-addressed store and the model gets a reference instead of the raw blob, freeing context for actual reasoning.

   claudeagentscost-optimization

   Read more: I cut 47% of Claude Code's tool-result tokens by replacing token transport with deterministic hooks

3. #3 fable-baton: route cheap Claude Code work to Haiku, save Opus for hard partstool

   A Claude Code plugin makes the top model an orchestrator that delegates file discovery, edits, and verification to pinned Haiku/Sonnet subagents.

   Cost-Optimized Agent Routing

   Route cheap work to Haiku, save Opus for hard parts

   Haiku (Cheap)

   • File discovery
   • Routine edits
   • Verification

   vs

   Opus (Premium)

   • Design decisions
   • Tradeoffs
   • Review

   Orchestrator delegates by task complexity

   fable-baton plugin for Claude Code

   Why it matters: Subscription/usage limits on premium models are the top complaint in Claude communities right now; model-routing by task type is a straightforward way to stretch a Max or Pro plan without sacrificing quality on the parts that need it.

   How to apply: Adopt a similar split in your own agent setup: use a small/cheap model for repo search and routine edits, reserve the frontier model for design decisions, tradeoffs, and review, and add a cheap verifier pass before accepting output.

   claudeagentscost-optimization

   Read more: I built a plugin so Fable 5 stops wasting its short subscription time on grep runs

4. #4 Unsloth ships 2.5x faster NVFP4 quants for Qwen3.6technique

   W4A4 quantization using real 4-bit tensor cores makes Qwen3.6 27B up to 2.5x faster than NVIDIA's own NVFP4 quants with no accuracy loss.

   Performance Comparison

   Unsloth NVFP4 vs NVIDIA NVFP4 on Qwen3.6 27B

   vs

   Unsloth

   NVIDIA

   Inference Speed (27B)

   2.5x faster

   Baseline

   Accuracy

   No loss

   No loss

   Unsloth wins the row NVIDIA wins the row

   Also 1.56–1.79x faster on 35B-A3B variant. No accuracy degradation.

   Why it matters: Faster quantized inference at the same accuracy directly lowers the hardware bar for running capable local models, and the same technique applies across the 35B-A3B variant (1.56-1.79x faster).

   How to apply: If you're running Qwen3.6 locally on NVFP4-capable hardware, swap to Unsloth's quants for a free speed win; check their HF repo for the specific 27B and 35B-A3B builds.

   quantizationlocal-llmperformance

   Read more: 2.5x faster Qwen3.6 NVFP4 Unsloth quants

5. #5 Skills vs MCP servers: a one-line decision ruletip

   Use a Skill when it's one user in their own context with their own credentials; reach for an MCP server the moment access needs to be shared or governed.

   Why it matters: Teams keep over-engineering single-user tool access into full MCP servers, or under-engineering shared access into ungoverned skills — this gives a fast, defensible rule for which to build.

   How to apply: Before building new agent tooling, ask who else needs this access. Single-user/local: ship a Skill. Multi-user/needs enforcement: stand up an MCP server with the auth pattern above.

   mcpagentsarchitecture

   Read more: Skills or MCP servers: when you need a server · coles.codes · Skills or MCP servers: when you need a server · coles.codes

6. #6 A local RAG baseline with zero embeddings, zero vector DBtechnique

   JAS RAG indexes Markdown into SQLite and retrieves with FTS5 full-text search instead of embeddings or a vector database.

   Why it matters: Before reaching for rerankers and hosted vector APIs, having a boring, inspectable, fully local baseline makes it much easier to know whether added complexity is actually earning its keep.

   How to apply: Stand up the SQLite FTS5 baseline first for any new RAG project, measure retrieval quality against a small golden-query eval set, and only add embeddings/vector search once you can show FTS5 is the bottleneck.

   raglocal-llmsqlite

   Read more: I built a tiny local RAG baseline with SQLite FTS5, no embeddings or vector DB · I built a tiny local RAG baseline with SQLite FTS5, no embeddings or vector DB

7. #7 Metallama: a lightweight web UI for managing multiple llama.cpp instancestool

   A free web-based manager for juggling GGUF downloads, inference parameters, and multiple running llama.cpp instances from one place.

   Local LLM Tool

   One dashboard for llama.cpp instances

   Replaces a pile of terminals with a single web interface.

   Why it matters: Anyone running more than one local model quickly ends up with a pile of terminals and manual GGUF management; a single control surface removes real day-to-day friction.

   How to apply: If you regularly switch between local GGUF models, try Metallama instead of hand-managing llama.cpp processes and download scripts.

   llama.cpplocal-llmtool

   Read more: I made a simple tool to manage llamacpp instances (Metallama) · I made a simple tool to manage llamacpp instances (Metallama)

8. #8 Prefill, not decode, ate 45% of local inference timetip

   Instrumenting a 9B model on M4 Pro/MLX showed nearly half the wall-clock time went to the model re-reading its own prompt, not generating tokens.

   LOCAL INFERENCE

   Prefill dominates local inference time

   45%

   of wall-clock time spent on prefill

   vs 55% decode

   Model

   9B on M4 Pro / MLX

   Insight

   Nearly half the time is re-reading the prompt

   Takeaway

   Optimizing decode speed won't help if prefill dominates

   Profile your own pipeline's prefill vs decode split before optimizing.

   Why it matters: Most local-LLM benchmarking only reports decode tok/s; if prefill dominates your pipeline's latency, optimizing generation speed won't move the needle at all.

   How to apply: Profile your own local pipeline's prefill vs decode split before optimizing. If prefill dominates, look at prompt caching, shorter system prompts, or KV-cache reuse across turns rather than a faster decode-focused quant.

   local-llmperformancemlx

   Read more: We measured where our local pipeline's time actually goes: ~45% was the model re-reading its own prompt (9B on M4 Pro, MLX)

9. #9 HiLS-Attention: end-to-end learned sparse attention for cheaper long contextpaper

   Tencent's chunk-wise sparse attention mechanism learns which chunks to attend to under the language-modeling loss itself, enabling native sparse training.

   Paper & Model Release

   HiLS-Attention: End-to-End Learned Sparse Attention

   HiLS-Attention-7B

   model Learned Sparsity

   Tencent

   Hugging Face

   runEnd-to-end learned chunk-wise sparsity under LM loss

   Enables native sparse training for cheaper long-context inference.

   Why it matters: Long-context inference cost is dominated by attention; a mechanism that learns sparsity end-to-end (rather than heuristically) is a promising direction for cheaper long-context open-weight models, and this one ships weights.

   How to apply: If you're evaluating architectures for long-context fine-tuning or inference efficiency work, review the HiLS-Attention-7B repo and weights on Hugging Face as a reference implementation.

   quantizationlong-contextarchitecture

   Read more: tencent/HiLS-Attention-7B · Hugging Face

10. #10 Overburn audits Claude Code logs for recoverable token wastetool

    A CLI tool parses local Claude Code/Cowork logs to classify spend as useful versus recoverable waste, not just total dollars burned.

    Why it matters: Existing usage trackers like ccusage tell you how much you spent; this is the first tool aimed at telling you why, which is what you actually need to change behavior.

    How to apply: Run Overburn against your local Claude Code session logs to find patterns of wasted spend (redundant re-reads, oversized context, etc.) before deciding whether to change workflow or upgrade plan.

    claudecost-optimizationtool

    Read more: More than 60% of my Claude usage was wasted

11. #11 Free rules-based vulnerability scanner as a companion to /security-reviewtool

    An open-sourced, zero-token rules-based scanner catches trivial vulnerabilities that /security-review otherwise burns tokens finding.

    Why it matters: Anthropic's built-in /security-review is accurate but expensive on trivial findings; running a free static pass first reserves LLM review budget for the vulnerabilities that actually need reasoning.

    How to apply: Run the open-sourced scanner (or point your agent at it) before invoking /security-review, so token-costly LLM review is reserved for logic-level issues the rules-based pass can't catch.

    securityclaudetool

    Read more: 0 cost security scanning for Claude