TobyOnFitnessTech
←All Episodes
Kimi K3, Meta Muse Spark, and the Million-Token Era — Episode 88 cover art
Episode 88·July 18, 2026·34:06

Kimi K3, Meta Muse Spark, and the Million-Token Era

Today's AgentStack Daily covers OpenAI Codex rust-v0.144.5 and Claude Code CLI 2.1.205, plus Kimi K3 and Meta's Muse Spark 1.1 — both arriving on OpenRouter with million-token context windows. We look at a code-search tool claiming 98 percent token savings, clidey's whodb 0.121.0, Transformers 5.14.1 with two Inkling fixes, and a 2-bit 27B chat model trending online. NVIDIA Nemotron 3 Embed tops RTEB, FastMCP passes 26K stars, and OpenAI argues for a 'reverse federalism' AI safety approach. Show notes: https://tobyonfitnesstech.com/podcasts/episode-88/

🎧 Listen to Episode

Listen & Subscribe

SpotifyAppleiHeartYouTube MusicAmazonRSS

AgentStack Daily EP088 — Kimi K3, Meta Muse Spark, and the Million-Token Era

Title: Kimi K3, Meta Muse Spark, and the Million-Token Era

Tagline: OpenAI ships Codex rust-v0.144.5 and Anthropic pushes Claude Code CLI to 2.1.205. On the model side, Kimi K3 lands on OpenRouter with a million-token context window, while Meta's Muse Spark 1.1 also debuts on OpenRouter with a 1M-token context. A code search tool claims it cuts agent token usage by 98 percent, and clidey's whodb 0.121.0 ships with a data-access-meets-ops pitch. Transformers 5.14.1 lands two Inkling integration fixes, a 2-bit 27B chat model trends upward, and NVIDIA Nemotron 3 Embed takes the top overall spot on RTEB. A codebase MCP server turns repos into instant queries, and FastMCP crosses 26K GitHub stars.

Feed description: Today's AgentStack Daily covers OpenAI Codex rust-v0.144.5 and Claude Code CLI 2.1.205, plus Kimi K3 and Meta's Muse Spark 1.1 — both arriving on OpenRouter with million-token context windows. We look at a code-search tool claiming 98 percent token savings, clidey's whodb 0.121.0, Transformers 5.14.1 with two Inkling fixes, and a 2-bit 27B chat model trending online. NVIDIA Nemotron 3 Embed tops RTEB, FastMCP passes 26K stars, and OpenAI argues for a 'reverse federalism' AI safety approach.

