top of page
Search

Knowledge Engineering: The Foundation of Agentic AI

Nov 10
18 min read

Knowledge Engineering: The Foundation of Agentic AI



Case Study - Root cause analysis of events and alarms using Graph RAG, and Human Review.
Case Study - Root cause analysis of events and alarms using Graph RAG, and Human Review.

Overview

Agentic AI can plan, retrieve, reason, and act. But before an agent can do any of those things reliably, someone has to define what the agent is looking at, what the evidence means, and where its authority ends. We explore that work through a class project using ADT home-security events and Eero network activity—an exercise readers can adapt to event exports from their own homes. The journey begins with raw logs and ends with reviewed conclusions, moving through normalized events, candidate alarms, evidence graphs, and hypotheses along the way. The central idea is simple: an agent becomes trustworthy when the application can show what was observed, which rule fired, what remains uncertain, and who approved the outcome.

This is not a sprint but a marathon for us.  Our work in commercial and applied AI spans more than 40 years, from Dispatcher and Simulation Craft in the 1980s to knowledge graphs, Graph RAG, and agentic systems today. Across those decades, we have repeatedly seen the same lesson: impressive reasoning creates lasting value only when it is embedded in a complete application grounded in domain knowledge.

 

1. Agentic AI Begins with Knowledge

The current generation of AI systems makes agency visible. We can watch a model break a goal into tasks, call tools, retrieve information, coordinate other agents, and revise a plan. It is tempting to treat that visible reasoning as the intelligence of the application. In practice, it is only the part we can see most easily.

The harder work starts with the domain. An agent needs to know which records are observations, which identifiers refer to the same entity, which rules create a reviewable condition, which relationships are only temporal, and which actions require human approval. If those distinctions are missing, the agent can move quickly while carrying an ambiguous premise through every subsequent step.

Consider a simple example. A security camera goes offline, an Eero client reports an authentication timeout, and a door opens within the same minute. A person sees a possible story. An agent can produce that story even faster. Yet the logs may refer to different devices, the door may have opened while the system was disarmed, and the camera outage may have started earlier. The sequence is useful context, but it is not yet an incident explanation.

 

Knowledge engineering supplies the structure that keeps those possibilities separate. It defines the domain concepts, relationships, constraints, provenance, and decision rights shared by the data pipeline, deterministic analytics, Graph RAG retrieval, language model, workflow, and human reviewer. For agentic AI, this is not background documentation. It is the operating knowledge of the application.

 

2. Dispatcher and the Enduring Lesson

Dispatcher was the first-ever full stack commercial AI application. Its historical importance is not limited to a reasoning technique or a model. Dispatcher showed that commercial AI requires the entire application stack: domain knowledge, a working knowledge representation, reasoning, data interfaces, user interaction, exception handling, and operational accountability.

 

We were not observers of this history. Our work on Dispatcher and Simulation Craft helped shape how we think about knowledge-intensive applications: the knowledge has to be elicited from domain experts, represented precisely enough for a machine to use, connected to operational data, and exposed through a system that people can understand and improve. The technology has changed dramatically over four decades; that engineering responsibility has not.

 

That history matters now because the language around AI has changed faster than the underlying application problem. Today we talk about agents, tools, memory, retrieval, and orchestration. Earlier systems used knowledge-based systems and reasoning engines. The enduring challenge is still to connect domain knowledge to a working process that people can inspect, correct, and trust.

 

A model is therefore one component of an intelligent application. The business system still needs a vocabulary that domain experts recognize, rules that can be inspected, evidence that can be traced, and controls that keep the system from claiming more than the evidence supports. It also needs an interface that exposes uncertainty instead of hiding it behind a fluent answer.

 

Modern agentic AI expands the implementation choices, but it does not remove the full-stack requirement. Tool use needs agent contracts. Memory needs semantics and retention rules. Retrieval needs a model of relevance. Multi-agent coordination needs state, checkpoints, and escalation. Human review needs a clear record of what the system observed and inferred. These parts become dependable only when they share the same domain meaning.

 

3. Why Data Alone Is Not Knowledge

Operational systems produce records, not explanations. ADT can report motion, a contact opening, a panel state change, a camera capture, or a device going offline. Eero can report a client association, authentication timeout, roaming transition, disconnection, or node outage. Each record says that a source system observed something. It does not automatically say why it happened or what a person should do about it.

