What makes modern AI agents actually useful in the real world? In this video, Kwasi Ankomah of SambaNova breaks down one of the biggest shifts in AI right now: The move from simple, shallow agents to more capable deep agents that can plan, use tools, manage memory, and handle complex tasks over longer time horizons. He opens with an introduction to SambaNova as a full-stack AI company built around custom silicon, fast inference, and agentic AI workloads, then shares how the company’s new SN50 chip is designed to deliver the low-latency, high-throughput performance these systems need. For anyone trying to understand where AI agents are headed, this session offers a strong foundation.
What makes modern AI agents actually useful in the real world? In this video, Kwasi Ankomah of SambaNova breaks down one of the biggest shifts in AI right now: The move from simple, shallow agents to more capable deep agents that can plan, use tools, manage memory, and handle complex tasks over longer time horizons. He opens with an introduction to SambaNova as a full-stack AI company built around custom silicon, fast inference, and agentic AI workloads, then shares how the company’s new SN50 chip is designed to deliver the low-latency, high-throughput performance these systems need. For anyone trying to understand where AI agents are headed, this session offers a strong foundation.
TL;DR
-
Deep agents differ from shallow agents in three ways: extended reasoning, the ability to spawn subagents, and access to a file system. Together those let them run far more complex tasks than a simple ReAct loop with a single tool call.
-
Coding agents are the first deep agents to reach mass adoption, which makes their architecture the blueprint worth learning from.
-
Most custom agents fail for four reasons: context collapse over multi-step tasks, no planning, tools that break, and no way to evaluate whether the output is correct.
-
Five pillars make agents reliable: orchestration, memory, tools, evaluation and agent skills, all demonstrated in a live LangGraph build with Langfuse traces.
Why coding agents took off, and why custom agents fail
A major focus of the video is the rise of coding agents and why they have become one of the first clear examples of AI agents reaching mass adoption. Kwasi explains why tools like Claude Code, Cursor, Windsurf, and Codex are gaining traction with both developers and non-technical users. He also explores why many custom agents still fail, pointing to common issues like context collapse, weak planning, broken tool use, and poor evaluation. From there, the session shows what coding agents get right, especially through the use of a strong harness that brings together memory, tools, evaluation, and reusable skills to make agents more reliable and more effective.
The five pillars of reliable agents
The video also introduces the 5 pillars of reliable agents: orchestration, memory, tools, evaluation, and agent skills. These ideas are explained in plain language, making the content approachable even if you are still early in your agent-building journey. Kwasi walks through concepts like the ReAct loop, state management, context offloading, file systems, tool ecosystems, and observability, helping viewers see how deep agents operate behind the scenes. He also highlights why skills matter, showing how plain-language instructions can become reusable capabilities that extend an agent’s value without adding unnecessary code complexity.
A live build in LangGraph
What makes this session especially useful is its practical, hands-on approach. Rather than staying at a theory level, the video moves into a live demo using LangGraph, SambaCloud, MiniMax, Tavily, and Langfuse to show how an agent can reason, act, observe, use tools, track to-dos, write files, and expose its state through traces. This gives viewers a clear look at how real agentic systems are built, tested, and monitored. The walkthrough makes it easier to connect the architectural ideas to working code, while also showing how observability and evaluation help teams improve agent performance before and after deployment.
Who this session is for
For developers, architects, and business teams exploring agentic AI, this video is a valuable starting point. It combines strategic context with practical implementation and ties it back to SambaNova’s platform, including fast inference, accessible cloud tools, developer resources, and infrastructure built for the demands of deep agents. If you want to better understand coding agents, learn the building blocks of reliable agent systems, and see how SambaNova can support faster and more efficient AI development, this session is well worth watching.
FAQs
A deep agent is an AI agent with three capabilities that shallow agents lack: extended reasoning, the ability to spawn subagents, and access to a file system, whether that is real, virtual, or held in the agent’s memory. Those three together allow sophisticated planning and reflection across complex, multi-step tasks, rather than the single LLM call plus one tool execution that characterized early agents.
Four patterns account for most failures. Context collapse, where context accumulates over multi-step tasks until the agent loses track of what matters. No planning, so the agent wanders without a structured approach. Tools that break. And no way to evaluate whether an output is correct, which is why evaluation is treated as a day zero requirement rather than something added later.
Orchestration, or how a complex task is decomposed. Memory, so the agent persists what it has done and where it went wrong. Tools, the external capabilities and integrations that let it act. Evaluation, to measure performance and catch drift in production. And agent skills, which run across all four as reusable, composable instructions.
Tools are written as code and declared through a decorator. Skills are written in plain text as markdown files, which makes them accessible to non-technical users who can describe a standard operating procedure in plain English. Skills supplement tools rather than replacing them. The key practical difference from a reusable prompt is that a skill is retrieved on demand only when the agent decides it needs it, so it does not consume context on every turn.