Many of my previous and even some current projects and new features were deeply developed using vLLM’s OpenAI Completion API or various model providers’ SDKs. I even wrote numerous strategy patterns to integrate different modalities. For example, in a robot’s real-time interaction scenario, the robot needs multi-modal capabilities: after voice interaction, it pushes to a semantic model for reasoning, uses different sub-agents to trigger modal tasks for different scenarios — calling a vision model on vLLM when video understanding is needed, and combining outputs from different modal contexts as a single task output when TTS is required.
I was relatively early in adopting LangChain, and I did use it for development at the time. But I later found that using the OpenAI SDK or Completion API directly was even more streamlined and flexible. When LangGraph came along, I only briefly looked at its logic and felt the learning curve was a bit steep, so I didn’t dive deep into it. My projects already had logic similar to LangGraph, though the level of implementation varied across projects. Looking back now, the code and structure of those projects appear quite messy.
Here’s a simple example: my tasks were previously all triggered through MCP, including structured outputs, tool calling, and even context integration. When I needed to ask the agent about my meeting records from recent days, it would call a time tool, query the database (either vector search or inverted index), then orchestrate and integrate the outputs from different tools with deep-thinking context before responding. When multiple tasks came in simultaneously, I had the concept of sub-agents, but unlike Deep Agents where each sub-agent has its own isolated context, all my agents shared a single context, managed through key-value numbered asynchronous operations. At the same time, to achieve different state effects, I designed an instance-level variable orchestration state machine. The state transitions were often just to escape async callback hell!
As the number of projects grew, many problems surfaced. The code structure I wrote at the time was overly complex — or rather, chaotic — violating the original intention of keeping things simple (even though it was flexible).
Now, with new technologies like skills and AI coding, I’ve tried them myself and found the results quite good. I also noticed Deep Agents and realized it was exactly what I needed — both now and before!
I recently started using Deep Agents in my projects, and the results have been excellent. I no longer need to reuse my messy legacy code. After a brief look at the Deep Agents package source code, I noticed that when you use synchronous calls externally, it internally resolves the blocking issue through a thread pool. The code logic is also very elegant.
Using Deep Agents, I quickly built a streamlined yet flexible AI coding tool combined with vLLM (using ChatOpenAI) — just like Claude Code.
What I want to say is: Deep Agents fulfilled my dream of rapid development, haha.
Can I dive directly into the Deep Agents source code to learn? Or should I first study LangGraph in depth?
When was Deep Agents released? It’s truly a remarkably “fast” package.