Story Slate

  1. Agent Stack Release Readout: OpenAI Codex rust-v0.144.5; Claude Code CLI 2.1.205 OpenAI Codex CLI rust-v0.144.5 shipped July 16 with broader dangerous-command detection, catching more forced rm variants and giving clearer reasons when a command is refused. Claude Code CLI also moved forward, advancing to 2.1.205 on July 8 as a new stable release with no published changelog body. Together the two updates reinforce the quiet safety and versioning layer that production coding-agent workflows depend on. Technical depth angle: Codex expanded its pre-execution blocklist so additional forced rm shapes are recognized as destructive, and the rejection text now identifies the specific rule so users can grant an override or rewrite the prompt. Claude Code's 2.1.205 carries no published change notes, so the operational signal is the new stable version itself, useful for CI pinning and compliance tracking. Actionability angle: For teams running Codex in CI or locally, the improved rejection messages make it easier to triage a denied command without digging through source, which means fewer mystery failures during agent runs. For Claude Code users on pinned versions, the 2.1.205 bump gives a new build to point automation at, and downstream watchers can pick it up without manual chase. Listener hook: The coding agent that types into your terminal just got a slightly better grip on the rm -rf self-destruct button, and the other major CLI shipped a quiet version bump worth knowing about.

  2. Kimi K3 Lands on OpenRouter With a Million-Token Context Window Kimi K3 from Moonshot AI is now listed on OpenRouter as an open-weight multimodal reasoning model with a one-million-token context window. The listing highlights three target workloads: complex coding, knowledge work, and long-horizon agentic workflows. For builders, the practical change is being able to pass an entire large codebase, a long document bundle, or a multi-step agent task into a single call without writing chunking glue. The interesting question going in is how the model actually behaves near that context ceiling on long-running agent jobs. Technical depth angle: Kimi K3 pairs an open-weight multimodal design with a one-million-token context window and reasoning capability. The useful mechanism for builders is the combination: long context gives the model room to hold a full repository or document bundle in working memory, while reasoning capability supports sustained planning across many tool calls without losing coherence. Actionability angle: This means builders can run whole-codebase or whole-document tasks through a single API call instead of building chunk-and-stitch pipelines. It matters for anyone building long-running agents, because K3's context and reasoning posture is built for jobs that stretch across many steps. Watch real latency and cost behavior at full context before committing it to production workflows. Listener hook: Kimi K3 just arrived on OpenRouter with a one-million-token context window, and that kind of capacity changes what you can hand an AI in a single prompt.

  3. Meta's Muse Spark 1.1 lands on OpenRouter with a 1M-token context window Meta has listed Muse Spark 1.1 on OpenRouter as a multimodal reasoning model designed for agentic tasks. It accepts text, images, video, audio, and PDF input and returns text output, with a context length of just over one million tokens — roughly seven hundred fifty thousand words. That lets agents keep an entire codebase, research packet, or multi-document contract review in working memory at once. Independent benchmarks, latency numbers, and pricing have not yet been published. Technical depth angle: A multimodal reasoning model from Meta with a 1,048,576-token context window, accepting text, images, video, audio, and PDF input and returning text, optimized for agentic tasks. The defining mechanism is the combination of long context and multimodal ingestion: agents can hold novel-length material and reason across mixed document types in a single conversation. Actionability angle: For builders running agent pipelines that lose track of long documents, a 1M-token context window removes the need for aggressive chunking and re-feeding. Multimodal input — PDF, image, audio, video, plus text in one prompt — opens workflows where a single agent reads a contract, a chart, and a transcript together. Independent benchmarks and pricing are not yet public, so production decisions should wait for community results. Listener hook: Meta just put a million-token, multimodal reasoning model on OpenRouter, and it could finally unblock long-document agent pipelines.

  4. Code search that cuts agent tokens by 98% MinishLab released v0.5.1 of semble, a code search library built specifically for AI agents. The project's headline number is roughly 98% fewer tokens than the typical grep-then-read workflow. The repository has accumulated 5,634 GitHub stars and saw updates through mid-July, suggesting active iteration by the agent-building community. Technical depth angle: The mechanism: instead of grepping for keywords and then reading every matching file into the agent's context window, semble is built to return targeted, relevant code snippets directly. The 98% token reduction comes from skipping the wholesale file reads that the traditional workflow forces on the model. Actionability angle: What this means for builders is that swapping a naive search step for a purpose-built one can free up meaningful portions of an agent's context window, leaving more room for actual reasoning. It also tends to shorten run times, because the model does less reading per task. The interesting question now is which coding harnesses adopt it by default. Listener hook: If you have ever watched a coding agent burn its context window reading a whole file just to find a single function, this is the tool that wants to fix that.

  5. clidey's whodb ships 0.121.0 with a data-access-meets-ops pitch The open-source database tool whodb, hosted under the clidey organization on GitHub, shipped release 0.121.0 on July 16, with the project self-describing as 'where data access meets operational intelligence.' The repository has accumulated roughly 4,930 stars and saw fresh commit activity the day after the release, suggesting an actively iterated project rather than a frozen one. For developers, it represents another community-funded option in the data tooling space. Technical depth angle: whodb frames itself as collapsing the gap between querying a database and operating on it — connecting, pulling data, and surfacing operational signals from a single surface rather than a stack of separate tools. Actionability angle: For builders tired of juggling a separate query client and an ops dashboard, whodb is worth evaluating as an open-source alternative. The repository is public, so spinning it up against a non-production dataset is low risk. Why this matters: another community-funded database tool is shipping in this space, keeping pressure on commercial offerings. Listener hook: An open-source database tool just pushed a fresh release and is approaching five thousand GitHub stars — here's why that combination is worth a look.

  6. Transformers 5.14.1 Ships Two Inkling Integration Fixes huggingface/transformers released version 5.14.1, a patch focused on two integration bugs that surfaced when teams wired up a model called Inkling. The first fix addresses an issue with EncoderDecoderCache during assisted generation. The second resolves a prefill problem with StaticCache and sdpa attention on unpadded inputs that rely on position_bias. Self-hosted inference for Inkling and similar encoder-decoder models should now run cleanly through these caching paths. Technical depth angle: Two integration bugs were closed. Assisted generation lets a small draft model propose tokens that a larger model verifies in batches, cutting latency; the bug blocked the encoder-decoder cache path during that step. The second bug broke prefill when StaticCache preallocates memory and sdpa attention runs on unpadded inputs that depend on position_bias to indicate where each token sits in the sequence. Actionability angle: If you self-host Inkling or any encoder-decoder model that uses assisted generation or StaticCache with sdpa, upgrading to 5.14.1 removes two crash paths. For teams running inference at scale, this is a clean patch to roll in without API changes. Watch whether the same bug shape shows up for other position_bias models in the next minor release. Listener hook: A quiet patch release that fixes the kind of bugs only surface when real models hit real inference caches.

  7. A 2-Bit 27B Chat Model Is Trending A new open-weight conversational model called Ternary-Bonsai-27B is climbing Hugging Face's trending list. Published by prism-ml on July 4, 2026, the repo packages a 27B-class chat model in GGUF format with weights compressed to roughly 2 bits each — an unusually aggressive quantization that the local-AI community is testing across llama.cpp, CUDA, and Apple Metal backends. With over 200,000 downloads and 637 likes already, it's one of the week's loudest signals that mid-size open models are getting small enough to run on laptops and single-GPU boxes. Technical depth angle: The 27B-class chat model is shipped as a GGUF file for llama.cpp, with weights quantized to roughly 2 bits each — the 'ternary' in the name. That compression level usually only works when training itself is low-bit aware, so quality is the open question. CUDA and Metal tags confirm the package targets NVIDIA GPUs and Apple Silicon out of the box. Actionability angle: This puts a mid-size conversational model within reach of local-inference workflows, since the GGUF/2-bit packaging targets llama.cpp on CPU, CUDA on NVIDIA GPUs, and Metal on Apple hardware. Whether the quality truly survives the 2-bit squeeze will come down to per-backend testing once people start publishing evals. Listener hook: If you've been waiting for a mid-size open chat model that runs locally, this week's trending list just gave you a serious candidate to try.

  8. NVIDIA Nemotron 3 Embed Takes Top Overall Spot on RTEB NVIDIA's Nemotron 3 Embed took the top overall spot on RTEB, a widely-watched retrieval embedding benchmark, according to a Hugging Face blog post on July 16. The headline frames the result as a step forward for agentic retrieval — the kind of look-up-heavy workload that AI agents lean on when they need to fetch the right passage before answering or acting. The model is available through Hugging Face, putting a fresh top-ranked embedding option in front of any team building or refreshing a retrieval pipeline. Technical depth angle: The model is an embedding — a function that turns text into numeric vectors so a search system can rank passages by similarity. The overall-rank win on RTEB aggregates many retrieval task types into one score, which is why a single number at the top tends to drive default-model choices across agent stacks. Actionability angle: For builders wiring retrieval into agents, the headline points to a fresh retrieval candidate that slots into the existing shortlist of options to consider. It also signals that retrieval quality is moving fast enough that any production agent stack built last year is probably overdue for an embedding re-check. Listener hook: NVIDIA's new embedding model just sat down at the top of a retrieval leaderboard that most production agent stacks watch closely.

  9. OpenAI pushes 'reverse federalism' for AI safety rules On July 15, OpenAI published a policy argument for 'reverse federalism' in AI governance, where state-level laws do the early work of testing safety approaches and feed lessons into a national framework. The framing flips traditional federalism: instead of the federal government setting the floor and states adding rules on top, OpenAI wants states to set early examples and the federal government to learn from them. This is a position paper, not new legislation, and it lands while AI rules are being debated in statehouses across the country with no unified federal rulebook in place. Technical depth angle: The core concept is reverse federalism — flipping the usual top-down model so that state legislatures experiment with AI safety rules first, and the federal government adopts the working approaches as a national framework. OpenAI's argument is that parallel state experimentation produces better evidence than trying to draft one perfect federal law upfront. Actionability angle: Today's piece is a position paper, not a regulation, so there are no immediate compliance changes for builders. What this means in practice is that the state-by-state AI rulemaking currently in motion will shape whatever federal framework eventually emerges. Why this matters: the patchwork is being framed as the strategy, not a bug to be fixed later. Listener hook: A major AI lab just told Washington to let the states lead on AI safety — here's why that framing matters.

  10. Research digest: Search agents that stop getting stuck in loops When AI research agents chase a hard question across the web, they often burn through searches hitting the same dead ends, looping without real progress. A new framework called SearchOS turns fragile, implicit search progress into persistent, shared state across multiple cooperating agents. The system tracks which entities it has discovered, what evidence is anchored to sources, which gaps remain, and which search strategies have already failed. By overlapping multiple agents and refilling freed slots with fresh tasks targeting uncovered ground, it keeps search budgets productive. Result: fewer wasted queries and more complete answers when a question spans many linked facts. Technical depth angle: The core move is reframing web research as filling linked tables: agents discover entities, populate attributes, and anchor every value to a source citation. State is externalized into a frontier task, evidence graph, coverage map, and failure memory so the system can see what it has already tried, which gaps remain, and when a query strategy has stopped yielding new evidence. Actionability angle: For builders wiring up autonomous research agents, the takeaway is that explicit, shared state about what has been tried and what is still missing can replace the brittle default of hoping the model remembers its own progress. The practical payoff for anyone relying on long-running research assistants is fewer burned budgets on dead-end searches and more answers that actually cover the question. Worth watching: whether the framework ships open-source and how it benchmarks against existing deep-research products. Listener hook: If you've ever watched an AI research assistant burn twenty searches going in circles, this is the fix.

  11. 2022 Telegram Data Centers Deep-Dive Resurges to 262 Hacker News Points A 2022 engineering write-up titled "Mysteries of Telegram Data Centers" on dev.moe is currently trending with a 262-point Hacker News score and an active Lobsters discussion under the AI tag. The piece is a long-form look at where Telegram's servers actually live and how the platform structures its infrastructure at scale. It is getting renewed attention four years after publication, which is unusual for any infrastructure retrospective. Technical depth angle: A long-form engineering walkthrough of Telegram's data center footprint originally written in 2022, resurfacing on Hacker News this week with 262 points and a parallel Lobsters conversation under the AI tag. Actionability angle: For builders running chat infrastructure at any scale, the original 2022 piece plus its 262-point comment thread is worth reading together, because the comments likely carry the current thinking on what still applies and what has shifted. Older infrastructure retrospectives from large platforms tend to age slowly, so this kind of post still beats fresher surface-level coverage. Listener hook: A four-year-old behind-the-scenes look at Telegram's servers is suddenly the most-discussed infrastructure post on Hacker News this week.

  12. Research digest: AI coding assistants still can't read your bug screenshots A new benchmark called MM-IssueLoc tested whether AI coding assistants can use visual evidence like screenshots and error dialogs alongside text descriptions when locating bugs in real codebases. Across 652 issue-and-fix pairs spanning 23 programming languages, even the best agent only identified the correct file within its top five guesses 39 percent of the time. The benchmark shows that high scores on text-only coding tests do not transfer cleanly when screenshots are added, suggesting most current tools are effectively text-only systems with image pre-processing bolted on. For builders, it sets a clearer bar for what "multimodal coding assistant" should actually mean in practice. Technical depth angle: The benchmark isolates visual evidence as its own evaluation variable, pairing every issue with both a text-only version and a with-image version so researchers can measure how much the screenshots actually help. Results show that current multimodal systems effectively mishandle the images, with localization accuracy staying low when visual context is added rather than providing the lift a human developer would expect. Actionability angle: What this means is that any team calling their coding tool "vision-aware" should check whether it can locate the broken file from a screenshot alone, not just describe what's in the image. Why it matters: high scores on text-only coding benchmarks are not a reliable proxy for multimodal performance. The signal worth watching is whether models trained on paired visual-and-code data start moving these numbers. Listener hook: If your coding assistant can't tell which file is broken from a screenshot, the "multimodal" label is doing a lot of heavy lifting.

  13. A Codebase MCP Server That Turns Repos Into Instant Queries DeusData has shipped codebase-memory-mcp, a high-performance code intelligence server that indexes repositories into a persistent knowledge graph. The current release, v0.9.0, landed July 8, 2026, and the project carries 32,285 GitHub stars. It supports 158 languages, returns sub-millisecond queries, and ships as a single static binary with zero dependencies, with the project claiming 99% fewer tokens when an agent pulls context. Technical depth angle: It builds a persistent knowledge graph from a codebase and exposes it through the Model Context Protocol, so an assistant can query structure and meaning in under a millisecond rather than re-reading raw source files on every turn. Actionability angle: This means a coding agent can answer structural questions across a large monorepo without re-reading every file on each turn. Builders wiring MCP into their editor or agent loop get faster, cheaper context retrieval out of the box. Listener hook: What if your coding assistant could query a whole repository in under a millisecond?

  14. FastMCP Crosses 26K Stars as a Top Python Path to MCP Servers FastMCP, the open-source Python framework from PrefectHQ for building MCP servers and clients, has crossed 26,000 GitHub stars. The maintainers shipped version 3.4.4 on July 9 and pushed new code on July 16, showing active upkeep. MCP, the Model Context Protocol, is the standard for letting AI models discover and call external tools. FastMCP positions itself as the fast, Pythonic way to ship MCP servers and clients, reducing the protocol plumbing a Python developer has to write by hand. The star count signals where the Python side of the agent tooling ecosystem is consolidating. Technical depth angle: FastMCP is a Python framework that abstracts the Model Context Protocol — the standard AI models use to discover and call external tools — so a developer can write a normal Python function and let the library handle the protocol handshake, capability listing, and call format. The 'Pythonic' pitch is fewer protocol lines and more ordinary code. Actionability angle: If you're building agent tooling in Python, FastMCP is worth a look as the lowest-friction option in the ecosystem right now. What this means for builders: a single Python file can become a registered tool that any MCP-compatible client can call, which collapses what used to be a multi-day integration into an afternoon. Why it matters now: with version 3.4.4 shipping on July 9 and another push on July 16, the library is under active maintenance. Listener hook: Python developers building tools for AI agents now have a clear default — and 26,000 other developers have already voted for it.

