The Agentic Enterprise (Early Release) A Leaders Guide to Orchestrating, Governing, and Scaling AI Agent Systems (Babak Hodjat, Antoine Blondeau) (z-library.sk, 1lib.sk, z-lib.sk)

The Agentic Enterprise A Leader’s Guide to Orchestrating, Governing, and Scaling AI Agent Systems With Early Release ebooks, you get books in their earliest form—the authors’ raw and unedited content as they write—so you can take advantage of these technologies long before the official release of these titles. Babak Hodjat and Antoine Blondeau

The Agentic Enterprise by Babak Hodjat and Antoine Blondeau Copyright © 2026 O’Reilly Media, Inc. All rights reserved. Published by O’Reilly Media, Inc., 141 Stony Circle, Suite 195, Santa Rosa, CA 95401. O’Reilly books may be purchased for educational, business, or sales promotional use. Online editions are also available for most titles (https://oreilly.com). For more information, contact our corporate/institutional sales department: 800-998-9938 or corporate@oreilly.com. Acquisitions Editor: David Michelson Development Editor: Shira Evans Production Editor: Jonathon Owen Interior Designer: David Futato Interior Illustrator: Kate Dullea August 2026: First Edition Revision History for the First Edition 2026-02-18: First Release See https://oreilly.com/catalog/errata.csp?isbn=9798341672512 for release details. The O’Reilly logo is a registered trademark of O’Reilly Media, Inc. The Agentic Enterprise, the cover image, and related trade dress are trademarks of O’Reilly Media, Inc. The views expressed in this work are those of the authors and do not represent the publisher’s views. While the publisher and the authors have

used good faith efforts to ensure that the information and instructions contained in this work are accurate, the publisher and the authors disclaim all responsibility for errors or omissions, including without limitation responsibility for damages resulting from the use of or reliance on this work. Use of the information and instructions contained in this work is at your own risk. If any code samples or other technology this work contains or describes is subject to open source licenses or the intellectual property rights of others, it is your responsibility to ensure that your use thereof complies with such licenses and/or rights. 979-8-341-67251-2 [LSI]

Brief Table of Contents (Not Yet Final) Introduction (available) Part 1: Why the Agentic Enterprise Matters Chapter 1: From Automation to Agents (available) Chapter 2: The Business Case for Agentic AI (available) Part 2: Finding the Right Use Cases Chapter 3: High-Impact Enterprise Applications (unavailable) Chapter 4: Evaluating ROI and Risks (unavailable) Part 3: Architecting the Agentic Enterprise Chapter 5: Core Capabilities and Technical Foundations (unavailable) Chapter 6: Designing for Scale and Experience (unavailable) Part 4: Governance, Trust, and Scale Chapter 7: Building Trustworthy Systems (unavailable) Chapter 8: Scaling Without Lock-In (unavailable) Part 5: Leading Into the Future Chapter 9: The Road Ahead for Agentic Enterprises (unavailable) Chapter 10: Checklists, Templates, and Further resources (unavailable)

Introduction A NOTE FOR EARLY RELEASE READERS With Early Release ebooks, you get books in their earliest form—the author’s raw and unedited content as they write—so you can take advantage of these technologies long before the official release of these titles. This will be the introduction of the final book. If you’d like to be actively involved in reviewing and commenting on this draft, please reach out to the editor at sevans@oreilly.com. Humans are Agents. When we say ‘we have agency’ we mean we are able to postulate a goal of our own making, devise an action plan, and execute to deliver on that goal. As agents we have the ability to organize and impact our world, get feedback from our actions, and modify our actions based on that feedback in order to improve. Machine intelligence has improved such that it is taking a greater share of our decision-making, complementing and augmenting our world as AI agents. Like AI itself, and most other modern digital technology, we owe the concept of AI Agents to Alan Turing. In his 1950 treatise on Computing Machinery and Intelligence, he described machines that perceive input and act toward goals. This definition is silent on the environment within which the agent is operating and perhaps, Turing’s idea was that the agent would be unconstrained to act in the world. Today, the world in which an AI agent can operate has vastly expanded. Not only do we have a virtual world in the shape of the internet to complement the real world, we can also define any manner of virtual world we can imagine and engineer it into existence through programming. So which world do AI agents operate in? Is it fair to assume that ultimately an AI agent is to be able to perceive any given environment, and act toward

any given goal? Who defines the goals? Are agents autonomously to decide on which goals to pursue? While this is possible at lower levels, at some point in the hierarchy of agents there needs to be an uber-goal that directs the system and its highest order agents in how they define their goals. Even if we borrow from nature and define the higher level goal to be survival, we, as humans, are still engineering this into the AI agents. The same applies to inputs. Surely an AI agent cannot be perceiving the world in its entirety, and so we’d have to engineer sensors for it, designed based on what we believe to be the most important information it would need in its pursuit of its goals. So AI Agents are an engineering concept. Through the years, as computing, storage, and AI have progressed, this definition of an AI agent has been adopted, implemented and experimented on in a variety of ways. In the seventies and eighties, AI scientists started off thinking we could create a single entity that would be artificially intelligent with no need for constraints. This generally capable AI agent would primarily be able to operate in the real world, perceiving any input and acting towards any given goal. This ambitious definition failed, in part due to lack of compute and labeled data resources, and in part because the AI algorithms were simply not up for the job. In the mid-nineties, the problem of AI was simplified, by simplifying the world within which the intelligence would manifest itself. What if we build an intelligent agent, representing us, not in the complex world we live in, but in the simpler world of the internet, which back then, was mostly text and hyperlinks. Thus, Agent-based AI took center stage. A popular AI textbook, published in the late nineties, was called “Artificial Intelligence: A modern Approach” and the modern approach was this new constrained agent-based definition of AI.

Before long, people started wondering what would happen if your agent ran into someone else’s agent. Should they collaborate or compete? Would there be a common inter-agent language? Multi-Agent systems became a subfield of AI, with some, including the authors, suggesting a new software paradigm called Agent-oriented Software Engineering (see Figure I-1) as a follow on to the object-oriented movement.

Figure I-1. The original Siri Natural Language used an agent-based architecture. Fast forward to today: Generative AI has shown unexpected emergent capabilities, most important of which is the understanding of Natural Languages. LLMs are able to understand, translate, and even write code or produce images based on a natural language description. Natural Language Processing, Understanding, and translation, problems that were the first

non-numerical application of computers, and considered very difficult to solve, have been effectively addressed through the use of LLMs now. What’s more, these AI models can express intent and context in natural language. The very human ability to put concepts together in order to form new concepts, describe new contexts, or express new meaning is now available in machines, which makes them much more robust than any artificial system ever made. Language was developed by humans as a means for structured, high conceptual bandwidth communications. Without language, human societies would not be functional. Over the years language has become richer as new concepts have emerged. Now that machines ‘get’ human language, we have a universal protocol for human-to-machine communication -- we can talk to them in our language, and they can respond in kind. Interestingly, as a consequence of the invention of LLMs, we now also have a much richer and more robust machine-to-machine communication language in the form of our own natural language. Since machines understand English (or German, Chinese or Hindi), we can have them communicate in one or more language, and this has the double benefit of being rich in abstractions and concepts, covering the entirety of humans- developed ontologies, and it has the added benefit that it is understood by us, which is helpful if we want to understand and follow the decision- making process. So, out of the box, we have a universal protocol for inter-agent communications. Because of the flexibility of natural language to express intent, and the ability of LLM-based agents to map such intent to the manner by which their tools are called, software systems of the future will be much less brittle than the ones we have today: an agent responsible for a functionality takes care of mapping intent to the specific API calls, and so it will be much less of a hassle to change the API, or employ a different software with similar capabilities. This will give organizations more flexibility in upgrades or with third-party services.

If inter-agent communications and coordination are done in a manner that guarantees the encapsulation of responsibilities, then future enterprise applications will be much more robust, with new capabilities and functionality being introduced to a preexisting network of agents with little to no need for reengineering the system that is already there. Given how a machine learning approach, using deep learning and transformer architectures, and training on language modeling, has resulted in such capable systems as LLMs, it is natural to think that we are back on track to create a single model that is generally intelligent. In other words, some people think that building ever larger LLMs, and training them on more and more data, will result in an LLM that is more intelligent than humans in every aspect of human intelligence. It seems, however, that for very different reasons, we are now back to considering agent-based systems as a next natural step for software (see Figure I-2).

Figure I-2. Agent-based Systems. AI has come full circle: Initial failure in building generally intelligent systems resulted in breaking the problem into smaller sub problems, handled by agents in multi-agent systems, which, in turn, led to distributed AI. Large Neural Networks, or Deep Learning, can be thought of as a Distributed AI system, and LLMs are a special kind of Deep Learning. We make the case that a single very capable LLM cannot be generally intelligent, unless it is used as a multi-agent system. Generative AI is pre-trained and so it is difficult to make it fundamentally change its world model online. Generative AI is typically trained on publicly available data, so, not having information in its training that is specific to a commercial problem domain, say proprietary data a company may be collecting and using, it is not generally useful out of the box for business applications. Also, LLMs need to be given a system prompt in order to be useful. A system prompt is part of the LLMs input context that keeps being repeated with every distinct input, so as to remind the LLM who it is and what is expected of it. Through system prompts, LLMs can take different personas and operate differently. This means that, to play a specific role within a knowledge workflow, we need to give an LLM specific instructions, declare it to have specific expertise, and give it a specific job description and set of responsibilities. The ability of machines to both understand highly complex human-designed concepts and execute specific instructions has led to resurgence in interest in agent-based AI, or agentic AI. Can we get machines to chart their own path towards executing on complex goals, and engineer the set of instructions to make that happen, and do so autonomously? The challenge is altogether very different to that which the early AI pioneers faced in the nineties: back then, we were forced to simplify the problem domain because of lack of compute resources and model capabilities. Now, we still simplify the problem domain but that is because Generative AI models are too powerful and flexible, and we need to contain them and taskmaster them to specific roles within our organizational use- cases. Thus the advent of modern LLM-based Agents.

Multi-Agent Systems Many uses of Generative AI call for confining an LLM to a specific role. In figure 3, for example, we could choose to have the LLM respond to the query “What is the average weight of penguins on Biscoe?”. It may already have learned the answer from its general knowledge, but if it has not, it will try to guess, and the answer might not be reliable. But there is a more reliable alternative: if we have access to a database that we know to include reliable data, say on penguins, it is preferred that we tell the LLM about the schema of the database and the type of SQL used to query it, and have it translate our natural language inquiry into a call into the database. LLMs are great at writing code, but they don’t have the facility to make the actual call and retrieve the data, so we need some helper code for that. Our code would pattern match this intent of the LLM and make the call to the database, retrieve the answer, and pass it on to the LLM to formulate it into a natural language response (see Figure I-3). Figure I-3. Using an LLM as an agent to make call to a database. In fact, a popular use-case of Generative AI these days is Retrieval Augmented Generation (RAG). Many companies are seeking a ChatGPT- like interface to their proprietary document repositories, and this is implemented by summarizing the documents offline and storing them, along with the LLM’s representation of the summaries (known as embeddings), in a vector database. The embeddings are vectors capturing the meaning, or semantics, of the summaries. By storing them in a vector

database, we can calculate numerical distances between the summaries, making it easier to search by meaning, rather than strict and rigid pattern matching of the words and sentences. This system can then respond to future natural language questions regarding the proprietary documents by mapping the requests to queries to the vector database, finding summaries that are closest in their meaning, to the query at hand. Hence, you can see here too that RAG can be thought of as a multi-agent system, with an agent for offline summarization, and one tasked with responding to the user’s natural language queries (see Figure I-4).

Figure I-4. RAG can be thought of as a multi-agent system. But much more can be done. Any workflow requiring knowledge workers can be thought of as a multi-agent system. In Figure I-5, for instance, we can have a planning agent come up with various plans, say for an upcoming

vacation, an actuation agent with knowledge of APIs for internet services such as Expedia or Hotels.com, can then call the API and get actual numbers, say for airline price or hotel dates, into the plan. And a critic agent can check the results and decide whether they are plausible (e.g., is the connection time for a flight reasonable?) and send them back for refinement if they are not.

Figure I-5. A Multi-Agent Planning System. Let’s formalize our view for an agent-based system a bit. What we mean by an agent is a Generative AI LLM wrapped around a module, function, service, or database. This allows an end user to interact with that functionality in natural language (see Figure I-6). It also allows us to log the intent of the agent upon servicing every input from the user. In other words, we can log the why and what of the agent’s behavior, because the agent understands and can produce natural language describing every step it is taking. This also allows us to introduce safeguards on the agent’s behavior, by having it observed by another agent, let’s call it the Safeguard Agent. This agent can be tasked with our ethics, compliance, or regulation guidelines, and intervene if what is asked of the system is not compliant.