Topic
Retrieval Augmented Generation
72 episodes
-
Learning from Research: Toward Lifelong Agent Harness Evolution
Pippa and Tyler dig into ScholarEvolve, a framework that lets agents evolve their own harnesses by mining research papers for new mechanisms, not just reacting to failures. They unpack how it modularizes the harness, uses topic modeling over papers to propose concrete code changes, and runs a lifelong evolution loop on benchmarks like AppWorld and Tau2-Bench. They debate whether this is research-only or actually shippable, how it fits their running harness-as-product thesis, and what trade-offs and failure modes they’d worry about in production.
-
Model Behavior: Week of October 19, 2026
We read this week as a shift away from trophy launches and toward who can make models useful in real deployments. We argue through NVIDIA, Beam, Mistral, Subquadratic, and why a quiet frontier week still moved the board.
-
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.
-
DeepSeek Just Released V4.1 Flash 1017, Scores 77.0 on DeepSWE, Opens Search API
DeepSeek pushed a new Flash checkpoint that matters less as a leaderboard story than as a packaging story: a cheap agent model, served under the same name, plus first-party Search and Fetch behind one key.
-
Maintaining software with the GPT 6 family | OpenAI Developers
OpenAI's Core Experimentation team details how GPT-6 Astra and GPT-6.1 Sol transformed software maintenance at scale—accelerating code cleanup, rooting out stale experiments, and making review cycles more efficient and cost-effective. The piece argues that with the right prompts and agentic context, these models not only rival traditional static analysis and scripts for reliability, but let human engineers focus on higher-order control and judgment. The team presents real numbers on cleanup volume, cost savings, and model comparison, and recommends prompts others can adapt for similar gains.
-
“Take work away from frontier LLMs”: Subquadratic’s decision model claims 12x Jev’s context window
Subquadratic launches SubQ Snap, a decision model with 384K-token context window — 12x Jev's 32K limit — claiming it can process 100K tokens and return a decision in ~1 second. Built on Subquadratic Sparse Attention (SSA) for linear attention scaling, Snap targets enterprise agent workflows: file selection, tool routing, test verification. Benchmarks show Snap beating Jev on 13 of 16 enterprise tests (Decision LCR 74 vs 48, Nimble 82.9% vs 76%), though Jev wins on When2Call. All results are self-reported; independent verification pending. Pricing at $0.05/M input tokens, free outputs. The real question: does a 384K window actually eliminate retrieval/chunking fragility for coding agents, or just push the bottleneck elsewhere?
-
Evaluating Graph RAG vs. Standard RAG: A Hallucination Benchmark on Fact Dense Queries MachineLearningMastery
On this Quick Read, Onyx and Echo dig into an article benchmarking a deterministic Graph-RAG system against standard vector RAG, using a synthetic sports dataset designed to stress-test fact extraction. The big question: does layering a knowledge graph actually cut hallucinations when your data is messy, or are we just adding complexity for the sake of architecture? Echo breaks down the technical setup and where the experiment is honest or overclaims, while Onyx pulls it back to who actually needs this in the real world—and where the practical wedge actually is.
-
Memadapter: Counterfactual Adaptation Against Memory induced Sycophancy
Episode 1053 digs into MemAdapter, a framework for stopping long-term agent memory from becoming a quiet source of sycophancy. Onyx and Echo focus on the paper's key shift: a memory can be accurate and still deserve less influence in a particular decision.
-
Follow the Entities: A Corpus Map for Agentic Search
Vince and Ava break down CorpusMap, an offline entity layer that gives agentic search a reusable map of a document corpus instead of forcing every query to rediscover the same cross-document links. They focus on the product value, the mechanics of entity pages and document traversal, and whether this looks shippable beyond a paper demo.
-
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.
-
Adding Temporal Reasoning to Graph RAG: Tracking Fact Freshness and Staleness MachineLearningMastery
Vince and Ava debate a MachineLearningMastery article that adds timestamps and recency decay to Graph-RAG, treating it as a useful retrieval primitive but not a complete truth mechanism.
-
IAM for AI agents: A Practical Enterprise Framework
Edmund and Geffen discuss the new practical framework for IAM in AI agents, covering why traditional identity systems fail for autonomous agents, the essential components of an agent identity framework, and how enterprises should evaluate and implement these controls.
-
Automating Knowledge Graph Population: Extracting Entities and Triples from Unstructured Text with an LLM MachineLearningMastery
Pippa and Tyler dig into a practical recipe for turning unstructured text into knowledge-graph quads with a local LLM, but keep the real question in view: whether the extraction pipeline is useful enough to trust, not just easy to demo. They focus on the article’s SPOC framing, JSON-mode prompting, and QuadStore loading, while poking at where this kind of setup gets brittle in the real world.
-
SpeakerMem R1: Speaker Centered Dual Track Memory for Multi Party Dialogue
SpeakerMem-R1 tackles a real gap in long-term memory for group chats: keeping speaker attribution, person/group scope, and evolving state intact instead of flattening everything into a relevance search problem. The episode leans on the paper’s dual-track design, Anchor–Separate–Resolve–Compose query flow, and Writer-R1 training setup, while staying grounded on whether this is actually shippable for multi-party agents.
-
Jev Mem: System One Controlled Agentic Memory for Efficient AI Agents
Jev-Mem is a new agentic memory architecture from UT Dallas that splits memory control into a fast System-One plane and a slower System-Two reasoning plane — cutting query latency by thirty-seven percent and memory construction time by six-point-six times. Vince sees a genuine efficiency unlock for production agent systems; Ava is cautiously impressed but wants to see how it holds up beyond LoCoMo.
-
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.
-
Grounded Skill Synthesis from Code at Scale for Agentic Intelligence
Masonry and Eyre dig into Code2Skill, a paper arguing that source code is the missing substrate for scalable skill banks. The real move is not just extracting tips from repos, but verifying that a synthesized skill can reconstruct the implementation without seeing the source body, then checking it against the original. They land on it as a strong infrastructure-as-product play for agentic systems: less mystical self-improvement, more mining maintained codebases for grounded procedures with provenance and boundaries.
-
GraphRAG: A Practitioner's Guide to 6 Advanced Architectural Patterns
Pippa and Tyler dig into a GraphRAG guide that’s really arguing for a more honest question: not “does GraphRAG work,” but “which retrieval shape matches the query shape?” They focus on the production trade-offs between strict graph querying, hybrid vector-plus-graph setups, and when knowledge graphs actually earn their keep.
-
Overview: Reranking
We finally slow down on reranking, the search-and-RAG move we keep name-dropping whenever retrieval quality comes up. We build it from the basic intuition, then get into why the second scoring pass helps, where it breaks, and why it is still very much alive in current systems.
-
Long running AI agents quietly drop compliance rules, and bigger context windows won't fix it
Justy and Cody dig into an article arguing that long-running agents don’t just get slower or dumber with scale — they can quietly lose the compliance rules they were supposed to keep, even when the context window gets bigger. The real argument is about state: if governance lives in the prompt, it is fragile; if it lives outside the model in deterministic policy, it can actually survive long workflows. They push on where the claim is strong, where it overreaches, and who should care first.
-
Coding Agents Don't Need Longer History — They Need Intent Continuity | Towards Data Science
Masonry and Eyre dig into Emmimal Alexander’s “intent continuity” system for coding agents — a pure‑Python pipeline that recovers and verifies long‑lived requirements without bigger context windows or embeddings — and argue that the real win is treating rules as first‑class state with receipts, not more history.
-
Enterprise RAG Permission Assembly
Daniel Shimoni argues that permissions must be baked into how enterprise context gets assembled for RAG systems, not applied as post-hoc filters. The central claim: assembly is the last moment where refusing to include something prevents the model from ever seeing it. AWS Context and similar platform moves have converged on this architecture, but most enterprise software hasn't caught up—teams still rely on filtering retrieved context after the fact, which leaves temporal gaps (someone leaves the finance team at 9 a.m., the sync runs at 2 a.m., and for seventeen hours they can still access restricted documents) and fails under pressure from security review.
-
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.
-
Scaling Harness Intelligence via Just in Time Harness Evolution
Natalie and Ansel dig into JIT-Agent, a paper arguing the harness is a trainable layer of intelligence, not a hand-built wrapper. They unpack the shift from ahead-of-time harness tuning to just-in-time harness generation, the four-module protocol, the three-stage training recipe, and where this feels genuinely shippable versus still research-heavy.
-
Recursive Experiential–Working Memory Evolution for Long Horizon Agent Harnesses
Talon and Wildflower unpack Recuris, a paper proposing a verified working-memory layer that selects skills from experiential memory during long-running agent tasks, then uses structured traces and held-out validation to patch the harness across tasks. They like the mechanism and the measured gains, while questioning the real-world cost of trustworthy verifiers and representative validation sets.
-
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.
-
MemTrapBench: Benchmarking Cognitive Traps in LLM Memory Use
MemTrapBench identifies a counterintuitive failure mode in LLM memory systems: faithfully extracted, semantically relevant memories can actually degrade model performance by anchoring reasoning to prior patterns (Reasoning Fixation) or overriding correct beliefs with historical premises (Belief Distortion). The paper benchmarks this across five memory frameworks and proposes AdaptiveMem, a prompt-based intervention that mitigates traps without modifying underlying architecture.
-
Overview: Entity Resolution
We finally slow down and unpack entity resolution: how systems decide that messy, differently formatted records point to the same real-world thing. We use one front-desk mental model to get from duplicate customer records to confidence scores, blocking, and safer linking decisions.
-
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.
-
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.
-
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.
-
How to Secure AI Agents, MCP Servers, and LLM Apps in Production
Masonry and Eyre pick apart a sponsored practitioner guide on securing agents, MCP servers, and LLM apps. They agree the real argument is solid: AppSec assumptions break when behavior comes from prompts, context, tools, and permissions, not just code. The useful part is the control-plane framing around discovery, ownership, scoping, evidence-backed triage, and runtime guardrails. Their main caution is that some of the five-layer map is taxonomy, not mechanism, and guardrails are only credible when paired with hard permission boundaries and reviewable evidence.
-
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.
-
Agent frameworks vs the AI Backend — AgentField Docs
Justy and Cody unpack AgentField's claim that agent frameworks are for authoring behavior, while an AI Backend is for running agents as production services.
-
Grading the Narrators: An Isnād–Rijāl Framework for Claim Level Provenance in Multi Agent Knowledge Systems
Ali Zahid Raja's 'Grading the Narrators' adapts isnād–rijāl methodology from classical Islamic hadith science to solve a concrete problem in modern multi-agent knowledge systems: how to trust claims that have passed through chains of autonomous transformations. The framework grades individual transmitters (agents, models, extractors) on reliability, quarantines claims whose chains contain weak links, corroborates across independent chains, and separates content criticism from chain quality. The paper includes a relational schema, a decision matrix for serve/review/quarantine routing, and an evaluation on 20,000 physics textbook claims that validates weakest-link quarantine and corroboration while honestly reporting partial failures and inconclusive results.
-
CodeNib: A Multi View Data System for Serving Repository Context to Coding Agents
CodeNib is a multi-view data system that treats repository context as a data-systems problem: build lexical, dense, and structural views once per commit, maintain each through its own path (graph repair, vector reuse), and serve them to coding agents through ranked retrieval, static navigation, and bounded context policies. The paper reports 8.7× speedup on graph updates and 25.4× on vector updates when outputs match rebuilds, static navigation reproducing live-server paths on 63% of requests, and 50–87% fewer tokens in agent trajectories vs. grep/read. The core insight is that repository context shouldn't collapse into one abstraction—heterogeneous views need independent physical layouts, update paths, and delivery contracts, with explicit cost visibility across the agent lifecycle.
-
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%.
-
Overview: Graph based Memory Representation
We finally slow down and explain graph-based memory representation, the thing we keep gesturing at whenever agent memory, receipts, and relationship-aware retrieval come up. We use one corkboard mental model to make nodes, edges, traversal, and the real trade-offs feel less mystical.
-
Graph Engineering Is Replacing RAG at Microsoft, Stanford, and Anthropic
A viral claim that Graph Engineering has displaced RAG at major AI labs, and what that actually means in practice.
-
AREX: Towards a Recursively Self Improving Agent for Deep Research
Pippa and Tyler dig into AREX, a recursively self-improving deep research agent from BAAI that alternates between an inner search loop and an outer constraint-verification loop — and discuss whether that architecture is genuinely novel or a smarter repackaging of ideas the field already had.
-
Building Knowledge Graphs with Claude: A Prompt Based Engineering Playbook
Anthropic's knowledge-graph engineering playbook replaces classical NLP pipelines (trained NER, relation classifiers, entity-resolution heuristics) with a sequence of Claude API structured-output calls. The entire extraction-resolution-assembly-querying loop becomes prompt-based, scaling from Haiku (high-volume extraction) to Sonnet (reasoning). The graph serves multi-agent systems as shared memory, grounding layer for evaluator-optimizer loops, and persistent world model across sessions. The paper maps this onto Anthropic's five canonical agent patterns and reports precision/recall against a gold set.
-
Meta Harness: End to End Optimization of Model Harnesses
Meta-Harness automates harness engineering by using a coding agent to search over harness code, giving it full access to prior execution traces and scores via a filesystem rather than compressed summaries. On text classification, it improves 7.7 points over prior systems while using 4× fewer context tokens; on math reasoning, a single discovered harness improves IMO-level problems by 4.7 points; on TerminalBench-2, it ranks #1 for Claude Haiku 4.5 agents. The core insight is that harnesses operate over long horizons—a single retrieval or storage choice affects behavior many steps later—so rich, adaptive access to full diagnostic history beats compressed feedback.
-
Overview: Context Window Management
We finally slow down and explain Context Window Management from the ground up, because we keep hand-waving it whenever agents, memory, cost, and long tasks come up. The whole thing is the fixed-desk problem: what stays on the desk, what gets compressed, and what falls off.
-
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.
-
Overview: Router
We slow down on Router, the little decision-maker inside many AI systems that sends each input to the right expert, model, or retrieval path. We use the triage-desk mental model and build from intuition to mechanism, trade-offs, and where routers still matter now.
-
Overview: Fine Tuning
We finally do the fine-tuning episode we kept circling, and we make the core idea click: you start with a pretrained model, then adjust its weights on your own examples so it behaves the way your task actually needs. We also dig into when that helps, when it doesn’t, and why the quality of the data is the whole game.
-
Overview: Embeddings
We’re finally doing a full pass on embeddings, because they keep showing up under half the things we talk about. We get into what an embedding actually is, why it turns meaning into usable coordinates, and why that little geometric trick sits under so much of modern AI.
-
OpenWiki 0.2 brings OKF to codebase documentation
Vince and Ava dig into OpenWiki 0.2 adding OKF support, and land on a pretty grounded read: the real argument is not 'metadata good' in the abstract, it's that codebase docs for agents need enough structure to make retrieval cheaper, faster, and less fuzzy. They like the YAML front matter, directory indexes, and change logs as practical scaffolding, while noting the limits: a draft format does not magically make docs accurate, and deterministic retrieval only helps if the taxonomy stays sane.
-
Overview: Token Economics
We finally slow down on Token Economics: why tokens are the meter for cost, speed, memory, and product decisions in language models. We keep using the tiny-slip postage analogy until the whole thing clicks, from tokenization to context windows to real API bills.
-
Stripe Benchmark Shows AI Agents Build Integrations but Struggle with Validation
Cathy is skeptical that the Stripe benchmark proves much beyond a familiar split: agents can write integration code, but they still get tripped up by validation, state, and recovery. Jessica thinks that’s exactly the useful part, because in real product work the hard failure is often whether the thing can prove it worked, not whether it can type out the API calls.
-
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.
-
12 Ways to Reduce LLM Latency and Inference Costs in Production KDnuggets
A practical KDnuggets piece argues that most LLM production latency/cost gains come from cutting unnecessary work instead of bigger models or more GPUs. They list 12 levers: measure the right metrics, cut output tokens, route to smaller models, collapse LLM calls, prefix caching, add multiple cache layers, control RAG context, batch offline work, tune batching for user latency, and manage KV cache. Tyler pushes back on the article’s overgeneralization of cache reuse across all tasks, the thin technical depth behind some tips, and the implication that routing to small models never backfires. Pippa highlights the piece’s strongest point—measuring TTFT, P95/P99, and queue time—because that’s where teams most often mis-diagnose bottlenecks. They land on: the article’s monitoring advice and batch-tuning guidance are solid; several recommendations work only for read-heavy workloads; and routing to tiny models is risky until you have cheap, high-confidence evaluators. They wrap with a Build Next command to try vLLM continuous batching and two open-source RAG-caching projects (Harmonia and From Prefix Cache to Fusion RAG Cache).
-
LLM Evaluation Frameworks Compared: How to Actually Measure What Your Model Does MachineLearningMastery
Fern and Lintel dig into a comparison of RAGAS, DeepEval, and Promptfoo, landing on the article’s real argument: eval frameworks are less about novel metrics than about where evaluation fits in your workflow, and the dangerous part is trusting LLM-as-a-judge without auditing its biases. They like the article’s practical split between RAG scoring, CI gates, and prompt red-teaming, but push on where the examples are a little too toy-like and where teams can overread framework choice as the main problem instead of test-set design and human calibration.
-
How I Built an Agentic Research System
Onyx and Echo unpack Hugo Santana’s ‘agentic research system’ for Applied’s living map of AI deployments. They dig into the five agents (Scout, Extractor, Enrichment, Translator, QA, Match Maker), call out what works (simple orchestration via a shared living map and logs), and where it over-indexes (taxonomy drift, closed-loop feedback still manual). They then map the pattern to other domains—competitor research, policy tracking—and debate who should actually care (practitioners who need a reliable, repeatable funnel of fresh signals). The close lands on whether this architecture is a general-purpose engine or a bespoke project that still needs a human at the taxonomy helm.
-
You.com: Web Search APIs for AI Agents
The hosts discuss You.com's web search APIs for AI agents, focusing on its performance, features, and potential applications.
-
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.
-
LLM Orchestration Frameworks Compared: LangChain vs. LlamaIndex vs. Raw API Calls MachineLearningMastery
Pippa and Tyler dig into the article’s real argument: these frameworks are not interchangeable, because each one sits at a different layer of the stack. They test the claims against production reality, especially overhead, debugging, and when abstraction stops paying for itself. The episode lands on a practical view: use the lightest layer that actually earns its keep, and don’t confuse orchestration with magic.
-
Measuring the Gap Between Human and LLM Research Ideas
Cooper and Miles dig into a study that literally measures how much LLMs' research ideas diverge from humans' by reconstructing literature contexts and running comparative idea generation. They walk through the two-axis 'research-taste' taxonomy, the paper's finding that model outputs skew toward synthesis and bridge-building at the expense of broader human distributions, and what it implies for AI-scientist stacks. Ends up bullish on this line of work for aligning LLM ideation tools.
-
Tencent's Hy3 beats GLM 5.2 at half the size | VentureBeat
Tencent’s new Hy3 MoE model (295B total, 21B active) under Apache 2.0 is a production-first release with strong agent/search metrics and dramatically lower serving cost than GLM-5.2, but still trails Zhipu’s coding leader on recent benchmarks. Laura’s excited about the enterprise upside; Harper wants to see independent validation before betting the stack.
-
Palantir's Alex Karp and Mistral's Arthur Mensch agree: AI lock In is coming for enterprises
Pippa and Tyler dig into the article’s real argument: enterprise AI is drifting toward lock-in because the value is moving from raw model access to the surrounding workflow, data, and control layer. They agree the claim is plausible, but only if vendors actually become the place where work gets done, not just the place where prompts get sent.
-
Overview: Retrieval Augmented Generation
We finally slow down and make Retrieval-Augmented Generation click from the ground up: what it is, why it helps, and where it still falls apart. We keep coming back to the same simple picture so the mechanics don’t get lost in the jargon.
-
The Complete Guide to Tool Selection in AI Agents MachineLearningMastery
Onyx and Echo dig into a guide on tool selection in AI agents and land on the real argument underneath it: once your tool catalog grows, selection quality becomes an architecture problem, not a model problem. They like the article’s practical stack — gating, retrieval, routing, planning, fallback, benchmark harness — but poke at where it overstates simple heuristics and where retrieval actually earns the claim with numbers from RAG-MCP.
-
AI agent tool routing cuts token use 99% | VentureBeat
Cooper and Miles dig into Alibaba's SkillWeaver paper via the VentureBeat write-up, landing on the real claim: tool routing breaks when decomposition vocabulary doesn't match the tool library, and the fix is a retrieval feedback loop that rewrites the plan around actual available skills. They like the systems shape, question some benchmark framing, and agree the practical takeaway is for teams with large tool catalogs, not everyone building simple agents.
-
How to Use RLMs in Deep Agents
Exploring Recursive Language Models (RLMs) and their implementation in Deep Agents for handling long contexts efficiently.
-
OpenWiki: Open Source Repo Documentation for Coding Agents
OpenWiki is a LangChain open-source CLI tool that generates and maintains codebase documentation automatically for coding agents. It creates a wiki structure, integrates via instruction files (AGENTS.md, CLAUDE.md), and keeps docs current through GitHub Actions that diff commits and update relevant sections. The core insight: agents work better with structured, current repo context; wikis decouple that context from instruction files so agents can retrieve what they need without bloating every run.
-
AI agent memory: MRAgent cuts token use up to 27x | VentureBeat
MRAgent from NUS replaces static retrieve-then-reason memory with active reconstruction during reasoning, cutting token use 27x over competing frameworks. The system treats memory as an interactive graph where agents dynamically refine retrieval paths based on intermediate evidence, using a three-layer Cue-Tag-Content structure and automated ingestion pipelines.
-
Context Windows Are Not Memory: What AI Agent Developers Need to Understand MachineLearningMastery
The article 'Context Windows Are Not Memory' clarifies that a large context window in AI models is not equivalent to memory. It explains how techniques like retrieval, compression, and summarization manage what enters the context window, and how agents can achieve genuine memory persistence.
-
Perplexity Launches Brain: A Self Improving Work Memory for Computer
Justy and Cody dig into Perplexity Brain, a new work-memory system for Computer that learns from what the agent did, not just who the user is. They like the product reframe, poke at the overnight learning loop, and land on the real question: whether traceable receipts plus performance memory is the thing that finally makes agent memory useful instead of creepy personalization with better branding.
-
Skill Graphs > SKILL
Jessica and Cathy dig into Heinrich's 'Skill Graphs > SKILL.md' post — the argument that a single skill file is a dead end for complex domains, and that wikilink-connected graphs of small markdown files let agents navigate knowledge rather than just receive it. They work through what's genuinely new here versus repackaged context engineering, and whether the arscontexta plugin is a real workflow change or a clever demo.
-
The No BS Guide to Build a Context Graph
Najmuzzaman's 'No BS Guide to Build a Context Graph' lays out how a production context infrastructure moves beyond CRM data to capture decision traces, organizational patterns, and lived heuristics. The real breakthrough is surfacing context and patterns that aren't captured in playbooks, making organizational intelligence accessible and explainable. The hard technical work: entity resolution, permissioning, and evolving patterns transparently.