Editorial Mix Check

  • flagship_products: 5
  • builder_projects: 6
  • local_ai: 2
  • hardware_compute: 2
  • policy_regulation: 1
  • research: 2

Model Discovery Check

  • MoonshotAI: Kimi K3 (moonshotai) — Newly listed this cycle (verified July 17, 2026). Primary source: https://openrouter.ai/models/moonshotai/kimi-k3. Availability: API via OpenRouter. params_active: n/a; params_total: n/a; context: 1048576 tokens; modality: see primary source. Capabilities: context length 1048576; Kimi K3 is an ultra-large-scale, open-weight multimodal reasoning model from Moonshot AI. It is suited for complex coding, knowledge work, and long-horizon agentic workflows, and is particularly strong at navigating.... Try now / integration angle: Route a coding-agent session through https://openrouter.ai/models/moonshotai/kimi-k3 and compare it with the current default. Decision: Selected — new major-provider model not featured on a recent broadcast.

  • Meta: Muse Spark 1.1 (meta) — Newly listed this cycle (verified July 17, 2026). Primary source: https://openrouter.ai/models/meta/muse-spark-1.1. Availability: API via OpenRouter. params_active: n/a; params_total: n/a; context: 1048576 tokens; modality: see primary source. Capabilities: context length 1048576; Muse Spark 1.1 is a multimodal reasoning model from Meta, built for agentic tasks. It accepts text, images, video, audio, and PDF documents and returns text, with a 1M-token context.... Try now / integration angle: Route a coding-agent session through https://openrouter.ai/models/meta/muse-spark-1.1 and compare it with the current default. Decision: Selected — new major-provider model not featured on a recent broadcast.

