Introducing The Agentic Enterprise: A Leader's Guide to Orchestrating, Governing, and Scaling AI Agent Systems

A new O’Reilly book by Babak Hodjat and Antoine Blondeau on how enterprises can design, govern, and scale multi-agent AI systems, and why those systems succeed or fail on architecture rather than on model capability. 

Agentic AI has moved from experiment to deployment faster than almost any enterprise technology in recent memory. Organizations that were running their first proofs of concept a year ago now have agents working inside claims processing, investment research, and software delivery, and the sharp rise in token consumption over recent months suggests the trend is accelerating rather than settling. Alongside that momentum, though, a second and less encouraging pattern has become just as consistent. Pilots multiply, demos dazzle, and production deployments stall.

The instinct in most organizations is to blame the model and wait for the next one. That instinct is usually wrong, and correcting it is what our new book is about.

I am excited to share that The Agentic Enterprise: A Leader's Guide to Orchestrating, Governing, and Scaling AI Agent Systems, written with my longtime friend and business partner Antoine Blondeau, is published by O'Reilly and available now.

Antoine and I have been working together for more than 25 years, since the days of the natural language agents we built at Dejima that eventually found their way into Siri, and there is something satisfying about writing this particular book together after all that time. It is the book we would have wanted when we started, bringing together what we have learned about designing, governing, and scaling multi-agent systems inside real businesses. We wrote it for the boards and executives weighing these decisions, and just as much for the architects, developers, and workflow owners who have to turn them into working systems.

When an agentic system fails to reach production, the cause is rarely the model

The failures we see most often are architectural, organizational, or a matter of accountability that nobody assigned to anyone in particular. Agents proliferate across teams, each department builds on a different stack, dependencies quietly accumulate on a single model provider, and the system that looked elegant in a demo becomes something no one is willing to put in front of a regulator. A more capable foundation model does not fix any of this. Neither does a governance policy written after the system is already built, because by then the decisions that matter have been made. How you structure your agents is what determines what you can audit, what you can secure, what you can replace later, and what you can explain when someone asks.

Underneath this sits an argument that shapes everything else in the book. In the 1970s and 1980s, AI researchers tried to build one generally intelligent entity and failed, partly for want of compute and data, partly because the algorithms were not up to it. In the mid-1990s, the field simplified the problem by simplifying the world in which intelligence had to operate, which is how agent-based AI took center stage and how some of us came to propose agent-oriented software engineering as a successor to the object-oriented movement. Then came deep learning, then transformers, then large language models, and with them the reasonable-sounding assumption that scale would eventually deliver the general intelligence the first attempt could not. Our position, argued at length in the book, is that a single very capable LLM cannot be generally intelligent unless it is itself designed as a multi-agent system. AI has come full circle.

The practical version of that argument matters more than the philosophical one. LLMs have real limits on context and on tool use, and those limits are structural rather than temporary. As the number of tools available to one agent grows, the model has to understand what each tool does and also decide when to use it, so eventually it will pick the wrong one, call them in the wrong order, or garble the syntax of the call. Nobody hands a single engineer the job of writing an entire CRM system. Distributing responsibilities across specialized agents is not a workaround for weak models – it is how you get consistent behavior out of strong ones, and it brings secondary benefits that are easy to overlook. You can safeguard an agent by pairing it with a safeguard agent rather than asking it to be careful, and you can run smaller and cheaper models wherever the responsibility is narrow, including models hosted locally when the data is sensitive.

We are not the only ones who see it this way. Two early readers, whose own work has shaped much of this field, were generous enough to share their thoughts on the book.

"The emergence of enterprise AI agents represents a fundamental shift in how organizations develop, maintain and improve their workflows, from deterministic applications to adaptive systems capable of autonomous execution. Realizing this opportunity requires far more than advances in foundation models; it demands new approaches to orchestration, governance, security, human oversight, and organizational transformation. The Agentic Enterprise captures this new paradigm with depth, combining technical rigor with operational insight. It is an important contribution to the global conversation on how enterprises can harness agentic AI to drive long-term competitiveness and innovation."

— Yann LeCun, Executive Chairman, Advanced Machine Intelligence Labs, and former Chief AI Scientist at Meta

"The real promise of agentic AI isn't smarter software, but a new model of work where humans and AI collaborate seamlessly to accomplish what neither could achieve alone. The Agentic Enterprise explores what it really takes to realize that vision, offering both the technical foundation and an organizational framework for humans and AI to work together effectively, responsibly, and at scale."

— Adam Cheyer, Cofounder of Siri

