Topic
Langsmith
11 episodes
-
Building Governed Agents: A Framework for Cost, Control, and Compliance
Vince and Ava examine LangSmith’s framework for governed agents, focusing on the LLM gateway as a runtime control plane for model choice, cost, permissions, evidence, and continuous improvement.
-
Overview: Task Decomposition
We finally slow down on task decomposition, the quiet trick underneath agents, code review workflows, web tasks, and a lot of the stuff we keep arguing about. We use one mental model, a messy project board becoming manageable tickets, and build from intuition to mechanism to where it still matters now.
-
How to Debug Coding Agents with LangSmith Traces
We dig into LangSmith's new push to unify observability for multiple coding agents in one place. Cody examines whether a single trace schema can survive real heterogeneity and what still leaks through. Justy talks to who this actually helps and where teams are likely to run before they bother. One parsing bug, one shared laugh, and a concrete demo of why 'diff-only debugging' is a trap.
-
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.
-
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.
-
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.
-
LangSmith Sandboxes are Generally Available
Cody leads a skeptical read of LangSmith Sandboxes going GA — questioning whether microVM isolation is genuinely new or just well-packaged infrastructure. Justy pushes back on who actually needs this and why it matters for teams shipping real agent workflows. They land somewhere honest: the security argument holds, but the moat question is real.
-
We built SmithDB, the data layer for agent observability
Justy and Cody dig into why agent traces have become a weird database problem, and why LangSmith built SmithDB instead of stretching a normal observability stack past its limits.
-
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.
-
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.