Local LLM Spotlight

  • prism-ml/Ternary-Bonsai-27B-gguf — https://huggingface.co/prism-ml/Ternary-Bonsai-27B-gguf — Ternary-Bonsai-27B is a 27-billion parameter open model distilled into 2-bit ternary weights and packaged as a GGUF that runs through llama.cpp with both CUDA and Metal acceleration. The combination of 2-bit weight packing and a hybrid-attention block design shrinks the resident memory footprint enough to load the model on consumer GPUs and well-equipped laptops while still targeting conversational tasks. It has already cleared 200,000 downloads on Hugging Face, marking it as one of the more exercised on-device 27B inference options currently available. Try now: Pull the GGUF with llama.cpp's hf-cli, launch llama-server with a quantized KV cache, and benchmark tokens-per-second on a 4K-token prompt to see if it fits your hardware budget.

GitHub Project Radar

  • microsoft/mcp-for-beginners — https://github.com/microsoft/mcp-for-beginners — Microsoft's open-source curriculum walks through Model Context Protocol fundamentals with real, cross-language samples in .NET, Java, TypeScript, JavaScript, Rust, and Python. stars: 16,772; stars_delta_30d: n/a — first tracked appearance; latest_release: none published on GitHub as of 2026-07-17. Why this is on the radar now: The repository was updated on 2026-07-16 and enters the radar with 16,772 stars. Stack improvement angle: Use the multi-language samples as scaffolding to expose tool surfaces from any backend service into a Codex or Hermes agent via MCP, without reimplementing client glue per language. Try now: Clone the repo, run the Python calculator MCP server sample, and point a local MCP client at it over stdio to confirm a tool-call round-trip.

  • CoplayDev/unity-mcp — https://github.com/CoplayDev/unity-mcp — A Model Context Protocol bridge between AI assistants and the Unity Editor that exposes tools for managing assets, controlling scenes, editing scripts, and triggering editor automation. stars: 12,580; stars_delta_30d: n/a — first tracked appearance; latest_release: v10.1.0 (2026-07-13). Why this is on the radar now: v10.1.0 shipped on 2026-07-13 and the repository was updated on 2026-07-13. Stack improvement angle: Wire Unity MCP into Codex or Hermes coding sessions so an agent can mutate scene state, swap assets, and rewrite C# scripts directly against the running editor rather than editing files blind. Try now: Install the Unity package, then ask an MCP-aware agent to enumerate scenes and instantiate a directional light in the active scene to verify the bridge.

  • mcp-use/mcp-use — https://github.com/mcp-use/mcp-use — mcp-use is a full-stack framework for shipping MCP servers aimed at AI agents and MCP Apps that run inside ChatGPT and Claude clients, sharing primitives across both targets. stars: 10,323; stars_delta_30d: n/a — first tracked appearance; latest_release: [email protected] (2026-07-08). Why this is on the radar now: [email protected] shipped on 2026-07-08 and the repository was updated on 2026-07-17. Stack improvement angle: Adopt mcp-use as the orchestration layer that composes multiple MCP servers and chat-surface adapters behind one agent entrypoint, removing bespoke per-client integration code. Try now: Scaffold a server from the framework starter, define one tool function, and load it inside the bundled browser playground to verify tool discovery.

Extra Research Candidates

  • firecrawl/firecrawl-mcp-server — 🔥 Official Firecrawl MCP Server - Adds powerful web scraping and search to Curso — https://github.com/firecrawl/firecrawl-mcp-server — 🔥 Official Firecrawl MCP Server - Adds powerful web scraping and search to Cursor, Claude and any other LLM clients. GitHub reports 6978 stars. Latest release: v3.2.1 2025-09-26T07:31:17Z. Repository pushed 2026-07-17T09:54:05Z. Technical depth angle: It exposes Firecrawl's scrape, crawl, and search primitives as MCP tools over stdio and SSE transports, with server-side markdown conversion so models receive structured, token-friendly payloads.

  • **getsentry/XcodeBuildMCP — A Model Context Protocol (MCP) server and CLI that provides tools for agent use ** — https://github.com/getsentry/XcodeBuildMCP — A Model Context Protocol (MCP) server and CLI that provides tools for agent use when working on iOS and macOS projects. GitHub reports 6081 stars. Latest release: v2.6.2 2026-06-02T20:38:36Z. Repository pushed 2026-07-16T19:12:17Z. Technical depth angle: It wraps xcodebuild and xcrun simctl as MCP resources and tools, letting an agent drive simulator boot, build, and test cycles through structured JSON-RPC invocations against the Xcode toolchain.

  • nanbingxyz/5ire — 5ire is a cross-platform desktop AI assistant, MCP client. It compatible with ma — https://github.com/nanbingxyz/5ire — 5ire is a cross-platform desktop AI assistant, MCP client. It compatible with major service providers, supports local knowledge base and tools via model context protocol servers . GitHub reports 5277 stars. Latest release: v0.15.4 2026-03-1 Technical depth angle: It implements an MCP client over stdio and Server-Sent Events with tools/list discovery and tools/call JSON-RPC, translating registered MCP server tools into the desktop assistant's native function-calling schema.