What the book covers, and who each part is written for

The book is organized in four parts. Each chapter is designed to stand on its own, so readers can go directly to what their role requires, though a single argument runs through all four and the book is a more coherent read taken in full.

Part 1 makes the business case, tracing how enterprise AI evolved from robotic process automation to agents, where the returns are real, and what agentification looks like across software development, retail, telco, finance, healthcare, HR, marketing, and IT. The examples come from organizations operating at scale rather than from pilots. Allianz Partners moved past proofs of concept to automate as much as 90% of eligible claims, cutting settlement times from roughly 30 days to three or four. Franklin Templeton has gone from pilot programs to production deployments across multiple departments, starting with its investment teams. This part also covers frameworks for assessing ROI and total cost of ownership, build-versus-buy decisions, and the risks worth taking seriously.

Part 2 turns to the technical foundations. It covers grounding, coordination, memory and planning, and the difference between turn-taking, continuous, and triggered agents, along with the design decisions that separate a reliable system from a fragile one. It closes with a chapter on pitfalls that I suspect will get more use than the rest, because the failure modes are consistent and mostly avoidable once you can name them. Networks of agents fall into tailspins where they talk to each other indefinitely. Individual agents get overloaded with instructions no current model can reliably follow. Context gets passed down the chain when it should have been reset, confusing everything downstream. Teams reach for a single coordinator agent because it feels deterministic, then discover it is a single point of failure that will not scale.

Part 3 addresses trust and scale, which belong together. Trust in an agentic system is not binary, and it is not granted once. It is calibrated and layered, and it has to be maintained over time through accountability structures, explainability, logging, and technical guardrails. Any organization that wants to run agents at scale has to earn something like a license to operate from its employees, its customers, and its regulators. The chapter on scaling then works through five architectural decisions that build on one another: encapsulation and coordination, model and cloud agnosticism, future-proofing for upgrades, the balance between central platform ownership and empowered business units, and emerging open standards such as Model Context Protocol and agent-to-agent communication.

Part 4 looks ahead to the World Wide Agentic Web and what it will take to build, including agent identity and generally recognized registries. It asks what happens to brands and intermediaries when the buyer on the other side of a transaction is an agent rather than a person. It closes on the questions about autonomy and responsibility that cannot honestly be deferred to a later generation.

The ideas in the book are ones you can run, not just read

Nothing in the applications chapter is hypothetical. Every system described there has been built, and several are deployed, which matters because architectural principles are easy to assert and considerably harder to hold up once real workflows and real data are involved. A good number of those systems were built on Cognizant Neuro® San, the open source multi-agent framework we develop and release at the Cognizant AI Lab. The book points readers there who want to work through these ideas without deep engineering experience, since agent networks can be vibed into existence rather than hand-coded.

The overlap between the book and the framework is not a coincidence, because Neuro San was built from the same convictions the book argues for. Its coordination comes from AAOSA, the Adaptive Agent-Oriented Software Architecture that shaped the agent-based design of the original Siri, in which every agent acts as coordinator for the agents beneath it and gathers their claims into a coherent response for the agent above. That structure is what delivers encapsulation, the principle the book returns to quite often. Because each agent's responsibilities stay self-contained, you can add a new subnetwork without re-engineering the agents already running. It also means the network is entry-point agnostic, so anyone who already knows which part of the system their request belongs to can address that subsystem directly rather than starting from the top coordinator each time.

Other arguments in the book have the same kind of counterpart in working code. Deciding what belongs to an agent's LLM and what belongs to its code is among the first design choices worth making explicitly, and sly_data is how that choice gets enforced, carrying structured information between agents through code so that sensitive material never enters a model's context at all. The case against committing to any single provider is why agent networks are defined declaratively in configuration files rather than hardcoded in Python, why any agent can be assigned whichever model suits its particular job, and why the framework is built to work alongside open standards like Model Context Protocol and existing platforms rather than in place of them. And because the book recommends sandboxing long before grounding, there is a testing framework that runs a whole network in simulation, repeatedly, before it touches anything live.

Where to start

The Agentic Enterprise is available for order from Amazon and other booksellers. Antoine and I will also join O'Reilly's Beyond the Book series for a live conversation and open Q&A September 11th, which is a good opportunity to raise the specific version of this problem you are working through in your own organization.

If you would rather build than read, Neuro San is on GitHub with demo agent networks you can clone and run in a few minutes. Every organization adopting this technology is now in a state of perpetual agentification, building and modifying and extending these systems the way we already do with every other kind of software, and the sooner you have something running, the sooner the questions in this book stop being abstract.