Last Updated on October 15, 2026 by Aram
AI agents are becoming an important part of modern software engineering. We’re moving beyond simple LLM integrations and chatbots toward systems capable of reasoning, using tools, coordinating tasks, and operating across longer workflows.
But there is an important distinction between knowing how to use an agent framework and understanding how an agent actually works.
That is precisely what caught my attention about AI Agents & Harnesses Foundations:
Building from ReAct Loops to Long Horizon Agent Harnesses with LangChain and LangGraph
Written by Eden Marco and published by Packt.
Rather than focusing exclusively on high-level frameworks and abstractions, the book takes a practical approach to explaining what happens underneath an AI agent, from basic chains and reasoning loops to more sophisticated agent harnesses.
A Bit About the Author
Eden Marco is an AI Architect at Google Cloud and a LangChain Ambassador, with a background in software engineering, cloud architecture, and security.
He was also among the early engineers at Orca Security, holds a computer science degree from the Technion, and has taught at Reichman University.
His professional experience spans AI engineering and building secure, production-oriented systems, which makes his perspective particularly relevant to developers interested in taking agentic AI beyond experimentation.
What Makes This Book Interesting?
One of the things I appreciate about the book’s approach is how it gradually removes the abstractions that normally hide the inner workings of an AI agent.
It starts by introducing familiar concepts and frameworks, then challenges readers to understand what those frameworks are actually doing.
The progression is particularly valuable because building an agent with a few lines of code is relatively straightforward today. Understanding its execution flow, decision-making, tool interactions, and failure scenarios is a different challenge.
The book explores these concepts across seven chapters.
1. Building the Foundations with LangChain
The opening chapter introduces LangChain’s essential building blocks, including prompt templates, chat models, and chains.
Readers build a text summarization chain, experiment with local open-weights models using Ollama, and integrate LangSmith for tracing.
I particularly like the early introduction of observability.
When working with LLM applications, understanding which prompts were executed, what the model returned, and how requests move through a workflow is essential for debugging and improving reliability.
2. Understanding the Difference Between Chains and Agents
This chapter addresses one of the most important architectural distinctions in agentic AI.
With a traditional chain, the developer defines the execution sequence.
With an agent, the model can dynamically decide which action or tool to invoke next, within the boundaries established by the application.
Readers implement a working agent that uses web search and explore how models interact with tools and structured outputs.
This is where AI applications begin moving from predefined workflows toward more dynamic execution.
3. Looking Inside the Agent Loop
For me, this is one of the most valuable parts of the book.
Instead of treating LangChain’s create_agent as a black box, Eden explores the underlying agent loop through three approaches:
- Using LangChain’s built-in abstractions.
- Implementing tool calling through manually defined JSON schemas.
- Building a raw ReAct implementation using prompts, regular expressions, and a scratchpad.
This comparison helps explain how an agent selects tools, executes actions, processes observations, and decides whether to continue or return an answer.
It also reinforces an important engineering principle: frameworks simplify implementation, but understanding their internal mechanisms helps us troubleshoot and extend them.
4. Building an Agent Loop Without a Framework
The next chapter takes that understanding further by removing LangChain’s tool abstractions.
Readers manually convert Python functions into tool schemas, manage execution, and reconnect tracing.
I find this particularly relevant from a software architecture perspective.
It demonstrates which responsibilities a framework handles on our behalf and which responsibilities we must implement when building our own orchestration layer.
That knowledge becomes useful when customizing agent behavior, integrating internal enterprise services, or evaluating whether a framework is necessary for a particular solution.
5. ReAct from Scratch
This chapter revisits the foundations of ReAct, the reasoning-and-acting pattern behind many agent implementations.
Rather than relying on native function calling, readers build an agent using raw model outputs, stop sequences, regex-based action extraction, and a manually managed scratchpad.
What makes this exercise valuable is not necessarily that we should build production agents using regex parsing.
It is that we understand how the reasoning and action cycle works, including the limitations of earlier approaches and why structured tool calling became so important.
6. Prompt Engineering Meets Context Engineering
Another particularly relevant chapter focuses on the evolution from zero-shot and few-shot prompting to ReAct and function calling.
But the discussion extends beyond writing effective prompts.
It introduces context engineering, which I consider one of the most important disciplines in building reliable agentic systems.
An agent needs more than a good system prompt. It needs the right information, at the right time, in a form that supports the current task.
Poor context management can introduce irrelevant information, increase token consumption, degrade decision quality, and make long-running workflows increasingly unreliable.
This is especially important when agents interact with external tools, retrieve documents, or accumulate lengthy execution histories.
7. Agent Harnesses and Long-Horizon Agents
The final chapter moves into what I consider the natural next stage of agent engineering: building systems that can sustain execution beyond a single request or a few tool calls.
It explores agent harnesses, planning, persistence, delegation to sub-agents, failure recovery, and safer execution.
The book also introduces LangChain’s Deep Agents approach.
The key distinction here is that a powerful language model alone does not make a dependable autonomous system.
The surrounding harness must coordinate execution, preserve useful state, manage tools, and provide mechanisms for recovering from failures.
This becomes increasingly important when agents perform multi-step engineering tasks, research workflows, or complex business processes.
My Perspective as a Software Architect
What stands out to me about this book is the emphasis on understanding the underlying engineering rather than simply learning another framework.
Having worked extensively with distributed applications, backend systems, and software architecture, I see several familiar engineering concerns appearing again in agentic AI:
Observability, state management, execution control, security boundaries, failure recovery, and system reliability.
These are not entirely new problems.
What changes with AI agents is that part of the execution flow is influenced by a probabilistic model rather than being completely predetermined by application code.
That introduces different challenges around predictability, testing, and operational control.
I particularly appreciate the decision to show agent loops implemented both with and without frameworks. Developers who understand these mechanics are better equipped to evaluate abstractions, diagnose unexpected behavior, and make appropriate architectural decisions.
Who Should Read This Book?
I would recommend this book to software developers, AI engineers, technical architects, and engineering teams who want to understand how modern AI agents operate internally.
It is also useful for experienced backend developers moving into AI engineering.
The examples use Python, LangChain, LangGraph, and LangSmith, but many of the architectural principles extend beyond those technologies.
Even if your primary development stack is .NET, Java, or another ecosystem, understanding agent loops, tool calling, context engineering, and orchestration remains highly relevant.
Final Thoughts
The real value of this book lies in its progression from using an AI framework to understanding what that framework does, and eventually exploring how more sophisticated agent systems are assembled.
It encourages developers to look beyond working demos and investigate the mechanics that influence agent behavior.
For me, the most important takeaway is this:
Building an AI agent is becoming easier. Engineering an AI agent that is observable, controllable, reliable, and secure remains the real challenge.
Understanding the foundations is what enables us to make that transition.
If you’re exploring AI agents, LangChain, LangGraph, or the emerging world of agent harnesses, this is a practical book worth checking out.
Book: AI Agents & Harnesses Foundations
Author: Eden Marco
Publisher: Packt Publishing
I’d also be interested in hearing from developers already building agentic systems:
What has been your biggest challenge when moving AI agents from experimentation into production: reliability, security, observability, or controlling their behavior?
Thanks to Packt for the sponsorship of this post.
Bonus
Enjoy this masterpiece while reading this book.
Händel – 12 Concerti Grossi, Op.6 | The Academy of Ancient Music