This distinction became vivid when a domain expert described an early AI explanation as "word salad." The remark was blunt and accurate. The system had produced fluent language, but the domain evidence underneath it was not organized well enough to support a useful conclusion. Asking for smoother prose would only have produced smoother word salad.

The remedy is to make the evidence states explicit and carry them through the data model, retrieval process, generated explanation, and review interface:

  • An observed event is a normalized source record with its original timestamp, identifiers, and source lineage intact.

  • A candidate alarm is a rule-generated finding that identifies the event or events that caused a versioned rule to fire.

  • A hypothesis is a plausible explanation supported or contradicted by the available evidence, but not yet confirmed.

  • An approved finding is the conclusion recorded after the required human review or independent validation step.  

Imagine the progression in ordinary language. The source recorded a client authentication timeout. A rule determined that the pattern deserved review. The investigation proposed roaming and authentication negotiation as possible explanations. A reviewer then checked whether the evidence supported either one. Each sentence has a different evidentiary weight.

These labels are not editorial qualifiers added at the end. They are data that the application must preserve. They prevent the system from silently converting a recorded event into an incident, a time correlation into an identity match, or a hypothesis into a root cause.

 

4. A Knowledge Engineering Methodology for Agentic AI

Our methodology starts with evidence and adds interpretation in controlled stages. Raw event logs are ingested and normalized. Versioned rules identify candidate alarms. A semantic model connects the relevant events, entities, and relationships. Graph retrieval assembles an evidence subgraph. A language model drafts a preliminary explanation. A reviewer then approves, revises, or rejects that explanation.

Figure 1. Knowledge engineering lifecycle for agentic AI, from business problem and domain expertise through governed feedback and continuous learning.
Figure 1. Knowledge engineering lifecycle for agentic AI, from business problem and domain expertise through governed feedback and continuous learning.

The order matters. If the application begins by asking a language model to interpret a folder of mixed files, the model has to guess which files contain events, which rows are duplicates, how timestamps align, and whether similar names identify the same device. Those are engineering decisions. They should be handled explicitly and tested before the model writes a narrative.

 

The same principle applies to the handoffs among agents. A specialized agent can do useful work without owning the final decision. Event analysis can normalize records. Alarm analysis can apply the rule catalog. An investigation agent can assemble evidence and propose hypotheses. Validation can challenge weak links. The orchestrator can coordinate all of this while retaining execution state, checkpoints, rule and model versions, evidence references, and approval status.

 

What Each Agent Is Allowed to Do

A useful agent contract names the inputs an agent may read, the objects it may create, the inferences it may make, and the decisions it may not approve. This keeps a later explanation from inheriting authority that an earlier step never had.

Table 1. Agent responsibilities and evidence boundaries


Component

Primary responsibility

Boundary

Agent 1  Event analysis

Ingest, deduplicate, normalize, classify, and preserve source lineage.

Does not decide that an event is an alarm.

Agent 2  Alarm analysis

Apply the versioned rule catalog and prioritize candidate alarms.

Does not confirm an incident or root cause.

Integration layer

Align ADT and Eero timelines and retain vendor-specific identifiers and quality flags.

Does not infer a cross-vendor identity from time alone.

Agent 3  Validation

Check evidence quality, identity links, and review criteria.

Keeps independent validation separate from model output.

Agent 4  Investigation

Build the evidence subgraph and draft a qualified explanation.

May propose hypotheses; may not approve them.

Orchestrator

Manage handoffs, state, checkpoints, reruns, versions, and approval gates.

Cannot erase uncertainty or bypass required human review.


The most important boundary is between deterministic processing and language-model interpretation. The language model may summarize, compare, and explain structured evidence. It may not invent a device identity, rewrite the rule that generated a candidate, confirm an incident, or approve its own root-cause conclusion. The application should enforce those limits in workflow and data permissions, not merely state them in a prompt.

 

5. What the ADT and Eero Logs Actually Showed

Before we asked an agent to explain anything, we spent time understanding what the files actually contained. That sounds obvious, but it is where many AI projects begin to drift. A folder labeled as logs may include time-series events, inventory snapshots, configuration exports, status reports, and duplicate extracts. Treating all of them as one stream creates a false chronology before reasoning has even begun.

 

The ADT data contained 17,259 raw records and 17,103 unique events after 156 duplicates were removed. Motion detected and motion cleared each appeared 7,783 times. Other recorded categories included 427 contact openings, 426 closings, 356 camera captures, 36 device-offline records, and one camera-capture failure.

 