Show Notes

Episode 088 — July 17, 2026

[00:00] Episode hook

OpenAI Codex CLI rust-v0.144.5 shipped July 16 with broader dangerous-command detection, catching more forced `rm` variants and giving clearer reasons when a command is refused. Claude Code CLI 2.1.205 landed the same day with targeted fixes of its own. Moonshot AI's Kimi K3 arrived on OpenRouter as an open-weight multimodal reasoning model with a one-million-token context window, and Meta followed with Muse Spark 1.1 on the same router, accepting text, images, video, audio, and PDF input and targeting agentic workloads. clidey's whodb shipped 0.121.0 the same day, positioning the open-source database tool for teams that need operational intelligence alongside data access, and huggingface/transformers 5.14.1 patched two integration bugs that surfaced when teams wired up a model called Inkling. MinishLab's semble v0.5.1 also shipped, claiming roughly 98% fewer tokens than a typical grep-then-read workflow for code search.

[02:00] Agent Stack Release Readout: OpenAI Codex rust-v0.144.5; Claude Code CLI 2.1.205

The OpenAI Codex CLI shipped rust-v0.144.5 on July 16, and the change is small but it bites in the right place. The terminal agent that runs your shell commands on your behalf just got better at refusing to nuke your filesystem when an instruction goes sideways. The release tightens dangerous-command detection so that more flavors of forced `rm` commands get caught before they execute, and the rejection messages now spell out more clearly why the command was denied. If you have ever watched a coding agent confidently type `rm -rf` against a wrong path, this is the kind of guardrail that turns a near-disaster into a recoverable error message.

In practice, the assistant still has the same broad authority to run shell commands on your behalf, but the tripwires for the most destructive patterns got a fresh coat of paint. The reviewer can now point at a denial and tell you exactly which rule fired, which makes it easier to either refine the prompt or grant an explicit override when you genuinely do want that command to run. For a one-person builder shipping fast, this is the difference between losing an afternoon to a corrupted repo and spending two seconds on a retry.

Separately, Claude Code CLI advanced to 2.1.205 on July 8 as a new stable release. The vendor did not publish a changelog body for this version, so the meaningful fact is the version bump itself. Operationally, anyone tracking Claude Code for compliance or pinning a specific build in CI now has a fresh build to point at, and downstream tooling that watches for new stable releases can pick up the update without manual intervention.

Both of these releases sit firmly in the unglamorous-but-important category: vendors tightening the quiet infrastructure that makes a coding agent trustworthy enough to leave running in the background. For builders, the default safety posture of these harnesses is tightening even on patch releases, so it is worth re-running your red-team prompts against the latest Codex build and re-pinning Claude Code if your scripts care about which version they call. Watch for the next Codex point release and the next Claude Code changelog with substantive notes, because that is where the feature surface actually moves.

[03:34] Kimi K3 Lands on OpenRouter With a Million-Token Context Window

Kimi K3 just landed on OpenRouter as an open-weight model from Moonshot AI, and the headline number is the context window: one million tokens. That's the kind of window where you can hand a model an entire large codebase, a long meeting transcript, or a stack of PDFs and ask it to reason across all of them in a single turn instead of chopping things up and stitching them back together.

Moonshot is positioning K3 as a multimodal reasoning model, meaning it accepts more than text and is built for harder thinking tasks. The listing flags three target workloads worth paying attention to: complex coding, knowledge work, and what the company calls long-horizon agentic workflows. The last one is the most interesting in practice. A long-horizon agent is a system that has to plan, call a tool, read the result, decide what to do next, and keep going across many steps without losing the thread. Most models lose coherence as the task stretches out, so a one-million-token window combined with reasoning capability is the lever that gives the agent room to remember its own plan and the documents it has already touched.

For builders, the practical change is that a single API call can now carry roughly a mid-sized novel's worth of material into the model. That unlocks things like dropping a whole repo in and asking for a refactor plan, or uploading a 200-page contract bundle and asking for a clause-by-clause risk summary, without writing chunking glue yourself.

The thing to watch is real-world latency and cost at full context. A million-token window is impressive on paper, but the interesting question is how K3 actually behaves when you push it near that ceiling on long agent runs.

[05:23] Meta's Muse Spark 1.1 lands on OpenRouter with a 1M-token context window

Meta has a new model listed on OpenRouter, and the context window is the headline. Muse Spark 1.1 is described as a multimodal reasoning model built for agentic tasks. It accepts text, images, video, audio, and PDF documents and returns text output. The context length is one million forty-eight thousand tokens, which works out to roughly seven hundred fifty thousand words — enough to fit several novels, a large codebase, or a long contract review into a single prompt at once.

For builders, the multimodal input side is the practical story. You can hand it a PDF, a chart image, and an audio transcript in the same conversation and ask it to reason across all of them at once. Agentic pipelines — assistants that read documents, plan steps, and call tools — usually lose track after a few turns because the working memory fills up. A million-token window means an agent can keep an entire research packet, a multi-document legal review, or a full repository in memory without aggressive summarization dropping important details on the floor.

The catch is that this is a listing on a model router, not a hands-on review. The source material does not include independent benchmark scores, latency numbers, or pricing for Muse Spark 1.1, so the first wave of community results will be the real signal. Watch for two things over the next few weeks: how the model handles long-context retrieval tasks where smaller models tend to lose details buried in the middle of the window, and whether Meta publishes its own evaluation results to anchor expectations.

If you run agent pipelines that have been bottlenecked by context loss — multi-document analysis, long codebase reviews, video-plus-transcript comprehension — Muse Spark 1.1 is worth a test drive this week, especially on workflows where you currently chunk and re-feed files just to keep the model oriented.

[07:19] Code search that cuts agent tokens by 98%

Code agents spend a lot of their context window on a surprisingly boring chore: finding the right lines in a big repository. Most setups still lean on the same pattern developers have used for decades, which is grep for a keyword, then read every file that matches. That works, but every read costs tokens, and tokens are what the agent has to spend its thinking budget on.

A new library called semble, from MinishLab, is built for that exact problem. The project frames itself as fast and accurate code search designed for agents, and the headline number on its README is the one that matters: it claims to use roughly 98% fewer tokens than the grep-plus-read workflow. In practice, that means an agent asked to refactor a function, trace a bug, or update a call site gets back the relevant lines and their surroundings without having to ingest whole files just to find them.

