Grounded data agent (GraphRAG)

Ask two agents the same question. "Which customers does the F-02 freezer breach hit?"

The first answers: Acme and Globex, and it shows you the route it took. Freezer F-02 cooled shipment SH-9, which carried orders O-101 and O-102, placed by Acme and Globex. Every step is real, and you can check it.

The second answers: Meridian Cold Storage. Clean and specific, and it sounds sure of itself. There is one problem. There is no Meridian Cold Storage. It was never in your data. The agent made it up, and it made it up in the same steady voice the first one used to tell the truth.

Same model. Same question. You have seen this exact split once already, on the very first page of this course. Here is why it happens.

An answer needs evidence, or it needs to invent one

A language model is a very good guesser. Give it a question and no facts, and it will still answer, because answering is what it was trained to do. It looks at everything it has ever read and gives back the words that sound most likely to come next. Sometimes that is right. Often it is a smooth, made-up answer, and nothing in the answer itself tells you which one you got.

Grounding stops the guessing. Instead of letting the model answer from memory, you retrieve the real evidence the question needs and put it in front of the model, so the answer has to come from that evidence and not from a guess. Same model, same words, but now it is reading from your data instead of making things up.

Look at the two panels. Nothing changed about the model between them. What changed is that the left one had a path to walk and the right one had a blank to fill. A blank always gets filled. That is the whole reason behind a confident hallucination, a made-up answer said with full confidence.

Retrieval, but over a graph

Here is what "grounded" actually does, step by step. The agent takes your question, finds the nodes the question touches, walks the relationship edges between them, and puts that walked subgraph together as the evidence it answers from. Only then does it write a sentence.

That middle part has a name. Retrieval-augmented generation is the general idea: fetch the relevant evidence, then let the model answer from it. When the thing you retrieve over is a graph, and retrieval means walking edges instead of collecting loose bits of text, it is GraphRAG. The difference matters for the breach question. The answer does not sit in any one document, waiting to be found. It is a path across four connected things, and only a walk can put it together.

That is also why grounding on a graph beats grounding on plain tables. Tables give the agent rows to match. A graph gives it relationships to follow, so it can reach an answer that no single row holds and still point to every step it took.

Flip the switch yourself and watch the answer change.

Off, the agent never touches your data, so it has nothing to show and everything to invent. On, it has to walk first, so the answer comes with its proof attached. That is grounding you can try for yourself.

The data agent, grounded on the ontology graph

Fabric has a name for an AI agent grounded in your data: a data agent. It is the same idea you just toggled, built into the ontology. Instead of answering from training, the data agent retrieves and traverses the ontology graph, the queryable instance graph (the graph of real records) you built over your OneLake tables, and answers from what it walks. That traversal is the retrieval, so the grounding here really is GraphRAG: the evidence is a graph and the agent walks it.

Two more pieces make it usable. First, the data agent reads its agent instructions, a plain-text note that sets what it should talk about and ties the words to your business, so "customer" means your customer and not some general idea. Second, it can hand back the traversal path as the explanation, the same way the toggle showed you the route. Behind the scenes the walk runs as GQL, the ISO-standard graph query language, right on the graph. Nothing is copied into a separate store.

This is the result from the top of the page, now with a reason. Grounding on the ontology graph reduces hallucination compared with an ungrounded model guessing from raw tables, because the agent has real edges to walk instead of a blank to fill. As of July 2026 the data agent and the graph engine under it are both generally available. What is still in preview is the ontology item, and pointing a data agent at a graph or an ontology as its source, which is exactly the setup this page depends on, so expect that part to change. The core idea will not change: retrieve real evidence, answer from it, show the path.

The one trap

Do not trust an answer because it sounds sure. Sounding smooth is free. A model will say a made-up answer just as calmly as a real fact, because the wording comes from the same place either way. The thing worth trusting is not the confidence, it is the proof: can the agent show you the evidence it walked? If it can, you can check it. If it cannot, you are reading a very good guess that only looks trustworthy.

So the grounded agent can answer your questions and prove its answers. This is the right moment to get suspicious of a page like this one. The graph won here, against an agent that had nothing. That is not a hard fight. Next: what happens when you give it a real one.