adaptive-memory-multi-model-router 2.13.11 → 2.13.13

package/README.md

@@ -13,6 +13,8 @@
 
 **One prompt in. The right model out.** An open-source **AI gateway** that auto-routes every query to the cheapest capable model across **47+ LLM providers**. Features **parallel ensemble execution**, **semantic cache**, **budget enforcement**, **intelligent failover**, and **independent benchmark validation**. Start in <100ms. Python SDK + TypeScript SDK.
 
+### 📖 AI-Friendly: [`llms.txt`](./llms.txt) · [`llms-full.txt`](./llms-full.txt)
+
 ### Quick Start: [`docs/QUICK_START.md`](./docs/QUICK_START.md)
 
 ### 📊 By the Numbers

package/_schema.html

@@ -0,0 +1,34 @@
+<!--
+AI discoverability: Schema.org markup for LLM search engines
+{
+  "@context": "https://schema.org",
+  "@type": "SoftwareApplication",
+  "name": "A3M Router",
+  "applicationCategory": "DeveloperApplication",
+  "operatingSystem": "Node.js",
+  "description": "Open-source LLM router with parallel multi-LLM execution, 47+ providers, 99.5% routing accuracy, 62% cost savings. 19.5 KB, zero ML dependencies.",
+  "url": "https://github.com/Das-rebel/a3m-router",
+  "downloadUrl": "https://www.npmjs.com/package/adaptive-memory-multi-model-router",
+  "softwareVersion": "2.14.0",
+  "license": "MIT",
+  "author": {
+    "@type": "Person",
+    "name": "Das-rebel"
+  },
+  "offers": {
+    "@type": "Offer",
+    "price": "0",
+    "priceCurrency": "USD"
+  },
+  "featureList": [
+    "Parallel multi-LLM execution",
+    "RouteLLM-style routing with 12 signals",
+    "47+ LLM providers",
+    "Semantic cache (30%+ hit rate)",
+    "Budget enforcement",
+    "Circuit breaker with failover",
+    "Prompt injection guardrails",
+    "Independent benchmark validation"
+  ]
+}
+-->

package/articles/FRESH_devto_2026_05.md

@@ -1,95 +1,73 @@
----
-title: "Three LLM Infrastructure Problems That Shouldn't Exist in 2026"
-published: false
-description: "Every LLM gateway claims to solve these. Most don't. Here's what actually works and why 10K developers downloaded a 19.5 KB router in two weeks."
-tags: llm, devops, infrastructure, ai, opensource
-cover_image: https://raw.githubusercontent.com/Das-rebel/a3m-router/main/docs/benchmark-chart.png
----
+LLM infrastructure has three problems that shouldn't exist in 2026. Here's what we built because nobody else fixed them.
 
-LLM infrastructure has a dirty secret: most "solutions" solve imaginary problems while ignoring the real ones.
+---
 
-After building and shipping an open-source LLM router that hit 10K downloads in two weeks with zero marketing, here are the three actual problems developers told us they were trying to solve.
+## Problem 1: Your LLM bill is unnecessarily high
 
----
+Everyone routes everything to GPT-4 because who has time to configure per-query routing. The bill hits 3-5x what it should be for zero extra value.
 
-## Problem 1: Your LLM Bill Is 3x Higher Than It Should Be
+People are already switching because of this. A dev on X: *"Cancelled both my Claude Code Pro and ChatGPT Pro. Kimi K2.6 is just as good for my side projects as Opus or GPT 5.4 were. The price for this is crazy low."*
 
-Most teams route every query to GPT-4. Not because every query needs GPT-4 — because nobody has time to configure per-query routing.
+Another one: *"Just used gemini-embedding-2 to vectorize 27,603 notes for semantic search. Total cost: $0.07. That's pretty amazing."*
 
-The result is predictable: monthly bills that are 3-5x higher than they need to be, with zero visibility into which team or query type is driving costs.
+The pattern is obvious — developers are actively looking for cheaper alternatives. The problem is doing it query-by-query without wasting time.
 
