cd /news/ai-tools/newllm-what-is-new-changed-and-gone-… · home › topics › ai-tools › article
[ARTICLE · art-159510] src=gist.github.com ↗ pub= topic=ai-tools verified=true sentiment=· neutral

newllm — what is new, changed, and gone among free & stealth LLMs on OpenRouter.

A developer released newllm, a Node.js command-line tool that monitors OpenRouter's free model catalog and Stealth Program codenames, diffing each run against saved state to report which free models appeared, disappeared, or stopped being free. The tool pulls from OpenRouter's public models API, stealth pages, and provider list without requiring an API key, and offers JSON, quiet TSV, ranked, and full-detail output modes, with a ranked comparison that sorts free models by Artificial Analysis intelligence index and flags whether providers train on prompts.

by read36 min views45 publishedOct 25, 2026

| | #!/usr/bin/env node | | | /** | | | * newllm — what is new, changed, and gone among free & stealth LLMs on OpenRouter. | | | * | | | * WHAT IT DOES | | | * Monitors OpenRouter's free model catalog and its Stealth Program codenames. | | | * On each run it fetches the current catalog, compares it against the state | | | * written by the previous run, and reports what appeared, what disappeared, | | | * what stopped being free, and which stealth codenames came or went. It also | | | * offers a ranked comparison of free models, full detail blocks, and a | | | * machine-readable summary. | | | * | | | * DATA SOURCES (all public; no API key required) | | | * catalog https://openrouter.ai/api/v1/models | | | * Every public model with pricing, architecture, supported params, | | | * benchmarks, description and expiry metadata. | | | * stealth https://openrouter.ai/stealth | | | * Stealth Program codenames. These are NOT in the catalog, so each | | | * codename's name/context/description is scraped from its own page |

|  | * at https://openrouter.ai/stealth/<codename> (og:title and | 
|  | * og:description meta tags). | 

| | * providers https://openrouter.ai/api/frontend/v1/all-providers | | | * Provider list with dataPolicy.training, used for the "prompt | | | * training" column in --rank. Provider names and display names are | | | * normalized (lowercased, non-alphanumerics stripped) to match the | | | * org prefix of a model id. | | | * | | | * STATE AND CACHE — ${XDG_STATE_HOME:-$HOME/.local/state}/newllm/ | | | * catalog.json last successfully fetched catalog response | | | * providers.json last successfully fetched providers response |

|  | * state.json { updated, free: { id: {prompt, name, first_seen} }, | 
|  | * stealth: { id: {name, ctx, desc, first_seen} } } | 

| | * The first run with no state.json is a BASELINE run: it records what exists | | | * now and prints it, and only later runs report differences. | | | * | | | * FREE DEFINITION | | | * A model is free when BOTH pricing.prompt == "0" AND pricing.completion == "0". | | | * Two kinds are distinguished when rendering detail: | | | * ":free" id suffix -> promotional variant, can be withdrawn |

|  | * base model at $0 -> free by policy | 
|  | * A $0-per-token model can still charge per artifact (e.g. per image); that | 

| | * only ever appears in the description, so the description is scanned for | | | * "$N" price tags and surfaced as a note. | | | * | | | * DIFFING (previous run -> now) | | | * NEW free model present now, absent from previous state | | | * GONE free model from previous state, absent now AND absent from the full | | | * catalog (i.e. delisted entirely) | | | * UNFREE free model from previous state, absent from the free set now, but | | | * still present in the full catalog (i.e. it now costs money) | | | * Stealth codenames are diffed as plain sets: NEW-STEALTH and GONE-STEALTH. | | | * | | | * OUTPUT MODES (first matching branch wins, in this order) |

|  | * --json machine-readable summary: counts plus the changed lists | 
|  | * -q/--quiet/--check one TSV line per change, "BASELINE" line on first run; | 

| | * exit status 1 when there were no changes (for cron) | | | * --rank two lists (see below); also the default when no mode is given | | | * --all every free model detail block, then every stealth block | | | * --changes only what changed since the previous run, else "nothing changed"; | | | * with no prior state this prints the baseline listing instead | | | * | | | * --rank DETAIL | | | * List 1 — SCORED: free models carrying an Artificial Analysis intelligence | | | * index, sorted descending by that index. Columns: rank, model, three bars | | | * (intelligence / coding / agentic), context window, and whether the model's | | | * provider trains on prompts (yes/no/unknown; "router" for openrouter/*). | | | * Each bar is scaled relative to the best score in its own column, so a | | | * short coding bar means "weak in coding", not "weak overall". | | | * List 2 — UNSCORED: free models with no intelligence index. They cannot be | | | * ranked, so they are listed with context window, any Design Arena Elo | | | * (with its category), an expiry date if near, and a per-artifact charge | | | * note. A model here is unmeasured, not necessarily bad. | | | * | | | * RENDERING |

|  | * hum() compact numbers: 2500000 -> "2.5M", 131072 -> "131k", 4096 -> "4096". | 
|  | * perm() per-token price -> dollars per million tokens, decimals trimmed | 
|  | * bar() fixed 10-glyph cell: blue fill over a dim track, then the raw | 

| | * number in a 5-column right-aligned field. An unknown value renders | | | * as a dim run of 10 dashes with a "·" placeholder, so every cell | | | * keeps the same width and columns stay aligned. Corners are square | | | * because Unicode has no rounded block glyphs. | | | * snippet() truncate on a word boundary with an ellipsis | | | * | | | * ENVIRONMENT | | | * OPENROUTER_API_KEY optional; sent as Authorization: Bearer on the catalog | | | * NO_COLOR set to disable colour | | | * --offline use cached catalog and providers, do not touch the network | | | * | | | * EXIT STATUS | | | * 0 normal; 1 --check with no changes, or a fetch/cache failure; 2 bad option | | | * | | | * CAVEATS | | | * Free windows are time-limited (expiration_date is surfaced when near or past). | | | * Stealth providers may retain your prompts and completions — read what you send. | | | */ |

