book

Context Engineering for Multi-Agent Systems

Name: Context Engineering for Multi-Agent Systems
Author: Denis Rothman
ISBN: 9781806690053

by Denis Rothman

November 2025

Intermediate to advanced

396 pages

9h 28m

English

Packt Publishing

Read now

Unlock full access

Preface
Free Benefits with Your Book
Chapter 1: From Prompts to Context: Building the Semantic Blueprint
Understanding context engineeringLevel 1: The basic prompt (zero context)Level 2: The better context (linear context)Level 3: The good context (goal-oriented context)Level 4: The advanced context (role-based context)Level 5: The semantic blueprintSRL: from linear sequences to semantic structuresBuilding an SRL notebook in PythonThe main function: visualize_srlDefining the semantic rolesThe plotting engine: _plot_stemma and canvas setupDynamic positioning and drawing the stemma (graph)Running SRL examplesExample 1: Business pitchExample 2: Technical updateExample 3: Project milestoneEngineering a meeting analysis use caseLayer 1: Establishing the scope (the “what”)Layer 2: Conducting the investigation (the “how”)Layer 3: Determining the action (the “what next”)SummaryQuestionsReferencesFurther reading
Chapter 2: Building a Multi-Agent System with MCP
Architecting the MAS workflow with MCPBuilding an MAS with MCPInitializing the clientDefining the protocolMessage formatTransport layersProtocol managementBuilding the agentsCreating the helper functionDefining the Researcher agentDefining the Writer agentBuilding the OrchestratorRunning the systemError handling and validationBuilding robust components for the LLMValidating MCP messagesAdding agent specialization controls and validationThe final Orchestrator with a validation loopRunning the final robust systemThe evolution of AI architectureTools for building agent systemsSummaryQuestionsReferencesFurther reading
Chapter 3: Building the Context-Aware Multi-Agent System
Architecting a dual RAG MASPhase 1: Data preparationPhase 2: Runtime execution analysisRAG pipeline data ingestion (context and knowledge)Installation and setupInitializing the Pinecone indexData preparation: the context library (procedural RAG)Data preparation: the knowledge base (factual RAG)Helper functions for chunking and embeddingProcess and upload (upsert) dataContext libraryKnowledge baseBuilding the context-aware systemDefining the agentsBuilding the OrchestratorSummaryQuestionsReferencesFurther reading
Chapter 4: Assembling the Context Engine
Architecting the Context EngineArchitectural overviewFunctional deep diveAssembling the systemThe specialist agentsContext Librarian agentResearcher agentWriter agentAgent RegistryThe Context EnginePlannerExecutorExecution TracerPutting it all togetherRunning the engineSummaryQuestionsReferencesFurther reading
Chapter 5: Hardening the Context Engine
Step-by-step architectural walk-throughPhase 1: InitiationPhase 2: The planning stagePhase 3: The execution loopPhase 4: FinalizationRefactoring for scalability in the real worldCreating the centralized setup functionsSimplifying the main notebookHardening the helper functionsEnhancing modularity with dependency injectionImproving transparency through production-level loggingIncreasing efficiency with proactive context managementUpgraded helper functions in actionRefactoring the agents for productionContext Librarian agentResearcher agentWriter agentRefactoring the Agent RegistryFinal hardened codeUpgrading the central orchestratorFinal hardened codeRunning the hardened engineVisualizing the traceStandard workflow executionComplex workflow executionDeconstructing the engine's thought processInitiation and planningExecution step 1 – The LibrarianExecution step 2 – The ResearcherExecution step 3 – The WriterFinalizationModularizing the engineLocal importsModule independenceIssue 1: Missing agentsIssue 2: Mismatch of data structuresThe final pre-production notebookCentralized execution function (the engine room)User interactions (the control deck)SummaryQuestionsReferencesFurther reading
Chapter 6: Building the Summarizer Agent for Context Reduction
Architecting the glass-box systemStep-by-step architectural walkthroughSeparation of responsibilitiesWhy the glass box mattersImplementing context reduction with the Summarizer agentFoundation for cost managementBuilding the Summarizer agentMicro-context engineeringIntegrating the new agent into the engine's toolkitReinforcing the Writer agent for greater flexibilityExploring the Summarizer in actionDeconstructing the engine's thought process: the proof is in the traceTranslating technical efficiency into business valueSummaryQuestionsReferencesFurther reading
Chapter 7: High-Fidelity RAG and Defense: The NASA-Inspired Research Assistant
Architecting a trustworthy research assistantStep-by-step architectural walkthroughSeparation of responsibilitiesImplementing high-fidelity RAG and agent defensesPart 1: Upgrading the ingestion pipelinePreparing source documentsUpdating the data loading and processing logicVerificationPart 2: Upgrading the context engine's capabilitiesImplementing the helper_sanitize_input functionHigh-fidelity Researcher agentPart 3: The final application: the NASA research assistantThe control deckDeconstructing the high-fidelity trace and outputValidation and retro compatibility of the context engineComplete inventory of the context engineMain application notebook functionsHelper functions (helpers.py)Specialist agents (agents.py)AgentRegistry (registry.py)Engine core (engine.py)How the context engine thinksThe architecture as a wholeSeeing the system in motionValidating the mind of the machineChapter 7test case: High-fidelity, secure research workflowChapter 6test case: Validating the system through backward compatibilityChapter 5test case: Grounded reasoning and preventing hallucinationSummaryQuestionsReferencesFurther reading
Chapter 8: Architecting for Reality: Moderation, Latency, and Policy-Driven AI
Architecting the enterprise-ready Context EngineStep-by-step architectural walkthroughThe deliberate pace of a reasoning engineImplementing moderationBuilding the moderation gatekeeperIntegrating the moderation gatekeeperModeration guardrail in actionArchitecting a policy-driven meta-controllerPrinciple 1: AI systems must continuously adapt to realityPrinciple 2: Limits of automated contextual judgmentPrinciple 3: New engineer's mindsetPrinciple 4: Policy as the ultimate contextPrinciple 5: Architectural solutionMulti-domain, generic control decksTemplate 1: High-fidelity RAGTemplate 2: Context reductionTemplate 3: Grounded reasoningApplying the engine: the legal compliance assistantBuilding the legal knowledge baseLegal use cases and real-world limitsControl deck 1: High-fidelity RAGControl deck 2: Context reductionControl deck 3: Grounded reasoningSummaryQuestionsReferencesFurther reading
Chapter 9: Architecting for Brand and Agility: The Strategic Marketing Engine
Step-by-step architectural flowDesigning the marketing knowledge baseRunning the engineValidating production safeguardsUse case 1: Competitive analysisUse case 2: Transforming technical specs into marketing copyUse case 3: Synthesizing a persuasive pitch from multiple sourcesSummaryQuestionsReferencesFurther reading

