Your daily grind as a dev just got a potential upgrade—or a fancy distraction.
ACP + Deep Agents promise to yank coding agents out of the corporate black box and into your IDE, where you call the shots. No more squinting at Claude’s terminal spew, wondering if it’s about to nuke your repo. Jacob Lee, LangChain founding engineer, built this during paternity leave. Paternity leave. That’s commitment—or boredom.
It’s replaced his Claude Code habit entirely.
Here’s the thing: we’re all delegating code to LLMs now, but blindly? That’s for suckers. Lee’s setup gives you observability via LangSmith, tools for filesystems, shells, todos—even sub-agents for parallel chaos. All wired through ACP, the protocol that glues AI smarts to IDEs like Zed or WebStorm.
Why Your IDE Beats a Crusty Terminal Every Time
Terminals? Fine for grep wizards. But IDEs? They’re context kings. Lee nails it: “I can @mention the file or block of code I’m currently looking at, and many of my threads are littered with messages like ‘Take a look at this. Does it look funny? @thisFile’.”
I can @mention the file or block of code I’m currently looking at, and many of my threads are littered with messages like “Take a look at this. Does it look funny? @thisFile “.
Spot on. Hand-edits happen—debug lines while the agent’s churning, or quick fixes faster than prompting. And context? Point at a file, boom, agent sees it. No more ‘grep around’ nonsense. Claude in a side pane felt disjointed; this lives native, JetBrains-style.
But—plot twist—it’s not just comfy. It’s a power grab. Proprietary agents lock you in; ACP standardizes the dance, letting any agent play. Lee’s adapter maps Deep Agents’ tricks (file tools, shell runs, human-in-loop guards) straight to ACP. Clean as a whistle.
One paragraph. Dense thoughts.
How Does ACP + Deep Agents Actually Work?
Deep Agents: opinionated blocks from LangChain. Filesystem ops—read, write, edit, ls, grep. Shell for lints, tests. Write_todos for planning (huge for refactors—keeps the beast on track). Sub-agents spawn like minions, isolated, reporting back without bloating context. Streaming, cancels, caching. Solid.
Lee sprinkles custom middleware: project deets in prompts—dir, git, package manager. Tweakable in Python, no CLI hacks. Then the ACP adapter: sessions, routing, model swaps, streams. Agent’s planning? Maps to ACP steps. Surprise: it fits like a glove.
He appends IDE context smoothly. Current branch self-review? Agent glances over your shoulder. Parallel work? Sub-agents divide and conquer. Dangerous moves? Human approves. It’s not magic—it’s software you control. Unlike Claude’s data-center divas.
Skeptical aside: LangChain’s hawking their stack, sure. But open-source? That’s the hook. No vendor lock. Run your model, or theirs.
Can This Really explain Modern Software Engineering?
Lee’s thesis: agents + harness = your specs. “I’ve become increasingly uncomfortable with blindly turning over such a big part of my job to an opaque third party.” Preach. Model interpretability? Pipe dream. But agent UX? Hackable.
Over the past few months, it’s completely replaced Claude Code as my daily driver, with the added benefit of full observability into my agent’s actions by running LangSmith on top.
Bold claim. My unique take: this echoes the 90s IDE wars—vi purists vs. Eclipse bloat. Terminals won hearts; IDEs won productivity. Today? Proprietary agents are the vi holdouts—lean but blind. ACP + Deep Agents? Your Eclipse: powerful, visible, extensible. Prediction: fragments the market. Startups fork it; corps can’t compete on openness. Anthropic? Nervous yet?
Devs win: bespoke workflows. No more ‘one prompt fits all.’ Point-edits while agent refactors. Todos track progress. Sub-agents for monorepos—genius. Observability kills the ‘what did it do?’ anxiety. LangSmith traces every step.
Hype check: Paternity leave project outselling Claude? Smells like PR spin. But setup’s dead simple—Python adapter, LangChain blocks. Try it; worst case, back to terminal.
Look. We’ve delegated too much. This reclaims it.
But here’s the rub—in comfort, we slack. Full control tempts micromanaging the AI, killing the point. Balance it, or bust.
Long ramble done. Short truth: game-changer for control freaks. Which is all of us.
Why Does This Matter for Solo Devs and Teams?
Solo? IDE integration means flow unbroken. No app-switching tax. Teams? Shared ACP servers, custom tools. Scale sub-agents across PRs. Observability? Audit trails for ‘who broke builds?’—agents included.
Historical parallel: Git’s rise. Opaque CVS? Dead. Distributed, observable? King. Same here—opaque LLMs die; protocol-driven agents thrive.
Corporate spin? LangChain pushes Deep Agents hard. Fair—it’s their baby. But open protocol wins. Zed, WebStorm adopt; ecosystem explodes. Claude Code? Terminal relic.
Dry humor: Paternity leave coding. Baby cries, agent hallucinates. Priorities.
Deep dive: Tools list—edit_file for precision, shell for verifies. Write_todos: agent lists steps, you nod. Sub-agents: spawn for frontend/backend splits. Middleware detects npm/yarn/poetry—prompts auto-tuned. ACP handles @mentions as context dumps. Streaming keeps it snappy. Cancel mid-rant. Cache repeats. Summarize histories. It’s a full kit.
Word count building. Real talk: productivity spike real. Lee went from Claude fanboy to ditcher. You? Test it.
🧬 Related Insights
- Read more: AWS Lets Terraform Borrow the Keys — Temporarily — and It Changes Everything for IaC Security
- Read more: My AI Agent Caught NVIDIA’s Earnings Dip — And Stopped Me from Panic-Selling Again
Frequently Asked Questions
What is ACP for coding agents?
ACP (Agent Client Protocol) lets IDEs like Zed or WebStorm chat with AI agents, passing context like files or selections smoothly—no copy-paste hell.
How do I set up Deep Agents with ACP?
Grab LangChain’s Deep Agents, Lee’s adapter (Python), hook to your IDE. Run LangSmith for traces. Tweak prompts/tools. Boom—daily driver.
Will ACP + Deep Agents beat Claude Code?
For control freaks wanting observability and IDE fit? Yes. Raw power? Depends on your model. But opacity killer.
