2026-11-15
Knowledge Graphs for Manufacturing: Giving AI the Context of Your Factory

Show notes
AI answers get better when it understands the context of your factory. In this episode of the iFAKT series, we discuss knowledge graphs: modeling equipment, processes and relationships, and linking them to AI. You will learn how a graph can give AI the context it needs. Who it is for: Data architects, AI teams and manufacturing engineers. Become a supporter of this podcast: https://www.spreaker.com/podcast/m365-fm-microsoft-365-azure-cloud-power-platform-ai--6704921/support. This episode includes AI-generated content.
Host: Mirko Peters
Related articles
- What Is a Smart Factory? A Plain Explanation for Plant Managers
- Product Mix Planning in Manufacturing: Decide What to Make
- OEE Software: How to Choose It and Roll It Out Without Regret
- Modular Production Planning Software: Which Modules to Add First
- Manufacturing Optimization in Aerospace: What to Optimize First
- Manufacturing KPI Dashboard: What to Show and How to Build It
- Automotive Production Planning: Leveling, Sequencing, Changes
- Value Stream Mapping Examples From Discrete Manufacturing
Transcript
Read the full transcript
iFAKT - Knowledge Graphs for Manufacturing - Giving AI the Context of Your Factory 00:00:00 Speaker: Imagine a machine stops halfway through an urgent order. You ask your AI assistant which deliveries face delay, but it only knows the machine status, not which orders depend on it or which alternatives are approved. That gap changes what the assistant can tell you. I want to work through what factory context actually means, where Microsoft technology fits, and how a narrow first use case can help a planner assess an outage without pretending to solve the whole production schedule. Let's follow the failure beyond the machine itself for this hypothetical example. Picture machine for cutting parts during the morning shift with one batch already finished and the next batch still clamped inside the machine. Then a fault stops the cycle. The operator checks the fault and calls maintenance, but nobody can yet give the planner a firm time for when production can safely start again on that machine, the order still needs those parts. At first, the planner's question sounds simple how much work remains on machine for, and can another machine finish it before the parts need to reach the next step in the production route? The order belongs to a customer expecting shipment tomorrow, and the remaining parts still need a finishing step before inspection can clear them for packing and dispatch. cutting isn't the last job. That finishing step has a slot later today shared with other work that also needs to leave the plant, so missing the slot could push the order behind another batch. Now the outage threatens a hand off. The planner opens the production records to check progress, because the planned quantity doesn't explain how many parts have actually cleared the operation and how many remain inside it. A partial batch complicates the answer. Some parts sit beside machine for, others have already moved toward finishing, and the operator still needs to confirm whether the interrupted cycle left the clamped parts usable. The planner can't treat them all alike, so the first task involves a few calls. Before choosing another machine, the planner needs a checked count of finished parts, unfinished parts, and parts that might need further work after the stop. Meanwhile, someone suggests moving the remaining work to machine six, which runs similar jobs and appears to have a gap before its next planned order begins this afternoon. It sounds like a sensible option, but the urgent order uses a shared tool. That tool sits on machine four, and another order expects to use it later, so moving the job could change more than one machine assignment. The planner needs to know whether the tool can move now. How long the change will take, and whether moving it would interrupt work that somebody else has already prepared. An empty machine doesn't settle that. Then there's the material batch allocated to the order, with some stock already cut into blanks, and the remaining stock held near the original machine for the next run, someone needs to check what's actually ready. The planner can't simply tell machine six to start. The right blanks need to reach the machine, and whoever prepares the job needs to know which material belongs to this order before loading anything. While those checks continue, the finishing team asks whether it should keep the slot open or bring forward another batch that already sits ready beside its work area. Waiting also changes the plan. If they prepare for the urgent order and the parts don't arrive, they lose setup time, but switching to another batch could remove the wrote back when cutting finally restarts. Neither choice comes free. I wouldn't call this a slow planner. The planner is checking whether a proposed move can actually work. While several people hold facts that could change the choice within the next few minutes, maintenance knows what it's checking on machine for. The operator knows where the interrupted run stopped, and the finishing team knows how long it can wait before changing its work. Those answers need to meet under time pressure. It's tempting to move the order first and resolve the details afterward, especially when the customer commitment keeps coming up in every call about the outage. That's how rushed changes spread. The planner might save time at cutting, but lose it at finishing, or move a shared tool and leave another team ready to run a job it can no longer start. The local fix creates another delay. So before judging the delivery risk, the planner checks the order, record the current, run the tool booking the material batch and the finishing slot with the people responsible. Each check answers something different. That's the work behind the question which orders are affected? Each system holds part of the answer, and the planner still has to work out how those parts depend on one another during this particular outage. It helps to ask what each system actually records. Your enterprise resource planning system, or ERP manages business commitments and planning records, but the detail it holds depends on how your plant runs and configures it. An order might carry a quantity, a required date, and a product reference, along with planned operations and material requirements that guide purchasing and production planning across the business. Those records support real decisions. Calling ERP a system that only records yesterday misses its planning role because it can also hold future demand, plant supply, resource assumptions and dates that teams use to coordinate work. The question is how those records stay current. A planned completion date expresses an expectation based on the planning inputs and rules, while a posted completion records a business transaction that someone or something has submitted. Those aren't the same kind of statement. Your manufacturing, execution system or mess works closer to production. Depending on its scope. It can manage dispatched work, record operations, starts and completions, and collect quantities, scrap reasons, and the production history attached to a job. That gives you a different kind of detail. When a planner checks an operation, the mess might show that work has started, how much output the team has reported and which equipment recorded that activity. Even here, the recording method shapes what you know. If operators report quantities at the end of a run. The latest production record won't necessarily describe the physical count at the moment you ask the question. Automated collection can reduce that reporting gap, but it still depends on what the collected event means and whether the production system accepts it as evidence of completed work. A cycle count isn't always a good part count. Then you reach the machine signals themselves. A control system might report a fault code, a cycle state, or a mode change much faster than a person can enter a production update into another system. Those signals describe the equipment within the limits of its controls and instrumentation. So an idle state might mean a planned pause, a missing input, or a problem that needs attention. Idle alone doesn't explain the cause. Even the same fault code can carry different meaning across equipment models, controller versions, or machine builders, which makes the equipment documentation part of interpreting the signal correctly. The code needs its equipment context. I wouldn't rank these sources from smartest to simplest. Each captures a different part of production at a different pace, with different rules about when a change becomes a record that another team can trust. There's also the spreadsheet nobody mentions in the architecture meeting. It might hold a dispatch sequence, a list of exceptions, or a note about a setup rule that the formal planning records don't currently express. That doesn't automatically make the spreadsheet a bad practice. Sometimes it lets a planner handle a real constraint quickly, especially when entering the same rule into a larger system would require a change request and testing. The concern starts when that local rule changes a production decision, but remains invisible to everyone using the formal records, including an assistant asked to explain the current situation, its importance comes from its use. I'd ask who maintains that sheet and why people trust it. The answer may reveal a reporting delay, a missing field, or a practical exception that the current system design doesn't give people a useful way to record. Connecting these sources gives you access to more records. You can move ERP orders, mess updates, machine events, and selected spreadsheet entries into a shared data platform without changing what any individual record actually means. The remaining work concerns the meaning between those records. A successful data transfer tells you that a row arrived, but it doesn't establish whether a machine event should change an operation status or alter a planning assumption. That's where I draw the distinction between connected records and connected meaning because a planner needs to know how one reported fact changes the interpretation of another before acting on it. Access gets the records within reach. I'd give factory context a fairly strict definition. It's the relationships and operating conditions that let you interpret a production fact for a particular decision, together with when those relationships apply and what evidence supports them. Start with the identity behind the event. When the outage arrives, the useful connection runs from the specific piece of equipment to the operation assigned there, and from that operation to the production order it belongs to that connection needs a precise meaning assigned to run. Describes a planning decision while currently running describes execution. So the context must tell you which relationship you're following when you ask about the interrupted work. Suppose the assignment changed just before the fault. If the assistant follows yesterday's assignment, rather than the operation active at the time of the stop, it could name the wrong order while correctly identifying the failed machine. A relationship only helps if it applies. Now for the planner's question. Context needs to establish which assignment covered the outage rather than simply finding an order that has some connection to the equipment. Operating conditions at another part of that meaning a process might require the machine to run within a stated range using a particular setup. So a general link between that process and the machine doesn't describe every valid use. This is where capability and availability need separate treatment capability describes the work a resource can perform under defined conditions, while availability describes whether that resource can take work during the period you're asking about. Machine six could remain capable while unavailable. Its ability to perform the cutting step doesn't disappear when another job occupies it, and an open period doesn't expand the range of work it can perform for an assistant. Those should be separate questions. First, does the equipment meet the requirements of this operation, and then does it state during the relevant period allow it to take that work? The answer might remain incomplete. You could have evidence for capability but no checked availability for the afternoon, which gives the planner a specific information gap rather than an unsupported suggestion to move. Production. Context also depends on the decisions. Time frame an outage that matters immediately to the operator might have little effect on today's handoffs if the next operation doesn't need the output until a later shift, change that timing and the consequence changes. Keep the same machine, the same fault, and even the same remaining quantity, but place the next required handoff sooner and the planner faces a different exposure. The order matters just as much. Two orders waiting for the same operation can carry different consequences, because one has room before its next required step, while the other has already used that room. So context belongs to a situation, not just an asset. A detailed equipment record can describe the machine well, but assessing an outage requires the relationships around that machine during the period the planner needs to examine. Evidence keeps those relationships grounded. If a record states that an operation belongs to an order, the context should retain a way to check that statement against the production record that supports it. That doesn't mean reading every supporting record aloud. It means the answer rests on identifiable records, rather than on the assistant's assumption that two items belong together because their descriptions happen to sound related. I'd use a simple test here for any claimed consequence. Can you explain which relationship connects the outage to the order when that relationship applies, and which record supports the connection you're relying on? If you can't, the context still has a gap. The useful next step is to identify the missing connection, whether that's an active operation assignment or a condition attached to the equipment's ability to perform the work. You can begin with a small relationship model. Describe the equipment, the operation, and the order. Then state how they connect under what conditions and during which period those statements hold. Before adding an AI layer. That small model has a name, a knowledge graph. It represents named things and the relationships between them with enough meaning attached to those relationships that a system can follow them to answer a question. The name things are often called nodes. In our example, machine for gets a node, the interrupted cutting operation gets another, and the urgent production order gets its own. Rather than combining everything into one equipment record, each node has a type calling something, a machine, an operation, or an order tells the system what sort of thing it represents and which relationships make sense for that type of thing. Relationships connect those nodes through stated meanings. Instead of storing a loose association between the order and the cutting operation, we can state that this order requires this operation, which gives the connection a defined purpose. Listen to the chain as a sentence. The order requires the cutting operation. The cutting operation uses machine four and machine four carries a current state of unavailable following the reported stop. During this run. The graph keeps those statements distinct. The orders required quantity belongs with the order, while the machine's equipment type belongs with the machine, and the assignment can carry facts about the relationship itself. A connection can have its own details. For example, the assignment between an operation and machine four can identify whether the machine is the primary assigned resource or a supporting resource for that particular operation. That distinction changes how a query follows the graph. If machine four only supports a separate activity, treating every connected operation as interrupted would produce a different answer from following the primary assignment for the stopped run. Direction matters as well. Order requires operation gives us a path from the order toward its required work. While following that same relationship, backward lets us find the order that requires the operation. Reversing the path doesn't reverse the meaning. When we start at machine four and work back toward the order, we're asking which operation uses this machine and which order requires that operation, not whether the machine requires an order. That's why relationship names deserve care. A label such as related to leaves the query with little to work with, because it doesn't distinguish required work from a past association or a passing reference. More links don't automatically produce a better answer. A useful graph gives each connection a purpose, so the query can select the relationships that answer the production question and leave unrelated connections out of the result. There's also a difference between stored and derived statements. The production system can explicitly record an operations machine assignment, while a query can use that assignment and the outage state to derive that an order has exposure. I'd keep that distinction visible. This operation is assigned to machine four comes from a source record. While this order is exposed to the outage follows from that record. Under a stated rule for assessing exposure, a derived statement needs a rule you can inspect. If the rule says that an unfinished required operation assigned to unavailable equipment creates exposure. You can check the conditions and understand why the order enters the result. Exposure still doesn't establish a missed delivery. That stronger claim needs further evidence, so the graph should preserve the narrower conclusion supported by the dependency path, rather than quietly turning it into a confirmed delay. Unverified claims need their own treatment. If someone suggests that another machine can take the work, the system can retain that suggestion as a claim without treating it as an established relationship. In the approved model, the graph doesn't make a statement true. Its job is to express the statement clearly enough that you can distinguish a recorded assignment, a rule based conclusion, and a suggestion that nobody has checked yet. Now we can ask whether the model earns its upkeep. Those distinctions give us a way to explain the outages reach, but someone still needs to define and maintain the relationships whenever the underlying production records change. That effort needs a production reason. Before choosing how to build the graph, I test whether the questions you need to answer really benefit from following these relationships, and whether that benefit justifies maintaining them. I'd put a relational database on the short list first. If your production records already connect equipment assignments to operations and orders through stable identifiers, a well-designed query may answer the question without another storage platform. Tables can handle relationships perfectly well. A join lets you combine records through shared identifiers, so the presence of several connected objects doesn't by itself create a reason to move away from relational storage. Consider a report with a fixed scope. If it always checks, the same production area, follows the same assignments and returns the same fields. Your team may find a maintained database view quite straightforward. That can be the right engineering choice. You get a defined query that people can test and support using skills and tools your organization already has, rather than adding a new system. Because the topic sounds interesting, the calculation changes when the questions keep branching. A request might begin with equipment assignments then need to follow shared resources across several operations, with the number and type of connections varying between cases. A graph approach can make those paths easier to express. Rather than writing a separate fixed query for every path. Your team can work with defined relationship types and rules for how far a search should follow them. But easy expression doesn't guarantee faster execution. Performance depends on the storage engine, the amount of data, the shape of the connections, and how tightly you limit the question you're asking of that data. A broad search can still become expensive. If a query follows every possible connection without a useful stopping point, graph storage won't rescue a question that effectively asks the system to examine the entire plant. I test actual questions, not database labels. Take representative requests from the people who will use the answer. Then compare how each design handles those requests with data. Volumes that resemble your intended workload. Include awkward cases in that test. A design that works well for a machine with a few assignments might behave quite differently for a shared resource connected to work across many production areas, there's a separate choice about the model itself. You can define a knowledge graph, concepts and relationships while storing the underlying records in relational tables, provided your implementation preserves those meanings and supports the required queries. The model and the database aren't the same. Decision one defines what your production facts mean and how they connect, while the other determines how you store, update, and retrieve those facts in practice. That separation gives you room to start simply. You can establish whether the relationship model helps answer the question before committing to a dedicated graph database. Although changing storage later will still require engineering work, maintenance belongs in the comparison from the start. Ask how much effort each option needs. When a relationship type changes, a query grows another step, or the volume of connected records increases beyond the initial test. Team skills count as part of that cost. A platform that feels clear to its designer can become hard to support. If the people responsible for daily operation can't diagnose a slow query or correct a modeling error. I'd also set a response time requirement. In plain terms, an answer needed during an active disruption has a different operating requirement from an overnight analysis, and both designs should face the same test under expected load. Measure the whole request, not just the database lookup. Preparing the query and assembling its result also take time, so a fast traversal alone doesn't prove that the planner receives a usable answer quickly enough. 00:16:52 Speaker: The choice should survive a fairly dull review. You should be able to explain which questions become easier, what the team must maintain, and why the added operating cost makes sense for those questions. If that case doesn't hold, keep the simpler design before selecting storage. Write down the production question, the relationships it must follow, and what counts as an acceptable answer. Then choose the implementation that meets that need. Put the planner's wording into the first design discussion. Ask what they need to know when the outage call arrives. Before anyone starts describing databases or asking which AI model should answer the question. For our hypothetical outage, I'd start with one request which unfinished orders have work assigned to machine for between now and the end of this shift? That gives the team a question it can actually build against the wording leaves several choices open for agreement. Does the planner want only work already dispatched, or also work planned for later in the shift? That hasn't yet reached the point where an operator can start it. Those two requests produce different results if you include future assignments, the answer can help the planner prepare for further disruption, but it must distinguish those assignments from the work interrupted by the stop. I'd settle that with the planner, not guess. For a first version we could include both while keeping interrupted work separate from work. Scheduled to use machine for later within the agreed period. Then ask what the planner would do with that result. Perhaps they need to contact the owners of the exposed orders, check the next handoff, or decide which uncertainty deserves a phone call first. That tells you how much explanation the answer needs. A list of order numbers might support a quick lookup, but it won't help someone judge which entry needs attention unless the reason for inclusion comes with it. So the next question should follow naturally. Why is this order included? The answer should identify the unfinished work that connects it to the outage, rather than asking the planner to accept a label without a reason, there's a useful design exercise here. Ask the planner to choose one order they expect to find, then describe what they'd need to read or hear before trusting its inclusion in the result. The response becomes part of the answers requirements if they need to distinguish work underway from work merely expected later, that distinction belongs in the response, not in a separate investigation. After every request, the next follow up concerns what the result leaves unresolved. What information would change this assessment? Gives the planner a way to direct further checks. Instead of treating the initial answer as a finished judgment, make that question specific to the order. If the remaining work hasn't been confirmed, the response should say that the order's inclusion depends on an unfinished assignment whose actual progress still needs checking. That gap can guide a useful call. Instead of asking someone to review the whole job, the planner can ask whether the assigned operation still needs machine time during the period covered by the assessment. Keep the task at impact assessment for now. The first service helps establish which orders warrant attention and why. While the planner retains responsibility for deciding what checks or changes should follow from that information. Rescheduling starts a different piece of work. Once you ask where an operation should move or when it should start, you're asking the system to propose a changed plan rather than explain the reach of the outage. Dispatch. Goes further because it directs work. A request to identify exposed orders shouldn't quietly become permission to issue new instructions to production, even if the same assistant could eventually support both workflows. Write that boundary into the initial brief. Users should know that asking about an outage returns an assessment for review, and that moving work or issuing instructions remains outside this first task. Choose one production area with its planners that keeps the first question tied to a known set of working practices. Rather than expecting an early model to account for every local exception across the plant. Give the question a firm time boundary, too. For this example, the end of the current shift provides a practical stopping point with any assessment beyond that period left outside the agreed scope. Now the model has a concrete job. We can identify the smallest set of factory objects needed to answer that bounded question, and leave out anything that doesn't help explain an orders exposure. I'd organize those objects around products, processes, and resources. These give the team a practical way to describe what production needs to deliver, what work that requires, and what the plant uses to perform that work. Begin with the product definition for the urgent order. That means the part the customer expects, including the revision and quality requirements that determine what the finished parts must satisfy before production can count them as acceptable output. A product number alone might leave too much open. If the same part exists under different revisions, the model needs to connect the order to the required revision, rather than treating every version as interchangeable because they share a name. Keep the requirements attached to that product definition. A required surface finish, for example, helps explain why a particular operation belongs in the root without forcing the planner to read the full engineering specification whenever an outage occurs. The process describes how production reaches that result. Here we need the operations required for the ordered product, their sequence, and any allowed alternatives with enough detail to distinguish a required step from a preferred way of performing it. Sequence gives those operations their place in the work. If inspection follows, finishing the model should express that dependency directly, so a query can distinguish work that must wait from work that can proceed independently for this product. Allowed alternatives belong beside the required sequence. A product might permit more than one route through production, but the model should use the alternatives supplied by manufacturing records rather than create a new route from loosely similar operation descriptions. Resources describe what performs or supports the work equipment belongs here, along with tools, people, and other production means. Because an operation can depend on more than the machine named in its main assignment, don't turn each resource into a complete digital replica. For this task, the model needs the resources role in the operation and the links required to assess exposure, rather than every technical detail someone could collect about it. There's a distinction between an operation definition and its execution. Cutting as a defined process describes a kind of work. While the cutting operation for this particular order represents work that someone plans, starts, and eventually completes that distinction keeps the model usable across orders. Several orders can refer to the same process definition while retaining their own operation records, so a change in one order's progress doesn't alter the recorded progress of every order. Using that process, the production order connects the requirement to actual work. It points to the product and revision being requested, then to the operations needed for that order, which in turn connect to the resources assigned to perform them. Materials need a place in this structure to connect a material requirement to the operation that consumes it and to the order it supports. So the relationship describes where the material enters production, rather than merely associating it with a product. Keep that link as narrow as the question requires. If material detail doesn't affect whether an order has unfinished work on the failed machine, it can remain outside the first query while still fitting the model for later use. I checked the model with a real planning record. Ask a planner to identify the ordered product, follow its required operations, and point out the resources involved. Then compare that account with the relationships the team proposes to store. Stop when the bounded question has enough structure. You don't need every utility department or spare part represented before you can assess the orders assigned to one production area during the current shift, the next check concerns the names behind those connections. Before trusting a link from an operation to a resource, we need to establish whether the resource named in one system represents the same thing named elsewhere. Try searching for machine four in the maintenance register. In this hypothetical plant, maintenance lists it under an equipment number. The production system calls it Cutting Station four, and the machine gateway sends events under a controller address. None of those names needs to be wrong. Each system identifies the equipment in a way that suits its own task, but the context model needs a checked connection between those identifiers before it combines their records. Otherwise, the outage can attach to the wrong resource. A label such as M4 might also appear in another production area, so matching on that text alone could connect the fault to assignments belonging to different equipment. I'd give the physical asset a stable internal identifier. Keep that identifier independent of its display name, network address or location so routine changes to those details don't accidentally create a new machine in the model. Keep the original source identifiers beside it. The mapping should state which system supplied each identifier, because an equipment number without its source can look unique, while another system uses exactly the same number elsewhere. That gives every incoming record a defined lookup. An event carrying a gateway identifier can resolve to the stable asset identifier through a maintained mapping. Rather than asking an AI model to guess which machine the text describes. Someone needs to own that mapping maintenance might confirm the physical equipment identity. While the production systems team confirms the execution resource with a named person responsible for reviewing changes that affect the connection between them. Matching rules need that same ownership. The team should record which fields support a match and which combinations require review, so a later integration change doesn't silently replace a checked rule with a loose text comparison. Some matches will be straightforward. A unique equipment reference recorded in both systems can provide a firm basis for linking records, provided the responsible teams confirm that the reference actually identifies the same physical asset. Other matches deserve a pause. Similar descriptions, nearby locations or matching machine models can help someone investigate, but they don't establish identity when several pieces of equipment share those details across the plant, hold those cases outside the confirmed mapping, show the candidate matches and the reason for uncertainty to the person reviewing them, then retain the review decision so the next import doesn't reopen the same question. An unresolved match should remain visible to the planner. If an outage event can't be tied confidently to a production resource. The assessment should identify that gap rather than quietly merge records and return a neat but misleading order list. There's another distinction inside the plant itself the physical machine and the production role it fills need separate identities because the equipment occupying a work center can change while the planning reference stays the same. Suppose maintenance replaces the machine at cutting station four. Planning might continue assigning work to that station, while the replacement carries a different equipment number, and the removed machine remains in the maintenance history under its original identity. Those records should describe a replacement, not a rename. Keep the station as a production role. Give each physical machine its own identity and record which machine occupies that role during the relevant period. That lets you follow the right connection. A fault from the removed machine shouldn't attach to new work, merely because both machines have occupied the same station, and historical production shouldn't shift onto the replacement. Check what the assignment actually points to. If production assigns an operation to a work center rather than a specific machine, the mapping needs to preserve that distinction. Instead of presenting the work center as physical equipment. Names can still change without breaking these connections. When someone renames cutting station for the stable, identifier should stay intact, while the mapping retains enough detail to interpret records that still carry the earlier name. Test identity with ordinary plant changes. Move equipment. Replace a controller, rename a resource and introduce a duplicate label in a test environment. Then check whether each record still resolves to the intended thing. Shared identity settles which thing a record describes. Once that connection holds, the teams can still disagree about what its status means, so matching the machine correctly leaves another piece of work before the records support a common answer. Ask two teams whether a resource is available. Maintenance might mean that no repair prevents its use, while planning means that it has room for another job during the period they're trying to schedule. Both teams can answer correctly and still disagree. The trouble starts when an integration takes either answer, places it in a field called available, and lets everyone else assume that the field matches their own definition. Released creates a similar problem. An order released for production might still contain material awaiting quality release, because those approvals refer to different things and come from different people with different responsibilities. The word needs an object and a defined purpose. Instead of treating release as one universal status, the model should distinguish order, release from material release and state what each permits within the plant's working rules. Complete deserves the same care. An operator might use it when physical work ends, while another team expects reported quantities and required checks before accepting the operation as complete in its own workflow. Don't settle that difference by choosing the loudest team right. Separate definitions where the distinction affects work. Then describe the condition under which one status can support a conclusion about another without erasing the difference. This shared set of definitions is often called an ontology. In plain terms, it names the kinds of things your model contains, the relationships allowed between them, and the rules that give those statements their meaning. Keep the first version small for the outage question. Define only the terms that affect which work enters the assessment, and how the planner should interpret the result during the agreed period. For example, unfinished operation needs a definition people can test. Does an operation remain unfinished until its remaining quantity reaches zero, or until someone accepts its completion? And how should the assessment handle a reopened operation? That discussion belongs with the people who run the process a production planner, an operator and the person responsible for production reporting can explain which distinctions change a decision and which merely reflect different ways of speaking. Engineers turn those decisions into contracts and checks. A contract states what an incoming record means, which values it can contain, and what conditions must hold before the system accepts a particular relationship or status. A check can reject an undefined status rather than guess. If a source introduces conditionally complete, the integration should flag that new value for review instead of quietly treating it as complete. Because the words sound close enough, free text still has a place people can explain unusual circumstances in notes, while the fields that drive the assessment use agreed terms whose meaning doesn't depend on how an assistant happens to interpret a sentence. Assign an owner to each shared definition. That person needs enough authority to resolve questions with the relevant teams, rather than simply maintaining a document that nobody consults when the source system changes. Changes need a practical review path. When a team proposes a new meaning for a status check, which queries and reports depend on the old meaning before accepting the change into the shared model. Keep earlier meanings identifiable when definitions change. Otherwise, a planner reviewing an earlier assessment could interpret its result using today's definition, even though the service applied a different rule when it produced that answer. Different plants can retain different working terms. A shared model can preserve a common definition for order release, while allowing a plant to describe an extra local review, provided that extension doesn't silently redefine the shared term. Local details should stay explicit. If one plant requires an extra completion, check, record that requirement as a local rule, rather than changing what complete means for everyone without telling the teams consuming the data. You can review this vocabulary using awkward examples. Give the team an operation with physical work finished but reporting still open. Then ask whether each agreed term describes that situation without forcing someone to add an unwritten exception. The test is whether people predict the same interpretation. When two teams read a modeled statement, they should understand what it permits them to conclude and which further questions still remain open for review. That gives us a firmer basis for describing equipment capability. Before connecting a machine to work, it can perform. We need agreed meanings for the terms that distinguish a technical ability from permission to use it. A capability claim needs conditions. You can check for the cutting operation. That means connecting the machine to the required process, the product revision, the tolerance and the tooling under which it can perform the work. Start with the operations actual requirements. In our hypothetical example, the urgent order needs a cut that must hold a specified dimensional tolerance using a setup defined for the product revision on that order. Machine six is general description won't answer that question. A record calling it a precision cutting machine tells us its broad purpose, but doesn't establish that this particular setup can meet the requirement. For this part, I'd model the supported combination explicitly. The relationship should describe which operation the machine can perform for, which product revision, within which limits and with which required tool and set up conditions in place that gives capability a useful boundary. A machine might support the rough cutting step for a part, but lack evidence that it can perform. The final cut within the tolerance required by the drawing tooling can narrow that boundary further. A machine's travel and spindle range might suit the work. While the required fixture doesn't fit its mounting arrangement or support the part correctly during the specified cutting sequence, the model needs to preserve that condition if capability depends on a particular fixture. The relationship should name that fixture rather than imply that any setup on the machine supports the same result for this operation. Technical suitability still leaves an approval question. Manufacturing engineering might have demonstrated that machine six can perform the cut, while the controlled route for this product revision still permits production only on machine four, both statements can belong in the model record the demonstrated capability with its supporting evidence, and retain a separate approval status that tells the planner whether production can currently use that alternative. For this work. I wouldn't let the assistant close that gap. Its answer can explain that a technically supported option awaits approval, but the authority to approve it stays with the people responsible for the manufacturing process and approved alternative needs a controlled reference that could be an alternate route or an approved resource assignment maintained in the manufacturing records, with a clear link to the operation and revision it covers. Follow that reference before presenting the alternative as permitted. If the approval covers an earlier product revision, the service should report that limit rather than assume the approval extends to the revision on the urgent order. Similar machines can carry different permissions. Two machines of the same model might use different fixtures or control configurations, and the plant may have accepted one configuration for this operation without accepting the other. Operating limits can differ even after approval. An alternative might permit a narrower range of part dimensions or a reduced cutting load, so a broad approved label can hide a restriction that changes whether this order qualifies. Those restrictions belong with the approval relationship. The query needs to check the order's requirements against the permitted conditions, rather than stop as soon as it finds a connection between the operation and another machine. 00:34:00 Speaker: Evidence should identify what supports each statement. A capability assessment might refer to an engineering trial, while permission comes from the controlled manufacturing record that accepts a defined machine and setup for production use. Keep those references attached to the relationship itself. Someone checking why machine six appears as an option should be able to find the evidence for that specific operation and setup, not just a general machine document. The answer can then stay precise. It might tell the planner that machine six has documented capability for the required operation, but the available approval doesn't cover the product revision on this order. That's a useful finding. Even without a permitted alternative, the planner can direct the question to manufacturing engineering with the missing approval clearly identified. Instead of asking someone to investigate the machine's entire suitability from scratch. A checked approval moves the assessment one step forward. It establishes that the machine and defined setup may perform this operation under the recorded conditions, without claiming that every other requirement for starting the job has been met. The next condition concerns what the machine will consume. Even with the right capability and permission, the planner still needs to establish whether the material assigned to this order can support the proposed work on that resource. Material readiness starts with more than a stock balance. For this order, we need to connect the required material specification to the cutting operation, then identify which allocated batch is intended to satisfy that requirement. A specification describes what the material must meet. The batch identifies a particular quantity received or produced under a traceable reference, which lets the plant attach inspection results and restrictions to that material rather than to the material type. Generally, that distinction changes the planners question. Instead of asking whether the plant stocks the right grade, the assessment asks whether the batch assigned to this operation meets the approved specification and carries the required release. An inventory record can show stock without establishing usability. Some of that quantity might already belong to another order, await inspection, or sit under a hold that prevents production from consuming it for the work being assessed. Allocation doesn't establish readiness either. A batch reserved for the urgent order might still need a quality decision, so the relationship between batch and order should remain separate from the batches Permission for use location adds a physical condition to that assessment. Material recorded in the warehouse can't support an immediate restart until the required quantity reaches the work area, in the form that the next operation can actually accept. The planner needs that difference stated plainly, allocated stock exists and released blanks already at the machine. Describe different situations with different checks required. Before anyone can issue a realistic instruction to start cutting, consider another development in a hypothetical outage. Quality places the remaining blanks from the allocated batch on hold after a receiving inspection result raises a question about whether they meet the specified material condition. The hold applies to those blanks wherever they sit. Moving them to machine six won't remove the restriction because the restriction follows the material batch rather than the equipment that happens to consume it. Machine six could now look ready and still lack usable input. The outage assessment should distinguish the equipment dependency from the material restriction, so the planner doesn't treat resolving one problem as resolving the whole operation's exposure. A batch hold needs a defined scope. It might cover the whole batch or a specifically identified portion, and the model should preserve that scope rather than turn every quality restriction into a blanket statement about all related stock. Partial release makes quantity checks more demanding. If quality releases only some blanks, the assessment needs the released quantity available for this order, not simply the total quantity listed against the batch in inventory. Traceability carries the connection through material changes when stock becomes blanks and those blanks become parts, the records need to retain the links that let the responsible team identify which output came from the restricted input. That path also limits unnecessary disruption. If the records distinguish affected material from other batches, quality can assess the relevant output without the assistant assuming that everything with the same material description shares the same status. Someone may suggest a substitute batch or grade. Treat that as a separate material choice, requiring evidence against the approved specification, rather than accepting a similar description as permission to consume it on this order. Substitution can carry conditions of its own. A permitted substitute might require a particular inspection or apply only to certain products, so its approval needs to connect to the intended use rather than sit as a general note, release authority stays with the designated quality process. The assistant can report or hold, explain which operation it blocks and identify the recorded release requirement, but it can't turn missing evidence into permission to proceed. A useful answer would keep those findings separate. It could explain that machine six is permitted for the operation while the allocated material remains on hold, and no approved released substitute has been identified for the required quantity that gives the planner a focused next check. Quality can clarify the material restriction, while logistics can confirm where any release stock sits and whether it can reach the operation within the period under review. Released material at the work area clears another condition. Whether that readiness supports production during the current shift still depends on who can perform the work and whether the required tools are free when they're needed. People introduce a different kind of production constraint for the proposed move to machine six, the planner needs to establish whether someone covering the relevant shift holds the qualification required for that operation, and setup. Being assigned to the machine isn't enough. The qualification record should connect the person to the work they are permitted to perform, including any limits that affect whether they can set up, run or check that operation. Those responsibilities can belong to different people. A shift might include someone qualified to run the established cycle, while setting up the fixture requires another person who isn't assigned to that area during the proposed production period. The model should preserve that distinction, otherwise, finding one qualified operator could produce an apparent staffing match, even though nobody on the shift can perform. The setup needed before the first part enters production. Qualification also needs a valid period. A record showing that someone completed training doesn't establish that their authorization still covers the proposed work, especially when the plant requires renewal or reassessment for that task. Return to our hypothetical afternoon move. Machine six has an open slot. The required blanks have reached the work area, and the shift roster names an operator whose qualification appears suitable for the operation. Then the qualification check finds an expired authorization. The service should report that the recorded authorization doesn't cover the proposed work period, leaving the responsible supervisor to check whether a current authorization exists or another qualified person can cover. Don't turn that into a judgment about the person. The finding concerns a production requirement and its supporting record, not an assessment of the operator's skill, performance or ability to carry out other work on that shift. Shift coverage needs more detail than attendance. Someone can be present in the plant, but committed to another operation, so the planner needs coverage for the required task, rather than a list of people currently clocked in. Supervision requirements can affect coverage, too. If the plant permits a task only with a designated supervisor present, that condition belongs with the staffing requirement, rather than remaining an assumption inside the shift team's daily arrangements. Tools introduce another set of assignments to check. Instead of treating the shared cutting tool as simply present or absent, connect its booking to the operations that need it and the periods those bookings cover. A tool can exist without being ready for use. Its recorded condition might require inspection or servicing before the next job, and that restriction needs to reach the planner alongside the booking rather than remain hidden in the tool room. Fixtures deserve their own resource records where they constrain work. If two operations require the same physical fixture. A query needs to recognize that shared dependency, even when the machines themselves have separate capacity available during the shift, maintenance windows can close and otherwise open slot. A machine might show no production assignment, while a planned maintenance task reserves it, so production bookings and maintenance reservations both need to inform the resource check. Keep the personal data narrow for this assessment, the service generally needs a controlled person reference relevant qualification status and shift assignment with any further details justified by the work the user actually needs to perform. A planner may only need a coverage answer. No confirmed qualified coverage for the proposed setup can identify the constraint without exposing training histories or personal information that doesn't help resolve the production question. Under review, access should follow the user's role. A supervisor responsible for staffing may need to identify a suitable replacement, while another user only needs to know that the operation lacks confirmed coverage during the requested period. That distinction should shape the model's outputs, store and retrieve only what's needed for the task and apply. Role based access to a production dependency doesn't become an excuse to expose personnel records across the plant. Assign upkeep to the people responsible for each resource shift. Supervisors can confirm coverage arrangements. The designated qualification owner can maintain authorization records, and two room staff can maintain the booking and condition information within their remit. All these connections have limits. In time. A person can cover an operation this morning, but not this afternoon. While a fixture becomes free after its current job and equipment enters a reserved maintenance window. The relationship needs to tell us when it applies. Without that boundary, the planner receives a collection of individually plausible facts that may never describe a period when the operation can actually run. I'd make the time question explicit in every assessment. Are we describing what production expects to happen, what the equipment has reported, or what the records show happened during an earlier period? Those represent different states. A planned assignment for this afternoon tells us where work should run, while an observed start tells us where execution began, even when those records point to different resources. Neither record should overwrite the other if production starts work somewhere other than the planned resource. Keeping both lets the planner recognize the difference between the intended assignment and the reported execution. Historical state needs its own treatment when reviewing an earlier outage, the service should reconstruct the assignments that applied. Then, rather than follow today's assignments and present them as the conditions surrounding that earlier stop. That requires more than saving the latest value when an assignment changes, retain when the previous assignment stopped applying and when the replacement began. So an assessment can select the relationship relevant to its requested period. Machine messages introduce another clock, the timer controller reports an event can differ from the time the receiving platform accepts it, particularly when a connection drops and messages wait locally before transmission resumes. Call those event time and arrival time. Event time describes when the reported change occurred, while arrival time describes when your architecture received the message and could begin using it in an assessment, consider a delayed recovery message machine for reports. A return to operation loses its connection, then stops again before the buffered recovery message reaches the shared context service after the newer stop message arrival order would tell the wrong story if the service treats every newly received message as the latest physical state. That delayed recovery could incorrectly replace the more recent outage with an operating status use event ordering rules suited to the source equipment timestamps, sequence numbers and clock quality can help establish that order, but the design needs an explicit response when those signals disagree or don't establish a reliable sequence. Plant clocks need attention here. If two systems disagree about the time and apparently precise timestamp won't reliably establish whether an assignment change occurred before or after the machine stopped during the run. Keep that uncertainty visible. The assessment can identify that it can't establish the sequence closely enough. Rather than choosing an order simply because one timestamp contains more digits than another. Validity periods answer a different question. They describe when a qualification assignment, route or approval applies, which can differ from both the time someone entered the record and the time your service received it. A future change illustrates the distinction. Manufacturing engineering might enter a route approval this morning That takes effect tomorrow. So receiving that record today shouldn't make the route permissible for work during this afternoon's shift. Expiry creates a similar boundary during an operation. If an authorization ends partway through the proposed production period, checking its validity only at the planned start leaves the rest of that period unresolved. Check the interval the requirement actually covers. The relevant rule might concern setup, the full run or a specific inspection, and the time check should follow that defined requirement. Rather than assume one rule fits every authorization. Now consider the whole answers. Timing. Suppose the operation assignments reflect a recent update. The equipment state hasn't arrived for several minutes, and the shift coverage comes from an earlier roster that hasn't been refreshed. Those facts don't form a checked current state. A useful decision snapshot states the time being assessed and establishes which records apply to it, while identifying any source whose updates can't support that assessment. A snapshot doesn't require simultaneous source updates. It requires a defined way to select applicable records, check their freshness against the task, and disclose where differing update times leave a gap in the answer. Set freshness limits with the people using the assessment. A delayed equipment update may prevent a current state conclusion, while an unchanged route can remain applicable much longer, provided its validity covers the requested period and its change feed remains dependable. Let the planner request an assessment time as of the outage. Supports a different investigation from as of now, because later developments can change the exposed work without changing what the earlier assessment could establish. Time makes the dependency path specific enough to examine. We still need to establish where its statements came from, because a relationship can carry the right dates while relying on a record nobody has checked. The planner needs a way to challenge the answer. When an order appears in the outage assessment, the service should let them trace the finding back to the records used, including how those records became the facts presented. That record of origin is called provenance. It identifies the source system, the particular record, its update time, and any processing that changed its meaning or structure before the assessment used it to reach a conclusion. A source name alone won't support that check from production data leaves the planner unable to locate the assignment, whereas a reference to the source operation record gives someone a specific place to investigate a disputed finding. Processing history matters just as much. Suppose an integration converts a source status into the shared definition of unfinished work, then uses that converted status to decide whether an order belongs in the assessment. Retain the conversion rule and its version. If the result surprises the planner. The team can then check whether the source record contains an error, or whether the conversion applied an incorrect interpretation to an otherwise correct record. Evidence also needs to follow derived conclusions for finding assembled from several records retain the references used and the assessment rule applied so a reviewer can reproduce the finding rather than merely confirm that its ingredients exist. The spoken answer can stay brief. It might identify the operation assignment supporting an order's exposure, then make the supporting record references available through the assessment record. For anyone who needs to check the details. Missing evidence needs equally careful wording. If the service can't find a current material release, it should report that release remains unconfirmed in the evidence it checked. Rather than declare that quality has rejected, the material unknown and negative require different responses. A confirmed restriction directs the planner toward the responsible release process, while an unknown status calls for a check that establishes whether permission exists before anyone judges the production consequence. Absence becomes evidence only under defined conditions. If a source owner confirms that every valid approval must appear in a particular register. A complete check of that register can support a narrower conclusion about the approval record. Without that assurance, keep the finding open. An incomplete import or an unavailable source might explain the missing record, and the answer should distinguish that retrieval problem from a checked absence in the authoritative system. Disagreement between records needs an explicit resolution policy rather than choosing whichever record arrived last. Assign authority by the fact being assessed, with the responsible teams agreeing which source governs that particular field. Different fields can have different owners. The equipment register might govern an asset serial number, while the designated quality system governs a batch hold, so neither source receives blanket authority over every fact connected to production. Some disagreements still need a person when two records claiming the same authority conflict retain both references and flagged the disputed field. Instead of letting the assistant select whichever wording seems more plausible, make the consequence of that dispute explicit. If the conflicting field determines whether an order enters the result, label its exposure unresolved and explain which confirmation would allow the service to classify it with the other findings. Fluent wording shouldn't change that classification. A language model can produce a confident sentence from incomplete evidence, so the application's evidence checks need to determine the answer's status. Before the model writes its explanation. For the planner, I'd avoid an unexplained confidence percentage. A number can hide whether uncertainty comes from a missing assignment, a disputed status, or an incomplete source check. Even though each problem calls for a different response from the planner, use evidence labels with defined meanings instead, supported by checked records should require the agreed evidence to pass its checks, while unresolved. Should identify the missing or disputed fact preventing the service from reaching that standard. Those labels need testing against real disagreements. If planners consistently interpret supported as a delivery guarantee, the wording needs changing because the evidence may establish exposure to an outage without establishing the final effect on shipment. This gives us a useful question about digital twins. When someone describes a maintained representation of the factory, we can ask which statements it supports with evidence, and which parts still depend on assumptions that the user needs to examine. I judge a digital twin by the job it supports. For our outage assessment, that job could be maintaining a digital representation of the production area that lets the planner examine the consequences of a reported equipment stop. The purpose sets the level of detail. A representation built for assessing order exposure needs different information from one build to study cutting vibration, even when both represent the same physical machine in the same plant. That's why I define the purpose before discussing twin technology. A digital twin is a maintained digital representation of something physical, used for a defined purpose, with connections to information about the thing it represents. 00:51:20 Speaker: Maintained carries a practical obligation here. Someone needs to keep the representation useful as the physical equipment and its operating conditions change, rather than treating the initial model as a finished engineering deliverable. The knowledge graph supplies structure within that representation. It expresses how the represented equipment connects to production work and other relevant things, giving the twin a way to describe dependencies beyond the boundaries of one asset. The two concepts describe different concerns. The graph describes connected meaning, while the twin brings a maintained representation into use for a particular operational task, potentially drawing on several kinds of models and data. You can build a twin using a graph based structure. You can also use a knowledge graph for tasks that don't involve maintaining a representation of a physical system, so neither term should automatically replace the other. For machine for structure tells only part of the story. Observations supply the changing state, allowing the representation to reflect reported conditions rather than remain. A description of how the production area is normally arranged. The update mechanism connects those observations to the representation it needs to interpret incoming changes and update the appropriate state. Because defining a machine in a model doesn't establish a working connection to that machine, that gives the twin something to describe. Now the planner can ask about the represented production area under its reported conditions, with the graph supplying the relationships needed to interpret those conditions for the stated purpose. A further question requires a different kind of model. If the planner asks how the area might behave under a proposed change, the architecture may need a simulation that represents the behavior relevant to that question. Consider the finishing step in our hypothetical plant to explore how waiting work might accumulate during an interruption. A simulation could represent processing times and the way work moves through that step. Understated assumptions those behavior rules need their own engineering. Connecting a machine to an operation doesn't tell a simulator how processing time varies, or how the operation behaves. When work arrives in a different sequence during the shift, a simulation can use the twin structure and reported state. Its predicted results still depend on its behavior model and assumptions which need checking against the purpose. Before anyone treats those results as a useful guide. Our first outage assessment doesn't require that addition. A twin supporting dependency inspection can meet its stated purpose without simulating production, provided users understand that its maintained representation supports assessment rather than a forecast of plant behavior. As your digital twins is one implementation option to assess, it supports defining models, creating digital twin instances, and connecting those instances through relationships, which can provide a model structure for an operational representation of the production area. Your organization still supplies the manufacturing, meaning the service doesn't decide what a cutting operation requires or which relationships matter to your planner. So those definitions remain part of the design work owned by the plant. The surrounding integration remains your responsibility too. You need to connect source information, arrange updates, and build the application behavior that makes the represented state useful. To someone asking a production question during an outage, I'd assess its fit against that actual workload, its modeling and query behavior need to suit the representation you intend to maintain, rather than assuming that a service with digital twins in its name settles the architecture, the representation can also draw on information held elsewhere. Choosing a twin service doesn't mean every supporting record must move into it, especially when another system already manages that information in a form suited to its use. That leaves a concrete storage decision. We need to choose what the relationship model must hold directly and what it should reference, so maintaining the twin doesn't become an obligation to copy every piece of factory data. A practical dividing line is the kind of question each store answers, sends a history, supports questions about measured behavior over time, while the relationship layer supports questions about which production objects connect and what those connections mean. Those workloads ask different things of storage. A sensor analysis might read a continuous stretch of measurements, compare values across channels, and calculate changes over an interval without following any production relationships at all. Keep those measurements in storage suited to that work. Depending on the plant's needs, That could mean an industrial historian, a time series database or analytical storage designed to handle timestamped readings at the required volume. The graph can retain a reference to that history. That reference should identify the relevant data source and measurement channel. So a request about an asset can locate its readings without storing every reading. As another graph object, consider spindle current on machine for during a cutting run, the collected readings could support an investigation into changing load, but the outage assessment doesn't need to traverse a separate relationship for each current measurement, it needs a much smaller piece of information. The operation connects to the machine, and the machine connects to a defined measurement channel whose history can be retrieved when someone needs to investigate the reported stop. That channel definition deserves care. Its unit measurement, location, and connection to the physical equipment help distinguish a useful reading from a number whose interpretation changes depending on which sensor supplied it. A channel name isn't enough if a monitoring device measures a shared power supply, assigning its readings directly to one machine could imply an equipment specific observation that the instrumentation doesn't actually support. Keep the measurement scope explicit in the relationship model. A shared measurement can connect to the equipment group it covers, while a machine specific channel can connect to the particular asset whose behavior it records. This also helps when instrumentation changes. Replacing a sensor or changing its configuration should leave enough information to establish which measurement definition applies to the historical interval being investigated, rather than applying today's setup to earlier readings. Raw readings and detected events need separate treatment to a fault detector can examine measurements and produce an event that identifies the suspected condition with a reference back to the interval and channels supporting that detection. That event becomes a useful point of connection. The relationship layer can associate it with the affected asset and retain the reported condition, while the detailed measurements remain available in their original analytical store. Keep the Detector's conclusion at its actual level of certainty. An unusual current pattern can support a detected anomaly without establishing a failed component, so the recorded event should identify what the detector found rather than invent a diagnosis. A controller reported fault follows a similar storage boundary. The context service can retain the relevant state change and a reference to the fault record without copying the complete stream of controller observations into the relationship layer. Now, the planner can ask a more focused follow up for an exposed order. The service follows its required operation to the assigned machine, then uses that machine's data reference to request the history surrounding the reported interruption. Each store handles its part of the request. The relationship query finds which asset and measurement channels matter, while the time series query retrieves the readings for the selected interval rather than scanning every channel in the production area. The result doesn't have to return raw measurements to the planner. A checked analysis could describe a detected condition and identify the supporting interval, leaving detailed investigation available to the engineer who needs to examine the underlying readings. That keeps the ordinary outage question reasonably small. Most assessments can use the relevant machine, state and dependency paths with a separate history request only when the user asks a question that needs measured behavior. Storage separation does create an integration obligation. The asset reference and the measurement reference must continue to resolve correctly, or the graph can identify the right machine while sending the investigation to the wrong history. Test that connection with a known event. Follow an order to its machine. Retrieve a short interval around the interruption and verify that the returned channels actually belong to the equipment and period being assessed. The remaining question concerns how information reaches these stores before those references can support a dependable request. The machine observations and production records need a collection path that respects the way the plant operates. The collection path starts with an operating constraint. Whatever we add to gather information, must respect the equipment network and avoid creating a new dependency that production needs in order to keep running operational technology or OT controls and monitors physical production. Connecting that environment to enterprise information technology or. It means agreeing how information crosses the boundary without giving analytical applications unnecessary access to equipment controls or network services. I'd begin with read only collection wherever the equipment supports it. The production question needs reported conditions, so the collection account shouldn't receive permission to change machine settings simply because that permission comes with a convenient default connection. Read only access still needs an engineering check. Frequent requests can load an older controller or a limited network, so the controls team should approve the collection method and test its effect during representative production conditions. An existing collection interface may provide the safer route rather than adding another client directly to each controller. The plant might expose approved information through a gateway or an established industrial data service that already handles equipment communication. That boundary needs a named owner. Agree which connections are permitted, who manages credentials, and how the plant can isolate collection if it causes trouble without interrupting the control functions responsible for running production. Industrial Internet of Things or IoT provides part of this collection path. Here that means connected devices and software carrying approved equipment observations towards services that can use them beyond the immediate machine environment. The gateway should send enough context to process each message alongside the reported condition. Include the source reference and collection details needed to recognize where the observation entered the architecture, and whether collection itself experienced a problem. Connection health deserves its own reporting. A quiet machine connection could mean that nothing changed, or that the collector stopped receiving information, and the receiving service needs a way to distinguish those situations. Network loss needs a deliberate response to where supported and appropriate. An edge device can buffer observations locally, then forward them when communication returns, allowing collection to continue without requiring a constant connection to Azure. That buffer has physical limits define how much it can retain, what happens when storage fills, and whether a restart preserves queued messages. Because Store and Forward doesn't promise unlimited or lossless retention by itself. Recovery can produce a burst of traffic. The receiving path needs enough capacity or controlled draining, so restoring a connection doesn't overwhelm downstream processing. While current observations compete with the buffered backlog for the same resources, equipment collection then meets the business records, ERP and Ms. changes can arrive through supported interfaces or controlled extracts, with the integration method chosen according to what those systems expose and what their owners permit. Don't force every source onto the same collection rhythm. A machine collector may publish a change immediately, while a business system supplies periodic extracts, and the architecture needs to make those different delivery arrangements explicit. The shared intake needs recognizable record formats. Each source adapter should produce an agreed message structure and report records that can't translate. Rather than parsing malformed input onward and hoping a later service can interpret it. Azure functions can handle a bounded step in that flow. A function might validate an incoming equipment message, resolve its source reference through the maintained mapping and submit an accepted observation for the next processing stage. Keep that responsibility small enough to test. Connecting a function to an event source doesn't by itself establish durable business state, define recovery behavior, or ensure that every downstream write succeeds before processing ends. Those decisions belong in the surrounding design, depending on the trigger and workload cues. Persistent storage and explicit retry handling may be needed, with limits and an exception path for messages that repeatedly fail. Failed messages need somewhere actionable to go. Record the reason for rejection and alert the responsible support team so an unreadable event doesn't disappear into logs. While everyone assumes the equipment feed remains healthy. I would separate intake acceptance from context readiness. Receiving a message confirms that the collection path delivered something, while a later processing result confirms whether that information became usable by the shared context service. That distinction gives operations a practical support question. When a planner reports missing information, the team can establish whether collection, transfer or processing needs attention. Instead of treating the entire root as one undifferentiated integration failure. The accepted records now need a shared data destination. This is where Microsoft Fabric enters the discussion. After the plant connection and collection responsibilities have been defined, rather than as a substitute for that work for the planner. The immediate benefit is less hunting for usable data. Microsoft Fabric can support the engineering work that prepares production records for analysis, then lets reporting and context applications draw on those prepared records. I'd give that preparation work. A defined home fabric brings data integration, engineering, and analytical workloads into a shared platform so teams can manage the steps between incoming source records and data ready for a particular use. One Lake provides the shared data foundation within fabric. It gives those workloads a common data lake with options to access data without requiring every analytical task to maintain its own separate copy of the underlying records. Shared storage doesn't establish shared business, meaning putting an equipment record and an operation record into one lake makes them accessible, but your engineering workflows still need to apply the definitions and mappings that connect them correctly. That distinction shapes what the team should publish for consumption. Instead of asking every report or application to re-interpret incoming records, prepare curated data sets whose fields have defined meanings and whose intended uses are clear to their consumers. Take the asset dataset as a starting point. It could present the stable asset, reference, the associated production resource and the attributes needed by downstream applications, with the agreed identity mapping already applied during preparation. The ordered dataset has a different responsibility. It should present the business and production references needed for the assessment using agreed definitions, rather than exposing source specific status codes and leaving each consumer to translate them independently. Events need their own curated representation and accepted equipment. Event can become a record that carries its resolved asset reference and interpreted event type, ready for an application that needs to associate reported changes with production work. These datasets become an interface between teams. The engineers preparing them take responsibility for their stated meaning, while the application team can build against that meaning without embedding a different interpretation of every source system. Fabric, notebooks or data pipelines can support that preparation. The choice depends on the transformations involved and the team's working methods, rather than a requirement that every source pass through exactly the same engineering tool, I'd name the published outputs around their purpose. A data set described as equipment events prepared for outage assessment tells a consumer more about its intended use than a table name that merely identifies which integration created it. The context service then consumes those prepared records. It uses the asset order and event information to maintain the relationships needed by the application, through an integration path designed for that service's update requirements. That context service doesn't have to share. The analytical storage engine fabric can remain the place where data gets prepared and analyzed, while a separate service handles the relationship queries required by the planner's operational application. The handoff needs a clear responsibility Boundary fabrics preparation work should produce usable records, while the context service takes responsibility for organizing and retrieving the relationships that its application promises to answer questions about. Power BI supports another use of the same prepared data. A production manager might want to compare outage exposure across shifts, track how many unfinished orders entered an assessment, or review patterns across the production area over time. A power BI semantic model supports that analytical view. It defines relationships between analytical tables and provides measures such as counts or calculated totals, so reports can apply consistent calculations when users filter the data. Those relationships deserve a careful distinction from the graph model. Both models can connect records, but the power BI model is built around analytical questions. While our context model describes the dependency paths the outage application needs to follow. Consider two requests about the same disruption. How many orders entered the assessment? This shift asks for an analytical measure, while which operation connects this particular order to machine for. asks for a specific relationship path. Neither request makes the other model unnecessary. The report can help a manager review production patterns, while the context service gives the planner a record level explanation that follows the dependencies relevant to an individual order. I'd let those responsibilities guide the architecture use fabric where shared analytical data preparation, workflows, and reporting meet the need. Then define the relationship service around the questions it must answer and the conditions under which it must operate. That leaves the graph implementation as a separate engineering choice. We can now evaluate where those relationships should live based on the required workload, rather than choosing storage, simply because the analytical data already sits in fabric. I'd turn the storage decision into a workload specification before comparing services, write down the exact paths the application must retrieve, the update traffic it must accept, and the restrictions every request must respect. Start by specifying the result of each traversal. Does the application need only the matching orders, or must storage also return each connecting operation and assignment so the application can explain why those orders qualify. That difference affects the implementation. Returning distinct order identifiers can require less work than returning every supporting path, especially when several operations create separate connections between one resource and the same production order. Define how the query should handle multiple paths. The panel shouldn't receive duplicate orders, but the application may still need those separate paths to preserve. Every reason and order appears in the assessment. Next, describe the update workload in operational terms. Count the relationships that change during ordinary dispatch activity. Then consider periods when a planning update replaces assignments for much of the production area at once. Reads and writes need testing together. A query that meets its response target on an idle test system may slow down while the service applies a large assignment update under representative production conditions. History adds another storage requirement. Decide whether the service must answer only current questions or retrieve earlier relationship states directly, because that choice affects record structure, indexing and the amount of information retained. 01:08:50 Speaker: Check permissions at the same level of detail. If a user can access only one production area. The storage and application design must prevent a traversal from revealing restricted work through a shared resource. A relational implementation gives you specific options to test. You might store typed relationships in dedicated tables, use recursive queries where the engine supports them, and create indexes around the starting points and filters your requests use. Inspect the resulting query plans. They tell your engineers whether the database can narrow the search early, or must examine many records before applying the conditions that actually define the planner's question. Dedicated graph storage deserves an equally concrete test load. Representative relationships run the required traversals and check how the engine behaves when a heavily shared resource connects to a much larger set of operations. Ask how the engine distributes that connected data. A traversal that crosses storage partitions can have different latency and cost from one contained within a partition. So partition design belongs in the evaluation. As your cosmos DB for Apache Gremlin is one candidate, it supports a graph interface using the Gremlin traversal language, but your team should check its supported operations and limits against the queries this application actually needs. Don't assume every Gremlin example will transfer unchanged. Validate the service's supported behavior, partitioning requirements, throughput model, and consistency choices before treating a successful demonstration as evidence that the production workload fits include the application drivers behavior. In that test, your engineers need to understand connection handling, request limits, and how query failures reach the application, rather than judging the service only through an interactive query session. Azure Digital Twins needs a different evaluation. Assess whether its twin models, relationship structure and query language fit the maintained representation you intend to build, including the specific query patterns your application requires. It isn't an interchangeable graph engine. If the application needs a traversal pattern that its query language doesn't directly express, identify the extra application requests or processing required, then include that work in the comparison. I would keep the application contract separate from either service. Define an outage assessment request with agreed inputs and an agreed result structure. Then place the storage specific queries behind the component responsible for retrieving those results that won't make a future migration free. It does keep database specific traversal syntax out of every application component, reducing the places your team must change. If testing later points to what another implementation record. Why the selected option wins. The decision should name the workload it supports, the limits the team accepts, and the conditions that would trigger another review rather than imply permanent suitability. Include an exit check before approval. Confirm that you can export the identities, relationships and relevant history in a documented form, so the manufacturing model doesn't depend entirely on one service's internal representation. Storage selection settles only one part of the operating problem. The chosen service still needs a dependable way to reflect source changes, or its carefully tested queries will return precise answers about production conditions that no longer apply. The first synchronization problem appears before the service goes live. Loading existing assignments takes time, and production can change those assignments. While your integration is still reading the records needed to establish its starting state. You need a defined handover from loading to updating where the source supports it, capture a consistent starting data set and a change position, then apply the changes following that position without leaving an unobserved gap between them. Other sources need a different loading procedure. If a system can't provide that boundary, agree a controlled extraction and comparison process with its owner, rather than assuming that a completed import represents one consistent production state, keep the assessment unavailable until that starting state passes checks, compare record counts and required connections, investigate rejected records, and confirm that the update process has caught up to an agreed point before allowing planners to use the results. After that, expect messages to arrive more than once a sender can retry because it didn't receive confirmation, even though the receiving service already accepted and processed the original change before the connection failed. Design repeated processing to have the same result. Engineers call this Idempotency processing the same source change again shouldn't create another assignment, restore a removed connection, or otherwise alter what that change already established. Use a source change identifier where one exists. Retain enough processing state to recognize a previously accepted change and define how long that protection must last, given the source's retry and replay behavior. A retry can also arrive after a newer change. Suppose dispatch moves an operation away from machine four, but an earlier assignment update reaches the service again after that move has already been applied. That older update mustn't restore the previous assignment. Compare source versions or another dependable ordering reference before applying changes, and send cases with an uncertain order into a repair process instead of guessing which relationship should remain. Related rights introduce a further problem. Removing the old assignment and creating its replacement can leave an incomplete intermediate state. If processing stops between those steps and the storage system doesn't commit them together. Choose a supported way to protect that transition. You might use a transaction within the store's limits, or prepare a new relationship version and expose it only after the complete change passes. Validation deletion needs an explicit signal as well. An assignment disappearing from a source extract won't remove itself from the context model unless the synchronization process detects that absence and confirms what it means. Distinguish removal from temporary omission. A filtered export or interrupted extraction shouldn't erase valid relationships, so deletion handling needs a complete comparison scope or an explicit removal record from the authoritative source. Even a well-run change feed needs reconciliation. Periodically compare the maintained relationships against authoritative records, because missed changes and processing defects can accumulate without producing an obvious failure in the ordinary update path. Make that comparison about content, not just counts. Two data sets can contain the same number of assignments while connecting different operations to different resources, so check identifiers, relationship endpoints, and the source versions being represented. Repair should follow an owned procedure. Record each discrepancy identify whether the source or its maintained representation needs correction and rerun the affected comparison after repair, rather than treating a successful replay as proof. Watch for recurring differences in the same records. A repair that keeps getting undone points toward a synchronization rule or source contract problem, and repeating the repair merely hides the defect until another assessment depends on it. Manufacturing changes also alter the model's structure. When engineering changes a route or reorganizes a resource group, existing update logic may continue accepting records while building relationships that no longer express the intended production arrangement version. Those changes and test their migration. Define which records need rebuilding, how existing queries behave during the transition, and how you'll restore the previous working state. If validation finds a problem, keep synchronization status alongside the maintained model. The application needs to know when comparison last succeeded and whether unresolved update failures affect the requested area, so it can decide whether the context supports an assessment. That status becomes part of the handoff to an AI assistant before generated wording enters the workflow, the underlying service needs to establish whether it's maintained. Relationships are ready to support the question being asked. The assistant now needs a defined way to ask for information. I'd give it a small set of application tools, each built to answer a specific production question through the context service we've just described. A large language model, or LM interprets the planner's request. Its role here is to turn conversational wording into a structured request that another component can check and execute, then explain the returned findings in plain language. That division gives the model a useful job. It can recognize that what's exposed if machine four stays down. This shift asks for an outage assessment without deciding for itself how production records should be joined. The request becomes a tool call with defined inputs. Those inputs might identify the resource, the production area, and the assessment period using fields whose types and allowed values the application checks before doing any retrieval. Ambiguous wording needs clarification before execution. If the planner says the cutter and several resources match, the assistant should ask which one they mean. Rather than select the resource with the closest description, I'd make the tool narrower than a general database connection and approved query template can retrieve the required assessment information while the model supplies checked parameters. Instead of inventing query syntax against whatever records it happens to find, that template needs a maintained application contract, it states, which inputs the tool, accepts what the result contains, and how the tool reports an invalid request or a question it can't answer within its defined scope. Typed inputs catch problems before they become database requests. A resource identifier must resolve to a recognized resource, and a requested end time must follow its start time. Rather than passing unchecked text straight into a query. The model doesn't need freedom to rewrite those checks. Your engineers can change the tool when requirements change, with tests that establish whether its updated behaviour still matches the production question it promises to answer. The returned information then becomes the basis for the response. This approach is called retrieval, augmented generation, or Rag. The application, retrieves relevant evidence and supplies it to the model before the model generates its answer. Retrieval gives the model information for this particular request. Instead of relying on patterns learned during training to describe today's production situation. It receives selected records and findings from the system's. Your application has been designed to consult. The tool result should distinguish findings from explanatory notes. For example, it can return the assessed orders in a defined structure with supporting references attached, so the model can describe those findings without having to extract them from an unstructured report. Give the response writer explicit limits if the tool returns no assessment because an input couldn't be resolved, the assistant should explain that outcome. Rather than fill the empty space with a plausible account of production. Two retrieval methods can support different parts of the conversation. A graph query can obtain connected production facts, while document retrieval can locate approved instructions that help explain a procedure or a term used in those facts. Suppose the planner asks what a reported status requires. The document tool could retrieve the relevant passage from an approved procedure, giving the assistant a basis for explaining the required check without treating the procedure as evidence that someone completed it. Search results. Need enough surrounding text to preserve their meaning. A sentence describing an exception can mislead when separated from the condition that limits it, so document retrieval should return a coherent passage rather than a convenient fragment. Keep those sources distinct when composing the answer. An assignment record supports a statement about assigned work, while a procedure supports a statement about the prescribed process, and the assistant should identify which kind of evidence supports each explanation. A useful response can combine both without blurring their roles. It might explain the returned assessment finding, then describe the documented review step when the planner asks what that finding means within the plants working process. This arrangement also makes troubleshooting more specific. You can examine whether the assistant selected the right tool, whether the tool returned the right evidence, and whether the final wording faithfully represented that evidence to the planner. One request may still need more than one retrieval. The next design question is how to coordinate those steps while keeping each request bounded, rather than assuming that access to good tools guarantees good reasoning. For this next step, follow the retrieval rather than the conversation. The planner's question can sound open ended, but the application should turn it into a limited search with a clear starting point and a defined stopping condition. Start the search at machine for resolved identifier. From there, retrieve the operation assignments that overlap the requested assessment period. Then follow those assignments to the operations and the production orders that require them. The time filter belongs inside that search. An assignment ending before the outage shouldn't enter the result merely because it connects to the failed machine, and an assignment starting after the assessment period belongs outside this request. Be precise about what overlap means. An operation scheduled to continue beyond the shift can still qualify if part of its assignment falls within the requested period, even though its planned completion lies outside that period. Choose the relationship types before running the query for this request. The permitted path follows machine assignments and order requirements rather than wandering through maintenance documents, equipment, suppliers or every other object connected to the machine. That restriction protects the meaning of the result. A service record mentioning an order number doesn't establish that the order requires work on the failed machine. Even if a broad search could discover that connection, the stopping condition matters just as much. Once the query reaches the orders through the approved dependency path, it should return those findings rather than continue outward through customers and unrelated orders sharing the same customer account. Some requests need another permitted path. If the planner explicitly asks about downstream work, the application can use a separately defined traversal with its own relationship types and limits instead of silently extending the original search. Put a limit on returned paths, too. If a request exceeds that limit, the result should identify that it remains incomplete and ask for a narrower period or area rather than present the first matches as the complete answer. An empty result also needs a precise interpretation. The service can report that no qualifying dependency paths match the defined search without implying that the entire plant faces no consequences from the outage under any possible relationship. Document search can then answer a different follow up. Suppose the planner asks whether the reported fault requires an engineering inspection before restart, and the application searches the approved maintenance guidance associated with that equipment configuration. The best text match might still be the wrong instruction. Before using a passage, check that its source belongs to the approved document collection and that its applicability covers the machine model and configuration involved in this fault. Revision checks belong before the explanation. A superseded procedure can closely match the fault wording while prescribing a check that the current procedure has changed, so relevance alone shouldn't determine which passage reaches the assistant. Keep the retrieved passage tied to its document reference. The answer should distinguish the guidance it found from any missing guidance, including a case where no applicable current revision could be established for the reported fault. The two retrieval results can now sit beside each other. One establishes which orders have qualifying dependencies while the other supplies applicable fault guidance without treating the documents. Discussion of production disruption as proof that another order belongs in the assessment. You'll hear this described as Graf Rag, the term covers a family of approaches that bring graph structure into retrieval, so I'd ask exactly which relationships the implementation follows and how those relationships affect the evidence returned. Different approaches can behave quite differently. Some use extracted entities and relationships to organize document collections, while others query a curated operational graph and some combined graph queries with text search within one retrieval workflow. The label doesn't establish suitability for this factory question. A system designed to summarize themes across a document collection may need considerable additional work before it can retrieve the exact time bounded assignment paths behind an outage assessment, judge it by the paths it can return for machine for the useful output. Identifies the qualifying operations and orders. Preserves the connecting records and makes clear where the search stopped or applicable guidance couldn't be retrieved. That gives the planner an explanation they can examine. It establishes why particular work deserves attention under the reported outage. But choosing a revised production sequence requires a further decision process beyond the retrieval we've just defined. Choosing a revised sequence starts with defining what counts as acceptable. A planner might want to protect the urgent orders next handoff while avoiding changes to jobs whose materials and setups are already prepared for the shift. Those goals can compete. Bringing the urgent order forward could preserve its finishing slot, but interrupt another job. So the decision needs a stated preference rather than an assumption that urgency settles every conflict. The graph supplies inputs to that decision. Its relationships can provide the assigned work required resources, and recorded restrictions, which are. Scheduling service translates into constraints. It can evaluate against possible start times and sequences that translation needs checking. A requirement stored as a relationship only affects a schedule if the scheduling model represents it correctly, including whether it prohibits a choice or merely makes that choice less desirable. Schedulers often distinguish hard constraints from soft preferences. A hard constraint rules out a schedule, while a soft preference lets the system accept a less desirable result when satisfying that preference would conflict with other stated goals. The distinction needs an operational owner. Keeping an order on its assigned machine might be a preference in one process, while a controlled resource restriction makes that same choice mandatory for another product or operation. Advanced planning and scheduling, or APS addresses these resource and timing questions. Depending on its scope and configuration. An APS system can test whether the proposed work fits the modeled capacity, operation sequence, resource calendars, and other constraints for machine for. That changes the question. Instead of identifying exposed orders, the scheduler could evaluate a candidate sequence that moves eligible work to another resource and adjusts the start times of the jobs affected by that move. A free machine slot doesn't establish a feasible schedule. The scheduling model also needs durations for setup and processing, plus the dependencies that determine when the work can begin and when its output becomes available downstream. Those durations are planning inputs, not guarantees. If the interrupted operation needs an uncertain recovery period, the scheduler needs an explicit assumption or range rather than a precise restart time invented to complete the calculation. ERP remains part of this forward looking process. It can supply demand, due dates, planned supply material requirements, and production planning records with the exact division of scheduling work. Depending on the capabilities and configuration already in place. I wouldn't add apps without checking that division. Some organizations can address the required planning question within their existing ERP functions, while others need specialized scheduling capabilities to represent constraints at the required level of detail. Simulation asks a related but different question. Given a candidate's schedule and stated assumptions, a simulation can explore how production might behave when processing varies, queues develop, or interruptions occur during the period under study. It can test the candidate under different conditions. For example, one run might assume maintenance restores machine for before the next shift, while another explores a longer outage and its effect on waiting work. 01:26:26 Speaker: The result depends on the behavior model. If that model omits an important source of delay, repeated simulation runs won't compensate for the omission even when the results appear consistent across many trials of the candidate's schedule. Optimization searches for choices against a stated objective. It might seek a schedule with less late work or lower setup time, while respecting the constraints represented in the scheduling model and the available computation time. Best. Needs a definition before that search begins. A schedule that minimizes total lateness might still delay one important order, so the objective must express how the business wants competing consequences weighed rather than leave that judgment implicit. The result also needs the right label. Depending on the method, workload and time limit, the search may return a feasible candidate without proving that no better schedule exists under the same modeled conditions. Generative AI can explain those results to the planner. It's useful role is to describe the proposed changes, trade offs, and assumptions returned by the scheduling or optimization service, rather than improvised resource timings. In conversational text, a recommendation still has a separate status from a production instruction. The application can present a candidate schedule for review, but the organization must define which workflow turns an accepted proposal into authorized changes in its production systems. That boundary deserves its own design once a system can suggest moving work. The next question concerns who can request, approve, and issue that change. Because a plausible explanation doesn't grant production authority permissions need to follow the person asking the question before retrieving any factory records. The application should establish the user's identity and check whether that person can request this assessment for the production area involved. Authentication alone doesn't settle access. Microsoft Entry ID can establish identity and support application access, but your application still needs rules connecting that identity to permitted production areas. Records and assessment tools. Apply those rules before evidence reaches the model. Retrieving everything and asking the assistant to hide restricted details leaves the sensitive information inside the generation process, where a wording instruction becomes your only remaining protection. shared resources make this less straightforward. If a tool serves two departments, a user permitted to inspect one department's work shouldn't discover the other department's orders simply by asking why the tool can't move. Derived answers can disclose restricted information to a response, saying that an unnamed customer order takes priority. Could reveal a business commitment even without returning the order record or naming the customer involved. The access policy must cover those conclusions. Depending on the approved policy, the service might report a restricted resource commitment without identifying its origin or decline the comparison, because even that limited response would disclose too much. Keep authorization outside the model's discretion. The component executing each tool request should enforce permissions using the authenticated users context, rather than trust a user identifier or production area. Claim supplied in generated text. For the first deployment, I'd prohibit production rights, use service accounts and application permissions that allow the required reads but can't change dispatch assignments, release material, edit routes, or send commands toward equipment controls, that boundary should survive a misleading response, even if the assistant generates restart machine for no component should interpret those words as an executable command, and no connected account should possess the authority to perform it. Read only doesn't mean operationally harmless. An incorrect assessment can still influence a planner, so users need to understand that the output supports review and doesn't replace the plant's established operating or restart procedures. Retrieved documents introduce another security concern. A document can contain text that tells the assistant to ignore its instructions, reveal other records, or call another tool. Whether someone inserted that text deliberately or accidentally, that's a prompt injection attempt. The application must treat retrieved content as evidence to examine, never as permission to change its operating rules, expand the user's access, or perform a different task. Approved storage doesn't remove that distinction. A legitimate procedure might contain quoted commands, copied emails or supplier text, and none of those passages should acquire authority over the assistant's tools merely because retrieval returned them. Use technical restrictions alongside model instructions, keep the available tools narrowly defined, validate their inputs independently, and ensure that text from retrieved passages can't replace authorization settings or create a new action capability. If action workflows come later, approval needs an exact object. The reviewer should see the proposed production change and its assumptions, then approve that defined change. Rather than give a general instruction to accept whatever the assistant recommends. Next, approval also needs a validity check if assignments or operating conditions change after review, the system should stop and request another assessment instead of applying an earlier approval to a different production situation. Human review must connect to an accountable role name who can approve the particular change, what evidence that person must examine, and which conditions require escalation, rather than leave every surprising result to an unspecified human. Keep an audit record of the full transaction record. Who requested the assessment? Which permissions applied, which evidence and tool results supported it, and for any later action, the exact proposal and approval decision Audit access needs restrictions of its own. Those records can contain production and personal information, so define retention and access rules without creating a second route around the protections applied to the original assessment. Safety controls remain separate from this application machine interlocks safety functions and authorized restart procedures must operate independently, and an approved scheduling change must never count as permission to bypass a physical protection. These boundaries give the deployment a practical shape. We can now choose a narrow assessment task with explicit read permissions and review responsibilities without quietly introducing a route from generated language into production control. I'd write the pilot brief around one deliverable an outage assessment. A planner reports an equipment stop in the selected production area and receives the orders with qualifying dependencies, together with the evidence and gaps behind that result, the production area becomes a firm service boundary name. The resources included in the pilot agree which assignment records cover their work and state the assessment period, so users know exactly which production commitments the service examines. Define what starts an assessment for this pilot. An equipment outage qualifies, while a reduced production rate or an isolated quality issue remains outside the request unless it has produced the equipment state the service accepts as an outage that keeps the initial task recognizable. The planner shouldn't need to decide whether every unusual production condition counts, because the brief should state which reported conditions the service accepts and which require another established process. Next, list the inputs needed for that deliverable. The minimum package contains the checked asset mapping operation records covering active and upcoming work, their order connections, and the machine state applicable to the requested assessment. Treat that list as an admission requirement. If a resource lacks one of those inputs, leave it outside the supported coverage or explicitly mark its assessment incomplete rather than including it under a general claim of area coverage, the operation records need to establish what remains relevant. An operation that has started but still requires work belongs in consideration. While a future assignment needs enough timing information to establish whether it overlaps the agreed period. Keep the order link explicit in that package. The assessment needs to identify the production order requiring each qualifying operation without relying on a planner to recognize the order from a job description or informal batch label. Machine state must describe a bounded observation if the evidence confirms that equipment stopped but doesn't establish when it will return. The assessment should use that reported outage without manufacturing an estimated duration to complete the request. Then define the response before building the conversational interface. I'd require the same assessment fields whether the planner asks through an assistant or another application. So conversational phrasing doesn't change what the service promises to return. The first field identifies the orders included. Each order should appear once with its qualifying operations retained beneath it, allowing the planner to distinguish a single interrupted operation from several assignments exposed within the same assessment period. The next field explains each dependency path. It should connect the reported resource to the qualifying assignment, the unfinished operation and the production order, preserving the references needed to check why that order entered the result. Freshness belongs in the response itself. State when the assessment ran, which period it examined, and whether the supporting inputs met their freshness requirements. Rather than attaching one general update time to the whole answer, unresolved gaps need their own place to describe the missing information and the part of the result it affects, so a planner can distinguish an incomplete order assessment from a problem that prevents assessment of the entire resource. A result can contain findings and gaps together if some dependency paths have sufficient evidence while another operation lacks an order connection, return the supported findings while explicitly withholding any claim that the list includes every exposed order. I'd make those fields mandatory in the output contract. That contract should also distinguish a completed search with no qualifying orders from a search the service couldn't complete, because those outcomes call for different responses from the planner. The exclusions should be just as concrete. This service won't produce a replacement schedule, automatically move an operation to another machine, or update dispatch instructions, even when its evidence suggests that another resource deserves investigation. Delivery promises stay outside the contract as well. Identifying unfinished work on unavailable equipment establishes exposure within the defined scope, but it doesn't establish whether later recovery or existing timing margins will protect the shipment. That leaves a useful bounded handoff to the planner. They receive an evidence backed account of which orders need attention, where each dependency sits and what remains unresolved. While decisions about revised production arrangements stay in their existing workflow. The pilot now has a deliverable someone can inspect. We can put machine for outage through that defined service, and examine whether its first answer actually supplies the information the planner needs to begin checking the disruption. Let's put a specific assessment in the planners hands. In this hypothetical run, the outage message arrives with the Gateway's equipment reference, and the intake process resolves that reference to the physical asset identified as machine for the identity check succeeds without a manual match. The service then locates the production resource occupied by that asset at the reported stop time, allowing the assessment to search the assignments relevant to this outage. The planner requests coverage through the end of the shift. The query finds the interrupted cutting operation and another unfinished operation assigned later, then follows their order connections to return two orders with separate reasons for inclusion. Call them the urgent order and the later order. The first appears because its cutting operation remains active on the stopped equipment, while the second appears because its upcoming assignment overlaps the requested assessment period. The assistant opens with that distinction. Two orders have qualifying work assigned to machine four during this shift. One has work interrupted by the stop, and one has an assignment scheduled later. It doesn't announce two late deliveries. The returned evidence establishes those assignments and their connection to unfinished work, but it doesn't yet establish whether either order will miss its next handoff or shipment for the urgent order. The explanation names the cutting operation. It cites the execution record supporting the active assignment and the equipment events supporting the reported stop, giving the planner specific references to inspect rather than a general assurance. The later order receives different wording. Its inclusion rests on a scheduled assignment, so the assistant describes future exposure during the shift, rather than implying that the machine stopped while producing parts for that order. Now the planner challenges the first finding. Someone told me the urgent order has already moved to machine six, so why are you still showing it against machine four in this assessment? That's a useful challenge, not an inconvenience. The planner opens the referenced assignment and finds that it still names machine four, while the proposed move appears only in a dispatch note awaiting confirmation from production. The assessment hasn't established that the move occurred. Its answer can identify the recorded assignment and acknowledge the proposed transfer, leaving the actual execution location unresolved until the responsible team confirms which machine is performing the work. The planner then asks about permission for that transfer. A separate check of the linked manufacturing records finds an alternate route for machine six, but its approval covers the previous revision of the part. The assistant needs to state that limit directly. The retrieved alternate route approval doesn't cover the revision required by this order. So these records do not confirm an approved transfer. To machine six for the remaining operation. That wording avoids accusing anyone of an unauthorized move. There could be a newer approval that the service hasn't received, and the planner now has a precise reference to take to manufacturing engineering for confirmation. The outdated approval remains visible beside the assessment. It doesn't cancel the supported dependency on machine four, and it doesn't establish that machine six is forbidden under every possible approval held elsewhere in the plant. Next, the planner examines the urgent orders downstream exposure. The finishing slot still exists, but the assessment contains no confirmed recovery time and no checked estimate for completing the remaining cutting work after production resumes. The planner can confirm an interruption without confirming a missed slot. They can tell the finishing team that the incoming work needs attention, while withholding a firm arrival commitment until the remaining quantity and restart conditions have been checked. The later order needs a different conversation. Its scheduled machine time falls inside the assessment period, but a short outage might leave enough room to complete the work without changing its next required handoff. So the planner records two different review outcomes. The urgent order has a confirmed interrupted assignment, with downstream timing still unresolved, while the later order has confirmed scheduled exposure, whose eventual production effect remains uncertain. That distinction gives the first answer practical use instead of accepting or rejecting the whole response, the planner checks individual findings, corrects an unresolved execution detail, and directs the approval question to its responsible owner. A clean demonstration won't always end this neatly. The next question is whether the same assessment remains useful. When ordinary operating conditions leave the planner with fewer confirmed facts than this example provided. I'd ask the pilot to earn the planners trust through testing before expanding coverage, replay earlier disruptions and compare its findings with reference cases that planners have reviewed, including cases where the operational consequence remained uncertain. Build those reference cases from records, not memory alone. Ask the reviewing planner to identify which orders belonged in the assessment, why they belonged and which missing facts should have prevented a firm conclusion at that time. Keep later knowledge out of the replay. If maintenance eventually restored the machine quickly, that outcome shouldn't help an assessment running against the information available before anyone knew when production could safely resume. Some reference cases will need discussion when planners disagree about an expected result. Resolve whether the disagreement concerns missing evidence, the assessment rule or the scope before using that case to judge the application. Separate development cases from acceptance cases. Your engineers can use one collection to improve the service, while another collection tests whether those improvements work on disruptions they haven't already examined and adjusted for, then deliberately damage the test inputs, delay a machine event beyond its accepted freshness limit, and check whether the service withholds the affected conclusion, rather than returning an apparently current assessment from evidence that no longer qualifies. Remove a required connection in another test, the expected response should identify incomplete coverage, and the test should fail if the missing relationship merely shortens the order list without changing how the application describes its completeness. Permissions deserve tests with known expected outcomes run the same assessment under different authorized roles, including a user denied access, and check that neither the returned records nor the explanation disclose information outside that user's permitted scope. Introduce conflicting records as well. Check whether the service applies the agreed ownership rule or reports the conflict. Then inspect the generated wording for any certainty that the underlying finding didn't support. Measure errors in both directions. An incorrectly included order creates unnecessary checking, while a missed dependency can leave work unattended, so count those outcomes separately rather than hide them inside one overall accuracy score. Evidence coverage needs its own measure for each returned finding. Check whether the required supporting records are present and usable, then record how often missing or disputed evidence prevents the service from completing the requested assessment. Measure the time to a checked answer. Start when the planner requests the assessment and stop when they've verified enough of it to use, including the calls or record checks needed to resolve doubts about its findings. Fast text generation isn't the result you're measuring. Compare that checked answer time with the existing process on comparable cases, and record whether apparent speed comes at the expense of extra corrections or overlooked dependencies. Agree acceptance thresholds before reviewing the final results, the planners and service owners should decide which failures block release, which require restricted coverage and which can remain documented limitations, rather than moving those boundaries to accommodate disappointing test outcomes. Someone must own what happens after acceptance. Name the person responsible for model upkeep, including the review work triggered when production introduces a relationship or working rule that the supported assessment doesn't yet represent. Source quality needs a separate, accountable owner. That person should coordinate corrections with the teams maintaining the records, track recurring defects, and prevent application engineers from silently compensating for every source problem. With another local exception, security and cost need named owners to assign responsibility for access, reviews and security incidents, then give someone authority to track the expense of collection, storage, retrieval and support against the actual use the pilot receives. Include human upkeep in that operating cost. A service that produces useful answers but requires constant specialist repair may still suit a limited task, but that maintenance burden needs to inform any decision to cover more production. Set the expansion gate around reliable impact assessment only after the pilot passes the agreed tests should the team consider scheduling, integration or another production area with a new acceptance scope for the additional dependencies involved. A passing result doesn't transfer automatically to another plant, treat its local records and working rules as new test conditions, and keep unsupported coverage unavailable until the evidence shows that the service can handle those conditions. The planner needs a traceable dependency path, not just a fluent recommendation. If that path contains unresolved context, keep the gap visible before anyone changes production, because the wrong connection can send attention toward the wrong order. Which factory relationship would you model first for outage impact assessment? I'd like to compare that choice with yours.