Podcast Name: AI in Manufacturing Podcast (Industry40.tv)

Episode Title: Context Engineering Techniques for Building Reliable Industrial AI Agents

Guest: Zach Etier, VP of Architecture at Flow Software

Host: Kudzai Manditereza

This episode explores context engineering — the discipline of curating and managing the information supplied to AI agents — and why it is the key to building reliable industrial AI systems. Zach Etier, VP of Architecture at Flow Software, joins host Kudzai Manditereza to break down why simply pumping more data into an AI agent's context window actually degrades performance through dilution, hallucination, and lost instructions. Zach walks through three core context engineering techniques — persisting context, summarization/compaction, and isolation via sub-agents — and explains how each one maps to real manufacturing use cases like automated shift-handover reports. The conversation also covers the practical differences between skills, MCP servers, and sub-agents, and why deterministic code should handle calculations while agents handle orchestration. Finally, Zach makes the case that knowledge graphs with formal ontologies will become essential data architecture for scaling industrial AI across the enterprise. Whether you are evaluating your first agent pilot or planning multi-site deployment, this episode provides a concrete framework for engineering context that agents can reliably act on.

[00:33] — Meet Zach Etier — Zach introduces his role at Flow Software, his background at Northrop Grumman, and how he leads development of the Atlas knowledge modeling tool.

[06:04] — Defining an Industrial AI Agent — A clear breakdown: an agent is an LLM that can call tools in a loop, acting as an orchestrator that reasons on context to decide which tool to invoke next.

[09:54] — Shift-Handover Report Demo — Zach describes a concrete use case where an agent passively generates a shift-change report by pulling data from a historian, operator notes, the UNS, and MES/PLC data.

[12:58] — From Prompt Engineering to Context Engineering — Why reasoning models and tool-calling changed the game: prompts are static, but agent context is dynamic.

[16:37] — The Softmax Dilution Problem — How adding too many tokens dilutes relevant information through the normalization process, causing hallucinations and missed instructions.

[17:17] — Lost in the Middle — The Stanford "needle in a haystack" study showing agents recall content at the start and end of the context window but lose information in the middle.

[19:50] — Context vs. Knowledge — Context is curated knowledge packaged for a specific task — you don't read the entire equipment manual, only the sections relevant to your troubleshooting task.

[25:00] — Three Categories of Industrial Context — Domain knowledge (equipment manuals, SOPs), data context (historian, UNS, MES), human-generated context (operator notes, Excel sheets), and behavioral context (skills, guardrails).

[30:00] — Technique 1: Persisting Context — Writing context to the file system so agents (or sub-agents) can read curated information in future sessions.

[31:27] — Technique 2: Summarization/Compaction — Condensing large context into essential insights; why auto-compaction sometimes breaks agent behavior.

[33:56] — Technique 3: Isolation via Sub-Agents — Spinning up agents with clean context windows to offload research and prevent bloat in the main agent.

[36:05] — Deterministic Tools for Calculations — Why OEE and other calculations should be handled by validated scripts exposed as tools, not computed by the probabilistic model.

[54:21] — Knowledge Graphs for Enterprise-Scale AI — How ontologies provide a "map of meaning" that helps agents navigate large instance models across multi-site enterprises.

[1:02:00] — Federated Knowledge Graphs — Zach's argument for domain experts owning their own models, with governance at the integration interfaces between domains.

"Context is curated knowledge that is packaged for a specific task." — Zach Etier, VP of Architecture at Flow Software

"If you have something that can be done with a deterministic tool, it should be done with a deterministic tool. Don't use an agent to do a calculation." — Zach Etier, VP of Architecture at Flow Software

"You get the reliability by managing the context window." — Zach Etier, VP of Architecture at Flow Software

"Agents can't do on-the-job training. The context needs to be digitized and packaged in a way the agent can reason on." — Zach Etier, VP of Architecture at Flow Software

"My hope is agents being this passive thing happening in the background — augmenting humans rather than becoming the team." — Zach Etier, VP of Architecture at Flow Software

Context Engineering Definition: The practice of curating, managing, and optimizing the information placed into an AI agent's context window so that it contains only highly relevant content with no bloat. Why it matters: It is the primary lever for improving agent reliability and reducing hallucinations in industrial settings. Episode context: Zach contrasted it with prompt engineering, explaining that reasoning models and tool-calling made agent context dynamic rather than static, creating the need for deliberate context management.

Context Rot (Softmax Dilution) Definition: The degradation of an agent's ability to reason on relevant information as more tokens are added to the context window, caused by the softmax normalization distributing attention weight across all tokens. Why it matters: It explains why "more data" often leads to worse agent performance, which is counter-intuitive for many engineering teams. Episode context: Zach explained this as the core reason the industry shifted from "give the agent everything" to deliberate context engineering.