Version 0.5.1 shipped on July 13, and the repo shows it has earned 5,634 stars on GitHub, with code pushed again on July 17. So this is not a weekend prototype. It is being used, iterated, and talked about in the agent-building community.

For builders, the practical shift is small but real. If you are wiring an agent into a large codebase, swapping grep-plus-read for a purpose-built searcher like semble can dramatically cut the tokens burned on retrieval, which in turn leaves more room for the model to actually reason about the change it is making. It also tends to speed runs up, since fewer tokens means fewer round trips.

The thing to watch next is integration. Semble is a library, not a finished product, so the interesting question is which coding harnesses and IDEs start shipping it by default, and whether the 98% number holds up on messy, real-world monorepos.

[09:14] clidey's whodb ships 0.121.0 with a data-access-meets-ops pitch

The open-source database tool whodb shipped release 0.121.0 on July 16. The project, hosted under the clidey organization on GitHub, describes itself with a deliberately broad tagline: 'where data access meets operational intelligence.' That positioning places whodb in the neighborhood of tools that try to collapse the gap between a query client and an operations dashboard — letting a developer connect to a database, pull data, and surface operational signals from one place, rather than stitching those workflows together by hand.

The community signal is hard to dismiss. The repository has accumulated roughly 4,930 stars, and the project saw fresh activity the day after the 0.121.0 release. Among community-driven database tools, that is meaningful traction in a category that includes well-funded commercial options. A patch-level bump with active commits right behind it points to a project that is being touched and shipped on, not frozen in place. The version number itself — sub-1.0, in the 0.121.x range — is also a tell. The team is publicly iterating rather than declaring victory, which is what you want from a tool you might lean on operationally.

For builders, the practical takeaway is straightforward. If your workflow today looks like a query client on one screen and a separate observability tool on another, whodb is worth evaluating as a single open-source alternative. The repository is public on GitHub, which means a spin-up against a non-production database carries low risk. Why this matters: another community-funded database tool is shipping in this space, keeping pressure on commercial offerings.

One thing to watch next: whether the team continues to push follow-on commits and releases after 0.121.0, or whether activity quiets. Continued shipping would confirm real users feeding the backlog; silence would tell the opposite story.

[11:03] Transformers 5.14.1 Ships Two Inkling Integration Fixes

The transformers library, the most widely used toolkit for loading and running open-weight AI models, shipped a small but pointed patch release today. Version 5.14.1 went out July 16, and its entire purpose is fixing two integration bugs that surfaced when teams started wiring up a model called Inkling.

The first fix lands in the assisted generation path. Assisted generation is the speedup trick where a smaller draft model proposes candidate tokens that a larger model then verifies, letting the larger model accept batches at once instead of decoding one token at a time. The bug showed up when the cache used in that pipeline was an EncoderDecoderCache, which is the memory layout designed for models with separate encoder and decoder stages. With this fix, assisted decoding works again on Inkling without tripping.

The second fix addresses the prefill stage. Prefill is where the model chews through the input prompt before it starts generating, and StaticCache is the configuration that preallocates the key-value memory so each request gets a fixed slot. Sdpa, or scaled dot-product attention, is the kernel that does the actual attention math. The bug appeared when Inkling ran through StaticCache with sdpa on unpadded input and used a position_bias, which is the mechanism some models use to tell the attention layer where each token sits in the sequence. With this fix, that path no longer breaks.

For builders running self-hosted inference on encoder-decoder models, this is the boring release that turns "it crashes on my input shape" into "it just works." No API changes, no new features, just two regression-class bugs closed. Watch for whether other models with position_bias hit the same shape of issue next time, and whether the team expands test coverage to catch these earlier.

[12:53] A 2-Bit 27B Chat Model Is Trending

A new open-weight model called Ternary-Bonsai-27B is climbing Hugging Face's trending list right now, and the name does most of the talking. The "27B" puts it in mid-size territory, "GGUF" means it's packaged for llama.cpp — the popular CPU-and-GPU local-inference runtime — and "ternary" plus "2-bit" tells you the weights have been compressed to roughly two bits each. That's an unusually aggressive quantization that usually only works when the model was built or fine-tuned for low-bit math from the start.

The repo comes from prism-ml and has already pulled 200,774 downloads with 637 likes on the hub, so this is not a quiet drop. The tag list is the real tell: llama.cpp, llama-cpp, CUDA, and Metal. That's laptop CPU, NVIDIA GPUs, and Apple Silicon in one bundle. Most quantized checkpoints lean on a single backend; this one is shipping with the full local-inference stack.

Practically, what this means for builders: a 27B-class conversational model shipped in a 2-bit GGUF package, ready to run through llama.cpp, with CUDA and Metal in the tag list. That's a mid-size chat model that opens up local-inference workflows on Apple hardware via Metal, on NVIDIA GPUs via CUDA, and on plain CPU boxes through llama.cpp, without the memory footprint of a fuller-precision checkpoint. Agents that previously needed cloud round-trips for a mid-size chat model can now plausibly run the loop locally.

Watch next: whether the maintainers publish an upstream base card, what context length the checkpoint actually delivers, and how it holds up on reasoning evals once the community runs them. The download count says curiosity is already there; the open question is whether the quality truly survives the 2-bit squeeze, and on which hardware it lands best.

[14:40] NVIDIA Nemotron 3 Embed Takes Top Overall Spot on RTEB

NVIDIA's newest embedding model, Nemotron 3 Embed, took the top overall spot on RTEB, a widely-watched leaderboard for retrieval systems. The result, posted to the Hugging Face blog on July 16, lands in the middle of a busy stretch for retrieval work, where small ranking gains can change which model a serious agent stack defaults to.

What does that actually mean? RTEB, short for a retrieval embedding benchmark, measures how well a model can turn text into the numeric fingerprints a search or retrieval system uses to find the right passage out of millions. The overall rank on that leaderboard is the single number most teams glance at when picking an embedding for production, because it aggregates performance across many retrieval task types rather than rewarding a model that wins one narrow slice.

The agentic-retrieval framing is the interesting part. Agents, the assistants that take multi-step actions rather than just chatting, need to look things up constantly, and the quality of those lookups often caps how reliable the agent feels. A new top entry on the benchmark is essentially a claim that NVIDIA's model produces embeddings better suited to that look-up-heavy workload, which is exactly where most production agents live.

