This changelog contains notable updates (past, present, and upcoming) to the Context Engineering for Multi-Agent Systems repository.
🐬 Indicates new bonus notebooks to explore.
An interactive teaching deck built around astra.py, the computer-use harness sample that screenshots the desktop, sends the image to a model, and executes the returned mouse and keyboard actions. Its argument: the capability lives in the free-text objective, not in the code — the same loop is a helpful assistant or an autonomous operator depending on one sentence, and the jailbreak surface is ordinary drift (objective redirection, autonomy compounding, prompt injection, consent fatigue) rather than any exploit...
GPT-6-Astra_Governance.pptx
Computer use can be added to the Context Engine as a new agentic capability — extending the architecture from reasoning about an environment to directly perceiving and acting within it. With GPT-6 Astra, an agent can receive visual state, reason over the environment, select computer actions, and interact with a controlled execution layer. The local harness becomes the bridge between the model and the environment, providing screenshots, action execution, permissions, human oversight, and safety controls.
🐬 How to organize your GPT-6 Astra Computer-Use Workshop-documentation and code in Python for your team
The Claude Projects Edition of the Context Engine: the Context Engine with no code at all. Every other edition swaps the model or the framework; this one removes the program. The full pipeline — Gate 1 → Plan → Gate 2 → Execute → Trace — runs as natural-language protocol files inside a Claude Project: nine markdown files uploaded to the Project knowledge, one block of text pasted into its instructions. No Python, no API keys, no Pinecone, no embedding model, nothing installed: 📋claude_projects/README.md
📐 Three layers, and only the middle one changes: the kernel (01, always in context), the engine (10–14: constitution, roster, planner, governance, executor — not one of the five mentions any subject matter), and the domain pack (20–23: manifest, Context Library, knowledge packs). A new use case is a new set of data files, not a new engine.
⬆️ Upgrades to the Chapter 6-8 lineage: a dynamic DAG replaces $$STEP_N_OUTPUT$$ linear chaining; Gate 2 arrives, which Chapter 6-8 could not have because a list of steps has no edges to govern; seven governance domains with the Domain:Agent A2A seam; injection rejections reported in the trace instead of silently logged; orphan-node detection at planning time.
🐬 claude_projects/50_Pack_Builder.ipynb — the ingestion notebook, retargeted. Same job as Data_Ingestion_Marketing.ipynb with markdown packs as the destination instead of a vector index, plus an ingestion-time injection screen the original could not have. Point it at a folder of documents and it writes the uploadable packs. No API keys.
🔬 Evidence in the README: a full captured PLAN: transcript — Gate 1, the emitted DAG, all six Gate 2 checks with verdicts, the trace — plus input, expected output, and what failure looks like for all nine control decks. Trade-offs documented honestly, including the one that matters: with no code, Gate 2 is a protocol a model follows rather than a function that must run.
The NVIDIA NIM NEMOTRON DAG Edition of the Context Engine:** The NVIDIA NIM NEMOTRON Edition of the Context Engine adds a real-time DAG planner to the context engine:🐬nim/Universal_DAG_Engine_NIM.ipynb
🐳☁️ Docker + Railway Deployment: The NIM Nemotron engine is also packaged as a deployable FastAPI service — build it with Docker, ship it to Railway, and verify it live via Swagger.
LangChain Edition of the Context Engine
A Context Engine layer on a LangChain substrate.
🐬langchain/Universal_Context_Engine_LangChain.ipynb
README.md
🐬Chapter10/Universal_Context_Engine_Gradio_UI.ipynb now contains a deployable Gradio web app — live public URL in Colab, one-command deploy to Hugging Face Spaces.
Code review from a Return On Investment(ROI) perspective for real-world projects.
🧭 The Tiers of Context Engines — Tier 3 → Tier 2 → Tier 1.5 → Tier 1
⚖️ Compliance & Risk Management — GDPR · HIPAA · SOC 2 · ISO · FedRAMP
📣 Upcoming Live Workshop Session — Cohort 2
Stop tinkering with prompts. Start engineering context.
Update of the January 24, 2026 Release: OpenAI gpt-5.4 implemented in the Universal Context Engine Sovereign Universal Context Engine: A new Glass Box Context Engine implementation - Chapter10/Universal_Context_Engine.ipynb and Chapter10/Universal_Context_Engine_UI.ipynb- demonstrating domain-agnostic architecture by running cross-domain use cases on the same core. Token Analytics: engine.py and the Dashboard provide rigorous transparency into token usage (Input, Output, Difference) for cost and verbosity analysis.
Here is what GPT-5.4 brings to the notebook: 😎Massive 1.05M Context Window: We can now ingest entire codebases or massive legal repositories in a single pass, rather than relying solely on small vector chunks.
😎Unified Reasoning & Coding: The model absorbs specialized coding capabilities directly, making the Planner agent significantly more stable and reducing "NoneType" errors in complex JSON schemas.
😎Deferred Tool Loading: GPT-5.4 introduces optimized tool searching, which can reduce token consumption in the AGENT_TOOLKIT by up to 30%—a major win for the new Token Analytics dashboard.
😎Reduced Hallucinations: Factual accuracy has seen a 33% improvement, which is critical for the "High-Fidelity RAG" required in legal and marketing domains.
🎇The Stats: GPT-5.4 scores 83.0% on agentic capability benchmarks (GDPval), up from 70.9% in previous versions. This isn't just a model swap. It's a fundamental shift in how sovereign, domain-agnostic AI agents handle verifiable data!
The following benchmark is a comparison of the CPU and H100 execution environments for the Universal Context Engine.
The Takeaway Benchmarking confirms that the Universal Context Engine’s performance and output quality are decoupled from local compute power (CPU vs. H100). Because the architecture offloads heavy reasoning and retrieval to cloud-based APIs (OpenAI/Pinecone) and utilizes a Glass Box multi-agent orchestration, the system delivers identical high-fidelity results and consistent execution latencies regardless of the local hardware tier. This validates the engine as a truly sovereign, domain-agnostic system that maintains operational excellence without requiring expensive local GPU infrastructure if GPU infrastructure is a constraint. If GPU isn't the primary constraint but open source sovereignty is, then it is possible to use an open-source model such as DeepSeek R1 as shared in this repository: ➡️ DeepSeek‑R1 Sovereign AI Guide
The execution times across both notebooks are nearly identical, with most steps falling within a 29–86 second range depending on query complexity rather than hardware. This occurs because the "CPU" and "H100" labels refer to the local environment where the notebook runs, while the heavy lifting—specifically LLM generation and vector search—is offloaded to cloud-based APIs (OpenAI and Pinecone). Consequently, the local processor's speed has a negligible impact on total latency. In terms of quality, both environments produced high-fidelity, citation-backed results across Legal and Marketing domains. The "H100" environment did not show superior reasoning, as both used the same "gpt-5.1" model configuration and identical multi-agent orchestration logic.
| Metric | CPU Notebook (Universal Context Engine) | H100 Notebook (Universal Context Engine) |
|---|---|---|
| Average Execution Time | ~29.69s (Simple) to ~86.22s (Complex) | Identical (~29s to ~86s) |
| Output Quality | High: Consistent branding ("Innovate Forward") and factual accuracy. | High: Identical reasoning and structure. |
| Token Efficiency | Active: Summarizer saved ~1016 tokens in Marketing tasks. | Identical: Same token-saving logic applied. |
| Agent Performance | Reliable: Successfully chained Librarian, Researcher, and Writer. | Reliable: Exact same orchestration results. |
| Safety Guardrails | Functional: Pre/Post-flight moderation active. | Functional: Identical moderation report logic. |
The primary takeaway is that the architecture is infrastructure-agnostic; the quality and speed are governed by the Context Engineering (blueprints and retrieved data) and the API performance rather than the local compute instance.
For simple tasks, the engine orchestrates 3–4 agents with minimal reasoning effort.
This demonstrates that the engine.py orchestration layer adds near‑zero overhead, with latency driven almost entirely by underlying API response times.
This is where the Glass Box value becomes most visible.
In this window, the engine performs:
- Multi‑document cross‑referencing
- Semantic alignment with blueprints
- Rigorous fact‑checking
While 86 seconds may seem high compared to a single‑prompt chat, a human expert would require 15–30 minutes to achieve the same level of citation‑backed, brand‑aligned output.
The Context Engine delivers an industrial‑grade result ~20× faster than manual professional analysis.
Achievement: Successfully benchmarked domain-specific pretraining for a Customer Support agent on X (Twitter) data using the NVIDIA H100.
Performance Leap: Achieved 1,740.55 samples/sec, representing a 4.35x throughput increase over previous A100 baselines.
Sovereign Implications: Demonstrates that high-fidelity, domain-specific models can be trained from scratch in under 4 minutes, reinforcing the capability for fully independent, sovereign AI ecosystems.
Limitation This is a hardware benchmark, not a full quality evaluation. The goal was to obtain an acceptable result to build on, either with the implemented model or with another.
For organizations requiring 100% data privacy and zero external API dependencies, this repository provides a dedicated Sovereign Path.
By leveraging high‑reasoning open‑source models like DeepSeek‑R1, you can achieve industrial‑grade performance entirely on your own infrastructure.
⚡Performance: Benchmarked at ~9.75 seconds on NVIDIA H100 hardware for complex multi‑step reasoning.
🔍Transparency: Provides 100% Glass‑Box observability using local reasoning traces (</think> blocks).
🛠️Independence: Fully disconnected execution with no vendor lock‑in and no unpredictable API costs.
🚀 Launch the DeepSeek-R1 Sovereign AI Guide in Google Colab
👉 Access the guide here: https://github.com/Denis2054/Context-Engineering-for-Multi-Agent-Systems/edit/main/README.md
Upgraded the README with state-of-the art approaches to be educational bridge between the book, Context Engineering for Multi-Agent Systems that containts the architecture and code and the hands-on repository. Also, the README now contains links to the media folder of the repository.
README UPDATE
🛰️ View Software Evolution Timeline has been updated
Software Evolution Timeline: Integrated an interactive narrative tracing journey from Latent Semantic Structures in the 1980s to the 2026 Agentic Era.
APS-Engine_V7 Blueprint added as a link in the timeline: Deployed the 1997 industrial "Physics-Agnostic" Multi-Agent System (MAS) architecture as the cognitive precursor to the Universal Context Engine (Chapter 10).
Structural Invariance Framework: Added a theoretical breakdown of P (Probabilistic) vs. 1-P (Deterministic) ecosystems, detailing the algorithmic invariants that bridge C++ legacy systems with modern Natural Language agents.
Educational Bridge: Established cross-linked navigation between modern agentic implementations and industrial MAS heritage.Industrial Heritage Context: Documented the transition from millions of lines of C++ to Software 3.0 emergent reasoning, grounded in strategic corporate AI projects (Aerospace, SCM).
LinkedIn Integration: Added a direct link to professional milestones and technical breakthroughs for evidence and enhanced credibility for deep-dive research.
- AI Discovery Manifest (
llms.txt): Deployed a machine-readablellms.txtin the root directory. This manifest is optimized for AI agents and search engines to accurately index the Context Engine's capabilities, technical stack, and domain-agnostic architecture. - Keyword Optimization: Updated repository metadata with high-impact keywords:
mcp,agentic-rag,universal-context-engine, anddeterministic-aito improve visibility within the agentic AI ecosystem.
1.Download path tweaked during Quality Control.
2.Live event announcement:
📣 Free Live Event — February 2026
The live LinkedIn session on Context Engineering and Multi‑Agent Systems.
👉 Click here to view the event on LinkedIn
Tenacity, a Python library that provides flexible retry logic for handling transient errors, is part of Google Colab's environment.
Google Colab upgraded its runtime to Tenacity with >=9.0.0, which introduces breaking changes compared to the 8.x series.
The .ipynb notebooks and utlils.py were updated to ensure compatibility with Tenacity.
The repository now includes Chapter10/Universal_Context_Engine.ipynb(batch processing) Chapter10/Universal_Context_Engine_UI.ipynb(interactive sessions) that demonstrate the Glass-Box architecture's domain-agnostic capabilities:
-
Universal Architecture: Runs both Legal and Marketing use cases using the exact same code base, proving that the engine contains zero business rules and relies entirely on retrieved Context and Control Deck instructions.
-
Sovereign Solution: Utilizes High-Fidelity RAG for verifiable accuracy and fully controlled agents, eliminating black-box unpredictability.
-
Dual-Domain Support: Instructions added for appending Marketing data to the Legal index (
clear_index=False) to create a unified knowledge base. -
Token Analytics Upgrade: The
engine.pycore and the dashboard rendering logic have been upgraded to provide rigorous transparency into token usage. -
Token Tracking: The Render and Trace Dashboard now explicitly displays Input Tokens, Output Tokens, and the Difference for each step.
-
Cost-Efficiency Visibility: Allows users to immediately gauge the verbosity and cost implications of the model's reasoning process during execution.
-
IPython Interface in the
Chapter10/Universal_Context_Engine_UI.ipynb(interactive sessions) version
Building upon the foundational logic established in the standard Universal Context Engine, this version introduces an evolved IPython-based Control Deck with a drop-down menu containing multi-domain preset goals. While the original iteration relies on sequential cell execution and manual variable configuration to transition between Legal and Marketing domains, this notebook implements a dynamic user interface powered by ipywidgets. This evolution streamlines the orchestration process by centralizing goal selection, real-time input editing, and moderation guardrails into a single interactive dashboard, providing a more intuitive and efficient experience for managing complex multi-agent workflows.
- Commons upgrade
The Python dependencies are now in commons/engine/ in the Universal_Context_Engine_UI.ipynb to facilitate a deployment to your environment:
!curl -Lf https://raw.githubusercontent.com/Denis2054/Context-Engineering/main/commons/engine/utils.py --output utils.py
!curl -Lf https://raw.githubusercontent.com/Denis2054/Context-Engineering/main/commons/engine/helpers.py --output helpers.py
!curl -Lf https://raw.githubusercontent.com/Denis2054/Context-Engineering/main/commons/engine/agents.py --output agents.py
!curl -Lf https://raw.githubusercontent.com/Denis2054/Context-Engineering/main/commons/engine/registry.py --output registry.py
!curl -Lf https://raw.githubusercontent.com/Denis2054/Context-Engineering/main/commons/engine/engine.py --output engine.pyYou can thus deploy the Universal_Context_Engine_UI.ipynb and the commons/engine content to your environment.
You can also try using the new engine and engine agents, which allow wider RAG retrievals (k=15) and a more flexible execution engine.
!curl -Lf https://raw.githubusercontent.com/Denis2054/Context-Engineering/main/commons/engine/utils.py --output utils.py
!curl -Lf https://raw.githubusercontent.com/Denis2054/Context-Engineering/main/commons/engine/helpers.py --output helpers.py
!curl -Lf https://raw.githubusercontent.com/Denis2054/Context-Engineering/main/commons/engine/agents_k15.py --output agents.py
!curl -Lf https://raw.githubusercontent.com/Denis2054/Context-Engineering/main/commons/engine/registry.py --output registry.py
!curl -Lf https://raw.githubusercontent.com/Denis2054/Context-Engineering/main/commons/engine/engine_k15.py --output engine.pyNote that though the agents and engine files have a _k15 suffix, they are imported under their agents.py and engine.py names.
Google Colab comes pre-installed with a library called google-adkthat is used for Android development integration which requirements may produce a dependency conflict with the libraries installed in this repository.
You can ignore this error and proceed to the next cell of the installation section of the notebooks.
This notebooks in this repository do not use google-adk so a dependency conflict will not affect the Context Engine.
The repository has already been upgraded to GPT-5.1, which has improved speed and quality (see November 18, 2025, upgrades).
Some notebooks were running well with GPT-5, and GPT-5.1 added no significant value.
After evaluating GPT-5.2 in the context of this repository with some notebooks such as Chapter01/Use_Case.ipynb.ipynb, it appeared that GPT-5.2 did not provide sufficient evidence
of significant improvement over the GPT-5.1 upgrade for latency in the complex chapter-code.
Final assessment
- GPT-5 works fine for straightforward tasks such as embedding.
- GPT-5.1 significantly improves latency for complex notebooks.
- GPT-5.2 was evaluated. It provides some improvements, but it is not significant for this repository.
Execution Visualization: Updated execute_and_display in Marketing_Assistant.ipynb and Legal_assistant_Explorer.ipynb to utilize the new HTML dashboard renderer instead of standard print statements.
- Interactive Trace Dashboard: Introduced
render_trace_dashboardto visually render the Context Engine's execution trace.- Replaces raw text logs with a clean, CSS-styled HTML dashboard.
- Features collapsible steps, syntax-highlighted JSON, and status badges.
- Implemented in
Chapter08/Legal_assistant_Explorer.ipynbandChapter09/Marketing_Assistant.ipynb.
Data_Ingestion_Marketing.ipynb has been updated to clear or append data.
In section 2.Initialize Clients, we can clear the index of its content or append it:
clear_index = True # If True, empties the index namespaces. If False, appends to the existing index.Chapter01/Use_Case.ipynb
Chapter01MAS_MCP_control.ipynb
Chapter03/Context_Aware_MAS.ipynb
Chapter05/Context_Engine_MAS_MCP.ipynb
Chapter05/Context_Engine_Pre_Production.ipynb
Chapter06/Context_Engine_Content_Reduction.ipynb
Chapter07/NASA_Research_Assistant_and_Retrocompatibility.ipynb
Chapter04/Context_Engine.ipynb (fixed 1)
Chapter08/Legal_assistant_Explorer.ipynb (fixed 2)
Chapter09/Marketing_Assistant.ipynb (fixed 2
OpenAI API GPT-5.1:
GPT-5 has been upgraded to GPT-5.1, which improves API response time.
OpenAI API library has been upgraded to 2.8.1 in commons/utils.py, which is now the reference installation file for all notebooks in the repository.
OpenAI provided the following release notes that address, among other issues, latency for reasoning, which is important for MAS programs such as MAS Context Engine.
"We’ve released GPT-5.1 in the API, the next model in the GPT-5 series built to balance intelligence and speed across agentic and coding tasks. Here’s what’s new in GPT 5.1:
Adaptive reasoning that adjusts thinking time by task complexity—spending more time on complex tasks and responding faster on simple tasks. New reasoning_effort = 'none' mode, offers a fast, accurate non-reasoning path for latency sensitive use cases. Defaults to none when unspecified. Extended prompt caching with retention up to 24 hours to reduce latency for long-running conversations. Upgrades to coding: more communicative, highly steerable, better code quality, improved frontend UI generation. New tools: apply_patch (structured diffs) and shell (controlled local CLI). Pricing: Same pricing and rate limits as GPT-5."
Resolved an issue in the Context Engine where the Planner failed to parse valid JSON plans. Added support for the steps key in the LLM response schema to prevent execution errors.
- Moderation API Type: Resolved a critical formatting issue in
Marketing_Assistant.ipynb(Cell 4) where the OpenAI Moderation API failed withError code: 400when agents returned structured data (dictionaries or lists). Added logic to serialize these outputs into strings before submission.
- JSON Support: Added
import jsonto the execution cell to support data serialization.
- Output Rendering: Updated the
execute_and_displayfunction to detect JSON outputs and render them as formatted Markdown code blocks for improved readability in the notebook.
Repository made public.