Those counts immediately reveal why event volume and risk are different concepts. The two motion lifecycle categories account for most of the ADT activity, but repetition alone does not make them alarming. A motion event becomes significant only when a rule considers the security state, device, timing, sequence, or another relevant condition.

 

The Eero stream contained 5,380 raw records and 5,314 unique events after 66 duplicates were removed. It included 927 client disconnections. Most of the other Eero exports were configuration or inventory snapshots rather than time-series event streams. Separating a record that describes current state from a record that describes a change over time was essential to building an honest timeline.

Figure 2. Frequency histogram of observed ADT event categories.
Figure 2. Frequency histogram of observed ADT event categories.

Source: authors' ADT-Eero class project analysis. The remainder category is derived from the 17,103 unique-event total.

 

What Normalization Had to Preserve

Normalization did not mean erasing vendor detail. Each event needed a normalized UTC timestamp, a local display timestamp, an event ID, source system, event class, original file and row reference, available client or device identifiers, and data-quality flags. ADT local Pacific timestamps and Eero epoch-based UTC timestamps also had to be reconciled correctly, including daylight-saving transitions.

 

That source lineage matters later. If a reviewer questions a candidate alarm, the application should be able to move from the conclusion back to the rule, from the rule to the normalized events, and from each normalized event to the exact source record. Without that chain, an explanation may sound specific while remaining impossible to audit.

 

6. From Events to Candidate Alarms

Once the event stream was trustworthy enough to analyze, a second agent evaluated normalized events against a configurable rule catalog. This is the point where an observation can become a candidate alarm, but only because a named rule and its conditions say that the pattern deserves review.

 

Context changes meaning. A contact opening while a security panel is armed has a different significance from the same contact opening while the panel is disarmed. A single client disconnection may be routine. Repeated failures, a node outage, or a cluster of authentication problems within a defined interval may deserve attention. The event itself has not changed; the rule has added a reviewable interpretation.

 

The class project applied seven rule categories and produced 201 candidate alarm records. Among them were 87 high-priority Eero candidates: 58 authentication or handshake issues, 15 node-offline events, and 14 authentication failures. Seventy-two of the 87 were authentication-related.

Figure 3. Frequency histogram of the 87 high-priority Eero candidate alarms.
Figure 3. Frequency histogram of the 87 high-priority Eero candidate alarms.

Source: authors' ADT-Eero class project analysis.

 

A candidate alarm says that a pattern deserves review. It does not say that a security incident occurred or that a physical device failed. The 201 candidates therefore form an investigation queue, not a list of proven outcomes.

 

Every candidate should retain the rule version, firing conditions, threshold values, priority logic, and references to the source events. It should also record when the rule ran and which data version it evaluated. That audit trail allows an analyst to reproduce the result, compare a later rule version, and explain why a candidate entered or left the queue.

 

7. Evidence Before Explanation

The abstraction from logs to explanation should remain visible to the reader and to the reviewer. A raw row becomes a normalized event only after its timestamp, event class, identifiers, and lineage are established. A versioned rule may then create a candidate alarm. The investigation layer may propose hypotheses, but it must preserve the distance between a plausible mechanism and a supported conclusion.

 

This is especially important when combining vendors. Two events that occur within seconds of each other provide temporal context. They cannot be attributed to the same client or device without a reliable identifier or a verified cross-system mapping. Even verified entity linkage does not prove causation. Each relationship answers a different question.

Figure 4. Original conceptual view of the transition from raw event logs to processed events, candidate alarms, an evidence graph, and a grounded explanation.
Figure 4. Original conceptual view of the transition from raw event logs to processed events, candidate alarms, an evidence graph, and a grounded explanation.

The example rows are illustrative; the evidence counts and case findings in this article are from the class project.

 

Table 2. Evidence status in the ADT and Eero class project


Evidence status

ADT example

Eero example

What may be concluded

Observed event

17,103 unique events after deduplication

5,314 unique events after deduplication

The source system recorded an event at a stated time; source lineage is retained.

Candidate alarm

Rule-generated device or security conditions within 201 total candidates

87 high-priority candidates, including 72 authentication-related

A configured rule fired. This does not prove an incident or failure.

Hypothesis

A nearby ADT event may provide context

Authentication negotiation or roaming may explain the first investigated candidate

The explanation is plausible but unconfirmed; identity and causal evidence are still required.