What people can build: any retrieval pipeline that needed a refresh now has a fresh candidate to test, and the model is available through Hugging Face, so it is accessible to anyone running retrieval locally or in the cloud. Teams that already use NVIDIA hardware may see the cleanest gains, since the model comes from the same shop. The one thing worth watching next is whether independent reproductions hold the top spot, or whether other labs publish updated contenders this quarter and reshuffle the ranking again.

[16:28] OpenAI pushes 'reverse federalism' for AI safety rules

On July 15, OpenAI published a piece arguing for a "reverse federalism" approach to AI governance. The core idea: state laws should do the early work of figuring out what AI safety rules actually look like, and the lessons from those state efforts then feed up into a national framework for safe, democratic AI.

The framing matters because AI policy is currently being hashed out in state legislatures across the country, with no single federal rulebook in place. Different states are taking different approaches, and OpenAI is making the case that this parallel work is actually useful. Letting states experiment produces real evidence about what works before anyone commits to a permanent national standard.

This is a policy position from a major AI lab, not a new law or regulation. But the position is notable because OpenAI is essentially arguing for a particular model of how AI rules should get built — bottom-up rather than top-down. The "reverse" in reverse federalism is the key word. Traditional federalism has the federal government set the floor and states add their own rules on top. OpenAI is proposing to flip that, with state laws setting the early examples and the federal government learning from them.

For builders shipping AI products, nothing changes this week. There is no new compliance requirement here. But it is worth paying attention to which state AI bills actually move in upcoming legislative sessions, because those early state rules will shape what any eventual federal framework looks like.

The signal to watch next is whether any federal preemption language shows up — proposals that would replace state AI laws with a single national standard. That fight will decide whether reverse federalism is a temporary phase or the permanent structure of US AI policy.

[18:19] Research digest: Search agents that stop getting stuck in loops

If you've ever watched an AI research assistant spin its wheels—asking the same web searches in different words, returning shallow answers that miss half the question—you've hit the loop problem the new SearchOS framework targets. The core finding: when agents treat open-domain research as filling linked tables of entities and attributes, with every value cited back to a source, completion becomes measurable rather than vibes-based. A context layer externalizes four kinds of state—the frontier task ahead, an evidence graph of what sources have anchored which claims, a coverage map of which gaps remain, and a failure memory of strategies that already flopped. Sub-agents run in pipeline-parallel, and when one finishes, a fresh task targeting an uncovered gap takes its slot, so search budgets stay productive. The takeaway for builders of multi-agent research tools: external, shared state and explicit failure memory do the work that hoping-the-model-remembers cannot. Watch for open-source release timing and benchmarks against deep-research style products.

[19:18] 2022 Telegram Data Centers Deep-Dive Resurges to 262 Hacker News Points

A 2022 engineering write-up titled Mysteries of Telegram Data Centers is suddenly one of the most-discussed technical posts on Hacker News this week, currently sitting at 262 points with a parallel conversation on Lobsters. The piece, hosted on dev.moe, has been pulled back into circulation four years after publication, which is unusual for any infrastructure retrospective.

Telegram has historically kept quiet about the physical layer underneath its messaging service, so any long-form look at where the servers actually live tends to circulate for months among infrastructure engineers. That a 2022 post is climbing again in July tells you the underlying analysis has held up well enough to still be useful, and that enough fresh readers are landing on it through search and aggregators to push it back up the rankings.

The Hacker News thread, mirrored on Lobsters under the AI tag, is where most of the practical value sits for builders right now. Readers are going through the original 2022 write-up alongside each other and trading notes on which assumptions still apply and which the industry has moved past. The conversation is less about Telegram specifically and more about what a global chat platform's data center footprint looks like in practice, and which choices tend to scale and which ones don't.

For builders, the takeaway is twofold. First, infrastructure retrospectives from large platforms tend to age slowly, so older posts are often worth reading alongside newer ones. Second, the comment threads on resurgent posts like this often carry the most current thinking, since the original author is rarely there to update the piece itself. Worth scanning the 262-point thread this week if you run anything close to a chat service.

[21:04] Research digest: AI coding assistants still can't read your bug screenshots

Real bug reports almost always come with a screenshot: a red error dialog, a broken render, a stack trace from the browser. Today's AI coding assistants mostly ignore those images and treat the bug as text-only. A new benchmark called MM-IssueLoc, covering 652 real issue-and-fix pairs across 23 programming languages, put that assumption to the test. The verdict is rough: the best agent tested located the correct file within its top five guesses just 39% of the time when given screenshots alongside the text description. Tools that top text-only coding leaderboards didn't transfer cleanly to the visual version, the researchers found. For builders, the practical lesson is direct: if your coding assistant can't connect a screenshot to a specific file, you're shipping a text-only system with extra steps. The thing to watch is whether models trained on paired visual-and-code data start closing that gap.

[21:58] A Codebase MCP Server That Turns Repos Into Instant Queries

A new MCP server is turning whole repositories into instant queries. DeusData released codebase-memory-mcp, a code intelligence layer that indexes an entire repo into a persistent knowledge graph and exposes it through the Model Context Protocol. The current version, v0.9.0, shipped July 8, 2026, and the project already sits at 32,285 GitHub stars.

The draw is speed and reach. According to the repository, an average repo is indexed in milliseconds, queries return in under a millisecond, and the index covers 158 languages. Because the server ships as a single static binary with zero dependencies, dropping it into a local dev environment or a CI runner is a one-step install.

The practical effect for builders is a sharp drop in token cost. The project claims 99% fewer tokens than handing raw source to a model, because an agent asks a structured question and gets a precise answer instead of pulling whole files into context. For a coding agent working across a large monorepo, that is the difference between constant re-reads and a fast lookup against a graph that already knows the code.

The setup story is straightforward. Point the binary at a repo, let it build the knowledge graph once, and wire the MCP endpoint into Claude Code, an editor plugin, or a custom agent loop. After that, structural questions like "which functions call this one" or "where is this config used" come back almost immediately.

What to watch next is whether the indexing speed holds up on truly large monorepos in the millions of lines, and whether v1.0 ships with versioning guarantees around the knowledge graph schema. For now, it is one of the lightest ways to give an assistant real structural memory of a codebase.

[23:46] FastMCP Crosses 26K Stars as a Top Python Path to MCP Servers

