Coming from Springer Nature Expected December 2026

AI Agents

Designing, Orchestrating, and Governing LLM-Based Systems

Michael Bücker · Michael Hewing

With a foreword by Prof. Jan vom Brocke, Chair of Information Systems and Business Process Management and Director of the European Research Center for Information Systems, University of Münster

Getting useful output from a language model is easy. Building a system around one that an organization can run, audit, and maintain is not. This book is about the distance between those two things.

AI Agents: Designing, Orchestrating, and Governing LLM-Based Systems, by Michael Bücker and Michael Hewing, published by Springer.

What the book is about

An agentic system couples a language model with tools, memory, and an orchestration layer that decides what happens next. That combination turns a model which answers into a system which acts, and it moves the difficult questions out of prompting and into engineering, economics, and governance.

The book works through those questions in three parts. The first builds the architecture: how language models behave, how tools extend them, how memory persists across a run, and how an agent's control flow is shaped. The second places that architecture inside an organization, covering integration with existing systems, strategy, the economics of running agents, the policies that constrain them, and the processes they touch. The third is about operations: orchestrating several agents, governing them while they run, maintaining them as models and dependencies change, and securing them against a class of attack that did not exist before.

It grew out of research, teaching, and company collaborations at the Institute for Process Management and Digital Transformation at FH Münster. The code examples are Python that runs, and the outputs printed in the book are the ones that code produced. Every chapter opens with a quote from someone building these systems in industry.

How the book is organised

The three parts are the three layers of one framework.

The AI agent framework Three layers: an organizational layer with strategy, economics, input and output interfaces, policies, and business processes; an operations and processes layer with orchestration, runtime governance, build and maintenance, and security; and the agent architecture core, where an AI model interacts with memory and tools under a system prompt and agent flow. A dashed enclosing box labelled Harness surrounds the operations layer and the agent architecture core together. Tasks flow downward through the layers and responses flow back up. Part IIOrganization and EconomicsStrategyEconomicsInput interfaceUserTriggerOutput interfaceUserApplicationsPoliciesBusiness processesElicitationTaskSystem responseHarnessPart IIIOperationsOrchestrationRuntime governanceBuild & maintenanceSecuritySelectionAgent responseMulti-agent / A2APart IAI Agents: Design and ArchitectureAgent flowSystem promptInstructionsLLMMemoryAI ModelsToolsstoreretrieveactionresults
Part I builds the architectural core — the model, its memory, its tools. Part III is the operations layer that runs it: orchestration, governance, maintenance, security. Part II is the organization both answer to. The dashed box is the harness, the runtime that supplies the core and the operations layer together.

Contents

An introduction, then thirteen chapters in three parts.

I Design and Architecture

  1. 1Large Language ModelsHow the models behave, and where their limits actually sit.
  2. 2ToolsFunction calling, MCP, skills, CLI, GUI — five mechanisms, one cycle.
  3. 3MemoryWhat persists between turns, and what keeping it commits you to.
  4. 4Agent flowThe control structure of a single run: loops, budgets, recovery.

II Organization and Economics

  1. 5IntegrationHow an agent reaches the systems and the people around it.
  2. 6StrategyWhere agents fit an organization's plans, and where they do not.
  3. 7EconomicsCost per successful outcome, not cost per run.
  4. 8Organizational policiesThe constraints an agent must not be able to talk its way past.
  5. 9Business processesWhere deployments actually pay off, domain by domain.

III Operations

  1. 10OrchestrationCoordinating several agents, and keeping runs alive between sessions.
  2. 11Runtime governanceGovernance as a second loop, running alongside the first.
  3. 12Build and maintenanceBuilding an agent, and keeping it working as models move.
  4. 13SecurityPrompt injection and the attack surface a tool-using agent opens.

Who it is for

Graduate students in business, information systems, and data science, and practitioners who have to make decisions rather than demonstrations: the engineers who build agents, the architects who integrate them, and the people who carry the budget and the risk.

Ideas are anchored throughout in worked Python examples, each available as a runnable notebook. Most of them read like the one below, and the argument follows just as well if you never run a line. If you would rather have the basics first, Appendix B is a short introduction to the Python and the web APIs the listings use, free to read online. The book does not assume you have deployed a model before.

# Listing 4.1 — the agent loop, in full
state = initialize_state(user_input)

while not should_stop(state):
    action      = select_next_action(state)
    observation = execute_action(action, state)
    state       = update_state(state, action, observation)

response = finalize_response(state)
Nine lines, and every argument in the book is somewhere in them: what counts as state, who decides the next action, who is allowed to execute it, and what makes it stop.

What readers say

This book is exactly what I have been looking for for quite some time. It brings together a thorough technical explanation how agentic systems work under the hood with operational and strategic considerations. In my role, I don’t have the time to investigate all of this on my own and connect all the dots by myself. In this sense, this book is a valuable resource for anyone who wants to get real value from agentic AI and not just follow the hype.
Armin Müller, Global Head of Data & AI, Kaufland
What distinguishes this contribution is not so much any single chapter as the sensibility running through all of them: agentic AI is treated throughout as an organizational actor, not merely a technical artifact. It acts within processes, incentives, and governance structures, and must therefore be understood on those terms as much as on technical ones.
Jan vom Brocke, Chair of Information Systems and Business Process Management, University of Münster — from the foreword

The authors

Michael Bücker

Professor of Data Science, Mathematics, and Information Systems at the Münster School of Business, FH Münster, where he directs the Digital Business and Innovation Management programme and serves on the board of the Institute for Process Management and Digital Transformation. His work covers applied data science, machine learning, explainable AI, and statistical methods that bridge theory and organizational practice. Before entering academia he was a consultant and project manager at McKinsey & Company.

Michael Hewing

Professor of Information Systems and Digital Technologies at the Münster School of Business, FH Münster, and board member of the Institute for Process Management and Digital Transformation. He researches and teaches information systems management, digital transformation, business process management, and the integration of advanced technologies into organizational contexts. Before entering academia he was a Senior Managing Consultant at IBM, leading digitalisation and IT transformation projects for public-sector and enterprise clients.

Both author photographs: FH Münster/Hannah Jasiewitz

Material for readers

Code

Every example from the book as a runnable notebook, one per chapter, with the environment pinned to the versions that produced the printed output.

Appendices

Python setup, a reference on Python and web APIs, and the deep learning background the models chapter builds on. Readable online or as a PDF.