Chapter 10: The Blueprint for Production-Ready AI
Productionizing the glass-box engineEnvironment configuration and secrets managementBuilding the production API (orchestration layer)Asynchronous execution and task queuesCentralized logging and observabilityInfrastructure and containerizationDeploying enterprise capabilities and production guardrailsManaging operational costs with proactive context reductionEnsuring trust and compliance with high-fidelity RAGDefending the data pipeline against poisoning and adversarial attacksEnsuring compliance and safety with automated guardrailsEnforcing governance and quality with creative workflowsPresenting the business valueFrom cost center to value multiplierStakeholder trust through verifiability and securityCreating a strategic assetSummaryQuestionsReferencesFurther reading
Chapter 11: Unlock Your Exclusive Benefits
Unlock this Book’s Free Benefits in 3 Easy Steps
Appendix A: Context Engine Reference Guide
Theoretical foundationsSemantic blueprintMerits of the glass-box architectureSystem architecture and workflowPhase 0: Data ingestion pipelineContext Engine workflowThe commons library referenceFile: helpers.pyFile: agents.pyFile: registry.pyFile: engine.pyModule: utils.pyData ingestion pipelinePipeline stepsIngesting the context libraryExecution and operationEngine roomControl deckProduction safeguards: moderation, sanitization, and policyInput sanitization (prompt injection defense)Two-stage content moderation protocolLimits of automation and the role of policyPolicy-driven solutionOperational realities: latency and stochasticity
Appendix B: Answers
Chapter 1Chapter 2Chapter 3Chapter 4Chapter 5Chapter 6Chapter 7Chapter 8Chapter 9Chapter 10
Other Books You May Enjoy
Index

Content preview from Context Engineering for Multi-Agent Systems

Appendix B

Answers

Here you’ll find a compilation of all the answers to the review questions that appear at the end of each chapter. Use it to reinforce your grasp of the principles of context engineering as you prepare to apply them in your own projects.

Chapter 1

Is the primary goal of context engineering, as defined in this chapter, simply to ask an LLM more creative questions? (Yes or no)
No. The chapter defines context engineering as providing a structured plan to control and direct the AI’s output, rather than just asking questions.
Does a “Level 2: Linear Context” provide enough information to control an LLM’s narrative style and purpose reliably? (Yes or no)
No. A linear context improves factual accuracy but does not guide the AI’s style, ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781806690053

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design