What is determinism in AI?

Traditional determinism means the same input and system state produce the same output. For an AI agent, the practical goal is a consistent policy decision for a proposed action, evidence state, policy version, and time—even if the LLM's wording varies.

Can an LLM be deterministic?

Model settings can improve repeatability, but repeated wording does not prove an action is correct or authorized. A governed runtime treats the LLM's output as a proposal and checks it against evidence and policy before acting.

What are the six facets of determinism for agentic actions?

Authority, scope, risk, time, uncertainty, and outcome value. Together, they establish who may act, where an action is permitted, its potential impact, whether knowledge is current, how strong the evidence is, and whether acting is worth the potential cost.

What do allow, pause, and deny mean?

Allow means the proposed action meets policy requirements. Pause means it must wait for more evidence or an approval. Deny means it violates a boundary and must not proceed.

Can a paused agent action resume without human approval?

Yes, if policy permits. The agent can retrieve more authoritative or current evidence and submit the action for reevaluation. If policy requires a person or the uncertainty remains unresolved, it stays paused.

How do ontologies help agents act predictably?

Ontologies define entities and relationships explicitly, so agents and policies can distinguish meanings that look similar in text. This reduces reliance on a model's interpretation alone and makes the knowledge used for a decision easier to inspect.

Do knowledge graphs eliminate AI hallucinations?

No. Structured knowledge can still be wrong, incomplete, or outdated, and models can still make mistakes. Provenance and policy checks make those limitations easier to detect and can prevent unsupported actions from proceeding.

How do prospect theory and FAIR inform agent policies?

Prospect theory highlights how gains and losses may be valued differently. FAIR provides a framework for estimating cyber-risk exposure. They can inform thresholds for risk and outcome value, but each organization must define and test its own policy.

What makes an agent decision auditable?

An auditable decision links the proposed action to its source evidence, facet assessments, policy version, allow/pause/deny result, and any subsequent approval or outcome. TrustGraph's provenance and agent traces help expose those links.

Does outcome-oriented determinism guarantee success?

No. It makes the conditions for acting explicit and enforceable; it does not guarantee that every answer or real-world outcome will be correct. When required conditions are unmet, the runtime pauses or denies the action instead of treating uncertainty as permission.

What is Determinism for AI?

Determinism traditionally means that the same input, applied to the same system in the same state, produces the same output. Give a program A, and it produces B. For a bank ledger, that repeatability is indispensable: a balance cannot depend on which answer a language model happens to generate.

An AI agent is different. It may interpret a request, retrieve evidence, weigh alternatives, and propose an action. Its language model can produce different responses to the same prompt, and its evidence may change between runs. Yet organizations still need predictable behavior: an agent must not approve a payment without authority, use knowledge from the wrong customer, or act on a policy that expired yesterday.

The answer is not to make every word the model generates identical. It is to make the conditions under which an agent may act explicit, testable, and enforceable.

The old way: A always yields B

Traditional deterministic software puts the decision rule in code. Given the same inputs and state, a calculation or rule returns the same result. A transaction can be checked against defined constraints before it commits. An aircraft can use redundancy and error detection to tolerate a faulty component.

That last example matters: a predictable system-level outcome does not require every component to be infallible. It requires mechanisms that detect deviations, constrain their effects, and recover or stop safely. But even then, engineering provides bounded assurances and not a guarantee against every possible failure.

LLMs complicate this picture. They generate plausible language rather than execute a complete, predefined decision tree. A model might correctly identify a supplier in one answer and confuse two similar suppliers in another. Repeating the prompt, lowering temperature, or testing more examples may improve consistency, but none of those measures alone establishes that an action is authorized or safe.

Question	Traditional deterministic program	Governed agent using an LLM
Where is the rule?	Encoded in program logic	Encoded in explicit policies outside the model
What can vary?	Inputs and system state	Evidence, model proposals, and system state
What must be predictable?	The program's output for a defined input and state	The policy decision for a defined action, evidence state, and policy version
What happens when the rule cannot be satisfied?	Reject or raise an error	Deny, or pause to gather evidence or seek approval

This is a practical form of outcome-oriented determinism: allow only actions that satisfy the governing policy. It does not mean every request succeeds, every answer is correct, or every real-world outcome is guaranteed. It means uncertainty cannot silently become permission.

Why knowledge matters

A policy engine can be precise and still make a bad decision if the facts it receives are ambiguous. Consider a user asking an agent, “Who is on first base?” In the Abbott and Costello routine, Who is the player's name, not a request for someone's identity. A similarity search may retrieve relevant text, but similarity alone does not define which meaning the word has in this domain.

