I recently had the opportunity to read Building Agent-Powered Applications by Vasyl Zvarydchuk, PhD, after Dipali Malvatkar from Packt reached out and offered me a review copy.
A quick disclosure at the beginning: I received the book from Packt with the opportunity to read it and share my thoughts. This review reflects my own opinion.
The easiest way to describe the book is that it tries to cover a remarkably large part of the modern AI engineering landscape in one place.
It starts with the foundations of machine learning and neural networks, moves through Transformers and the development of large language models, and then continues into prompting, retrieval-augmented generation, fine-tuning, orchestration, and agent-based systems.
That breadth is the book’s greatest strength. It is also where most of its limitations come from.
A condensed map of modern AI engineering
One of the things I appreciated most was the effort to connect the different layers of the field.
A lot of material on current AI systems starts somewhere in the middle. You are introduced to a framework, an architecture, or an implementation pattern without spending much time on how we arrived there.
This book takes the opposite route. It tries to build the chain from more traditional machine learning ideas all the way to the systems now being built around large language models.
For me, the earlier chapters worked particularly well as a refresher.
I still consider myself very comfortable with the concepts behind neural networks, language models, and the broader theory involved. What I found useful was being reminded of details and connections that are easy to lose when you are no longer working on a particular topic every day.
There are areas, especially around specific training and fine-tuning techniques, where I used to have far more of the detail immediately available in my head. Reading the book brought many of those ideas back.
It also reminded me of the distinction between remembering the shape of a topic and truly having all its details at hand. If I wanted to return to the level of depth I once had in some of these areas, I would still go back to original papers, technical articles, and more specialized material.
I do not see that as a problem with the book. It is simply important to understand what kind of book this is.
It is not a definitive reference on every subject it touches. Given the number of subjects covered, that would hardly be possible. It works much better as a dense map of the field.
If you want to understand how machine learning, language models, prompting, retrieval, fine-tuning, orchestration, and agents relate to one another, it gives you a surprisingly efficient route through all of them.
The strongest parts are often the conceptual ones
What stood out most to me were not individual facts or implementation details, but the way certain ideas were framed.
There are several places where the author takes something that can easily sound like a vague new category and relates it back to much more familiar problems.
One example appears in the discussion of orchestration in multi-agent systems.
The book breaks an orchestration step into several tasks. The system needs to determine which tools are relevant, populate the required parameters, and decide whether it should continue or stop.
Viewed through the lens of more traditional machine learning or NLP, those tasks resemble classification, information extraction, and a higher-level decision process.
I found that framing particularly useful.
A few years ago, these would often have been treated as separate problems. Classification might have involved one dedicated model. Information extraction another. Routing and decision logic might have lived somewhere else entirely. You would then combine those pieces into a larger system.
Today, we routinely ask a single large language model to carry out several of these functions as part of one interaction.
That observation itself is not new. What I liked was the way the book articulated it.
It gives you a more grounded mental model for thinking about current AI workflows and makes some of the newer terminology feel less detached from what came before.
That is where I felt the author’s understanding of the field came through most clearly. Good technical writing is not only about explaining how something works. It is also about finding a useful way to think about it.
The book does that surprisingly often.
The prompt engineering chapter is particularly useful
Another section I enjoyed was the chapter on prompt engineering.
Prompting is one of those topics that is easy to either oversimplify or overcomplicate. At one extreme, it becomes a collection of tricks. At the other, it gets buried under terminology that makes something fairly practical sound unnecessarily obscure.
The book finds a good middle ground.
The sections on prompt structure and the core prompting techniques are concise, but there is enough substance behind them to make the material useful in practice.
That distinction matters.
Plenty of technical books give you enough information to recognize a topic, but not enough to do anything with it. I did not have that reaction here. You can read the prompting material and come away with concrete ideas that are immediately applicable to your own work.
For a book covering this much territory, that is not something I would take for granted.
The agent chapters are where the book is at its best
The chapters on agents and orchestration were, for me, the strongest part of the book.
They cover a large amount of conceptual ground while generally staying at the right level of abstraction. Just as importantly, the discussion does not become overly dependent on a particular framework or SDK.
I see that as a major advantage.
The framework ecosystem around AI applications changes extremely quickly. Libraries appear, become popular, change their abstractions, get replaced, or disappear altogether. A book that ties itself too closely to one implementation framework can start aging almost immediately.
By concentrating more on the underlying concepts, the author avoids much of that problem.
You are not reading the book to memorize which method to call in framework X. You are reading it to understand how agent systems are structured, what orchestration actually involves, how decisions are made, how tools fit into the loop, and how the individual components interact.
Those ideas have a much longer shelf life.
This is also where the book feels most confident. The material is not merely describing a fashionable category. It is trying to explain the mechanics underneath it.
Where the breadth becomes a limitation
Covering this much territory inevitably means that some topics receive less depth than others.
Fine-tuning is a good example.
The book gives you enough to understand what fine-tuning is, why it is used, and where it belongs in the broader landscape. If you need to speak with engineers about the subject, understand the main trade-offs, or follow a technical discussion, that level of coverage is genuinely useful.
You will have the vocabulary and the conceptual context to participate productively.
But fine-tuning is a deep subject. If your goal is to run serious fine-tuning projects and make informed choices around training strategy, datasets, optimization, evaluation, and the many practical details involved, this book alone will not take you very far.
For that, you will need more specialized material.
I had a similar reaction to the chapter on retrieval-augmented generation.
The chapter is substantial and certainly not an afterthought, but RAG has become an enormous field in its own right. Retrieval quality, indexing, embeddings, chunking, reranking, evaluation, hybrid search, query transformation, and plenty of other topics can each turn into fairly deep rabbit holes.
That puts the chapter in a slightly awkward position.
It contains too much material to feel like a brief introduction, but not enough to serve as a deep treatment. Given how central retrieval has become to many production systems, I would have preferred either a more focused overview or a significantly deeper chapter.
Personally, I would probably have chosen the former and used the space to expand the material on agents.
That is not because the RAG material is poor. The problem is simply that the subject is too large to be compressed comfortably into the role it plays here.
Breadth and depth are in constant tension
That trade-off runs through much of the book.
The chapters surrounding the core agent material are often very effective at giving you a bird’s-eye view. You can move through a surprising amount of material in relatively little time and come away with a coherent sense of where things belong.
What they generally do not give you is enough depth to consider yourself prepared to specialize in every topic.
I think that is perfectly reasonable, but it does create an interesting tension because the agent chapters show that the author is capable of going considerably deeper.
That occasionally made me wish the book had narrowed its scope.
A more focused version could have treated some of the supporting subjects more briefly, pointed readers toward external material, and spent the additional space on agents, orchestration, planning, tool use, and system design.
I think that would have played particularly well to the author’s strengths.
On the other hand, if what you want is one book that lets you cover a large amount of AI engineering territory quickly, then narrowing the scope would remove exactly what makes it useful.
So this is less a flaw with an obvious solution than a trade-off built into the book’s ambition.
More field guide than narrative
Another thing worth knowing is that this is not a book with a particularly strong narrative arc.
It does not read like a story about the development of AI. It feels much more like a compact field guide or technical reference.
That means I would not necessarily recommend it to someone looking for a relaxed or especially entertaining introduction to the subject. The appeal is elsewhere.
The value comes from density.
There is a lot of information packed into a relatively small amount of space, which makes the book useful when your goal is to build context quickly.
For example, if you work in a role where you need to move between conversations with machine learning engineers, software engineers, data scientists, product managers, and other stakeholders, this kind of overview can be extremely helpful.
You will not become a specialist in every topic the book touches. You will, however, understand the terminology, the main ideas, and how the pieces relate to each other.
Being able to move comfortably across those boundaries is a useful skill in itself.
Who I think the book is for
I would recommend Building Agent-Powered Applications primarily to people who want to understand the landscape of modern AI engineering without spending months studying each individual area.
It is especially useful if you already have some technical background and want to connect the dots.
The book gives you enough context around machine learning, language models, prompting, retrieval, fine-tuning, and related topics to have meaningful technical conversations. When it reaches prompting, agents, and orchestration, it becomes more substantial and, in my view, more interesting.
I would be more cautious about recommending it as the primary resource for someone who wants to specialize deeply in one of the supporting topics.
If your goal is to become very strong in RAG, fine-tuning, or the underlying theory of neural networks, you will need dedicated resources.
But that is not really what I think this book is trying to do.
Its real value is in helping you see the whole landscape without losing sight of how the individual pieces connect.
In a field that has become increasingly fragmented, with new terms, frameworks, and patterns appearing constantly, that is more useful than it may initially sound.
Final thoughts
Overall, I came away with a positive impression of the book.
Its breadth is impressive, the writing is clear, and the material on agents and orchestration is particularly strong. The best sections do more than explain concepts. They leave you with better ways of thinking about them.
That is probably what I will remember most.
I also appreciate the decision to focus primarily on concepts rather than tying the material too closely to individual frameworks. Given how quickly AI tooling changes, that makes the book considerably more durable.
My main criticism is that the scope occasionally forces worthwhile topics into a level of coverage that feels caught between overview and depth. Personally, I would have been happy to trade some of that breadth for even more on agents.
But if the goal is to provide a compact map of modern AI engineering and then spend more time where agent-based systems are concerned, I think the book succeeds.
Perhaps the best way I can summarize it is this:
Building Agent-Powered Applications is not the last book you will need on every subject it covers. It is a very good book for understanding which subjects matter, how they connect, and where you may want to go deeper next.
Thanks again to Dipali Malvatkar and Packt for giving me the opportunity to read the book and share my thoughts.