Author, Build a Multi-Agent System (From Scratch) @ManningBooks ◦ Ex Founding Engineer @llama_index ◦ PhD @UWaterloo
Toronto
Joined November 2020
- Tweets1K
- Following1.1K
- Followers2K
- Likes2.8K
Pinned Tweet
Been heads down on my book for the past couple of months. Major updates to share for Build a Multi-Agent System (From Scratch) with @ManningBooks!
Chapter 8 on Human-in-the-Loop is now in MEAP (@ManningMEAP). HITL may not be the hottest topic right now, but no foundational book on agents is complete without it.
Three patterns covered:
- Tool-based: new HumanInputTool added to the framework
- Result approval: optional approval gate in the processing loop
- Supervised task execution: full human control over step-by-step execution (see Agent Inspector GIF)
Now the big news: Part 3 is written, and it ended up being two chapters, not one.
Chapter 9 covers subagents from scratch — the pattern behind harnesses like Claude Code and Codex. Chapter 10 covers A2A (client and server), enabling interoperable multi-agent systems across frameworks.
Both are in editing. All chapters written. Book fully in edit mode.
📚 hubs.la/Q03Q0h4p0
💻 github.com/nerdai/llm-agents…
#AI #LLMAgents #MultiAgentSystems #A2A #subagents
nerdai retweeted
Save 45%, only on Oct. 9th!
Today, you can save on Build a Multi-Agent System (From Scratch) by @_nerdai_ and other related titles: hubs.la/Q04zPyRc0
Learn how to build an extensible multi-agent system and the skills to adapt it for research, business automation, or your own experiments.
nerdai retweeted
What's actually happening inside an LLM agent?
In his @acmeducation TechTalk, @_nerdai_ builds one from scratch, breaking down tool calls, the agent loop, MCP, Agent Skills, and memory along the way.
Watch: hubs.la/Q04y_fDP0
Go further with his book, Build a Multi-Agent System (From Scratch): hubs.la/Q04y_fvf0
nerdai retweeted
How do you actually use a decision model like Jev inside an agent?
I just added a bonus example under Chapter 4 of Build a Multi-Agent System (From Scratch) that shows one concrete place: the processing loop we build in the book. (@ManningBooks)
After every step, the LLM agent has to decide whether to take another step or return the result. In the book, the backbone LLM makes that call using a structured output call, and on the final step it also writes an answer that gets thrown away. In the bonus example, we instead hand over that decision to @typesafeai's Jev model.
To make the determination, we give Jev the execution state (the instruction, the steps so far, and the latest response) and ask one yes-or-no question: is the task done?
Using Jev's Noul question primitive, we get a response with a probability score. If it clears a threshold, the loop returns the result with no LLM call; otherwise, the LLM writes only the next step.
Check out the short video I put together (with help from Claude Opus 5.5).
How do you actually use a decision model like Jev inside an agent?
I just added a bonus example under Chapter 4 of Build a Multi-Agent System (From Scratch) that shows one concrete place: the processing loop we build in the book. (@ManningBooks)
After every step, the LLM agent has to decide whether to take another step or return the result. In the book, the backbone LLM makes that call using a structured output call, and on the final step it also writes an answer that gets thrown away. In the bonus example, we instead hand over that decision to @typesafeai's Jev model.
To make the determination, we give Jev the execution state (the instruction, the steps so far, and the latest response) and ask one yes-or-no question: is the task done?
Using Jev's Noul question primitive, we get a response with a probability score. If it clears a threshold, the loop returns the result with no LLM call; otherwise, the LLM writes only the next step.
Check out the short video I put together (with help from Claude Opus 5.5).
Notebook: github.com/nerdai/llm-agents…
The book is in @ManningBooks early access: hubs.la/Q03Q0h340
nerdai retweeted
Really enjoying the MEAP chapters of Build A Multi-Agent System (From Scratch). The intro to agents is especially strong—clear, grounded, no hype. Love that it builds agent + multi-agent systems from scratch instead of hiding behind frameworks.
manning.com/books/build-a-mu…
nerdai retweeted
There's more than one way to get better at building AI agents.
For example, you can start with the fundamentals. You may want to build one from scratch. You can explore practical applications. Or maybe even learn how to make multiple agents work together.
Here are four books that offer four different ways in:
• AI Agents in Action, 2nd Ed by @cxbxmxcx: hubs.la/Q04wkKx70
• Build an AI Agent (From Scratch): hubs.la/Q04wkKx80
• AI Agents and Applications: hubs.la/Q04wkKx90
• Build a Multi-Agent System (from Scratch) by @_nerdai_: hubs.la/Q04wkK8N0
They're all 50% off for Labor Day, along with the rest of our catalog.
Plus:
• $199.99 Annual Pro
• $10 LPs & LVs
• And 20% off annual team subscriptions
nerdai retweeted
In the fight to defend openness in AI, the Marin project is a precious demonstration of openness in model training, with open code, data, recipes, even experimental results. Releasing AI research openly used to be the norm; I'm grateful for @percyliang's open lab approach.
🚢 Marin 535B-A23B started training this week! As usual, the whole process is open.
Voyage plan: pretraining (80%) + midtraining (20%) on 18.75T tokens on 11 x GB200 NVL72 for ~3 months (2.7e24 FLOPs). Post-training will follow.
Before kicking off the run, we trained a 4-rung scaling ladder from 1.6B-A61M (48B tokens) to 27.7B-A1.2B (926B tokens) to debug issues, and to make a forecast of our hero run. This is by far our biggest run, so definitely expecting the unexpected.
Today's Deal of the Day for @ManningBooks is their "Agents made easy!" collection.
This collection includes my book: Build a Multi-Agent System (From Scratch).
If you have been thinking about picking up the book, today is a good time. The deal is live for 48 hours.
The book walks you through building an agent framework from scratch, where you'll learn how to:
- implement tool calling with LLMs
- build in support for MCP and Agent Skills
- give an LLM agent episodic memory
- support task execution with humans in the loop
- build modern multi-agent systems with subagents (as harnesses like Claude Code, Codex, and OpenCode support) and A2A
The first 7 chapters are live in @ManningMEAP and Chapter 8 on human-in-the-loop patterns is a couple of weeks out. I'm hoping to have Part 3 on subagents and A2A wrapped up by the end of the month!
If you've been following the GitHub repo, you may have noticed the code and chapter notebooks are already there — so you can give it a look before the writing is out.
📚 Deal: hubs.la/Q03-d27Y0
▶ Chapter 1 summary: youtube.com/watch?v=JoWCtS9Q…
💻 GitHub: github.com/nerdai/llm-agents…
#AI #LLMAgents #MultiAgentSystems #AgentSkills #MCP
Chapter 7 of Build a Multi-Agent System (From Scratch) with @ManningBooks is now live in MEAP (@ManningMEAP)!
Unlike MCP tools (Ch. 5) or skills (Ch. 6), there is no standard protocol for memory. Frameworks define it differently and there is no consensus on what memory even means for an agent.
My position: memory is what an agent learns from its own past task executions, nothing more, nothing less.
What we build:
- Episode: captures completed task executions
- BaseMemoryStore: common interface across storage backends
- Memory: recalls past episodes and records new ones
- Three recipes: recency-based, similarity-based, and reflective memory (inspired by Reflexion: arxiv.org/abs/2303.11366)
Up next: HITL (Ch. 8) and Part 3 — assembling multi-agent systems with subagents as well as Google's A2A.
📚 hubs.la/Q03Q0h4p0
💻 github.com/nerdai/llm-agents…
#AI #LLMAgents #MultiAgentSystems #AgentSkills
nerdai retweeted
No local GPU? That doesn't have to stop you from building.
@_nerdai_ created a @LightningAI Studio template for Build a Multi-Agent System (From Scratch) that comes with an L4 GPU, the repo cloned, and everything pre-installed. Clone the template, open examples/ch05 .ipynb, and start working through the book.
With Lightning AI's 15 free monthly credits, you can complete the chapter and bonus notebooks without needing your own GPU.
Setup: hubs.la/Q04qTD-g0
Template: hubs.la/Q04qTJzC0
Book: hubs.la/Q04qTRS20
nerdai retweeted
Despite being a part of regular AI conversations, it's common to not really understand the difference between an LLM and an AI agent.
So, what is it? An LLM generates. An agent system plans, uses tools, coordinates tasks, and takes action.
That's the core idea behind the first chapter of Build a Multi-Agent System (from Scratch) by @_nerdai_.
Watch the summary: hubs.la/Q04q2cJB0
nerdai retweeted
Want to build AI agents but not sure where to start?
Here's a practical progression:
• Build a DeepSeek Model (From Scratch)
• Build an AI Agent (From Scratch)
• Build an Advanced RAG Application (From Scratch)
• Build a Multi-Agent System (From Scratch) by @_nerdai_
With these, you can build the model and the agent. Then you can connect it to knowledge. And finally scale to multiple agents.
Access them with a Manning Online Teams Annual subscription, now 20% off.
More info: hubs.la/Q04nqKFQ0
Also through the Independence Day sale:
• 50% off all eBooks & print books
• Manning Online Pro for $199.99
• $10 liveProjects & liveVideos
Find everything at hubs.la/Q04nqxVg0
nerdai retweeted
After 18 months of writing, coding, and experimenting, Build a Reasoning Model (From Scratch) is
finally out!
My first copies just arrived! 📚
440 full-color pages. Inference scaling, reinforcement learning, and distillation from scratch.
nerdai retweeted
The hard part of AI isn't building a demo.
It's turning "look what this agent can do" into "we can trust this in production."
Build a Multi-Agent System (From Scratch) by @_nerdai_ covers agent coordination, delegation, and tool use.
Designing AI Systems by @inceptor92 and @SultaniaDewang covers evaluation, safety, retrieval, monitoring, and operations.
One focuses on intelligence. The other focuses on the infrastructure that supports it.
Both are 37% off this week:
• hubs.la/Q04ld6d40
• hubs.la/Q04ldsXZ0
My #ACMTechTalk "Inside an LLM Agent: A From-Scratch Walkthrough" is now
on YouTube!
2,100+ people joined live. Walked through the internals of an LLM agent
from scratch across 5 demos:
1. The tool-call gap: LLMs don't run tools, they request them
2. Closing the loop: what actually makes something an agent
3. Tools as a protocol: the entire MCP ecosystem in one line
4. Giving the agent a playbook: Agent Skills in action
5. Giving the agent a past: sneak peek at memory (Chapter 7, coming soon!)
Run the demos yourself with the companion notebook (Ollama locally or
free L4 on Lightning AI).
▶ youtube.com/watch?v=QwJnUkA8…
📓 github.com/nerdai/llm-agents…
📚 hubs.la/Q03Q0h4p0
@ManningBooks
#AI #LLMAgents #AgentSkills #MCP
nerdai retweeted
LiteParse, our open-source/Rust-based doc parser, runs so quickly that Claude Fable 5 doesn't think it's real 🔥
It is the fastest document parsing solution on the planet and a great choice for your AI document workloads.
Check it out: github.com/run-llama/litepar…
nerdai retweeted
Looking at data is actually critical work. It corrects so many issues very quickly that skew algorithmic performance. Should be owned by everyone.
I agree with Alex here.