Approved finding

Requires independent review

Requires independent review

A reviewer records the supported conclusion, uncertainty, and any needed action.


Table 3. Relationship semantics that must not be collapsed


Relationship

Meaning

What it does not establish

Temporal

Events occurred near one another within a defined time window.

That the records refer to the same device, or that one caused the other.

Entity linked

Records share a verified client, device, node, site, or durable cross-system mapping.

That the linked events form one incident or share a cause.

Causal

Independent evidence supports a mechanism connecting an antecedent to an outcome.

That every correlated or linked event is relevant to the cause.


The user interface should preserve the same distinctions. Observed events should look different from candidate alarms. Hypotheses should carry their supporting and contradictory evidence. An approved finding should name the reviewer, decision time, residual uncertainty, and any action taken. The application should never rely on prose alone to communicate evidence status.

 

8. The Semantic Model for Investigation

A semantic model gives every agent and retrieval step the same domain language. Without it, one component may treat an alarm as a source record, another may treat it as a verified incident, and a third may use the same device label for two different identifiers. The model turns those implicit assumptions into objects and relationships that can be checked.

The central objects in this case include Events, Alarms, Clients, Eero Nodes, ADT Devices, Sites, Cause Hypotheses, Explanations, and Human Reviews. The relationships include TRIGGERS, PRECEDES, OCCURS ON, ASSOCIATED WITH, SUPPORTS, CONTRADICTS, SUMMARIZES, and APPROVES. The names matter because they tell an agent what kind of claim each connection represents.

 

The graph should do more than connect nodes. Every relationship needs provenance, temporal validity, and evidence status. A client-to-device edge may be verified, inferred, disputed, expired, or unknown. A SUPPORTS edge should identify the evidence and the rule or reviewer that created it. A CONTRADICTS edge is equally valuable because it stops retrieval from presenting only the facts that favor a convenient explanation.

 

Time also belongs in the model. A client may connect through one Eero node in the morning and another in the afternoon. A device mapping may be valid for one period and wrong after hardware is replaced. If the graph stores relationships as timeless facts, an investigation can retrieve a correct relationship from the wrong date.

Figure 5. Home-monitoring knowledge graph semantic model linking source events, devices, clients, access points, alarms, incidents, evidence, causes, and remediation.
Figure 5. Home-monitoring knowledge graph semantic model linking source events, devices, clients, access points, alarms, incidents, evidence, causes, and remediation.

Identity Is a Knowledge Problem

Cross-vendor identity resolution remains one of the most important requirements. Matching an ADT camera to an Eero client cannot be assumed from a nearby timestamp, a similar display name, or a one-time co-occurrence. The mapping needs a durable identifier, a verified inventory relationship, or a review process that records confidence, provenance, and validity dates.

 

Unknown is therefore a legitimate graph value. When the identity is not established, the system should retain the unresolved relationship and explain what evidence would be needed to resolve it. That is better knowledge engineering than filling the gap with a plausible guess.

 

9. Graph RAG and Multi-Agent Investigation

Graph Retrieval-Augmented Generation, or Graph RAG, retrieves a connected evidence neighborhood rather than treating log lines as unrelated text. Starting with a selected candidate alarm, the application can retrieve the triggering event, nearby events, verified client and device relationships, prior incidents, rule evidence, supporting facts, contradictory facts, and unresolved data-quality issues.

 

This is different from placing a large set of logs into a prompt. The graph provides a controlled path through the evidence. It can restrict traversal to the right site and time window, prefer verified relationships, expose missing links, and show why each retrieved item belongs in the context.

 

A practical investigation sequence looks like this:

·  Start with the candidate alarm and its original triggering event.

·  Retrieve preceding and following events within a controlled time window.

·  Resolve verified client, node, device, and site identities.

·  Build the evidence subgraph without relabeling temporal proximity as causation.

·  Retrieve relevant historical cases and both supporting and contradictory evidence.

·  Ask the language model for a preliminary explanation that cites the retrieved evidence and names what is missing.

·  Record the review decision, uncertainty, and feedback separately from the generated explanation.

 

The First Eero Candidate

The first Eero candidate investigated in the class project occurred at 8:24:31 AM Pacific on October 19, 2026, with event ID d87c92beb88b3bd47e41. Six preceding events and one following event fell within a ten-minute window. A client association occurred about 5.942 seconds before the trigger. That sequence made authentication negotiation and wireless roaming reasonable hypotheses.

 