|  | import fs, { promises, existsSync } from "node:fs"; | 
|  | const { mkdirSync } = fs; | 
|  | const PROG = "newllm"; | 
|  | // ----------------------------------------------------------------- config | 

| | const HOME = process.env.HOME ?? ""; |

|  | const STATE_DIR = `${process.env.XDG_STATE_HOME ?? `${HOME}/.local/state`}/newllm`; | 
|  | const STATE_FILE = `${STATE_DIR}/state.json`; | 
|  | const CACHE_FILE = `${STATE_DIR}/catalog.json`; | 
|  | const PROV_FILE = `${STATE_DIR}/providers.json`; | 

| | const CATALOG_URL = "https://openrouter.ai/api/v1/models"; | | | const STEALTH_URL = "https://openrouter.ai/stealth"; | | | const PROVIDERS_URL = "https://openrouter.ai/api/frontend/v1/all-providers"; | | | const USAGE = `newllm — what is new, changed, and gone among free & stealth LLMs on OpenRouter. | | | newllm free models scored and ranked, with bars (the default) | | | newllm --rank same as the default (--offline uses the cached provider list) | | | newllm --changes new, gone and now-paid since the previous run | | | newllm --all every currently free model, with details | | | newllm --json machine readable | | | newllm -q one line per change, exit 1 when nothing changed (cron) | | | newllm --reset forget state and re-baseline | | | newllm --offline use cached catalog and providers, skip the network |

|  | newllm --no-color disable colour | 
|  | newllm -h, --help this text | 

| | `; | | | // ------------------------------------------------------------------ colour | | | const COLOR = !!process.stdout.isTTY && !process.env.NO_COLOR; |

|  | // Codes already carry their SGR terminator: "\x1b[1m", "\x1b[38;5;39m", ... | 
|  | const c = (code) => (COLOR ? `\x1b[${code}` : ""); | 
|  | const B = c("1m"), | 
|  | DIM = c("2m"), | 
|  | GRN = c("32m"), | 
|  | RED = c("31m"); | 
|  | const YEL = c("33m"), | 
|  | CYA = c("36m"), | 
|  | BLU = c("38;5;39m"), | 
|  | RST = c("0m"); | 
|  | // ------------------------------------------------------------------- helpers | 
|  | const NOW = Math.floor(Date.now() / 1000); | 
|  | const pad2 = (n) => String(n).padStart(2, "0"); | 
|  | const localDate = (d = new Date()) => | 
|  | `${d.getFullYear()}-${pad2(d.getMonth() + 1)}-${pad2(d.getDate())}`; | 
|  | const localDateTime = (d = new Date()) => | 
|  | `${localDate(d)} ${pad2(d.getHours())}:${pad2(d.getMinutes())}`; | 
|  | const isoUTC = (d = new Date()) => d.toISOString().replace(/\.\d+Z$/, "Z"); | 
|  | const TODAY = localDate(); | 
|  | /** Right-pad to n columns (printf %-Ns). */ | 
|  | const padEndS = (s, n) => (s.length >= n ? s : s + " ".repeat(n - s.length)); | 

| | /** | | | * Left-pad to n display columns (printf %Ns). Every glyph this renderer emits — | | | * ASCII, the block fills █ ░ ─ and the · placeholder — is exactly one column, so | | | * character count is display width. (bash's printf padded · by bytes, which made | | | * placeholder cells one column narrow and broke the alignment.) | | | / | | | const padStartS = (s, n) => (s.length >= n ? s : " ".repeat(n - s.length) + s); | | | /* Repeat a glyph n times. / | | | const rep = (glyph, n) => (n > 0 ? glyph.repeat(n) : ""); | | | /* | | | * Compact number: 2500000 -> "2.5M", 131072 -> "131k", 4096 -> "4096". | | | * Empty or zero prints "-", matching the "unknown" convention. | | | */ |

|  | function hum(n) { | 
|  | if (n === "" \|\| n === null \|\| n === undefined) return "-"; | 
|  | const x = Number(n); | 
|  | if (!isFinite(x) \|\| x === 0) return "-"; | 
|  | if (x >= 1_000_000) { | 
|  | const w = Math.trunc(x / 1_000_000); | 
|  | const r = Math.trunc((x % 1_000_000) / 100_000); | 
|  | return r === 0 ? `${w}M` : `${w}.${r}M`; | 

| | } |

|  | if (x >= 1000) return `${Math.trunc(x / 1000)}k`; | 
|  | return `${x}`; | 

| | } | | | /** Per-token price string -> dollars per million tokens, decimals trimmed. */ |

|  | function perm(p) { | 
|  | if (!p) return "-"; | 
|  | const v = Number(p) * 1_000_000; | 
|  | if (!isFinite(v)) return "-"; | 
|  | if (v === 0) return "0"; | 
|  | if (v >= 1) return String(Math.round(v * 100) / 100); | 
|  | return String(Math.round(v * 100_000) / 100_000); | 

| | } |

|  | /** "41.1" -> 411, "25" -> 250: fixed-point x10 so bars avoid floats. */ | 
|  | function scale10(v) { | 
|  | const s = String(v); | 
|  | return s.includes(".") ? Number(s.replace(".", "")) : Number(`${s}0`); | 

| | } | | | /** Models whose OpenRouter pricing is reported on every run. */ |

|  | const WATCHED = [ | 
|  | "deepseek/deepseek-v4-flash", | 
|  | "deepseek/deepseek-v4-pro", | 
|  | "deepseek/deepseek-v4.1-flash-1017", | 
|  | "z-ai/glm-5.3", | 
|  | "z-ai/glm-5.3-prime", | 
|  | "moonshotai/kimi-k3.1-pro", | 
|  | "minimax/minimax-m3.1-flash", | 
|  | ]; | 
|  | const DAY_NAMES = [ | 

| | "sunday", | | | "monday", | | | "tuesday", | | | "wednesday", | | | "thursday", | | | "friday", | | | "saturday", | | | ]; | | | /** Current UTC day name, lowercase, matching OpenRouter override utc_days values. */ |

