The mental model
Before touching any code, get a feel for what an agent is and isn't. Watch the three videos in order, then read the three pieces below them. That's a weekend, tops.
agent-patterns. Given a problem description, it should decide whether you need a workflow or an agent and which pattern fits, with a one-line reason. Write it in your own words, without copying from the articles.
A structured course optional
If you learn better with lessons and exercises than with reading, pick one of these. Neither ties you to a framework.
LangGraph & Deep Agents
LangGraph is the framework I'd learn first. It gives you control over state and flow, and the learning material around it is the best I've found. Deep Agents is LangChain's newer library on top of it, for long-running agents that plan, spin off sub-agents and work with files.
langgraph-scaffold skill describing how you set up a new graph: how you shape the state, where the tools live, which checkpointer you use and how you test it.
MCP & Agent Skills
These two ideas show up everywhere now. MCP is the standard way to give an agent tools and data. Skills are how you give it know-how: instructions, scripts and references it loads only when it needs them. Read the docs here rather than a third-party tutorial, because they're short and kept up to date.
SKILL.md is structured and which tools support it.mcp-server: how to add a tool to your server, test it and register it.
Tracing & evals
Agents get things wrong in ways you won't notice from a handful of manual tests. You need to see every step the agent took (tracing), and you need a repeatable way to check it's still good after you change something (evals). People skip this step a lot, and it's usually what separates a demo from a product.
- Groundedness
- Is the answer supported by the sources it was given, or did the model make it up?
- Relevance
- Does it actually answer what was asked?
- Coherence
- Does it hang together and read logically?
- Explainability
- Can you show why the agent did what it did? For agents this mostly comes from your traces: which tools were called, with what inputs, and which documents the answer was based on.
eval-checklist skill describing what you run before calling a change done. There's an example of this one in the repo.
Shipping it
An agent running in a notebook isn't finished. You need an API in front of it, somewhere to store state, a simple UI so other people can try it, and a place to run it. Don't learn all of these in depth. Learn enough of each to get your agent online.
deploy-agent skill should be the exact steps you followed, including the ones that went wrong.
Safety & governance
Once your agent can read untrusted input and take real actions, things can go wrong in ways that matter. In a company, someone will eventually ask you how you know it's safe. These are the resources that'll help you answer.
pre-launch-review skill: the checklist an agent (or you) should go through before anything goes live.
Two more frameworks
These are worth your time even if you've been doing this for a while. They do some things better than LangGraph, and knowing them makes you better at choosing a framework.
Visual builders optional
Drag-and-drop tools for building agents and automations. You don't need them to be an agent developer, but they're great for quick prototypes and for working with people who don't code. Pick one.
Going further
For when you've done the path and want to go wider. Building agents for real ends up being a lot of plain software engineering, especially distributed systems, so the second group here matters more than it looks.