Table 4. Evidence record for the first investigated Eero candidate


Evidence item

Observed or derived value

Status in the investigation

Trigger

Authentication or handshake candidate at 8:24:31 AM Pacific on October 19, 2026; event d87c92beb88b3bd47e41.

Observed trigger plus rule-generated candidate alarm.

Immediate context

A client association was observed about 5.942 seconds before the trigger.

Temporal evidence; client identity continuity was not established.

Investigation window

Six preceding events and one following event occurred within ten minutes.

Context available for retrieval; relevance varies by identity and event type.

Hypotheses

Authentication negotiation and wireless roaming could explain the pattern.

Plausible but unconfirmed hypotheses.

Supported conclusion

Device unknown; root cause not determined.

Correct preliminary conclusion pending stronger identity and causal evidence.


The records did not reliably establish that the nearby events involved the same client, and they did not identify a failed physical device. The correct preliminary conclusions were therefore "device unknown" and "root cause not determined." The system had useful context, but not enough identity and causal evidence to go further.

 

A grounded explanation can still be helpful under those conditions. It can state the observed trigger, summarize the surrounding sequence, identify the hypotheses, explain which evidence supports each one, list contradictory or missing evidence, and recommend the next diagnostic step. What it should not do is convert a coherent story into a confirmed cause.

 

Graph RAG improves retrieval; it does not manufacture causality. Its value comes from assembling the right evidence and making the relationships visible enough for the language model and the reviewer to reason within the same boundaries.

 

Two Alarms One Shared Cause

This separate cross-source episode produced the case study's clearest payoff. Two observed events occurred at the same time: the monitoring camera went offline, and the Wi-Fi network went down, interrupting a Zoom call Neena was running. The application treated these as two observations, not as a root cause.

 

Rules generated two candidate alarms: a camera-connectivity alarm and a Wi-Fi-connectivity alarm. When Graph RAG retrieved the surrounding evidence, both alarm paths supported the same hypothesis: a power failure or interruption. At that stage, the shared hypothesis was useful, but still unconfirmed.

 

Human review supplied the missing operational fact. A field technician had changed the camera's power supply and plugged it into the same power strip used by the Wi-Fi equipment. When he used the switch on the strip to reset the camera, he also cut power to the Wi-Fi. What first looked like two unrelated alarms was one physical action affecting a shared dependency.

Figure 6. Two simultaneous observed events produced separate candidate alarms that converged on a shared power-failure hypothesis.
Figure 6. Two simultaneous observed events produced separate candidate alarms that converged on a shared power-failure hypothesis.

Human review confirmed that resetting the camera with the shared power-strip switch also interrupted the Wi-Fi.

 

The distinction among evidence states is the punch line. The logs established the simultaneous observed events. The rules created the candidate alarms. Graph RAG connected the evidence and surfaced a shared power-failure hypothesis. The technician's account and the shared-strip configuration confirmed the root cause through human review. The conclusion came from evidence, a useful hypothesis, and human validation—not from fluent text alone.

 

10. A Class Project You Can Do with Your Own Home Data

This is a class project, not a production deployment. Its purpose is to showcase knowledge engineering with data many people can obtain at home: security-event exports, home-network logs, smart-home histories, and router status records. The goal is to learn how raw observations become traceable, reviewable conclusions—not to automate household decisions.

 

Start with Data You Already Own

Choose one modest dataset and one question. For example: What happened around a camera outage? Why did the home network drop? Which repeated events deserve review? Work from copies of your exports, remove personal details you do not need, normalize timestamps, deduplicate records, and preserve the source file and row for every event. A small, well-understood dataset teaches more than a large folder of mixed files.

 

Build the Knowledge Layers

Define the evidence states before asking an AI system to explain anything. Create a normalized event table, a short rule catalog for candidate alarms, and a small graph linking events, devices, times, evidence, and hypotheses. The graph can be drawn on paper, built in a spreadsheet, or implemented in a graph tool; the learning comes from making every relationship explicit.

 

Then investigate one episode from end to end. Retrieve events before and after the candidate alarm, follow only verified identity links, record supporting and contradictory evidence, and ask a language model for a qualified explanation. Keep the generated explanation separate from the evidence and from the final human decision. The shared power-strip episode shows the kind of insight this simple workflow can reveal.

 

Review What the Evidence Supports