|  | function nowUtcDay() { | 
|  | return DAY_NAMES[new Date().getUTCDay()]; | 

| | } | | | /** Current UTC time as an HHMM integer (e.g. 135 for 01:35, 1000 for 10:00). */ |

|  | function nowUtcHhmm() { | 
|  | const d = new Date(); | 
|  | return d.getUTCHours() * 100 + d.getUTCMinutes(); | 

| | } | | | /** The override entry matching the current UTC day and time, or null. */ | | | function matchingOverride(pricing) { | | | const ovs = pricing && pricing.overrides; |

|  | if (!ovs \|\| !ovs.length) return null; | 
|  | const day = nowUtcDay(); | 
|  | const hhmm = nowUtcHhmm(); | 
|  | for (const ov of ovs) { | 
|  | const days = ov.utc_days; | 
|  | if (!days \|\| !days.includes(day)) continue; | 
|  | const start = Number(ov.utc_start ?? 0); | 
|  | const end = Number(ov.utc_end ?? 2400); | 
|  | if (hhmm >= start && hhmm < end) return ov; | 

| | } | | | return null; | | | } | | | /** "peak" | "off-peak" | "flat" for the tier in effect right now. */ |

|  | function activeTierKind(pricing, active) { | 
|  | const allPrices = [Number((pricing && pricing.prompt) ?? 0)]; | 
|  | for (const ov of (pricing && pricing.overrides) ?? []) { | 
|  | allPrices.push(Number(ov.prompt ?? 0)); | 

| | } |

|  | const max = Math.max(...allPrices); | 
|  | const min = Math.min(...allPrices); | 
|  | if (max === min) return "flat"; | 

| | const activePin = active |

|  | ? Number(active.prompt ?? 0) | 
|  | : Number((pricing && pricing.prompt) ?? 0); | 
|  | if (activePin === max) return "peak"; | 
|  | if (activePin === min) return "off-peak"; | 
|  | return "off-peak"; | 

| | } | | | /** Short modality tag from a catalog modality field, e.g. "(text)", "(image+video)". */ |

|  | function modalityTag(modality) { | 
|  | const out = (modality \|\| "").replace(/->text$/, ""); | 
|  | const ins = out.split("+").filter((x) => x !== "text"); | 
|  | if (ins.length === 0) return "(text)"; | 
|  | return `(${ins.join("+")})`; | 

| | } | | | /** Print current OpenRouter pricing for the watched models, per 1M tokens. */ |

|  | function reportPricing(models) { | 
|  | const byId = new Map(models.map((m) => [m.id, m])); | 
|  | const rows = []; | 
|  | for (const id of WATCHED) { | 
|  | const m = byId.get(id); | 
|  | if (!m) { | 
|  | rows.push([id, "not listed"]); | 

| | continue; | | | } |

|  | const pricing = m.pricing \|\| {}; | 
|  | const active = matchingOverride(pricing); | 
|  | const kind = activeTierKind(pricing, active); | 

| | const pin = active | | | ? String(active.prompt ?? pricing.prompt ?? "") | | | : String(pricing.prompt ?? ""); | | | const pout = active | | | ? String(active.completion ?? pricing.completion ?? "") |

|  | : String(pricing.completion ?? ""); | 
|  | const pcache = perm(pricing.input_cache_read ?? ""); | 

| | let line; |

|  | if (kind === "flat") { | 
|  | line = `$${perm(pin)}/M in $${perm(pout)}/M out`; | 
|  | } else { | 
|  | const now = kind === "peak" ? "peak now" : "off-peak now"; | 
|  | line = `${now} $${perm(pin)}/M in $${perm(pout)}/M out`; | 

| | } |

|  | if (pcache !== "" && pcache !== "0") line += ` (cache $${pcache}/M read)`; | 
|  | line += ` ${modalityTag((m.architecture && m.architecture.modality) \|\| "")}`; | 
|  | rows.push([id, line]); | 

| | } |

|  | const wId = Math.max(...rows.map((r) => r[0].length)); | 
|  | console.log(`${B}current pricing (per 1M tokens, OpenRouter)${RST}`); | 
|  | for (const [id, line] of rows) { | 
|  | console.log(` ${padEndS(id, wId)} ${line}`); | 

| | } | | | console.log(); | | | } | | | const FILL = "█", | | | TRACK = "░", | | | DASH = "─"; | | | /** | | | * bar <value> <maxTimes10> -> fixed 16-column cell. | | | * Blue fill over a dim track, then the raw value right-aligned in 5 columns. | | | * An unknown value is a dim dash run of the same width, so every cell keeps | | | * the same display width and columns stay aligned. Corners stay square: | | | * Unicode has no rounded block glyphs. | | | */ |

|  | function bar(value, maxTimes10) { | 
|  | if (value === "" \|\| value === null \|\| value === undefined) { | 
|  | return `${DIM}${rep(DASH, 10)}${RST} ${padStartS("·", 5)}`; | 

| | } |

|  | let m = maxTimes10 ?? 0; | 
|  | if (m <= 0) m = 1; | 
|  | const s = scale10(value); | 
|  | let n = Math.trunc((s * 10 + Math.trunc(m / 2)) / m); | 
|  | if (n < 1) n = 1; | 
|  | if (n > 10) n = 10; | 
|  | return `${BLU}${rep(FILL, n)}${RST}${DIM}${rep(TRACK, 10 - n)}${RST} ${padStartS(value, 5)}`; | 

| | } | | | /** Truncate on a word boundary, with an ellipsis. */ |

|  | function snippet(s, n = 200) { | 
|  | if (s.length <= n) return s; | 
|  | let t = s.slice(0, n); | 
|  | const i = t.lastIndexOf(" "); | 
|  | if (i >= 0) t = t.slice(0, i); | 
|  | return `${t}…`; | 

| | } | | | /** Join with " · ", dropping empty parts. */ |

