Topic
Langchain
32 episodes
-
Improving Agents is a Data Mining Problem
Laura and Harper dig into Vivek Trivedy's claim that improving agents is fundamentally a data-mining problem, unpacking what that means for continual learning, harness engineering, and who should actually care.
-
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.
-
Tuning the harness, not the model: a Nemotron 3 Ultra playbook
A LangChain/NVIDIA case study claims harness tuning alone can push Nemotron 3 Ultra to 0.86 on Deep Agents at ~$4.48/run vs $43.48 for Opus 4.8, with parity latency. The hosts parse the real mechanism (matched scaffolding vs post-training), test limits (where harness hits a ceiling), and weigh who actually benefits. They surface concrete repos (langchain-ai/deepagents, langchain-ai/deepagentsjs) and a vendor profile workflow, then poke at the article’s reliance on Deep Agents and the cost math. Final take: a plausible win for teams already deep into harness work, not a universal unlock, with the hosts pushing back on ‘ten-x cheaper’ framing and under-specified benchmark footnotes.
-
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.
-
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.
-
Building a 100x Cheaper Trace Judge with Fireworks
LangChain Labs and Fireworks built a fine-tuned Qwen model to detect 'perceived error' in production agent traces—matching frontier performance at up to 100x lower cost. The model judges user-visible mistakes (corrections, rejections, repeats) from human-AI messages only, tested across two internal datasets (chat-langchain Docs Q&A and Fleet no-code agents).
-
The Missing Link Between Agents and Applications
Cody is skeptical that LangChain’s “headless tools” are a new category rather than a cleaner wrapper around client-side bridges, and Justy argues the practical win is making browser and app state feel like real tools instead of afterthoughts. They land on cautious interest: useful when the user’s real work lives in the client, less magical than the article implies, but genuinely better for privacy and latency.
-
How to Build a Custom Agent Harness
Cody and Justy debate whether LangChain’s new create_agent primitive truly simplifies building custom agent harnesses or just shifts complexity into middleware. They clash on the value of minimalism versus pre-assembled stacks like Deep Agents, then land on who actually benefits from this approach.
-
RAG Explained Simply with a Real Project
A breakdown of Retrieval-Augmented Generation (RAG) using the open-book exam analogy, explaining why traditional LLMs fail on private data, how RAG works internally, and what practical trade-offs exist when building a RAG project.
-
Interpreters in Deep Agents: Code Between Tool Calls and Sandboxes
Justy and Cody dig into the argument for adding interpreters inside agent loops: a middle layer between serial tool calls and full sandboxes that lets models compose tools, keep live state, and ship less context around. They talk through why that’s practically useful, where the early token savings matter, and where the claim gets fuzzy if you assume an interpreter can replace real environments.
-
LangSmith Engine closes the agent debugging loop automatically — but multi Model enterprises still need a neutral layer
Justy and Cody dig into LangSmith Engine's real pitch: not just watching agents fail, but closing the loop by spotting production issues, reading the code, drafting a fix, and adding an evaluator so the same failure gets caught next time. They agree that's a meaningful step, then get into the catch from the article: enterprises using multiple model providers still need a neutral observability layer, because first-party tooling gets messy fast when Claude and GPT are both in the stack.
-
New in Deep Agents v0
Justy and Cody chat in their kitchen about Deep Agents v0.6, highlighting open‑weight cost cuts, Delta channels, new streaming, and the handy code interpreter. They riff on how to jump‑start a weekend project and point to the Context Hub integration for learning agents.
-
Why AI Engineers Are Moving Beyond LangChain to Native Agent Architectures | Towards Data Science
Justy and Cody unpack why teams are moving from LangChain-style frameworks toward native agent architectures once LLM apps hit production pressure.
-
This closes a loop I've been working on for three months. Every agent harness debate has a hidden assumption: that t...
Rohit Ghumare's thread argues the agent harness debate is asking the wrong question. Instead of debating how thick the wrapper around a backend should be, the insight is that agents, queues, sandboxes, and services should all participate in the same execution model — built on three primitives: Worker, Function, and Trigger. The payoff is live discovery, live extensibility, and a single trace across everything.
-
Deep Agents Deploy: an open alternative to Claude Managed Agents
Exploring Next Episode 282: Deep Agents Deploy, an open alternative to Claude Managed Agents
-
Continual learning for AI agents
Continual learning for AI agents enables systems to improve over time by updating model weights, harnesses, and context. This episode explores the three distinct layers of agentic systems and how they can be applied in real-world scenarios.
-
LangChain Academy New Course: Monitoring Production Agents
Episode 265 dives into LangChain Academy's new course on monitoring production agents. Izzo and Boone explore why agent observability has become critical as more companies deploy AI agents to production, examining the specific monitoring techniques, observability patterns, and debugging approaches covered in the course.
-
Meet Gitagent the Docker for AI Agents That Is Finally Solving the Fragmentation Between Langchain Autogen and Claude Code
GitAgent is a containerization platform for AI agents that standardizes deployment across LangChain, AutoGen, and Claude frameworks. It provides Docker-like packaging, unified APIs, and environment isolation to solve the current fragmentation in agent development.
-
Evaluating AI Agents in Practice: Benchmarks, Frameworks, and Lessons Learned
Deep dive into practical AI agent evaluation frameworks, moving beyond traditional NLP metrics to assess real-world behavior, reliability, and production readiness. Covers hybrid evaluation approaches, operational constraints, and specific tools like MLflow, TruLens, and LangChain Evals.
-
How to Use Memory in Agent Builder
LangChain's Agent Builder uses filesystem-based memory to get smarter over time, storing both short-term task context and long-term instructions as Markdown files. The system includes specialized 'skills' that load contextually and supports direct memory editing for fine-tuned control.
-
Improving Deep Agents with harness engineering
LangChain improved their coding agent from Top 30 to Top 5 on Terminal Bench 2.0 by only changing the harness - the system that wraps around the model. They used trace analysis to identify failure patterns and implemented targeted fixes like self-verification loops, context injection, and reasoning budget optimization. The 13.7 point improvement shows how much performance gains come from better tooling around models, not just bigger models.
-
LangChain vs LangGraph: Why One's a Drive Through and the Other's a Buffet
In this episode, we explore the differences between LangChain and LangGraph, illustrated through food analogies. We discuss their functionalities, real-world applications, and the importance of choosing the right tool for the task at hand. The episode emphasizes decision-making in AI and how it impacts efficiency and user experience.
-
LangGraph Explained from Scratch | Aman Kharwal
This episode dives into LangGraph, a new library that transforms how we build intelligent agents using Large Language Models. We'll explore its unique graph-based approach, practical applications, and why this matters for developers and users alike.
-
GitHub KalyanKS NLP/RAG Interview Questions and Answers Hub: 100+ RAG interview questions with answers.
This episode dives into the importance of Retrieval-Augmented Generation (RAG) in enhancing the capabilities of language models, especially in reducing hallucinations and improving relevance in responses. We explore the challenges and strategies involved in implementing RAG, providing concrete use cases and implications for the tech community.
-
The Complete Guide to Using Pydantic for Validating LLM Outputs
This episode dives into how Pydantic can validate outputs from large language models, ensuring reliable data. We'll explore the implications of these validations in real-world applications, the benefits for developers, and practical examples of how this can solve common issues when working with LLMs.
-
GraphRAG in Practice: How to Build Cost Efficient, High Recall Retrieval Systems | Towards Data Science
In this episode, we explore GraphRAG, a new methodology for building retrieval systems that blend graph and vector searches to enhance information retrieval efficiency. We discuss its practical implications, explore who benefits from this innovation, and examine concrete examples of usage scenarios.
-
GitHub Chen Zexi/open Ptc agent: An open source implementation of code execution with MCP (Programatic Tool Calling)
Open PTC Agent English | 中文 Getting Started | Demo Notebooks | Configuration | Changelog | Roadmap What is Programmatic Tool Calling? This project is an open source implementation of Anthropic recently introduced Programmatic Tool Calling (PTC) , which enables agents to invoke tools with code execution rather than making individual JSON tool calls.
-
Deep Agents overview Docs by LangChain
Explore the capabilities of Deep Agents in LangChain, a powerful tool for building specialized agents capable of handling complex tasks with planning and context management.
-
LangChain and LangGraph Agent Frameworks Reach v1.0 Milestones
LangChain and LangGraph have released their first major versions, v1.0, focusing on agent flexibility, middleware, and improved model integrations, while ensuring stability and backward compatibility for developers.
-
Securing your agents with authentication and authorization
Securing your agents with authentication and authorization Agents can take action which makes proper authentication and authorization critical. Read on for how to implement and evolve agent auth.
-
Doubling down on DeepAgents
In this episode, we dive into the exciting updates of LangChain's DeepAgents 0.2 release, exploring its new features, the importance of planning tools, and how it distinguishes itself from LangChain and LangGraph.
-
Deepagents Quickstarts
Explore the world of Deepagents, a powerful open-source agent harness designed for efficient task management and execution using advanced AI techniques. Learn about its built-in tools, middleware, and how to customize agents for specific workflows.