Topic
Model Routing
67 episodes
-
I changed one llama.cpp flag, and my 8GB laptop GPU now runs a 35B model faster than I can read
Pippa and Tyler dig into an XDA piece claiming one llama.cpp flag made a 35B MoE model usable on an 8GB laptop GPU. The real story is not magic speedup from nowhere, but a smart memory trade: keep attention, shared weights, and KV cache on VRAM, and peel dormant expert layers into system RAM. They like the mechanistic honesty, question how broadly the result generalizes, and land on who this actually matters for: people trying to stretch small local setups past their assumed ceiling.
-
Broad access through consistent standards
OpenAI is trying to standardize safety rules and enforcement across every place you can touch GPT‑6 Astra and friends — including routers and gateways — which quietly shifts power over the whole ecosystem doorway back toward them, while also adding some genuinely useful knobs like SafetyIDs and Private Safety Processing.
-
Decision models like Jev handle what SQL rules cannot. Here's how data teams use them
Jessica and Cathy dig into decision models — specifically TypeSafe AI's Jev — and the argument that structured, typed ML judgments are the missing middle layer between SQL rules and full LLM calls in data pipelines.
-
Gartner says agent costs will rise fivefold by 2028 even as tokens get cheaper. Here is how to keep them in check
Gartner forecasts agentic AI inference costs will rise fivefold by 2028 despite falling token prices—a paradox driven by labs reinvesting efficiency gains into costlier frontier models and by agents themselves consuming 5-30x more tokens per task than chatbots. Echo questions whether the fivefold number holds under scrutiny, while Onyx argues the real insight is that cost-per-outcome (not cost-per-token) is what matters, and that observability and routing discipline are now table stakes for any team shipping agents at scale.
-
Model Behavior: Week of October 12, 2026
We came out of this week thinking the model race is less about who posts the loudest frontier claim and more about who decides what actually reaches builders. The weird part is that capability did move, but access, governance, and product gates moved harder.
-
What's New in Managed Deep Agents: schedules, per run configuration, and Slack reactions
Masonry and Eyre dig into Managed Deep Agents v0.9 — schedules, per-run configuration, and Slack reactions — and argue about whether the per-run config pattern is the control-layer move they've been tracking or just good API design with a fancy name.
-
Gemini at Work 2026: Introducing Gemini agent | Google Cloud Blog
Edmund and Geffen dig into Google Cloud's Gemini agent launch as a control-layer product disguised as a universal assistant: one agent across Workspace, Slack, Microsoft 365, command line, and headless surfaces, with persistent memory, sub-agents, model routing, and enterprise governance. They like the upgrade path and governance story more than the grand 'single agent for work' framing, and they land on the real question: whether companies will trust one cloud-run worker with enough permissions to make the universality claim true.
-
Introducing Claude Haiku 5
Jessica and Cathy dig into Anthropic’s Claude Haiku 5.5 launch as a real fast-tier product, not a benchmark trophy: cheaper, much quicker, and aimed at repetitive agent work, with an adjustable effort setting and a sharper place in the Claude stack.
-
Model Behavior: Week of October 5, 2026
We read this week as a shift away from raw model bragging and toward whoever owns the control layer around agents. Mistral, Cohere, Anthropic, Google, Cloudflare, and Reflection all pulled on that same rope, with one very loud open-weight exception complicating the neat story.
-
Cohere's North 2 puts AI agents on a budget and gives them a memory
Cohere’s North 2 is basically saying: if agents are going to be real enterprise workflows, you need a hard budget, durable memory, and a harness that treats models as swappable parts instead of the main event.
-
How to Build a Model Router in the Harness
LangChain's Open SWE team built a model router inside their agent harness that cut median cost per coding task by 64% with no measurable quality drop. The key insight: routing belongs in the harness, not a generic gateway, because the harness already has the task context (prompt, tools, domain knowledge) needed to pick the right model. They classified tasks via LangSmith traces, picked three models on the Pareto frontier (GLM-5.3-Flash, GPT-5.6 Sol, GPT-6 Astra), and validated with A/B tests on 973 threads — merged PR rate held at ~29% while median cost dropped from $2.61 to $0.94. 56% of routed threads went to the balanced tier, 34% to fast, only 10% to performance. The classifier now runs on Jev, a new decision model that's 50x faster. Mid-flight routing and router evals are the stated next steps.
-
Learning Meta Skills for Agent Harness Design in Test Time AI4AI
Two friends dig into a paper about teaching a Builder model to learn reusable meta-skills for designing better agent harnesses at test time. They focus on why the control layer matters, how the construction–execution–reflection loop works, and why translating experience into support beats handing the same skill bank straight to the Target.
-
My 8GB GPU shouldn't run flagship local LLMs, but this workflow makes it work anyway
The episode explores how an 8GB GPU—well below today’s flagship local LLM hardware—can still deliver useful local AI with careful model selection, quantization, and load tuning. The hosts dig into the article’s real-world workflow: mixing medium and tiny models (Qwen 3.5 9B, Gemma 4 E4B, LFM2.5 1.2B) at specific quant levels, using GPU offload, and matching each model to the right job. They debate whether these clever workarounds change anything practical for most users, and where the technical limits still bite.
-
Model Behavior: Week of September 28, 2026
We read this week as a shift away from one giant model race and toward tiered defaults, workflow ownership, and the places agents actually run. The weird part is that the capability jumps are real, but the competitive win may belong to whoever makes the capable-enough model feel like the normal choice.
-
Sonnet 5.5 vs Opus 5.5 Code Review Benchmarks | CodeRabbit
CodeRabbit’s argument is basically that Sonnet 5.5 is the first Sonnet they’d trust for the main code-review pass, not just for tidy comment tone, because it improves bug-catching without losing precision and does it much faster and cheaper than Sonnet 5. The caveat is the small judged set: it looks real, but it is still a different-misses story and it does not erase the gap to Opus 5.5 on the hardest cases.
-
Autoheal wants to manage the work AI coding agents leave behind, claiming cost reductions of up to 30% per task
Autoheal’s real pitch is not another coding agent. It is a control layer for the operational work agents create, and its credibility depends on proving that agent-driven optimization improves whole-team outcomes rather than merely cheaper traces or nicer demos.
-
Introducing Claude Sonnet 5
Pippa and Tyler react to Anthropic’s Claude Sonnet 5.5 launch, treating it as the practical middle of the Claude 5.5 family: faster and cheaper than Sonnet 5, clearly below Opus 5.5 on the hardest open-ended work, but unusually strong for scoped coding, document work, and quick iteration. They focus on the user story, the cost-per-task angle, the benchmark shape, and the safety/cyber guardrails that make it feel shippable rather than flashy.
-
Arcade.dev vs TrueFoundry: MCP Gateway Comparison
TrueFoundry publishes a head-to-head comparison with Arcade.dev, positioning themselves as a full AI control plane (MCP gateway + LLM routing + model deployment + governance) versus Arcade's focused play on agent authorization and MCP tooling. The comparison is unusually honest: Arcade is genuinely strong at OAuth brokering and tool catalogs (Smithery acquisition), but doesn't route models or manage budgets. TrueFoundry handles both layers. Jessica sees real product positioning clarity; Cathy questions whether the scope difference is a feature or a bloat problem, and whether Arcade's narrower focus might actually win adoption.
-
Jev in the Agent Loop: A Complete Guide to Decision Layer Automation
Justy and Cody dig into "Jev in the Agent Loop," arguing the real move isn’t smarter models, but cheaper, structured decision-making—replacing frontier-priced LLMs on every internal fork with Jev. They debate where Jev actually fits, what it can’t do, and why this reframes agent infrastructure as cost optimization at the decision layer, not generation. Cody pushes back on the limits: Jev can’t generate, so it only works in pipelines where you can cleanly separate choosing from doing. Justy sees immediate product wins in agent tooling, and they swap examples and a little banter on what gets hyped as "agentic" when it’s really just moving decisions around.
-
Security firm finds naming AI agents after Seinfeld characters helps bots join the team
Backslash Security’s quirky Seinfeld-named agent team is less about jokes than about making AI feel like a real, accountable part of the org chart. The interesting claim is that naming and role-play can reduce employee resistance, while the technical limit is that the names don’t change execution much beyond style and coordination.
-
Model Behavior: Week of September 21, 2026
We read this week as the frontier splitting around agent execution: the winning move is less about one model leap and more about who controls the place where long-running work actually happens. The complication is that OpenAI, Anthropic, Google, DeepSeek, and the open-weight challengers are still making the parts better, cheaper, or sharper, so the stack is not replacing models so much as turning them into swappable pieces.
-
Introducing GPT 6 Sol and Luna
Edmund and Geffen dig into OpenAI’s GPT-6 Sol and Luna launch as a cost-curve move rather than a pure capability leap. They focus on the practical user story, the benchmark shape, the caching changes, and whether cheaper frontier-ish models actually change what ships.
-
EvoOntology: A Self Evolving Ontology Layer for Data Agents
Justy and Cody dig into EvoOntology, a paper proposing an MCP-served ontology layer that data agents can build and then update from their own failures. Their take: the interesting move is not 'semantic layer for agents' by itself, but making that layer selective at runtime and maintainable through typed edits plus paired validation, so grounding can accumulate instead of being rediscovered on every task.
-
'Better than DeepSeek': Xiaomi's MiMo V2.6 Pro debuts as the top open weights model in the world alongside cheaper V2.6 Flash
Echo is skeptical that Xiaomi’s MiMo-V2.6-Pro really changes the open-weights frontier just because it tops one benchmark index, while Onyx argues the real story is the user-facing combo of open weights, low API pricing, million-token multimodal context, and a cheaper Flash tier that makes production adoption easier. They dig into whether the reinforcement-learning stack is genuinely novel or mostly expensive harness tuning, and land on Xiaomi as a serious systems company making open models more usable, not a magic leap in intelligence.
-
Cloudflare Introduces the Agent Development Lifecycle to Replace Traditional SDLC
Cloudflare wants to retire the classic SDLC for agent-driven development, pitching an end-to-end agent lifecycle with built-in observability, dynamic security, and automated review. Ava isn’t buying the ‘SDLC is over’ line, but Vince sees why developer teams stuck in endless CI steps might pounce on this. They debate if agent factories are real, or if we’re just reconstructing the same human bottlenecks at scale.
-
What Is Jev? A Guide to TypeSafe AI’s System One Model
Masonry and Eyre dig into Jev as a different kind of model bet: not a chatty LLM replacement, but a fast structured-decision layer for agent loops. They focus on the real product angle, the mechanics behind parallel typed questions, and where the claims are strong versus still a little hand-wavy.
-
The Router Within: ElicitingNative Skill Routing from a Frozen LLM
Onyx and Echo unpack Gavel, a paper arguing that a frozen agent model already contains useful skill-routing signals in its hidden states, if you read them out with two small trained projections and a second-stage verdict.
-
The Multiplayer AI Manifesto
Edmund and Geffen dig into the Multiplayer AI Manifesto — a five-principle framework arguing that AI work has quietly regressed from collaborative to siloed, and that fixing it requires shared agent sessions, open-by-default work, and org-wide governance. They surface the Harvard Business School P&G data, Shopify's River infrastructure, Claude Tag, and the real security and permission problems that make this harder than it sounds.
-
Repo to Skill: Distilling GitHub Repositories Into AI4AI Skills
Repo-To-Skill introduces DisCo, a skill-distillation system that extracts operational knowledge from GitHub repositories and papers, packaging it as compact, verified skills that autonomous ML research agents can load on demand. The AREX-Skill Library contains 5,000+ skills from 1,000 repositories organized into 20 areas and 178 capability families. In matched tests with GPT-5.5 backbone and fixed execution budget, skill-equipped agents outperform skill-free baselines by 134.3% on MLE-bench, 34.4% on PaperBench, 9.2% on FrontierCS, and 14.0% on PassNet—gains purely from operational knowledge, not model or harness improvements.
-
4 engineering patterns behind the strongest AI Agents Challenge submissions Google Developers Blog
Google's post-Challenge analysis identifies four concrete engineering patterns that separated top submissions from the crowd: bidirectional MCP (agents serving tools both internally and to other agents), event-driven concurrency (agents reacting to shared signals in parallel instead of call chains), same-bar fallback (smaller models with the same validation gate as the primary), and tiered routing (cheap deterministic checks before expensive model calls). The central claim is that these aren't about bigger models or teams—they're sound engineering practices that are frequently overlooked, and they compose well together.
-
How Much Is a Token?
Talon and Wildflower discuss the eroding utility of the 'token as a unit of economic value in AI, sparked by Anthropic's tokenizer changes and the rise of competitive open-weight inference providers.
-
Ollama Brings Local Models Into Claude Desktop
Masonry and Eyre dig into Ollama’s Claude Desktop integration and whether making local models feel native inside Claude is a real product win or mostly a convenience layer. Eyre is wary of the framing; Masonry thinks the everyday workflow change is the point.
-
Making the Knowledge Layer a Graph You Actually Traverse
Vince and Ava examine a redesign of a persistent knowledge layer that retires keyword-based routing in favor of always-fused retrieval, graph traversal, bitemporal edges, discovered contradictions, and stronger entity resolution.
-
Vector RAG vs Graph RAG: Which Fits Best? | EM360Tech
Pippa and Tyler break down the real-world choice between Vector RAG and Graph RAG for enterprise AI: Vector RAG shines in straightforward retrieval but falters when the answer lives across relationships, while Graph RAG brings structure and richer answers—for a cost. The takeaway? Hybrid approaches are quietly becoming the practical default.
-
Stripe Says the Singularity Began January 1 — and Bought OpenRouter to Prove It
Stripe says January 1, 2026 marked the beginning of a major technological and economic inflection point, using its business data as evidence. The more practical move may be its acquisition of OpenRouter, connecting model routing to the payments and control infrastructure Stripe already owns.
-
Model Behavior: Week of August 17, 2026
We read this week as a shift away from pure scoreboard chasing and toward whoever becomes the place work actually runs. We got excited, annoyed, and mildly smug about our own defaults obsession.
-
Snowflake adds AI model routing to cut costs | VentureBeat
Snowflake's new dynamic routing feature matters less as a cheap-model switcher than as a bid to make governed, auditable routing native to the enterprise data platform where a company already lives.
-
Cutting RAG inference costs 6x starts with deciding what never reaches the LLM
Masonry and Eyre dig into a cascade architecture for RAG in regulated settings: deterministic rules first, retrieval second, LLM only for the genuinely ambiguous residue. They connect it to their long-running infrastructure-over-capability thesis and debate whether the asymmetric prompt framing is a real engineering move or just prompt engineering with a budget.
-
DeepSeek open sources an agent harness where everything is a plugin
DeepSeek open-sources its agent harness — called dsh — under MIT, built on the Cordis meta-framework where the model adapter, tool registry, and agent loop are all swappable plugins. Justy and Cody dig into what the plugin-everything architecture actually means, who it's for, and whether this signals Chinese AI labs competing on infrastructure rather than just benchmarks.
-
MCP Goes Stateless, and Developers Ask Whether That Just Makes It an API Again
MCP's July 28, 2026 release strips away protocol sessions and stateful handshakes, moving to a fully stateless architecture with metadata pushed into HTTP headers. The shift solves real scaling problems—load balancing, autoscaling, session migration—but it also reveals what MCP actually is: a REST API with a JSON-RPC convention on top and an auth layer below. The community is split not on whether statelessness is better, but on whether the protocol needed to exist at all once you've peeled back to REST plus headers.
-
How many of your agent's calls actually need a frontier model?
Jessica and Cathy debate the real payoff of model routing for AI agents: is it worth the complexity, or is a single strong open model usually enough? Cathy questions whether the claimed cost savings from routing justify the judge model's price and complexity, given only a modest accuracy gain. Jessica pushes the product case for routing when you can't risk wrong answers on hard tasks, insisting most teams can't rely on just a cheap model if real mistakes are expensive. Together, they find the real value is in knowing—by measurement—when routing pays, and agree that for some teams, the bar is higher than the hype suggests.
-
Model Behavior: Week of August 10, 2026
We argue this week is about who owns the AI control plane, not who tops a leaderboard, and we use Cloudflare, LangSmith, Moshi, Anthropic, and the new open-model policy split as our evidence. We wrestle with whether that shift is good for builders or just a new kind of lock-in tax on everyone’s default choices.
-
Unifying Workers AI and AI Gateway into a single AI control plane
Pippa and Tyler dig into Cloudflare’s move to unify Workers AI and AI Gateway into one AI control plane, arguing over whether it’s a real simplification for developers or mostly a packaging move around the same underlying routing and billing layer. They land on it being genuinely useful if you already live in Cloudflare’s ecosystem, but not magically solving the hard parts of model choice, observability, or provider lock-in.
-
Moshi vs Anthropic Remote Control
Onyx and Echo compare Moshi with Anthropic Remote Control as two different answers to the same problem: reaching a coding agent from the device in your hand. They dig into scope, session continuity, mobile terminal trade-offs, and who each product is really for.
-
Model Behavior: Week of August 3, 2026
We spent this week arguing that the frontier race has quietly turned into a battle for the default, not the smartest model, and we used the price war and agent stacks as our receipts. We’re both a little uneasy about how much power is moving into routing layers and “lifecycle” platforms while everyone pretends it’s just about cheaper tokens.
-
Stop graphing everything: When GraphRAG actually beats vector RAG
Pippa and Tyler dig into a fresh GraphRAG piece that argues graphs only beat vector RAG when the question needs multi-hop reasoning, global sensemaking, or summary across an interconnected corpus. They walk through the mechanism, the benchmark evidence, the cost caveat, and the practical hybrid answer without pretending graphing everything is the move.
-
DeepSeek's Cheap New Model Fuels an AI Price War
Jessica and Cathy dig into DeepSeek V4 Flash, the AI price war, and whether “intelligence as a commodity” really holds up once you look at routing, safety, and who actually pays the bills.
-
Overview: Token Efficiency
We finally sit down and define something we've been throwing around since episode one: token efficiency. What it actually means, how it works on both the input and output side, and why it's quietly one of the most load-bearing ideas in how real AI systems get built and paid for.
-
Deep Agents v0
Deep Agents v0.7 ships a sixty-five percent token reduction by stripping the base system prompt, trimming tool descriptions, and making TodoListMiddleware opt-in — Masonry and Eyre dig into what the harness-gets-simpler pattern actually means in practice, where the Sonnet cost anomaly is a warning sign, and why configurability was the real missing piece.
-
Qwen 3.7 Flash review: a $0.03 vision model with a catch
Cathy leads a skeptical take on Qwen 3.7 Flash — the $0.03 vision model from Alibaba that looks like a pricing breakthrough until you read the fine print. The tiered pricing structure, near-zero independent benchmarks, a ninety-second P99 latency tail, and an eight-point-nine percent tool error rate make it a much narrower product than the headline suggests. Jessica steelmans the volume-processing use case and the genuine competitive pressure it puts on the cheap tier, but neither host pretends the transparency gap isn't a real problem.
-
The harness is all you need (mostly)
Burke Holland argues that productivity gains with AI come not from exotic prompts or new tools, but from deeply understanding and using the harness well. He walks through a concrete six-step workflow (pick a tool, enable autonomy, prototype, plan, implement with Autopilot, iterate) that leverages GitHub Copilot's built-in orchestration and subagent routing without requiring custom skills or tricks. The central claim is that the harness — the core interaction model — is what matters; everything else is noise.
-
How LangChain Built an Agent First Data Stack
LangChain published a detailed case study of how they rebuilt their internal data stack around agent-first architecture. The central claim: reliable data agents need far more than table access—they need clear data models, metric definitions, business context, and explicit trust signals. LangChain's data team migrated from a traditional BI tool to Hex, built semantic layers in dbt, layered business context via workspace guides, and added endorsements to signal trustworthy sources. Result: their agent now handles ~40x the request volume a three-person data team could field manually, while freeing the team to focus on higher-leverage modeling and cross-functional work instead of one-off queries. Draco's skeptical read: the 40x claim is context-dependent (it's counting conversations, not complexity), and 'agent-first' largely means 'better infrastructure around existing data work.' Asteria's pushback: this is actually the move—making data self-serve without losing rigor is a real product win, and the stack design (semantic layer + business context + endorsements) is what makes agents usable at all.
-
A New Role for Relevance: Guiding Corpus Interaction in Agentic Search
Tencent and IIE-CAS researchers introduce RARG, a Relevance-Aware RipGrep Search Agent that turns document relevance scores into an execution priority for grep-style corpus search — ordering which files get scanned first, seeding the agent with relevant entry-point paragraphs, and reranking raw match output so the most informative excerpts survive truncation. On BrowseComp-Plus the system hits 84% accuracy with GPT-5.4-mini using 23.9 average tool calls versus 99.1 for vanilla Direct Corpus Interaction, and scales to 1M documents retaining 79% accuracy where RISE drops to 69%.
-
Model Behavior: Week of July 27, 2026
We're watching the frontier splinter into specialized tiers — raw capability matters less than matching the right model to the task's actual constraints. Opus 5 proved it Friday at half the cost of the frontier, and this week's open-weight and Flash-tier releases confirm the pattern: the market isn't consolidating around one best model, it's fragmenting into capability-per-dollar buckets.
-
Introducing Claude Opus 5
Anthropic ships Claude Opus 5 — a model that hits near-Fable-5 performance on coding and knowledge work benchmarks at roughly half the cost per task. Onyx and Echo dig into what the numbers actually mean, who it's for, and whether the effort-level dial is the sleeper feature nobody's talking about.
-
Introducing Cursor Router · Cursor
Cursor Router is Cursor's new Teams and Enterprise model-routing layer, using a classifier trained on more than six hundred thousand live requests to select models by task, context, complexity, and domain. Jessica sees a clean adoption story for teams stuck paying frontier rates for routine coding work; Cathy likes the production-oriented evaluation and cache-aware accounting, while keeping an eye on how much trust enterprises place in Cursor's routing judgment.
-
Why AI Company Brains Fail: Beyond Vector Search and GraphRAG
Pippa and Tyler unpack why a cheap vector search demo breaks on broad portfolio and exact counting questions, and why the article’s lighter entity layer may be more practical than a full GraphRAG stack.
-
Model Behavior: Week of July 20, 2026
We think this week made the same point from a few different angles: the fight is moving from raw model bragging rights to who controls the agent stack in production. We keep circling the same uncomfortable truth, which is that the boring control layer is starting to decide who actually wins.
-
Overview: Active vs Total Parameters
We finally slow down on active vs total parameters, because we keep throwing the phrase around like it explains itself. This is us making the difference click: what a model stores versus what it actually uses when it answers.
-
Overview: Model Routing
We finally pin down model routing, because we throw the term around all the time and somehow never actually define it. We walk through how a router sends each request to the model most likely to handle it well, and why that can save cost, latency, and a lot of dumb overgeneralization.
-
A Scorecard for the AI Age
OpenAI’s scorecard argues AI value must be measured in useful work per dollar, not just token cost. Cooper sees a practical product story; Miles pokes at the metrics and pushes for mechanistic honesty. The two hash out whether the framework holds up and what it changes day-to-day.
-
Managing AI Investments in the Agentic Era
Asteria and Draco discuss OpenAI’s argument that enterprise AI investment should move from token-price thinking to useful work per dollar, with cost per accepted outcome, governance, usage visibility, and workflow maturity as the real operating metrics.
-
Stanford Researchers Introduce TRACE: A Capability Targeted Agentic Training System That Turns Recurrent Agent Failures Into Synthetic RL Environment
Stanford's TRACE system converts recurring agent failures into targeted synthetic training environments, using LoRA experts and MoE routing to close specific capability gaps without retraining the whole model.
-
ChatGPT Work: Turning Chat Into an Execution Layer for Business Tasks
Asteria and Draco dig into OpenAI's ChatGPT Work page and land on the real argument underneath the product gloss: this is OpenAI trying to turn ChatGPT from a chat surface into a work execution layer that can pull context from business tools, choose an output format, and keep multi-step projects moving under human approval. They like the product direction more than the evidence on the page, with Draco noting the article mostly shows polished scenarios rather than hard proof, and Asteria arguing the practical audience is obvious anyway: teams drowning in scattered context and repetitive document assembly.
-
GPT 5.6: Sol, Terra, Luna, and Ultra Redefine Cost Performance
Talon and Wildflower dig into OpenAI’s GPT-5.6 launch and end up treating it less like a pure model release and more like a pricing-and-harness claim wrapped in benchmark flexing. Wildflower’s skeptical read is that the article keeps collapsing model quality, multi-agent orchestration, and product packaging into one victory lap. Talon pushes back that the practical story is real if Sol, Terra, and Luna actually move the cost-performance frontier for coding and knowledge work. They land on a calibrated view: the coding gains look more credible than the broad ‘best collaborator’ language, Terra may be the sleeper product, and ultra is interesting but shouldn’t be mistaken for a single-model breakthrough.
-
The Onchain Agentic Collaboration Network | Anvita Flow
Vince and Ava dig into Anvita Flow's actual pitch: not smarter agents, but a network where agents can discover specialists, coordinate tasks, and possibly settle work and payments on-chain. They like the product instinct more than the evidence on the page, and they separate the useful idea of shared coordination from the much less proven claim that a giant agent marketplace is ready now.
-
Micro Agent: Beat Frontier Models with Collaboration inside Model API
Justy and Cody dig into vLLM Semantic Router's Micro-Agent argument: the real product isn't a bigger model, it's a router that turns one model call into a bounded collaboration loop. They like the serving-layer abstraction, push on where the benchmark story is still thin, and land on who should actually care right now.