|  | const joinDot = (parts) => parts.filter((x) => x !== "").join(" · "); | 
|  | // ------------------------------------------------------------------ fetch | 
|  | async function get(url, accept, auth = false) { | 

| | try { |

|  | const headers = { Accept: accept }; | 
|  | if (auth && process.env.OPENROUTER_API_KEY) { | 
|  | headers.Authorization = `Bearer ${process.env.OPENROUTER_API_KEY}`; | 

| | } | | | const res = await fetch(url, { | | | headers, |

|  | signal: AbortSignal.timeout(30_000), | 
|  | }); | 
|  | if (!res.ok) return null; | 
|  | return await res.text(); | 
|  | } catch { | 

| | return null; | | | } | | | } | | | async function readJsonFile(path) { | | | try { |

|  | return JSON.parse(await promises.readFile(path, "utf8")); | 
|  | } catch { | 

| | return null; | | | } | | | } | | | // ------------------------------------------------------------- current state | | | /** Free = prompt price 0 AND completion price 0. Catalog order: newest first. */ |

|  | function isFree(m) { | 
|  | const pr = (m.pricing && m.pricing.prompt) ?? "1"; | 
|  | const pc = (m.pricing && m.pricing.completion) ?? "1"; | 
|  | return pr === "0" && pc === "0"; | 

| | } | | | /** Flatten one API model into a row shape plus all derived display fields. */ |

|  | function toRow(m) { | 
|  | const desc = (m.description \|\| "").replace(/[\t\n\r]+/g, " ").slice(0, 400); | 
|  | const sps = m.supported_parameters \|\| []; | 

| | const prl = |

|  | m.per_request_limits == null ? "" : JSON.stringify(m.per_request_limits); | 
|  | const pin = (m.pricing && m.pricing.prompt) \|\| ""; | 
|  | const pout = (m.pricing && m.pricing.completion) \|\| ""; | 
|  | const pcache = (m.pricing && m.pricing.input_cache_read) \|\| ""; | 
|  | const pweb = (m.pricing && m.pricing.web_search) \|\| ""; | 
|  | const arenaArr = (m.benchmarks && m.benchmarks.design_arena) \|\| []; | 

| | const arena = | | | arenaArr.length > 0 |

|  | ? (() => { | 
|  | const last = [...arenaArr].sort((a, b) => a.elo - b.elo).at(-1); | 
|  | return `${last.elo}\|${last.category}`; | 
|  | })() | 
|  | : ""; | 

| | const created = m.created || 0; |

|  | const age = Math.trunc((NOW - created) / 86400); | 
|  | const listed = localDate(new Date(created * 1000)); | 
|  | const slugDate = /[0-9]{8}$/.test(m.canonical_slug \|\| "") | 
|  | ? (m.canonical_slug \|\| "").slice(-8) | 
|  | : ""; | 

| | // Capability flags, from supported_parameters plus pricing features. |

|  | const caps = []; | 
|  | if (sps.includes("tools") \|\| sps.includes("tool_choice")) caps.push("tools"); | 
|  | if (sps.includes("reasoning") \|\| sps.includes("include_reasoning")) | 
|  | caps.push("reasoning"); | 
|  | if (sps.includes("response_format")) caps.push("structured"); | 
|  | if (pcache !== "") caps.push("caching"); | 
|  | if (pweb !== "") caps.push("websearch"); | 

| | const params = | | | (desc.match(/[0-9]+(.[0-9]+)? ?B( |-)((total|active) )?parameters?/) && | | | desc.match( |

|  | /[0-9]+(\.[0-9]+)? ?B( \|-)((total\|active) )?parameters?/, | 
|  | )[0]) \|\| | 
|  | (desc.match(/[0-9]+(\.[0-9]+)? ?B (total\|active)/) && | 
|  | desc.match(/[0-9]+(\.[0-9]+)? ?B (total\|active)/)[0]) \|\| | 

| | ""; |

|  | // A $0-per-token model can still charge per artifact; the description says so. | 
|  | const pricetag = (desc.match(/\$[0-9][0-9.]*( per [a-z]+)?/g) \|\| []) | 
|  | .slice(0, 3) | 
|  | .join(", "); | 

| | // ":free" is a promotional variant; a base model priced at zero is free by policy. | | | const freeKind = m.id.endsWith(":free") | | | ? "free variant (promotional, can be withdrawn)" | | | : "priced at zero (free by policy)"; | | | const exp = m.expiration_date || ""; |

|  | let expDays = null; | 
|  | if (exp !== "") { | 
|  | // macOS `date -j -f "%Y-%m-%d"` keeps the current time of day, so a | 

| | // date-only expiry is a whole-day difference regardless of run time. |

|  | const clock = new Date(); | 
|  | const e = new Date( | 
|  | `${exp}T${pad2(clock.getHours())}:${pad2(clock.getMinutes())}:${pad2(clock.getSeconds())}`, | 
|  | ).getTime(); | 
|  | if (!isNaN(e)) expDays = Math.trunc((Math.floor(e / 1000) - NOW) / 86400); | 

| | } |

|  | const aa = (m.benchmarks && m.benchmarks.artificial_analysis) \|\| {}; | 
|  | const str = (v) => (v === undefined \|\| v === null ? "" : String(v)); | 

| | return { | | | id: m.id, | | | created, | | | name: m.name || m.id, | | | ctx: m.context_length || 0, | | | maxout: (m.top_provider && m.top_provider.max_completion_tokens) || 0, | | | modality: (m.architecture && m.architecture.modality) || "?", | | | hf: m.hugging_face_id || "", | | | sps, | | | mod: (m.top_provider && m.top_provider.is_moderated) || false, | | | slug: m.canonical_slug || "", | | | prl, | | | pin, | | | pout, | | | pcache, | | | pweb, | | | desc, |

|  | aaIntel: str(aa.intelligence_index), | 
|  | aaCode: str(aa.coding_index), | 
|  | aaAgent: str(aa.agentic_index), | 

| | arena, | | | exp, | | | cutoff: m.knowledge_cutoff || "", | | | age, | | | listed, | | | slugDate, | | | caps, | | | params, | | | pricetag, | | | freeKind, | | | expDays, | | | }; | | | } | | | // ------------------------------------------------------------- block output | | | /** One compact line: id, context, listing date/age, weights, modality, notes. */ |