An ontology can make the distinction explicit: Who is a Player; FirstBase is a BaseballPosition; and Who playsPosition FirstBase. The agent can retrieve that relationship rather than infer it anew from nearby words. For consequential actions, the same principle applies to suppliers, contracts, people, permissions, and obligations.

TrustGraph turns source material into ontology-enhanced knowledge with typed entities, defined relationships, and provenance. Agents can retrieve that knowledge through natural-language access or graph queries, while the TrustGraph Agent Runtime can trace behavior back to the knowledge used. This gives policy evaluation a stronger basis: not just a fluent model answer, but identifiable facts, their sources, and the relationships between them.

Structured knowledge does not eliminate extraction errors or hallucinations. It makes the evidence inspectable, so the runtime can check what is known, what is missing, and what should not be assumed.

Six facets of an agentic action

Before an agent acts, a governed runtime should evaluate six facets together. Each is a question about the proposed action, not merely the quality of the generated text.

Authority: Who requested the action, what delegated powers does the agent have, and which source is authoritative for the decision? A user request does not override a contract or approval policy.
Scope: Is the action limited to the permitted customer, workspace, collection, resource, and operation? A valid answer for one account must not become permission to act on another.
Risk: What is the exposure if the action is wrong, including financial, operational, security, and compliance consequences? A read-only lookup and an irreversible transfer require different controls.
Time: Are the evidence, permissions, and policy valid now? A superseded price list or expired delegation may have been correct when recorded but unusable for today's action.
Uncertainty: How strong and complete is the supporting evidence? Conflicting sources, missing relationships, and ambiguous entity resolution should affect the decision, not disappear inside a confident-sounding answer.
Outcome value: What is gained by acting, and what is lost by delay, abstention, or an incorrect action? The value of a quick response must be weighed against the cost of a mistake.

These facets are not necessarily six numbers to add together. Some are hard constraints. An agent with no authority cannot compensate by claiming high outcome value. Others support calibrated tradeoffs: a low-risk, reversible action may tolerate more uncertainty than a high-impact, irreversible one.

Prospect theory offers a useful reminder that potential losses and gains are not always valued symmetrically. FAIR, the quantitative cybersecurity risk approach, offers a way to think about likelihood and magnitude of loss. Both can inform how teams estimate the six facets in real time; neither automatically supplies the right thresholds or turns uncertain estimates into facts. Organizations must define and test those policies for their own decisions.

Allow, pause, or deny

The runtime's job is to take a proposed action, evaluate it against a versioned policy and the available evidence, and return one of three decisions:

Allow: All mandatory conditions pass, the evidence is sufficient, and the action falls within the applicable risk and uncertainty thresholds.
Pause: The action might be permissible, but the runtime needs more evidence, a fresher source, clarification, or human approval. It can retrieve again and reevaluate; if the missing requirement cannot be satisfied automatically, it waits for a person.
Deny: The action violates a hard boundary, such as missing authority, prohibited scope, or a risk threshold that cannot be mitigated by further evidence. The agent must not execute it.

For example, suppose an agent proposes changing a customer's payment destination after reading an emailed request. A policy might require a verified requester, an account match, current authorization, evidence from an approved source, and an independent approval above a specified exposure threshold. The email alone could trigger pause while the agent checks the governed customer record. If the records conflict, it stays paused for human review. If the requester lacks authority, it returns deny. Only when every required condition passes does it return allow.

The same rules should produce the same decision for the same normalized action, evidence snapshot, policy version, and evaluated time. The LLM may vary its wording or propose different actions, but it cannot grant itself an exception. The runtime records the proposed action, retrieved evidence and provenance, facet assessments, policy version, decision, and any subsequent approval or outcome. This makes a decision reproducible and auditable without pretending that the model itself is deterministic.

Determinism as a contract

The old contract was: given A, the program returns B. The agentic contract is more precise about what matters: given a proposed action, the applicable policy, and a defined evidence state, the system allows, pauses, or denies according to enforceable rules.

TrustGraph supplies the semantic foundation for that contract. Ontologies clarify what entities and relationships mean. Source-linked knowledge helps establish what an action is based on. Provenance and agent traces make it possible to inspect how a decision was reached. A policy-governed runtime can then use authority, scope, risk, time, uncertainty, and outcome value to decide whether the agent may proceed.

Probabilistic intelligence can propose and investigate. Deterministic governance decides whether it may act. That is how an AI system becomes more trustworthy without claiming it can never be wrong.