Success in the class project is traceability, not production accuracy. A reader should be able to move from the reviewed conclusion to the hypothesis, from the hypothesis to the candidate alarm, and from the alarm to the exact source events. Unknown identities, missing evidence, and rejected hypotheses are useful results because they show where the knowledge boundary lies.

 

A strong submission can remain compact: a normalized event table, the rule definitions, the semantic model, one evidence subgraph, the preliminary explanation, and the human-reviewed conclusion. Add a short reflection describing what the graph made visible and what the data could not establish.

 

You can repeat the exercise with your own datasets at home without turning it into a production system. Use only data you are authorized to inspect, protect household privacy, and keep any action recommendations advisory. The educational value comes from practicing the discipline of knowledge acquisition, representation, retrieval, explanation, and human review.

 

11. The Foundation of Agentic AI

Agentic AI is often described through models, tools, memory, and orchestration. Those components become a coherent application only when they share an engineered representation of the domain. Knowledge engineering defines what the system knows, how it knows it, what it may infer, and where human judgment remains necessary.

 

The ADT and Eero class project makes the point visible. Event detection and alarm detection are different activities. Multi-source consolidation improves context only when timestamps and identities are trustworthy. Graph RAG adds value by retrieving relationships and evidence. A language model can explain that evidence, but it should not replace deterministic rules, independent validation, or accountable decisions.

 

The Pattern Extends Beyond Home Monitoring

The same method applies anywhere operational logs have to become an explanation. The domain objects and rules change, but the knowledge work remains recognizable: normalize observations, preserve lineage, identify reviewable conditions, resolve entities, retrieve connected evidence, propose a qualified explanation, and record the approved conclusion.

Table 5. Other applications of the same knowledge engineering pattern


Application

Observed evidence

Investigation objective

Security surveillance

Access, camera, motion, and alert events

Reconstruct suspicious activity without treating proximity as proof.

CI CD pipelines

Commits, tests, builds, deployments, and infrastructure changes

Explain a failure through versioned dependencies and change history.

Device defect analysis

Defect logs, sensor readings, component history, and maintenance records

Distinguish recurring symptoms from a validated failure mechanism.

IT operations

Telemetry, crashes, service tickets, and change records

Connect a service symptom to verified systems, changes, and dependencies.

Cybersecurity

Authentication, endpoint, network, and identity events

Build an evidence-backed attack sequence while preserving uncertainty.


The goal is not to maximize the number of events processed, alarms created, or words generated. It is to convert fragmented operational data into conclusions that are traceable, appropriately qualified, and useful to the person making a decision.

 

That is the lesson connecting Dispatcher to today's agentic systems. An AI application becomes valuable when the model operates inside a carefully engineered body of domain knowledge, evidence, rules, relationships, and review. The agents may be new. The need for knowledge engineering is not. It remains the foundation of agentic AI.

 

References

1. Zemel, Richard, and M. Acock. "DISPATCHER: An Intelligent Approach to Factory Control." Proceedings of the 1986 American Control Conference, vol. 1, 1986, pp. 152-155. Contemporary discussion

2. Fox, Mark S., Neena Sathi, V. Baskaran, and J. Bouer. "Simulation Craft: An Expert System for Discrete Event Simulation." Proceedings of the 1986 Eastern Simulation Conference, Simulation Series 7, no. 2, 1986, pp. 42-47. University of Toronto bibliography

3. Newell, Allen. "The Knowledge Level." Artificial Intelligence 18, no. 1 (1982): 87-127. DOI record

4. Noy, Natalya F., and Deborah L. McGuinness. "Ontology Development 101: A Guide to Creating Your First Ontology." Stanford Knowledge Systems Laboratory, 2001. Stanford publication

5. Lewis, Patrick, et al. "Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks." Advances in Neural Information Processing Systems 33 (2020). arXiv

6. Edge, Darren, et al. "From Local to Global: A Graph RAG Approach to Query-Focused Summarization." 2024. arXiv

 

Note: The figures and counts distinguish observed source records, rule-generated candidate alarms, and unconfirmed hypotheses. The shared-power episode described in Section 9 was confirmed through human review. Broader cross-system identity resolution, corpus-level causal validation, and historical graph retrieval are possible extensions beyond this class project, not requirements for completing it.




 
 
 

Comments


  • Facebook
  • LinkedIn
  • YouTube

© 2026 Applied AI Institute. All rights reserved.

bottom of page