MCP (Model Context Protocol) Definition: A standard protocol that allows AI agents to connect to external tool servers, where the server supplies tool descriptions and context so the agent knows how to call tools it was never trained on. Why it matters: It enables agents to interact with industrial software like historians, MES, and ERP systems through a standardized interface. Episode context: Zach compared MCP to skills, noting that MCP loads all tool descriptions at once (potential bloat) while the vendor controls the context, whereas skills give users control with progressive disclosure.

Knowledge Graph (Ontology + Instance Model) Definition: A data structure combining an ontology (a model of meaning that describes domain concepts and relationships) with an instance model (actual data and values), linked by explicit relationships. Why it matters: It provides AI agents with a navigational map of the domain, enabling reasoning across large, complex enterprise data landscapes. Episode context: Zach described knowledge graphs as the future data architecture for industrial AI, and explained Flow Software's Atlas product as a knowledge modeling tool built on this approach.

Isolation (Sub-Agent Pattern) Definition: A context engineering technique where a sub-agent operates in its own context window, separate from the main agent, to perform research or noisy tasks without contaminating the main context. Why it matters: It prevents context poisoning and bloat in the primary agent, enabling multi-agent coordination for complex industrial workflows. Episode context: Zach used the example of a research sub-agent that reads many files, filters for relevance, and returns only the essential findings to the main agent.

Tools & Technologies: Flow Software Timebase (Historian, Explorer, Collector), Timebase Atlas (knowledge modeling tool), MCP servers, Claude Code, OPC UA, Unified Namespace (UNS)

Concepts & Frameworks: Context engineering, Lost in the Middle (Stanford paper), softmax normalization, needle-in-a-haystack testing, context rot, context poisoning, context confusion, research-plan-implement workflow, progressive disclosure, federated knowledge graphs

Companies & Organizations: Flow Software, Anthropic, Northrop Grumman, Google (Gemini), OpenAI

Standards & Architecture Patterns: ISA-95, knowledge graphs, ontologies, Unified Namespace, MCP (Model Context Protocol)

Zach Etier is the VP of Architecture at Flow Software, where he leads the development of knowledge graph technology (Timebase Atlas) and AI integration across the product portfolio. Before Flow, he spent 10 years at Northrop Grumman, starting in additive manufacturing operations and moving to the CIO office to architect digital manufacturing and Industry 4.0 service lines. He holds degrees in mechanical engineering, aerospace engineering, and computer science.

Q: What is context engineering in manufacturing AI? A: Context engineering is the practice of curating and managing the information placed into an AI agent's context window so it contains only the data relevant to a specific task. In manufacturing, this means selectively providing historian data, equipment manuals, operator notes, and MES information rather than flooding the agent with everything available. The goal is to maximize reasoning quality while minimizing hallucinations caused by token dilution.

Q: Why do industrial AI agents hallucinate, and how can you reduce it? A: Industrial AI agents hallucinate primarily because of context rot — when too many tokens are loaded into the context window, the softmax normalization process dilutes the attention paid to relevant information. This is compounded by the "lost in the middle" effect, where agents fail to recall content positioned in the center of long inputs. Reducing hallucinations requires managing the context window through techniques like summarization, sub-agent isolation, and persisting only curated context.

Q: What is the difference between MCP servers, skills, and sub-agents for industrial AI? A: MCP servers provide vendor-defined tool descriptions and context through a standard protocol, loading all tools at once. Skills are user-defined instruction sets with progressive disclosure — only metadata loads initially, and full content loads on demand. Sub-agents are separate agents with isolated context windows, used to offload research or noisy tasks. MCP is best when the vendor knows best how to use their tools; skills offer granular user control; sub-agents manage context isolation.

Q: How do knowledge graphs help AI agents reason about factory data? A: Knowledge graphs combine an ontology (a conceptual model of domain relationships) with an instance model (actual operational data). The ontology provides agents with a navigational map that explains how equipment, production lines, and processes relate to each other. Without this, agents see only flat data values and lose context in large enterprises. Knowledge graphs enable agents to traverse from a specific equipment instance up to conceptual relationships and back, dramatically improving reasoning across complex multi-site operations.

Q: Should AI agents perform OEE and other manufacturing calculations? A: No. Manufacturing calculations like OEE should be handled by deterministic scripts that are validated through traditional software testing and then exposed to the agent as callable tools. AI agents are probabilistic and can make calculation errors. The agent's role is orchestration — deciding when to call the calculation tool and how to present the results — not performing the arithmetic itself.

Q: What is the best data architecture approach for scaling industrial AI across an enterprise? A: A federated knowledge graph approach is recommended, where domain experts define knowledge models for their specific areas (manufacturing, quality, engineering) and governance is applied at the integration interfaces between domains. This aligns with how organizations actually operate, since no single person understands the full enterprise. Federation avoids the impractical requirement of building one monolithic ontology upfront while still enabling cross-domain agent reasoning.