Multi-Agent Coordination Grows Up: Stop Rules, One MCP for 70 Tools, Squeezed Pages

Today's findings

1. #1 Three coordination patterns for multi-agent teams, plus anti-loop rulestechnique

   Pick lead-routing, pipeline, or peer-review coordination explicitly, and add hard stop rules to prevent agent loops.

   Multi-agent coordination

   Three ways to wire an agent team

   Lead routing One router delegates open-ended goals

   Pipeline Fixed stages for known multi-step work

   Peer review Agents cross-check each other's output

   Open-ended Known steps Quality

   Whichever wiring: set loop budgets + termination checks to stop runaway agents before scaling.

   Why it matters: Multi-agent systems often fail on coordination rather than model quality; these patterns give a concrete starting taxonomy for browser automation and similar tool-using teams.

   How to apply: Start with a lead-router for open-ended goals, a fixed pipeline for known multi-step work, and explicit loop budgets/termination checks before adding more agents.

   agentsorchestrationprompting

   Read more: Three coordination patterns for multi-agent teams, and the 3 rules that stopped mine from looping · Three coordination patterns for multi-agent teams, and the 3 rules that stopped mine from looping

2. #2 One MCP server with discover, inspect, and run moves for 70 toolstool

   Collapse a sprawling tool list into a single MCP interface that discovers capabilities, shows inputs and price, then executes.

   Agent tool-use

   70 tools collapse into 3 MCP calls

   1

   Discover

   list capabilities

   ask for the job, not the vendor

   2

   Inspect

   inputs + price

   3

   Run

   execute via fallbacks

   One interface: each capability routes to fallback providers behind the scenes.

   Why it matters: Large tool menus eat context and cause wrong-tool selection; a capability-oriented MCP layer makes agents ask for jobs rather than vendors.

   How to apply: Expose three MCP methods—discover, inspect, run—and route each capability to fallback providers behind the scenes.

   mcpagentstool-use

   Read more: I gave my agent one MCP that reaches 70 GTM tools

3. #3 Squeeze fetched web pages before they bloat agent contexttechnique

   Fetch the full page in a side tool, answer the agent's specific question there, and return only the distilled result to the main context.

   Agent context hygiene

   Squeeze fetched pages before they enter the context

   Raw page

   • Full page HTML
   • Nav, ads, boilerplate
   • Off-topic text dilutes focus

   → Whole page → just the answer

   Answer only

   • URL + question to side tool
   • One extraction query
   • Compact result returned

   Fetch and distill outside the main loop so the agent stays lean and on task.

   Why it matters: Web fetches are a common source of context bloat and lost focus; a squeeze step keeps the main agent loop lean.

   How to apply: Add a URL-plus-question tool that retrieves the page, runs a single extraction query, and returns a compact answer instead of raw HTML.

   contextagentslocal-llm

   Read more: Webfetch squeeze to minimise context bloat

4. #4 Use a Claude Code PreToolUse hook to enforce real timestampstip

   Stop prompting Claude Code to check the clock; make a hook inject or validate timestamps before any Bash, write, edit, or message action.

   Claude Code guardrails

   Prompts can be ignored. Hooks can't.

   Prompt instruction

   • Memory files may be ignored
   • Model guesses the clock
   • Fabricated times persist in logs

   vs

   PreToolUse hook

   • Tiny script reads system time
   • Injects the real timestamp
   • Blocks or rewrites unchecked ones

   Deterministic enforcement beats reminders — make the clock a hook, not a request.

   Register one PreToolUse hook covering Bash, write, edit, and message tools.

   Why it matters: Memory-file instructions can be ignored, but deterministic hooks prevent fabricated timestamps in logs and operational notes.

   How to apply: Register a PreToolUse hook that runs a small Python script to read the system time and block or rewrite actions that contain unchecked timestamps.

   claude-codehooksguardrails

   Read more: My AI kept making up timestamps, so I stopped asking and made it impossible

5. #5 CanaryGuard screens prompt injections deterministically in under 0.1 mstool

   A heuristic firewall can catch delimiter injection, unicode obfuscation, and roleplay hijacks before prompts reach an agent.

   Prompt-injection defense

   Deterministic firewall for agent prompts

   0.1 ms

   to screen each prompt before it reaches the agent

   vs LLM-based guardrails, which add a model round-trip per prompt

   3

   attack families caught — delimiter, unicode, roleplay

   0

   LLM calls in the screening path

   1st

   line of defense, sitting in front of agent inputs

   Fixed rules can't be recursively jailbroken the way an LLM guardrail can.

   Why it matters: LLM-based guardrails add latency and can be recursively jailbroken; a fast deterministic layer is a useful first line of defense.

   How to apply: Put CanaryGuard or similar rules in front of agent inputs, then red-team with delimiter, unicode, and roleplay payloads.

   securityprompt-injectionagents

   Read more: Can you bypass a deterministic prompt-injection firewall? (<0.1ms latency benchmark & red-team challenge)