|  | function freeLine(r) { | 
|  | const w = r.hf ? "open" : "closed"; | 
|  | let extra = ""; | 
|  | if (r.aaIntel) extra += ` · intel ${r.aaIntel}`; | 
|  | if (r.expDays !== null) { | 
|  | if (r.expDays < 0) extra += ` · ${RED}expired ${r.exp}${RST}`; | 
|  | else if (r.expDays <= 60) extra += ` · ${YEL}expires ${r.exp}${RST}`; | 

| | } | | | console.log( |

|  | ` ${B}${r.id}${RST} ${hum(r.ctx)} ctx · ${r.listed} · ${r.age}d old · ${w} · ${r.modality}${extra}`, | 
|  | ); | 

| | } | | | /** Full detail block for one free model. */ |

|  | function freeBlock(r) { | 
|  | const sig = []; | 
|  | if (r.hf === "") { | 

| | sig.push( | | | /open[- ]weight/i.test(r.desc) | | | ? "weights not linked (description claims open-weight)" | | | : "no weights linked", |

|  | ); | 
|  | } else { | 
|  | sig.push(`open weights: ${r.hf}`); | 

| | } |

|  | if (r.params) sig.push(r.params); | 
|  | if (r.ctx >= 1_000_000) sig.push("million-token ctx"); | 
|  | if (/image\|video\|audio/.test(r.modality)) sig.push("multimodal"); | 
|  | if (r.mod) sig.push("input moderated"); | 
|  | console.log(` ${B}${r.id}${RST}`); | 

| | console.log( |

|  | ` ${r.name}${r.slugDate ? ` · slug date ${r.slugDate}` : ""}`, | 
|  | ); | 

| | console.log( |

|  | ` ${hum(r.ctx)} ctx · ${hum(r.maxout)} max out · ${r.modality}`, | 
|  | ); | 

| | console.log( | | | r.caps.length | | | ? ${joinDot(r.caps)} | | | : " no tools or reasoning reported", |

|  | ); | 
|  | console.log(` ${joinDot(sig)}`); | 
|  | const meas = []; | 
|  | if (r.aaIntel) meas.push(`intel ${r.aaIntel}`); | 
|  | if (r.aaCode) meas.push(`coding ${r.aaCode}`); | 
|  | if (r.aaAgent) meas.push(`agentic ${r.aaAgent}`); | 
|  | if (r.arena) | 
|  | meas.push(`arena ${r.arena.split("\|")[0]} (${r.arena.split("\|")[1]})`); | 

| | console.log( | | | meas.length |

|  | ? ` measured: ${joinDot(meas)}` | 
|  | : ` ${DIM}measured: none — no benchmark score carried${RST}`, | 
|  | ); | 
|  | if (r.exp === "") { | 
|  | console.log(` free window: ${r.freeKind}`); | 
|  | } else if (r.expDays !== null && r.expDays < 0) { | 

| | console.log( |

|  | ` free window: ${r.freeKind} · ${RED}expired ${r.exp}${RST}`, | 
|  | ); | 
|  | } else if (r.expDays !== null && r.expDays <= 60) { | 

| | console.log( |

|  | ` free window: ${r.freeKind} · ${YEL}expires ${r.exp} (${r.expDays}d)${RST}`, | 
|  | ); | 
|  | } else { | 
|  | console.log(` free window: ${r.freeKind} · expires ${r.exp}`); | 

| | } | | | if (r.pricetag) | | | console.log( |

|  | ` ${YEL}note: description quotes ${r.pricetag} — the catalog lists no token price${RST}`, | 
|  | ); | 
|  | if (r.prl) console.log(` per-request limits: ${r.prl}`); | 
|  | if (r.desc) console.log(` ${DIM}${snippet(r.desc, 220)}${RST}`); | 

| | console.log( |

|  | ` listed ${r.listed} (${r.age}d ago) · https://openrouter.ai/${r.id}`, | 
|  | ); | 

| | } | | | /** Detail block for a stealth codename (name/ctx scraped, no pricing). */ |

|  | function stealthBlock(id, all) { | 
|  | const j = all[id] \|\| { name: "", ctx: "", desc: "" }; | 
|  | console.log(` ${B}${id}${RST}`); | 

| | console.log( |

|  | ` ${j.name \|\| "anonymous"}${j.ctx ? ` · ${hum(j.ctx)} ctx` : ""}`, | 
|  | ); | 
|  | if (j.desc) console.log(` ${DIM}${snippet(j.desc, 240)}${RST}`); | 

| | console.log( |

|  | ` ${DIM}anonymous provider · data may be retained · https://openrouter.ai/${id}${RST}`, | 
|  | ); | 

| | } |

|  | // -------------------------------------------------------------------- diff | 
|  | function diffFree(cur, prev, all) { | 
|  | const cs = new Set(cur); | 
|  | const ps = new Set(prev); | 
|  | const stripped = (id) => | 
|  | all[id] != null \|\| all[id.replace(/:free$/, "")] != null; | 

| | return { |

|  | new: cur.filter((id) => !ps.has(id)), | 
|  | gone: prev.filter((id) => !cs.has(id) && !stripped(id)), | 
|  | unfree: prev.filter((id) => !cs.has(id) && stripped(id)), | 
|  | }; | 

| | } |