-**What we built:** A router that classifies every query by complexity (12 signals across 5 dimensions) and routes it to the cheapest capable model.
+We built a router that classifies every query by complexity and sends it to the cheapest capable model.
 
-```
+```javascript
 "Design a clinical trial protocol"  → premium  ($2.50/M tokens)
-"Write a Python sort function"      → cheap    ($0.20/M tokens)
+"Write a Python sort function"      → groq     ($0.20/M tokens)  
 "What is 2+2?"                      → free     ($0.00/M tokens)
 ```
 
-The result: **62% cost savings**. Not theoretical — measured across 200 real API calls in our benchmark suite.
+Result: **62% cost savings** measured across 200 real API calls. Not theoretical.
 
 ---
 
-## Problem 2: Sequential Fallback Is a Design Flaw
-
-Every LLM gateway uses the same pattern:
+## Problem 2: Sequential fallback gives you one answer, not the best
 
-```
-try Provider A → fails → wait → try Provider B → fails → wait → try Provider C
-```
+Every gateway does: try A → fail → try B → fail → try C.
 
-This is sequential fallback. It's the default. And it's wrong for three reasons:
+You always get one provider's answer. Never the best across all. If A is slow, everything waits.
 
-1. **You always get one provider's answer** — never the best across all
-2. **If the first provider is slow, everything waits**
-3. **No way to know if a different model would have given a better answer**
+Someone already built `ai-retry` — a library for retry and fallback mechanisms — because this is such a common pain. People are hacking around it manually.
 
-**What we built:** Parallel ensemble execution. Fire all providers at once. Score every result on specificity, structure, and relevance. Return the best answer with transparent reasoning about why it was chosen.
+We went further. Run all providers in parallel. Score every result on specificity, structure, and relevance. Return the best answer with reasons why it won.
 
 ```javascript
