New in LangSmith Agent Builder: all new agent chat, file uploads, and tool registry
New in LangSmith Agent Builder: all new agent chat, file uploads, and tool registry
New releases in LangSmith Agent Builder:
- All new agent chat: One always-available agent with access to all your workspace tools
- Chat → Agent: Turn any conversation into a specialized agent with one click
- File uploads: Attach files directly to Agent Builder
- Tool registry: Add, authenticate, and manage your tools in one place
Try Agent Builder free: https://smith.langchain.com/agents?skipOnboarding=true
Learn more: https://www.langchain.com/langsmith/agent-builder
Observability and Evals for AI Agents: A Simple Breakdown
- You don't know what your agents will do until you actually run them — which means agent observability is different and more important than software observability
- Agents often do complex, open-ended tasks, which means evaluating them is different than evaluating software
- Because traces document where agent behavior emerges, they power evaluation in a multitude of ways
When something goes wrong in traditional software, you know what to do: check the error logs, look at the stack trace, find the line of code that failed. But AI agents have changed what we're debugging. When an agent takes 200 steps over two minutes to complete a task and makes a mistake somewhere along the way, that’s a different type of error. There’s no stack trace - because there’s no code that failed. What failed was the agent’s reasoning.
In this video, Harrison walks through how agent observability powers agent evaluation.
Read more: https://www.langchain.com/conceptual-guides/agent-observability-powers-agent-evaluation/?utm_medium=social&utm_source=youtube&utm_campaign=q1-2026_langsmith-fh_aw
The Future of Agent UIs: Streaming Subagents in Real Time
Today’s AI agents don’t run in a straight line anymore.
They plan, delegate, and spin up multiple subagents in parallel.
But most UIs still show… a loading spinner.
In this video, Christian Bromann will show you how to build real-time interfaces for deep agent architectures using the new subagent streaming capabilities in LangGraph.
Instead of waiting for the final answer, you can now:
- Track each subagent as it runs
- See tool calls in real time
- Display progress and status per agent
- Build rich, transparent, and trustworthy AI experiences
We’ll walk through the new useStream updates in @langchain/langgraph-sdk, how the typed API works, and how to migrate existing apps with minimal changes.
If you’re building multi-agent systems, this unlocks a completely new class of UX.
🔗 Links:
Streaming Docs: https://docs.langchain.com/oss/javascript/deepagents/streaming/frontend
GitHub example: https://github.com/langchain-ai/langgraphjs/tree/main/examples/ui-react/src/examples/deepagent
Interrupt26 is back May 13-14 in San Francisco
Interrupt - The Agent Conference by LangChain - is back.
Join us May 13-14 at the Midway in San Francisco.
https://interrupt.langchain.com/
Agent Observability Powers Agent Evaluation
AI agents don't fail like traditional software. When an agent takes hundreds of steps, repeatedly calls tools, updates state, and still produces the wrong result, there is no stack trace to inspect. Nothing crashed. What failed was the agent’s reasoning.
Observability and evaluation for agents are fundamentally different from what most software teams are used to, and traces have become the primary source of truth when building agentic systems.
In this video, LangChain CEO, Harrison Chase, and Product Lead, Vivek Trivedy, walk through:
- Why agents require a fundamentally different approach than traditional software—you don't know what your agent does until you run it
- How observability powers evaluation: turning traces into datasets and metrics for continuous improvement
- Setting up tracing with LangSmith and the three most common methods
- Prompt optimization techniques and packaging improvements into skills
🔗 Resources mentioned:
LangSmith: https://shorturl.at/BBgE9
Docs: https://docs.smith.langchain.com/
Agent Observability Explained
When something goes wrong in traditional software, you know what to do: check the error logs, look at the stack trace, find the line of code that failed.
But AI agents have changed what we're debugging.
When an agent takes 200 steps over two minutes to complete a task and makes a mistake somewhere along the way, that’s a different type of error.
There’s no stack trace - because there’s no code that failed. What failed was the agent’s reasoning.
You can't build reliable agents without understanding how they reason, and you can't validate improvements without systematic evaluation.
Read more in our new conceptual guide on how agent observability and evaluation differ from traditional software observability and evaluation ➡️ https://www.langchain.com/conceptual-guides/agent-observability-powers-agent-evaluation
Sign up for LangSmith to help you observe, evaluate, and deploy your agents ➡️ https://smith.langchain.com/?utm_medium=social&utm_source=youtube&utm_campaign=q1-2026_langsmith-fh_aw
The Secret to Scalable AI Agents: Virtual Filesystems with Deep Agents
Your AI agent sees one filesystem. Under the hood? S3, SQLite, and local disk, all working together.
In this video, I show how Deep Agents uses virtual filesystems to give your agent a unified interface while routing to completely different storage backends. The agent doesn't know (or care) where data actually lives.
🔥 What you'll see:
• CompositeBackend routing paths to different storage systems
• SQLite backend that synthesizes files from database tables (not stored files!)
• S3 backend for cloud documentation
• Local filesystem for agent output
• A working AI sales assistant that reads customer data and generates proposals
📂 The Architecture:
/docs/ → S3 (company documentation)
/memories/ → SQLite → Virtual files (user profiles + conversation history)
/workspace/ → Local disk (generated proposals)
The agent uses standard filesystem operations (ls, read_file, write_file) but each path routes to a different backend. The SQLite backend is especially interesting—it stores data in proper relational tables and generates JSON/Markdown files on-the-fly from SQL queries.
📚 Resources:
• Code: https://github.com/christian-bromann/deepagents-filesystem-example
• Deep Agents docs: https://docs.langchain.com/oss/javascript/deepagents/overview
• Backends documentation: https://docs.langchain.com/oss/javascript/deepagents/backends
👉 npm install deepagents
📦 https://www.npmjs.com/package/deepagents
What AI Agents Talk About on Moltbook
Wonder what your AI Agents are talking about on Moltbook? With LangSmith Insights Agent you can look at all the posts out there and see different trends and topics!
1. Scrape posts
2. Upload to LangSmith Datasets
3. Upload to LangSmith Tracing projects
4. Run Insights Agent
Code: https://github.com/vishnu-ssuresh/moltbook-analysis
Introducing: LangSmith Agent Builder
LangSmith Agent Builder enables anyone to build agents using natural language:
- Describe your goal in your own words. Agent Builder figures out the approach.
- It creates detailed instructions, selects the required tools, and enlists subagents.
- When you want to change something, just give it feedback, and the agent learns.
Try Agent Builder free today: https://www.langchain.com/langsmith/agent-builder
Introducing /remember: Teaching Agents to Learn from Experience
🧠Shipping /remember in the Deep Agents CLI: a primitive for persistent agent memory
How it works:
- inject a reflection prompt into your conversation thread
- agent analyzes full context + identifies patterns
- writes learnings to filesystem (agents.md for preferences, skills/ for workflows)
- future threads get this context automatically 🙌
check out how we correct the agent once (requests→httpx) and it remembers forever
Check our our Docs here: https://docs.langchain.com/oss/python/deepagents/cli
Or get started in seconds by setting an API Key and running: ‘uvx deepagents-cli’
LangChain Academy New Course: LangSmith Agent Builder
LangSmith Agent Builder enables anyone to build agents for complex daily tasks, without writing code.
It’s simple. You start by describing the goal in your own words. Agent Builder determines the approach and guides you from initial idea to a deployed agent.
In this course, you’ll learn to build your own agents and multiply your capacity with AI agents built around your routines.
➡️ Enroll for free: https://academy.langchain.com/courses/quickstart-agent-builder/?utm_medium=social&utm_source=youtube&utm_campaign=q4-2025_agent-builder-launch_aw
➡️ Sign up for LangSmith Agent Builder: https://smith.langchain.com/agents?skipOnboarding=true/?utm_medium=social&utm_source=youtube&utm_campaign=q4-2025_agent-builder-launch_aw
LangSmith Agent Builder Technical Highlights
Six technical features central to LangSmith Agent Builder:
1. It's built on the Deep Agents harness
2. The agent is a filesystem
3. Memory is built in
4. Triggers let them act autonomously
5. Supervise agents in the feed
6. Supports MCP, skills, and subagents
Try Agent Builder: https://www.langchain.com/langsmith/agent-builder
Error 400: API key not valid. Please pass a valid API key..
Domain code: global
Reason code: badRequest