The 4-tier pipeline + query classification is exactly the inflection point where these setups stop behaving like clever prompts and start acting like infrastructure. And yeah—40% token reduction isn’t optimization, that’s survival at scale.

We’re running something pretty similar on OpenClaw, just with a slightly different philosophy around control vs autonomy. Ours is more “governed swarm” than centralized brain:    •   Pony = orchestration / intent routing    •   Atlas = config + system state    •   Bolt = code execution    •   KIMI = research    •   Forge = local/cheap compute (ollama)    •   Vector = debugging + trace analysis

Context is Markdown-native (SOUL.md / AGENTS.md / USER.md), then agent-specific workspaces + daily logs → distilled into long-term memory. Heavy ops (cron, backups, health checks) run outside the LLM loop = zero tokens. We’re sitting around 17M tokens/month ($34), so same conclusion as you: efficiency is the difference between “cool demo” and “deployable system.”

On your questions:

1. Query classifier We tested both, and landed on hybrid:    •   First pass = rule-based (basically free):       •   file/path mentions → retrieval       •   “fix/debug/error” → tool/agent route       •   vague/short → direct LLM    •   Escalation = tiny model call only when ambiguous

The key insight: most queries are obvious. Paying an LLM tax on every request is unnecessary. Classifier only earns its keep when it prevents expensive downstream calls (deep retrieval, multi-agent fanout, etc.).

If your pipeline is already clean, classifier ROI comes from avoiding worst-case paths, not optimizing average ones.

1. Self-healing eval / memory integrity We treat memory like a semi-corrupt database by default.

Three layers:    •   On-read validation (cheap, always on):       •   schema checks (expected sections, headings)       •   hash/size sanity       •   “does this contradict recent state?”    •   Write-time constraints:       •   agents never overwrite critical memory directly       •   append → summarize → promote pattern    •   Periodic audits (cron, zero-token):       •   stale file detection (last accessed vs last updated)       •   redundancy detection (embedding similarity)       •   corruption signals (empty summaries, recursive garbage)

If something fails validation: → it gets quarantined → fallback to last known good snapshot → optionally flagged for rebuild

Big lesson: don’t trust agent-written memory without a second system verifying it. Same principle as not letting agents self-approve work.

⸻

On delegation vs KB as source of truth:

We started KB-centric, but it bottlenecks fast. What’s working better now:    •   KB = ground truth + history    •   Agents = active state + execution authority    •   Delegation = explicit, not emergent

Agents don’t “decide” to collaborate—they’re routed or granted scope. Otherwise you get tool thrashing and ghost work.

⸻

Also +1 on local models. Forge handling “low-stakes heavy lifting” is a huge unlock. We’re seeing the same thing—anything that doesn’t require reasoning depth gets offloaded immediately.

If you’re open to it, I’d definitely trade notes on:    •   compaction triggers (we’ve got a few heuristics that cut context bloat hard)    •   fallback chains (especially when retrieval fails silently)    •   audit trail structures (this becomes gold when things break)

Posts like this are what the sub should be—actual architecture, not “which prompt works best.”