6. #6 CDRAG routes retrieval through LLM-labeled document clusterstechnique

   Pre-cluster documents, generate cluster keywords with an LLM, and route queries to relevant clusters before top-K retrieval.

   Why it matters: Standard cosine top-K can miss higher-level relevant documents; cluster-aware routing reported +12% faithfulness on legal QA.

   How to apply: Add a clustering and keyword-summary stage to your RAG index, then route each query to a shortlist of clusters before reranking passages.

   ragretrievalclustering

   Read more: CDRAG: LLM-guided cluster routing for RAG (+12% faithfulness on legal QA)

7. #7 Production RAG reference: hybrid search, RRF, parent-child chunking, and Promptfoo evalsrepo

   A FastAPI/Postgres RAG codebase shows table-aware PDF parsing, hybrid retrieval, reciprocal rank fusion, parent-child chunks, and eval wiring.

   Why it matters: It packages several practical RAG choices that are easy to discuss but hard to assemble correctly in production.

   How to apply: Use it as a review checklist or starting repo for financial/legal document QA, especially the parsing, fusion, and eval layers.

   raghybrid-searchevals

   Read more: [Code Review] Production-Grade RAG Assistant: Hybrid Search, RRF, Parent-Child Chunking, and Promptfoo Evals (Python/FastAPI/Postgres)

8. #8 New IQ2_K through IQ6_K quant types improve KLD over Q-quantstechnique

   llama.cpp PR 30715 proposes IQ K-quants with the same file sizes as Q-quants, better KLD, and only a slight performance cost.

   QUANTIZATION · LLAMA.CPP PR 30715

   IQ2_K–IQ6_K: same file size as Q-quants, better KLD, slight speed cost

   vs

   IQ K-quants (new)

   Q-quants (current)

   File size

   same

   same

   Output fidelity (KLD)

   better

   baseline

   Tokens/sec

   slightly slower

   faster

   IQ K-quants (new) wins the row Q-quants (current) wins the row

   Quality up without new hardware — swap Q-quants for K-quants at the same bytes.

   Why it matters: Local deployments constantly trade quality against memory; better quantization at the same size can raise quality without new hardware.

   How to apply: Test the PR's IQ K-quants against your current Q-quants on a representative model, watching KLD, tokens/sec, and memory.

   quantizationllama.cpplocal-llm

   Read more: New quant types suggested: IQ2_K, IQ3_K, IQ4_K, IQ5_K and IQ6_K

9. #9 Eight open models on 33 real DevOps tasks, measured on RTX 5090 and M4 Maxpaper

   A llama.cpp-based engine benchmark compares pass rate, tokens/sec, and memory for eight open models on practical infrastructure failures.

   Why it matters: It gives a concrete local-model selection signal for DevOps-style agent tasks instead of generic chat benchmarks.

   How to apply: Use the task set and engine setup to reproduce the eval on your own hardware before choosing a local model for ops automation.

   local-llmbenchmarkdevopsllama.cpp

   Read more: 8 open models on 33 real DevOps tasks, on an RTX 5090 and an M4 Max (48 GB): pass rate, tok/s and memory · 8 open models on 33 real DevOps tasks, on an RTX 5090 and an M4 Max (48 GB): pass rate, tok/s and memory

10. #10 Ling-3.1-flash ships MIT weights with long-context serving recipesrepo

    The open release includes SGLang/vLLM configs, structured tool calling, and a HiCache example restoring 5,952 of 6,000 prefix tokens.

    Why it matters: Long-context prompts become cheaper when the serving stack can reuse prefixes; the cookbook makes that operational pattern concrete.

    How to apply: Try the SGLang HiCache/Mooncake setup for repeated long prompts, and test the vLLM config for structured tool calling.

    local-llmlong-contextservingllama.cpp

    Read more: Ling-3.1-flash is open source, and its serving cookbook includes a 5,952-token prefix restoration example · Ling 3.1 Flash (560B MoE) loaded across 4 DGX Sparks using llama.cpp RPC

11. #11 asmsense dataset and Qwen3-8B LoRA for stripped-binary function namingpaper

    A 228k-function x86-64 dataset with source-aware labels trains a small Qwen3-8B LoRA to name and describe functions in stripped binaries.

    Why it matters: Reverse engineering and security triage can benefit from a local model that recovers function intent without source code.

    How to apply: Use the dataset and LoRA recipe to fine-tune a local Qwen3-8B model, then evaluate on your own stripped binaries before relying on it.

    reverse-engineeringdatasetloralocal-llm

    Read more: [P] asmsense: 228k stripped x86-64 functions with source-aware labels, and a map of the data we still lack. [P]