Understand

Understand is the first move of the Trust Loop. Once an agent is connected, every run lands as a trace, and AISquare extracts the reasoning behind it so you can see why the agent decided what it did, not just what it returned. A transcript tells you what was said. The reasoning graph tells you what the agent believed, what it leaned on, and how it got from one to the other.

Your agent's reasoning, as a graph

This is one refund-agent run, laid out as the graph AISquare records: the question it was asked, the context it fetched, the evidence and the one assumption it leaned on, the policy it cleared, the claim it made, and the decision it reached. Drag the canvas to pan, scroll to zoom, and follow the solid line for the timeline and the dashed lines for what each step produced and consumed.

A run is a graph, not a transcript

Each run is recorded as a graph of steps. A step is one unit of work: an LLM call, a tool call, a retrieval, a logic gate, a memory read. Every step carries its model or tool, its latency, tokens, and cost, a status, and the policies it triggered. This is the same anatomy you see in the dashboard.

Reading a step left to right: a refund agent looked up the order, searched the refund policy, reasoned over both, then branched on the customer tier. The third card is mid-execution, which is how a live run reads while the LLM step is still thinking. You can open any run as a flow diagram, as this graph, or as a plain-English narrative; all three are the same recorded decision.

A reasoning graph is not a knowledge graph

A knowledge graph stores what your organization knows: entities and the relationships between them. It is a map of facts, and it changes slowly. A reasoning graph records something a knowledge graph never holds: how an agent thought on one specific run. Which claims it committed to, which evidence it weighed, which assumptions it filled in, and how those connected to the decision it reached.

The two are complements, not competitors. An agent may well consult a knowledge graph as evidence, and that lookup appears as a step on the reasoning graph. But when someone asks why the agent decided what it did, a map of what was known cannot answer. Only the record of how it was used can, and that record is what AISquare captures.

Claims, evidence, and assumptions

Inside a reasoning step, AISquare structures the model's thinking into three parts. This is the reasoning markup (RML) view, and it is the clearest answer to "why did it decide that?"

• Claims are what the agent asserted, the conclusions it acted on.
• Evidence is what each claim rests on, every item carrying a confidence score so a weak input is visible rather than buried.
• Assumptions are the gaps the agent filled in for itself, the inferred facts that were not given to it directly. Surfacing them is the point: an assumption you can see is one you can challenge.

The inference chain then shows, step by ordered step, how the agent moved from evidence and assumptions to its claims.

The third piece of evidence here, that the customer tier resolved to standard, carries a noticeably lower confidence than the rest. That is an assumption the agent leaned on: tier was inferred, not confirmed. Seen on the graph, it is the first thing a reviewer would probe, and it is exactly the kind of weak link the Fix step exists to correct.

Why this matters

Structured reasoning is what turns a black-box run into a decision you can defend and improve.

• Audit. When someone asks why an agent did what it did, you point at the claims, the evidence, and the rule it triggered, not a wall of transcript.
• Debugging. A wrong answer usually traces to one weak claim or one bad assumption. The graph shows you which, so you fix the cause, not the symptom.
• Trust. Reasoning you can inspect is reasoning a regulator, an auditor, or a customer can be shown.

Understanding a decision is the input to acting on it. From here the loop continues: Prevent stops a bad action before it runs, Fix corrects a decision that already happened, and Remember carries the result forward so the next run starts ahead.

Next steps