A Python library for building tools that AI agents can call just hit a new milestone. FastMCP, the open-source project from PrefectHQ that bills itself as "the fast, Pythonic way to build MCP servers and clients," now sits above 26,000 GitHub stars. The maintainers shipped version 3.4.4 on July 9 and pushed another commit to the repository on July 16. For anyone new to the acronym, MCP stands for Model Context Protocol — a standard for letting AI models discover and call external tools in a structured way, instead of every team inventing their own ad-hoc integration. Building a server from scratch means handling the protocol details yourself. FastMCP's pitch is that you write a normal Python function, use the library's idioms, and the framework takes care of the protocol layer for you. Why the star count is news: this is the project the Python side of the agent ecosystem is rallying around. Twenty-six thousand stars is not a vanity metric at this scale. It reflects thousands of developers who have bookmarked this library as the path of least resistance for MCP work, especially teams who already live in Python. What this enables for builders: a small team can stand up an MCP server exposing a company's internal API or data source in a single Python file, then register that server with any MCP-compatible client. Because the discovery format is standardized at the protocol level, the same server can be reached by whichever MCP-aware applications show up next. What to watch next: the release cadence. The project shipped 3.4.4 on July 9 and pushed code again on July 16, a quick turnaround. If the pace holds, expect more incremental changes than long quiet stretches.

[25:33] Practical queue

From today's stories: For teams running Codex in CI or locally, the improved rejection messages make it easier to triage a denied command without digging through source, which means fewer mystery failures during agent runs. This means builders can run whole-codebase or whole-document tasks through a single API call instead of building chunk-and-stitch pipelines. For builders running agent pipelines that lose track of long documents, a 1M-token context window removes the need for aggressive chunking and re-feeding. What this means for builders is that swapping a naive search step for a purpose-built one can free up meaningful portions of an agent's context window, leaving more room for actual reasoning. For builders tired of juggling a separate query client and an ops dashboard, whodb is worth evaluating as an open-source alternative. If you self-host Inkling or any encoder-decoder model that uses assisted generation or StaticCache with sdpa, upgrading to 5.14.1 removes two crash paths. This puts a mid-size conversational model within reach of local-inference workflows, since the GGUF/2-bit packaging targets llama.cpp on CPU, CUDA on NVIDIA GPUs, and Metal on Apple hardware. For builders wiring retrieval into agents, the headline points to a fresh retrieval candidate that slots into the existing shortlist of options to consider. Today's piece is a position paper, not a regulation, so there are no immediate compliance changes for builders. For builders wiring up autonomous research agents, the takeaway is that explicit, shared state about what has been tried and what is still missing can replace the brittle default of hoping the model remembers its own progress. For builders running chat infrastructure at any scale, the original 2022 piece plus its 262-point comment thread is worth reading together, because the comments likely carry the current thinking on what still applies and what has shifted. What this means is that any team calling their coding tool "vision-aware" should check whether it can locate the broken file from a screenshot alone, not just describe what's in the image. This means a coding agent can answer structural questions across a large monorepo without re-reading every file on each turn. If you're building agent tooling in Python, FastMCP is worth a look as the lowest-friction option in the ecosystem right now.

Chapters

  • 00:00 — Intro: Agent Stack Release Readout: OpenAI Codex rust-v0.144.5; Claude Code CLI 2.1.205 / Kimi K3 Lands on OpenRouter With a Million-Token Context Window / Meta's Muse Spark 1.1 lands on OpenRouter with a 1M-token context window
  • 02:00 — Agent Stack Release Readout: OpenAI Codex rust-v0.144.5; Claude Code CLI 2.1.205
  • 03:34 — Kimi K3 Lands on OpenRouter With a Million-Token Context Window
  • 05:23 — Meta's Muse Spark 1.1 lands on OpenRouter with a 1M-token context window
  • 07:19 — Code search that cuts agent tokens by 98%
  • 09:14 — clidey's whodb ships 0.121.0 with a data-access-meets-ops pitch
  • 11:03 — Transformers 5.14.1 Ships Two Inkling Integration Fixes
  • 12:53 — A 2-Bit 27B Chat Model Is Trending
  • 14:40 — NVIDIA Nemotron 3 Embed Takes Top Overall Spot on RTEB
  • 16:28 — OpenAI pushes 'reverse federalism' for AI safety rules
  • 18:19 — Research digest: Search agents that stop getting stuck in loops
  • 19:18 — 2022 Telegram Data Centers Deep-Dive Resurges to 262 Hacker News Points
  • 21:04 — Research digest: AI coding assistants still can't read your bug screenshots
  • 21:58 — A Codebase MCP Server That Turns Repos Into Instant Queries
  • 23:46 — FastMCP Crosses 26K Stars as a Top Python Path to MCP Servers
  • 25:33 — Practical queue

Primary Links

Release Coverage Check

  • OpenClaw — Latest stable verified: v2026.7.1, published 2026-07-13T22:33:14Z. Recent episode version tags detected: v2026.7.1-beta.1, v2026.7.1-beta.2, v2026.7.1-beta.6, v2026.7.2-beta.1. No new stable release this cycle.
  • Hermes Agent — Latest stable verified: v2026.7.7.2, published 2026-07-08T03:11:22Z. Recent episode version tags detected: v2026.6.5, v2026.7.1, v2026.7.7, v2026.7.7.2. No new stable release this cycle.
  • OpenAI Codex — Latest stable verified: rust-v0.144.5, published 2026-07-16T02:54:48Z. Recent episode version tags detected: rust-v0.144.1, rust-v0.144.2, rust-v0.144.3, rust-v0.144.4. Selected missing version(s): rust-v0.144.5.
  • Claude Code CLI — Latest stable verified: 2.1.205, published 2026-07-08T19:34:57.777Z. Recent episode version tags detected: 2.1.197, 2.1.202, latest, stable. Selected missing version(s): 2.1.205.
  • Antigravity CLI — Continuous delivery model; no discrete release tags verified this cycle (latest build as of 2026-07-17). Recent episode version tags detected: none on record.

Harness Version Reference

  • OpenClaw — v2026.7.1 (stable) / v2026.7.2-beta.2 (prerelease)
  • Hermes Agent — v2026.7.7.2
  • OpenAI Codex — rust-v0.144.5
  • Claude Code CLI — 2.1.205
  • Antigravity CLI — Continuous delivery (no tagged release verified this cycle)

🎙 Never miss an episode — subscribe now

SpotifyAppleiHeartYouTube MusicAmazonRSS
🎙 Subscribe to AgentStack Daily