Everyone's building agents. Most are demos. Here's what teams are actually shipping to production—and what's still just Twitter hype.
What's working, what's breaking, and what's worth trying. No hype.
Join 700+ agent builders · Unsubscribe anytime
✓ You're in. See you Thursday.
Let's be honest: 90% of production "agents" are really just LLM chains with some tool calls. True autonomous agents that plan, execute, and recover from errors? Still rare outside demos.
That's not a bad thing. Chains are reliable. Agents are unpredictable. Most business problems are better solved by a well-designed chain than a fancy autonomous loop.
Here's how to think about it:
If you're building something serious, this is probably what you want. LangGraph lets you define agent workflows as graphs—nodes are actions, edges are transitions. You get explicit control over the flow while keeping the flexibility to branch and loop.
The key insight: it's a state machine for LLM apps. You can checkpoint, resume, and debug. When something fails, you know exactly where.
Used by: LinkedIn, Uber, Elastic, and a lot of YC companies. The LangChain ecosystem means tons of integrations.
Multi-agent framework where you define "agents" with roles, goals, and backstories. They collaborate on tasks like a team. Sounds gimmicky, but the role-based prompting actually works well for complex workflows.
Think: researcher agent finds info, writer agent drafts content, editor agent reviews. Each has clear responsibilities. Less prompt engineering, more org design.
researcher = Agent(role="Researcher", goal="Find accurate data")
writer = Agent(role="Writer", goal="Create clear content")
crew = Crew(agents=[researcher, writer], tasks=[...])
Good for: content pipelines, research workflows, anything where "team of specialists" is a natural mental model.
OpenAI's answer to LangChain. Assistants API with function calling, code interpreter, file handling. If you're all-in on OpenAI models, this is the path of least resistance.
The ChatGPT "Apps" (Spotify, Gmail, Photoshop integrations) are built on this. Tight integration with OpenAI's models, but you're locked in.
Function calling Code interpreter File handlingTradeoff: easiest to start, hardest to switch away from. Good for prototypes, think twice for production.
Microsoft's multi-agent framework. Good for research, complex for production. Being merged into Microsoft Agent Framework (coming 2026).
Docs →Best if you're doing RAG. Query engines, document understanding, knowledge bases. Less general-purpose than LangGraph.
Docs →Model Context Protocol. Standard for connecting LLMs to tools. Not a framework—a protocol. Growing ecosystem.
Docs →Microsoft's enterprise SDK. Good C# support. Being merged with AutoGen. If you're in Azure, worth considering.
Docs →The "give it a goal and walk away" dream. Manus, Devin, AutoGPT—exciting demos, but production usage is limited. Error recovery is hard. Costs spiral. Reliability isn't there yet.
That said, it's improving fast. Worth experimenting, not worth betting your product on.
Hundreds of agents collaborating on complex tasks. Great for papers and Twitter threads. In practice, 2-4 specialized agents usually beat a swarm. Coordination overhead kills you.
Start simple. Plain Python + function calling. No framework. See if that solves your problem. Often it does.
Add structure when you need it. Hitting reliability issues? Add LangGraph for explicit control. Need multiple perspectives? Try CrewAI's roles.
Don't go autonomous too early. Human-in-the-loop is your friend. Let the agent draft, human approves. Gradually reduce oversight as you build confidence.
Instrument everything. LangSmith, Langfuse, or roll your own. You can't improve what you can't measure. Agent debugging is hard—make it visible.
More from BuiltForAI