-const result = await executeEnsemble(query, systemPrompt, context, {
+const result = await executeEnsemble(query, context, {
   nvidia: callNvidia,
   groq: callGroq,
   openai: callOpenAI
 });
-console.log(`Winner: ${result.winner}`);    // → nvidia (scored 75)
-console.log(`Reason: ${result.reasoning}`); // → higher specificity on code
+// → nvidia (scored 75, higher specificity on code)
 ```
 
-This isn't a feature we added for marketing. It's what developers told us they were hacking together manually — running the same prompt through multiple providers in separate browser tabs and comparing outputs.
-
 ---
 
-## Problem 3: Every Gateway Claims "Negligible Overhead" — None Publish Numbers
-
-Gateways add latency. Everyone knows this. Nobody publishes the actual numbers.
+## Problem 3: Every gateway claims "negligible overhead." None publish numbers.
 
-The standard line is "negligible overhead" followed by zero data. When we started building A3M, we couldn't find a single competitor that published independent latency benchmarks for their own proxy.
+It's the standard line. "Negligible overhead" followed by zero data.
 
-**What we did:** Ran our proxy through [llm-gateway-bench](https://github.com/taffy-owo/llm-gateway-bench) — a third-party benchmarking tool — and published every number.
+We ran ours through a third-party benchmark tool (llm-gateway-bench) and published everything:
 
-| Scenario | TTFT | What happens |
-|:---------|:----:|:-------------|
-| Direct to Groq | **138ms** | Raw provider call |
-| Through A3M (forced) | **234ms** | Guardrails + cache + cost tracking |
-| Through A3M (auto) | **374ms** | Above + routing decision (12 signals) |
+| Scenario | Time | What's included |
+|:---------|:----:|:----------------|
+| Direct to Groq | **138ms** | Raw API call |
+| Through A3M | **374ms** | Routing + cache + guardrails + cost tracking |
 
-The overhead is real. It's also documented, reproducible, and pays for itself — 236ms saves 62% on API costs.
+236ms overhead. Not zero. But it saves 62% on API costs — that's ~$2,600/year at 100K queries/month.
 
 ---
 
-## Why Developers Switched
+## Why it grew
 
-The three pain points above keep coming up in the same pattern:
+10,024 downloads in 14 days. Zero marketing. Developers found it on npm, tried it, told other developers.
 
-1. **"My bill is out of control"** → They try the routing → 62% savings
-2. **"I'm tired of mediocre answers from the only model I can afford"** → They try the ensemble → better answers
-3. **"I don't trust black-box gateways"** → They see the benchmarks → they trust it
-
-10,024 downloads. 72 versions. Zero marketing budget.
+The feedback loop was: *"My bill is too high"* → 62% savings. *"I want the best answer, not the first one"* → parallel ensemble. *"I don't trust your latency claims"* → here's the third-party benchmark, run it yourself.
 
 ---
 
-*GitHub: [github.com/Das-rebel/a3m-router](https://github.com/Das-rebel/a3m-router)*  
 *npm: `npm install adaptive-memory-multi-model-router`*  
-*Benchmark methodology: [docs/BENCHMARK.md](https://github.com/Das-rebel/a3m-router/blob/main/docs/BENCHMARK.md)*
+*GitHub: [github.com/Das-rebel/a3m-router](https://github.com/Das-rebel/a3m-router)*  
+*Benchmarks: third-party via [llm-gateway-bench](https://github.com/taffy-owo/llm-gateway-bench)*

package/articles/hn_show_2026_05.md

@@ -1,14 +1,11 @@
-We built an open-source LLM router that solves three real problems developers keep hitting:
+Three LLM infrastructure problems nobody's fixing properly:
 
-**Problem 1 — LLM bills are 3x higher than they should be.**
-Every query goes to GPT-4 because nobody has time to configure per-query routing. A3M classifies queries by complexity (12 signals) and routes to the cheapest capable model. 62% cost savings.
+**1. Your bill is unnecessarily high.** Devs are already switching — one cancelled both Claude Code Pro and ChatGPT Pro because Kimi K2.6 is "just as good for side projects at a crazy low price." We automated that decision query-by-query. 62% savings.
 
-**Problem 2 — Sequential fallback gives you one provider's answer, not the best one.**
-Every other router does try-A-fail-try-B-fail-try-C. A3M runs providers in parallel, scores results on specificity/structure/relevance, and returns the best answer with reasoning.
+**2. Sequential fallback gives you the first answer, not the best.** Every gateway does try-A-fail-try-B. Someone already built `ai-retry` as a library because this is such a common hack. We run providers in parallel, score results, return the best with reasoning.
 
-**Problem 3 — Every gateway claims "negligible overhead" without publishing numbers.**
-We ran ours through llm-gateway-bench (third-party tool) and published everything: 138ms baseline → 374ms through full routing. 236ms overhead saves 62% on API costs.
+**3. "Negligible overhead" with zero data.** Every gateway says this. We published third-party benchmarks via llm-gateway-bench: 138ms → 374ms. Real numbers you can reproduce.
 
-19.5 KB. Zero ML dependencies. 47 providers. 10K downloads in 14 days.
+19.5 KB. 47 providers. Zero ML dependencies. 10K downloads in 14 days, zero marketing.
 
 https://github.com/Das-rebel/a3m-router

package/articles/twitter-thread-cost-savings.md

@@ -1,64 +1,50 @@
-1/7 Three LLM infrastructure problems that shouldn't exist in 2026:
+1/7 Three LLM infrastructure problems that keep coming up:
 
-• Your bill is 3x higher than it should be
-• Sequential fallback gives you one provider's answer, not the best one
-• Every gateway claims "negligible overhead" without publishing numbers
+• Your bill is 3x higher than it needs to be  
+• Sequential fallback gives you one answer, never the best  
+• Every gateway says "negligible overhead" — zero data  
 
-We built something that fixes all three.
+We built the thing that fixes all three.
 
-2/7 Problem 1: Your LLM bill is 3x higher than it should be.
+2/7 A dev on X: "Cancelled both my Claude Code Pro and ChatGPT Pro. Kimi K2.6 is just as good for side projects. Price is crazy low."
 
-Every query goes to GPT-4 because configuring per-query routing is a pain.
+Another: "Vectorized 27K notes for $0.07. That's pretty amazing."
 
-A3M classifies every query by complexity (12 signals) and routes to the cheapest capable model.
+Everyone's looking for cheaper options. The hard part is doing it per-query without wasting time.
 
-Simple Q&A → free ($0)
-Code → cheap ($0.20/M)
-Expert → premium ($2.50/M)
+We route every query to the cheapest capable model. 62% savings. Measured.
 
-62% cost savings.
+3/7 Every LLM "router" does: try A → fail → try B → fail → try C.
 
-3/7 Problem 2: Sequential fallback is a design flaw.
+You always get whatever A gave you. Nobody runs them all and picks the best.
 
-Every gateway does: try A → fail → try B → fail → try C.
+Someone already built `ai-retry` just for the fallback part — that's how common this pain is.
 
-You always get one provider's answer. Never the best across all.
+We run all providers in parallel. Score results. Return the best answer. With reasoning why it won.
 
-A3M runs ALL providers in parallel, scores every result, and returns the best answer with reasoning.
+4/7 "Negligible overhead" — every gateway claims this. Zero publish numbers.
 
-We call it parallel ensemble. No other router does this.
+We ran ours through llm-gateway-bench (third-party, not our tool) and published everything.
 
-4/7 Problem 3: "Negligible overhead" with zero data.
-
-Every gateway claims this. None publish numbers.
-
-We ran ours through a third-party benchmarking tool (llm-gateway-bench) and published everything:
-
-Direct: 138ms
+Direct: 138ms  
 Through A3M: 374ms
 
-236ms overhead saves 62% on API costs. Reproducible by anyone.
-
-5/7 Why 10K developers downloaded it in 14 days (zero marketing):
+236ms overhead. Real. Documented. Runs 62% cheaper.
 
-They told us they were hacking these solutions together manually — running prompts through multiple providers in separate browser tabs, comparing outputs by hand.
+5/7 The numbers since we shipped:  
+10,024 downloads in 14 days.  
+72 versions.  
+Zero marketing.  
+47 providers.  
+19.5 KB.  
+Zero ML dependencies.
 
-We automated what they were already doing.
-
-6/7 What's inside the 19.5 KB package:
-
-• Parallel ensemble (the unique feature)
-• RouteLLM-style routing (99.5% accuracy)
-• 47 providers
-• Budget enforcement with alerts
-• Semantic cache (30%+ hit rate)
-• Circuit breaker + auto failover
-• Persistent memory
-
-7/7 npm install adaptive-memory-multi-model-router
+6/7 npm install adaptive-memory-multi-model-router  
 npx a3m-router serve
 
-Point any OpenAI SDK at localhost:8787.
+Point any OpenAI SDK at localhost:8787. Works.
+
+7/7 GitHub: github.com/Das-rebel/a3m-router  
+Benchmarks: third-party via llm-gateway-bench 
 
-GitHub: github.com/Das-rebel/a3m-router
-Docs: github.com/Das-rebel/a3m-router#benchmark-results-real-api-calls
+Built because the existing stuff didn't fix the actual problems.

package/dist/tui/dashboard.d.ts

@@ -1,8 +1,5 @@
 #!/usr/bin/env node
 /**
- * A3M Router — Terminal Overlay Box
- * Draws a centered overlay ON TOP of existing terminal content.
- * Does NOT clear the screen. Restores terminal when done.
- * Pure ANSI — no fullscreen, no alt-buffer.
+ * A3M Router — Overlay Box (blessed, non-fullscreen)
  */
 export {};