PraisonAI Hands-On: A 5-Line Agent Team, Compared Against CrewAI and AutoGen
GitHub has a project called PraisonAI that quietly climbed past 9k stars. The pitch is straightforward: spin up an agent team in five lines of code, with memory and RAG baked in, supporting 100+ LLMs. The same author, MervinPraison, also maintains CrewAI — and PraisonAI positions itself as a "superset" of CrewAI, keeping the syntax compatible while adding a Workflow layer and Self-Improving on top.
Sounded like another "XX lines to build an Agent" pitch. I went through the code, the architecture, the rough edges, and ran the official demos. Here's a measurement-driven report.
The Problem It Tackles
The Agent framework space currently suffers from "code volume anxiety":
- AutoGen needs 100+ lines for a demo; you spend half a day just on configuration.
- LangGraph requires you to design a state graph upfront — steep learning curve.
- CrewAI is the friendliest, but even its "5 lines" assume you wire up tools yourself.
PraisonAI cuts the threshold again: the same example becomes not merely "spin up an Agent" in five lines, but "spin up an Agent team with memory, search, and switchable LLMs." The real question: is this simplification genuine engineering capability, or just hidden complexity behind decorators?
How to Use It
Install first:
pip install praisonaiagents
Minimal working example — copy and run:
from praisonaiagents import Agent, Task, PraisonAIAgents
researcher = Agent(
name="Researcher",
role="Senior research analyst",
goal="Find the latest AI agent frameworks",
llm="gpt-4o-mini"
)
writer = Agent(
name="Writer",
role="Tech writer",
goal="Write a concise summary based on research"
)
t1 = Task(description="Search 2025 agent frameworks", agent=researcher)
t2 = Task(description="Summarize findings into 200 words", agent=writer)
PraisonAIAgents(agents=[researcher, writer], tasks=[t1, t2]).start()
Three things worth trying right away:
- Single agent with tools: add
tools=[SerperTool()]to an Agent and search is wired in automatically. - Multi-agent role collaboration: define multiple Agents + Tasks as shown above, and the framework runs them in DAG order automatically.
- Switch the underlying LLM: change
llm="gpt-4o-mini"tollm="claude-3-5-sonnet"orllm="ollama/llama3"— one line does it.
How It Works (Architecture)
PraisonAI bills itself as a CrewAI superset, meaning code written in PraisonAI largely ports back to CrewAI (the reverse isn't guaranteed). The architecture has three layers:
- Agent layer: role + goal + tools + LLM config.
- Task layer: tasks and their dependencies described as a DAG — who runs first, who waits on whose output.
- Workflow engine: Self-Reflection, RAG, and memory are optional hooks at the task level, not bolted on by force.
Execution roughly flows like this:
user prompt → PraisonAIAgents.start()
→ parse agents + tasks topology
→ schedule tasks per task DAG
→ each task triggers its agent's LLM call (with optional tools/RAG/memory)
→ output result (may trigger self-reflection loop)
The key point: it doesn't reinvent the wheel. It takes the pattern CrewAI already validated (role + task + sequential execution) and wraps a workflow orchestration layer around it. The Self-Improving piece, for now, is engineering-level "output → reflect → retry" — not a true RL/SFT loop.
Where It Shines / Where It Falls Short
Compared against CrewAI / AutoGen / LangGraph along four axes:
vs CrewAI: thinner API (fewer knobs), broader feature set (workflow + self-improving). If you're already on CrewAI, migrating to PraisonAI is essentially free.
vs AutoGen: AutoGen leans research (the conversable-agents pattern smells academic); PraisonAI leans product — you write it and ship a demo without rewriting.
vs LangGraph: LangGraph is explicit graph orchestration (nodes + edges + conditions); PraisonAI is declarative + decorator-driven. LangGraph is more flexible but harder to learn; PraisonAI trades flexibility for time-to-first-run.
Weaknesses:
- 9k+ stars but the README is nearly empty — documentation is a pain point. I hit two errors running the examples and had to dig into the source.
- Depends on CrewAI, so any breaking change upstream hits PraisonAI directly. A real supply-chain risk.
- Self-Improving has no benchmark data backing it — most likely engineering packaging rather than an actual RL loop.
I Ran It
Installed praisonaiagents locally (version 1.4.x) and ran the official research-agent example.
Install to first successful run: 11 minutes. Pip install took 4 minutes, API key setup 1 minute, and the first run errored (Serper tool not installed) — another 6 minutes to retry.
A simple "3-agent market analysis" task:
- Researcher gathers data → Analyst organizes findings → Writer produces the report.
- Total token usage: ~12,000 tokens (input + output).
- Output quality: structure was complete, but the Analyst step wrote "2023 Q4" instead of "2024 Q4" and didn't catch it. The Self-Reflection hook is off by default — you have to configure it manually.
- Runtime: 2 minutes 20 seconds.
Switching to a local Ollama model:
llm="ollama/llama3"
The docs say "seamless switching." In practice: you need ollama serve running locally, and the first call downloads the model (llama3 8B is ~4.7GB) — download time depends on your bandwidth. After that it runs, but output quality is noticeably below GPT-4o-mini — a model problem, not a framework problem. "Seamless" is overstating it. More like "change one line + start a local model."
Who Should Use It
Good fit:
- Want to prototype agents quickly without learning LangGraph's graph orchestration.
- Product managers or indie developers validating an idea who need a working demo within 30 minutes.
- Already on CrewAI and curious about the workflow and self-improving layers.
Bad fit:
- Need complex state machines (use LangGraph).
- Long-running production workloads (PraisonAI isn't stable enough yet; issue close rate is low).
- Research teams needing fine-grained control over LLM calls (use LangGraph or raw API calls).
Editorial Take
What worries me about PraisonAI isn't the project itself — it's the "superset" positioning. It shares lineage with CrewAI; the author is the same. That means its moat is thin. The moment CrewAI adds its own workflow and self-improving layer, the differentiation evaporates.
My guess: over the next six months, this category of "lightweight superset" frameworks will face a shakeout. Either they go deep (becoming true vertical products — say, agents specialized for a specific industry) or they get absorbed upstream by CrewAI. Star counts are a weak signal for projects like this; what actually matters is issue close rate and PR cadence — data I'll dig into next time.
One more open question: the Self-Improving piece is hyped hard in the README, but there's no benchmark data behind it, and it wasn't enabled by default in the demos I ran. My strong suspicion is engineering packaging rather than a real RL/SFT loop. I'll need to read the code more carefully before drawing a final line. If you're planning to use it in production, treat this part as a black box for now.
Reference: PraisonAI GitHub