|  | const diffSet = (cur, prev) => { | 
|  | const cs = new Set(cur); | 
|  | const ps = new Set(prev); | 

| | return { |

|  | new: cur.filter((id) => !ps.has(id)), | 
|  | gone: prev.filter((id) => !cs.has(id)), | 
|  | }; | 
|  | }; | 
|  | // -------------------------------------------------------------------- main | 

| | /** Parse a stealth index page: unique codenames off https://openrouter.ai/stealth. */ |

|  | function stealthIds(md) { | 
|  | return [...new Set(md.match(/stealth\/[A-Za-z0-9._-]+/g) \|\| [])].sort(); | 

| | } | | | /** Pull one meta content value out of a page's HTML. */ |

|  | function meta(html, prop) { | 
|  | const m = html.match(new RegExp(`${prop}"\\s+content="([^"]*)"`)); | 
|  | return m ? m[1].replace(/&/g, "&") : ""; | 

| | } |

|  | async function main() { | 
|  | const args = process.argv.slice(2); | 

| | let ALL = false, | | | JSONOUT = false, | | | QUIET = false, | | | OFFLINE = false, | | | RESET = false, | | | RANK = false, |

|  | CHANGES = false; | 
|  | for (const a of args) { | 
|  | switch (a) { | 
|  | case "-a": | 
|  | case "--all": | 
|  | ALL = true; | 

| | break; |

|  | case "--rank": | 
|  | RANK = true; | 

| | break; |

|  | case "--changes": | 
|  | CHANGES = true; | 

| | break; |

|  | case "--json": | 
|  | JSONOUT = true; | 

| | break; |

|  | case "-q": | 
|  | case "--quiet": | 
|  | case "--check": | 
|  | QUIET = true; | 

| | break; |

|  | case "--offline": | 
|  | OFFLINE = true; | 

| | break; |

|  | case "--reset": | 
|  | RESET = true; | 

| | break; |

|  | case "--no-color": | 
|  | process.env.NO_COLOR = "1"; | 

| | break; |

|  | case "-h": | 
|  | case "--help": | 
|  | process.stdout.write(USAGE); | 
|  | process.exit(0); | 

| | default: |

|  | process.stderr.write(`${PROG}: unknown option ${a} (try --help)\n`); | 
|  | process.exit(2); | 

| | } | | | } | | | // Bare newllm prints the rank; the change report moved to --changes. |

|  | if (!JSONOUT && !QUIET && !RANK && !ALL && !CHANGES) RANK = true; | 
|  | // ---------------------------------------------------------- fetch catalog | 

| | try { |

|  | mkdirSync(STATE_DIR, { recursive: true }); | 
|  | } catch { | 
|  | process.exit(1); | 

| | } |

|  | if (RESET) await promises.rm(STATE_FILE).catch(() => {}); | 
|  | if (OFFLINE) { | 
|  | if (!existsSync(CACHE_FILE)) { | 

| | process.stderr.write( |

|  | `${PROG}: no cached catalog, run once without --offline\n`, | 
|  | ); | 
|  | process.exit(1); | 

| | } |

|  | } else { | 
|  | const body = await get(CATALOG_URL, "application/json", true); | 
|  | if (body) await promises.writeFile(CACHE_FILE, body); | 
|  | else if (!existsSync(CACHE_FILE)) { | 

| | process.stderr.write( | | | ${PROG}: catalog fetch failed and no cache exists\n, |

|  | ); | 
|  | process.exit(1); | 
|  | } else { | 

| | process.stderr.write( | | | ${PROG}: catalog fetch failed, using cached copy\n, | | | ); | | | } | | | } | | | const catalog = await readJsonFile(CACHE_FILE); | | | if (!catalog || !catalog.data || !catalog.data.length) { |

|  | process.stderr.write(`${PROG}: cached catalog is not usable\n`); | 
|  | process.exit(1); | 

| | } | | | const models = catalog.data; | | | const freeModels = models |

|  | .filter(isFree) | 
|  | .sort((a, b) => (b.created \|\| 0) - (a.created \|\| 0)); | 
|  | const rows = new Map(freeModels.map((m) => [m.id, toRow(m)])); | 
|  | const curFreeIds = [...rows.keys()]; | 
|  | const curFree = {}; | 
|  | for (const m of freeModels) | 
|  | curFree[m.id] = { | 
|  | prompt: (m.pricing && m.pricing.prompt) \|\| "", | 

| | name: m.name || m.id, |

|  | }; | 
|  | const allMap = {}; | 
|  | for (const m of models) { | 
|  | allMap[m.id] = { | 
|  | prompt: (m.pricing && m.pricing.prompt) \|\| "", | 

| | completion: (m.pricing && m.pricing.completion) || "", | | | name: m.name || m.id, | | | }; | | | } | | | // ---------------------------------------------------------- stealth set | | | // State from the previous run: needed both for the diff and so that an | | | // --offline run can carry the known stealth set forward instead of wiping it. |

|  | const state = (await readJsonFile(STATE_FILE)) \|\| {}; | 
|  | const prevFree = state.free \|\| {}; | 
|  | const prevStealth = state.stealth \|\| {}; | 
|  | const baseline = !existsSync(STATE_FILE); | 
|  | let curStealth = {}; | 
|  | if (OFFLINE) { | 

| | // No network: reuse the cached stealth set so nothing is falsely reported | | | // as retired and state.json keeps a correct stealth snapshot. |

|  | curStealth = { ...prevStealth }; | 
|  | } else { | 
|  | const md = await get(STEALTH_URL, "text/markdown"); | 
|  | if (md) { | 
|  | for (const sid of stealthIds(md)) { | 

| | const html = |

|  | (await get(`https://openrouter.ai/${sid}`, "text/html")) \|\| ""; | 
|  | const name = meta(html, "og:title").replace(/ - API Pricing.*/, ""); | 
|  | const desc = meta(html, "og:description"); | 
|  | const ctx = (desc.match(/[0-9][0-9,]* token context window/) \|\| [ | 

| | "", |

|  | ])[0].replace(/[^0-9]/g, ""); | 
|  | curStealth[sid] = { name, ctx, desc }; | 

| | } | | | } | | | } |

|  | // -------------------------------------------------------------- diffing | 
|  | const d = diffFree(curFreeIds, Object.keys(prevFree), allMap); | 
|  | const sd = diffSet(Object.keys(curStealth), Object.keys(prevStealth)); | 
|  | let count = 0; | 
|  | const note = () => count++; | 
|  | // ---------------------------------------------------------- pricing snapshot | 
|  | if (!JSONOUT && !QUIET) reportPricing(models); | 
|  | // ------------------------------------------------------------- rendering | 
|  | if (JSONOUT) { | 

| | process.stdout.write( | | | `${JSON.stringify( | | | { | | | updated: isoUTC(), | | | baseline, | | | counts: { | | | free: curFreeIds.length, | | | stealth: Object.keys(curStealth).length, | | | new_free: d.new.length, | | | gone_free: d.gone.length, | | | unfree: d.unfree.length, | | | new_stealth: sd.new.length, | | | gone_stealth: sd.gone.length, | | | }, | | | new_free: d.new, | | | gone_free: d.gone, | | | unfree: d.unfree, | | | new_stealth: sd.new, | | | gone_stealth: sd.gone, | | | }, | | | null, | | | 2, |

|  | )}\n`, | 
|  | ); | 
|  | } else if (QUIET) { | 
|  | if (baseline) { | 

| | console.log( |

|  | `BASELINE\t${curFreeIds.length} free\t${Object.keys(curStealth).length} stealth`, | 
|  | ); | 
|  | } else { | 
|  | for (const m of d.new) { | 
|  | console.log(`NEW\t${m}`); | 
|  | note(); | 

| | } |

|  | for (const m of d.unfree) { | 
|  | console.log(`UNFREE\t${m}`); | 
|  | note(); | 

| | } |

|  | for (const m of d.gone) { | 
|  | console.log(`GONE\t${m}`); | 
|  | note(); | 

| | } |

|  | for (const m of sd.new) { | 
|  | console.log(`NEW-STEALTH\t${m}`); | 
|  | note(); | 

| | } |

|  | for (const m of sd.gone) { | 
|  | console.log(`GONE-STEALTH\t${m}`); | 
|  | note(); | 

| | } | | | } |

|  | } else if (RANK) { | 
|  | await renderRank(rows, curFreeIds, OFFLINE); | 
|  | } else if (ALL) { | 

| | console.log( |

|  | `${B}FREE MODELS (${curFreeIds.length})${RST} · as of ${localDateTime()}\n`, | 
|  | ); | 
|  | for (const id of [...curFreeIds].sort()) freeBlock(rows.get(id)); | 

| | console.log( |

|  | `\n${B}STEALTH CODENAMES (${Object.keys(curStealth).length})${RST}\n`, | 
|  | ); | 
|  | for (const id of Object.keys(curStealth).sort()) | 
|  | stealthBlock(id, curStealth); | 
|  | } else if (baseline) { | 

| | console.log( |

|  | `${B}baseline${RST} — no prior state; recording what is free and live now (${TODAY}).`, | 
|  | ); | 
|  | console.log(`\n${B}FREE MODELS (${curFreeIds.length})${RST}`); | 
|  | for (const id of [...curFreeIds].sort()) freeLine(rows.get(id)); | 

| | console.log( |

|  | `\n${B}STEALTH CODENAMES (${Object.keys(curStealth).length})${RST}`, | 
|  | ); | 
|  | for (const id of Object.keys(curStealth).sort()) | 
|  | stealthBlock(id, curStealth); | 

| | console.log( |

|  | `\n${DIM}next run reports only what changed. --all shows everything, --json for machines.${RST}`, | 
|  | ); | 
|  | } else { | 
|  | let hdr = false; | 
|  | if (d.new.length) { | 
|  | console.log(`${B}${GRN}new free model(s)${RST}`); | 
|  | hdr = true; | 
|  | for (const m of d.new) { | 
|  | note(); | 
|  | console.log(); | 
|  | freeBlock(rows.get(m)); | 

| | } | | | } |

|  | if (sd.new.length) { | 
|  | if (hdr) console.log(); | 
|  | console.log(`${B}${CYA}new stealth codename(s)${RST}`); | 
|  | hdr = true; | 
|  | for (const m of sd.new) { | 
|  | note(); | 
|  | console.log(); | 
|  | stealthBlock(m, curStealth); | 

| | } | | | } |

|  | if (d.unfree.length) { | 
|  | if (hdr) console.log(); | 
|  | console.log(`${B}${YEL}no longer free${RST}`); | 
|  | hdr = true; | 
|  | for (const m of d.unfree) { | 
|  | note(); | 

| | const e = allMap || | | | allMap[m.replace(/:free$/, "")] || { prompt: "", completion: "" }; | | | console.log( |

|  | ` ${B}${m}${RST} $${perm(e.prompt)}/M in · $${perm(e.completion)}/M out (free preview over)`, | 
|  | ); | 

| | } | | | } |

|  | if (d.gone.length) { | 
|  | if (hdr) console.log(); | 
|  | console.log(`${B}${RED}delisted${RST}`); | 
|  | hdr = true; | 
|  | for (const m of d.gone) { | 
|  | note(); | 
|  | const was = (prevFree && prevFree[m].name) \|\| ""; | 
|  | console.log(` ${m}${was ? ` (${was})` : ""}`); | 

| | } | | | } |

|  | if (sd.gone.length) { | 
|  | if (hdr) console.log(); | 
|  | console.log(`${B}${RED}stealth codename(s) retired${RST}`); | 
|  | hdr = true; | 
|  | for (const m of sd.gone) { | 
|  | note(); | 
|  | console.log(` ${m}`); | 

| | } | | | } | | | if (!hdr) { | | | console.log( |

|  | `${DIM}nothing changed · ${curFreeIds.length} free · ${Object.keys(curStealth).length} stealth · checked ${localDateTime()}${RST}`, | 
|  | ); | 

| | } | | | } |

|  | // ---------------------------------------------------------- write state | 
|  | const merge = (cur, prev) => { | 
|  | const out = {}; | 
|  | for (const [k, v] of Object.entries(cur)) { | 
|  | out[k] = { | 

| | ...v, |

|  | first_seen: (prev && prev && prev[k].first_seen) \|\| TODAY, | 
|  | }; | 

| | } | | | return out; |

|  | }; | 
|  | const next = { | 
|  | updated: isoUTC(), | 
|  | free: merge(curFree, prevFree), | 
|  | stealth: merge(curStealth, prevStealth), | 
|  | }; | 

| | await promises |

|  | .writeFile(STATE_FILE, `${JSON.stringify(next, null, 2)}\n`) | 
|  | .catch(() => {}); | 

| | // Let the process end naturally: process.exit() can discard buffered stdout. | | | if (QUIET && count === 0) process.exitCode = 1; | | | } | | | // ------------------------------------------------------------------- --rank | | | /** Ranked + unscored free-model report. */ | | | async function renderRank(rows, ids, offline) { | | | // Provider training policy, keyed by normalized org name. |

|  | if (!offline) { | 
|  | const body = await get(PROVIDERS_URL, "application/json"); | 
|  | if (body) await promises.writeFile(PROV_FILE, body); | 

| | } |

|  | const prov = await readJsonFile(PROV_FILE); | 
|  | const provMap = new Map(); | 
|  | for (const p of (prov && prov.data) \|\| []) { | 

| | const flag = p && p.dataPolicy && p.dataPolicy.training ? "yes" : "no"; |

|  | for (const x of [p && p.name, p && p.displayName]) { | 
|  | if (!x) continue; | 
|  | const key = String(x) | 
|  | .toLowerCase() | 
|  | .replace(/[^a-z0-9]/g, ""); | 
|  | if (key && !provMap.has(key)) provMap.set(key, flag); // first match wins | 

| | } | | | } |

|  | const trainsFor = (id) => { | 
|  | const org = id.split("/")[0]; | 
|  | if (org === "openrouter") return "router"; | 
|  | const key = org.toLowerCase().replace(/[^a-z0-9]/g, ""); | 
|  | return provMap.get(key) \|\| "unknown"; | 
|  | }; | 
|  | const all = ids.map((id) => rows.get(id)); | 

| | const scored = all |

|  | .filter((r) => r && r.aaIntel !== "") | 
|  | .sort((a, b) => Number(b.aaIntel) - Number(a.aaIntel)); | 
|  | const maxOf = (pick) => | 

| | all |

|  | .map(pick) | 
|  | .filter((v) => v !== "") | 
|  | .reduce((m, v) => Math.max(m, Number(v)), 0); | 
|  | const MI = maxOf((r) => r && r.aaIntel); | 
|  | const MC = maxOf((r) => r && r.aaCode); | 
|  | const MA = maxOf((r) => r && r.aaAgent); | 
|  | if (scored.length === 0) { | 

| | console.log( |

|  | `${DIM}no free model carries a benchmark score right now${RST}`, | 
|  | ); | 

| | return; | | | } | | | console.log( |

|  | `${B}free models on OpenRouter, ranked by intelligence — ${localDateTime()}${RST}`, | 
|  | ); | 

| | console.log( |

|  | `${DIM}bars are relative to the best score in each column: intelligence ${MI \|\| "none"} · coding ${MC \|\| "none"} · agentic ${MA \|\| "none"}${RST}\n`, | 
|  | ); | 

| | console.log( |

|  | ` ${padEndS("#", 3)} ${padEndS("model", 50)} ${padEndS("intelligence", 16)} ${padEndS("coding", 16)} ${padEndS("agentic", 16)}`, | 
|  | ); | 
|  | let i = 0; | 
|  | for (const r of scored) { | 

| | i++; | | | console.log( | | | ${padEndS(String(i), 3)} ${padEndS(r.id, 50)} ${bar(r.aaIntel, scale10(String(MI)))} ${bar(r.aaCode, scale10(String(MC)))} ${bar(r.aaAgent, scale10(String(MA)))} ${padStartS(hum(r.ctx), 6)} ctx, | | | ); | | | } | | | console.log( | | | \n${DIM}the intelligence leader is not the coding leader — read the row, not the rank.${RST}, | | | ); | | | console.log( |

|  | `${DIM}unscored: no benchmark carried, so nothing to rank them by${RST}`, | 
|  | ); | 
|  | for (const r of all.filter((x) => x && x.aaIntel === "")) { | 
|  | const xnote = []; | 
|  | if (r.arena) | 
|  | xnote.push(`arena ${r.arena.split("\|")[0]} (${r.arena.split("\|")[1]})`); | 
|  | if (r.exp) xnote.push(`expires ${r.exp}`); | 
|  | if (r.pricetag) xnote.push("charges per artifact"); | 

| | console.log( |

|  | ` ${padEndS(r.id, 52)} ${padStartS(hum(r.ctx), 6)} ctx · ${modalityTag(r.modality)} ${xnote.join(" · ")}`, | 
|  | ); | 

| | } | | | } |

|  | main().catch((err) => { | 
|  | console.error(err); | 
|  | process.exit(1); | 
|  | }); |
── more in #ai-tools 4 stories · sorted by recency
── more on @openrouter 3 stories trending now
sponsored brought to you by zahid.host 4,200+ EU-deployed projects
reading about agents? ship yours in a single git push.

Run your AI side-project on zahid.host

EU-based hosting, git-push deploys, automatic HTTPS, no cold starts. Free tier with a custom domain — perfect for shipping the agent you just read about.

$git push zahid main
→ Live at https://your-agent.zahid.host ✓
Get free account → Pricing
from €0/mo · no card required
LIVE [news/newllm-what-is-new-c…] indexed:0 read:36min 2026-10-25 · —