Agent frameworks: LangGraph, CrewAI, Microsoft Agent Framework and no-code tools
An agent is a loop around model calls and tools, and you can write that loop in plain Python. Frameworks add model integrations, tool definitions, state management, checkpoints, human approval steps, multi-agent coordination and tracing, so you don't build them yourself. LangGraph gives fine control over agents as graphs of steps, CrewAI makes role-based multi-agent teams quick to set up, the provider SDKs (OpenAI Agents SDK, Google ADK, Microsoft Agent Framework) fit their ecosystems, and no-code tools like n8n suit simple automations. Build one agent from scratch first so you know what the framework does for you, then choose by the control, ecosystem and operations you need.
Build one from scratch first
An agent is not magic. It is code: a loop that calls a model, checks whether it asked for a tool, runs the tool, adds the result to the messages and calls the model again.
def run_agent(task: str, call_model, tools: dict, max_steps: int = 8) -> str:
messages = [{"role": "user", "content": task}]
for _ in range(max_steps):
reply = call_model(messages, tools)
if reply.get("tool") is None:
return reply["content"]
result = tools[reply["tool"]](**reply["args"])
messages.append({"role": "assistant", "content": f"call {reply['tool']} {reply['args']}"})
messages.append({"role": "tool", "content": str(result)})
return "Stopped: step limit reached."
Writing this once, with a real model, two or three tools, error handling and a step limit, teaches you what every framework is doing underneath. Then, when something goes wrong inside a framework, you know where to look.
What frameworks add
- Integrations with many model providers, vector stores and tools.
- Tool definitions from Python functions, with schemas and validation.
- State: a structured record of the task that persists across steps.
- Checkpoints: save state after each step, resume after a failure, replay a run.
- Human in the loop: pause for approval and continue.
- Multi-agent patterns: orchestrators, handoffs, roles.
- Streaming, tracing and integration with observability tools.
Main options
LangChain
A library for building applications with LLMs: model integrations, prompts, document loaders, retrievers and tools. It is where many people start, especially for RAG, and LangGraph builds on it for agents.
LangGraph
A framework for building agents and workflows as graphs: nodes are steps (a model call, a tool, a check), edges decide what runs next, and a shared state flows through. It gives you a lot of control, durable checkpoints, human approval points and support for long-running agents, which makes it a common choice for production agents. It takes more code and more understanding than simpler frameworks, the same way PyTorch gives you more control than higher-level libraries.
CrewAI
A framework for multi-agent systems built around roles: you define agents with a role, a goal and tools, define tasks, and put them in a crew that runs sequentially or with a manager. It is quick to get a multi-agent prototype running, and you have less low-level control than with LangGraph.
Provider SDKs
- OpenAI Agents SDK: a lightweight framework for agents with tools, handoffs between agents, guardrails and tracing, designed around OpenAI's models and also usable with others.
- Google Agent Development Kit (ADK): Google's open-source framework for building agents, integrated with Gemini and Google Cloud.
- Microsoft Agent Framework: Microsoft's open-source framework that brings together Semantic Kernel and AutoGen, aimed at enterprise agents in .NET and Python on Azure.
Other libraries
LlamaIndex (strong for data and RAG-heavy agents), Pydantic AI (type-safe agents with Pydantic), and smolagents from Hugging Face (minimal agents that write and run code) are all worth knowing.
No-code and low-code tools
Tools like n8n, Zapier, Make and Dify let you build agent-style automations visually, connecting triggers, model calls and hundreds of app integrations. They are fast for business automations and prototypes, and harder to test, version and customise deeply than code.
How to choose
| Need | Good fit |
|---|---|
| Learning how agents work | Plain Python, then LangGraph |
| Production agent with complex control flow, checkpoints and approvals | LangGraph |
| Quick role-based multi-agent prototype | CrewAI |
| You're committed to one cloud or model provider | That provider's SDK |
| RAG-heavy agents over many data sources | LlamaIndex or LangGraph |
| Business automation with many app integrations | n8n or a similar tool |
| A small agent with a few tools | Plain Python with the model's SDK |
Questions that decide it:
- How much control do you need over each step?
- Do runs need to survive crashes and wait for human approval?
- Which models and cloud are you using?
- Who will maintain it, and do they know the framework?
- How fast is the framework changing, and can you keep up with its updates?
What frameworks cost you
Frameworks evolve quickly, and their abstractions can hide what is sent to the model, which makes debugging harder. Pin versions, read the traces of what the framework actually sends, and keep your business logic and tools in your own modules, so you can change frameworks without rewriting everything.
The LangGraph vs CrewAI vs Microsoft Agent Framework comparison goes deeper.
From the floor
When I started the AI agents course, the first session used nothing but Python: environment setup, then a rule-based agent that responds to fixed patterns, then adding memory, then the other capabilities one by one, and running them together at the end. An agent is a Python script, and it gets more efficient as you move to libraries like LangChain, but building it from scratch first is the right way to understand it.
In the DevFix agent build, we used LangGraph, and I explained the split this way: LangChain is for integrating LLMs into your project, and LangGraph, built on top of it, is for writing agents, with more customisable code, similar to how PyTorch and TensorFlow give you control in deep learning. For the multi-agent job assistant, we used CrewAI, because it is designed for multi-agent systems.
In one of the first agent workshops, we also built an agent with n8n, a visual tool, to show that a working agent doesn't always need code, before moving to code-based frameworks.
Related
- LangGraph vs CrewAI vs Microsoft Agent Framework
- Agent state and recovery
- LlamaIndex vs LangChain
- Multi-agent systems