Spots 
Last month I rebuilt a piece of my content pipeline that had been running on a hand-rolled agent loop for about a year. The rewrite took a weekend because I finally leaned on open-source frameworks instead of maintaining my own scaffolding. This post is the honest tour: which free GitHub repos I actually run in production, where each one earns its keep, and where I've been burned.
Everything here is Apache-2.0 or MIT. No paid tier required to ship. The only money you spend is on model tokens and infrastructure. The short answer: which framework for which job
If you want the TL;DR before the details: LangGraph for anything with branching, retries, or human-in-the-loop; CrewAI for role-based content and research swarms; AutoGen for conversational multi-agent reasoning and code generation; Pydantic AI or llama-index agents when you want the smallest surface area possible; and smolagents from Hugging Face when you need code-writing agents that stay under 1,000 lines of dependencies. Here is how I actually decide, on a real project: The rest of the post is what I wish someone had told me before I picked one. LangGraph: the one I keep coming back to
LangGraph (github.com/langchain-ai/langgraph) is what I use for the orchestration layer in my BizFlowAI ContentStudio pipeline. It is a graph runtime: nodes are functions (usually LLM calls or tools), edges are transitions, and state is a typed dict that flows through. That model matches how production agent work actually behaves. You are not chatting with a magic entity, you are moving a piece of state through a series of decisions and side effects. What makes it stick for real systems:
Checkpointing works. The SqliteSaver and PostgresSaver let you resume a run after a crash, replay from any node, or hand control to a human and come back later. In my content pipeline, if the "publish" node fails because a WordPress endpoint is down, the graph resumes exactly there on the next scheduled run. No re-running the $0.40 of research.
Conditional edges are explicit. No hidden routing logic inside an agent prompt. You write add_conditional_edges and the failure modes are visible. Streaming is first-class. For a UI, you get token-level and node-level streaming without a wrapper.
The gotcha I hit: do not put your entire application state in one giant TypedDict. Split state per subgraph. When I had 22 fields flowing through 14 nodes, prompt debugging became painful because I could not tell which node mutated which field. Now I use small subgraphs with their own state, composed into a parent graph. A minimum viable node looks like this:
That is 20 lines and you already have retry logic, resumability (once you add a checkpointer), and observability via LangSmith or your own logger. CrewAI: when the mental model is a team
CrewAI (github.com/crewAIInc/crewAI) leans into the "give each agent a role, a goal, and a backstory" metaphor. I was skeptical at first because that sounded like anthropomorphized fluff. It turned out to be a useful abstraction for content workflows specifically, because SEO content really is a small team: researcher, outliner, writer, editor, SEO reviewer.
I use CrewAI for one specific sub-pipeline: long-form article generation with three specialized roles. It ships tomorrow, not next month, because the framework does the boring parts (task chaining, output parsing, tool binding) with about 40 lines of YAML or Python. Real numbers from my setup: 4 agents per crew, ~1,800 tokens of role prompts total Average article: ~$0.18 in Claude Sonnet costs, ~90 seconds end to end Failure rate before retries: ~4%, mostly JSON parsing when I forget to pin response_format
Last month I rebuilt a piece of my content pipeline that had been running on a hand-rolled agent loop for about a year.