Trust Evaluation in the Age of AI — Trace-based Trust and GNN-based Trust Scoring —

In the age of AI, one of the most important questions becomes:

“How should Trust be evaluated?”

However, what matters here is that:

Trust is not a simple numerical score.

Because real trust is formed through:

Relationships
History
Context
Responsibility
Coordination
Situational judgment

For this reason, future Trust evaluation may require two major approaches.

One is:

Tracing Trust directly as a graph structure.

The other is:

Quantifying Trust through machine learning and Graph Neural Networks (GNNs).

These two approaches are not opposites.

Rather, they complement each other.

1. Trace-based Trust Evaluation

— Evaluating Trust by Preserving the Trace Itself —

The first approach is based on the idea that:

Trust should not be forcibly compressed into numerical values.

Because trust is fundamentally:

the accumulated history of why someone is trusted.

Even in the real world, a high “trust score” alone does not necessarily mean someone is truly trustworthy.

What matters is:

What situations they faced
Who they coordinated with
How they responded to failures
What boundaries they checked
Where human review occurred
What responsibilities they accepted

In other words:

Trust is embedded within the Decision Trace itself.

Tracing Trust as a Trust Graph

This is where the idea of the:

Trust Graph

becomes important.

In a Trust Graph:

Nodes may represent:

Humans
AI systems
Agents
Organizations
Communities
Decisions
Boundaries

Edges may represent:

Trust
Approval
Collaboration
Influence
Responsibility
Escalation
Review

This means the graph traces not only:

“Who trusted whom”

but also:

“Why that trust was formed.”

For example:

Agent A makes a proposal
↓
A human reviewer approves it
↓
A boundary engine performs safety verification
↓
Organization B executes it
↓
A failure occurs
↓
Escalation happens
↓
Corrective action is taken
↓
Trust is updated

This entire history becomes part of Trust itself.

Why “Tracing Without Compression” Matters

The important point is that:

Trust is context-dependent.

For example:

A decision trusted in healthcare AI

may differ from:

A decision trusted in financial AI.

Furthermore:

An AI system that performs well under normal conditions

may not necessarily be trustworthy during abnormal situations.

This means:

Trust cannot be fully represented by static scores alone.

That is why:

Trust evaluation must preserve the Decision Trace itself.

Explainable Trust

The greatest advantage of this approach is:

Explainability.

Why is this AI trusted?
Why was this decision approved?
Why was authority granted to this Agent?

All of these can be explained through:

the trace itself.

This becomes especially important for:

Government AI
Healthcare AI
Manufacturing AI
Autonomous Systems

where accountability and explanation are essential.

2. Quantified Trust Evaluation

— GNN-based Trust Quantification —

At the same time, future society will generate:

massive Trust Networks.

As a result, humans will no longer be able to read every trace manually.

This is where:

Trust Quantification

becomes necessary.

Why Quantification Is Necessary

Future systems may involve:

Millions of Agents
Billions of Decisions
Massive coordination networks

In such environments:

reading every individual trace

becomes unrealistic.

Therefore:

a certain level of abstraction

is required.

This is where:

Graph Neural Networks (GNNs)

may become extremely important.

GNN-based Trust Evaluation

Trust fundamentally has:

a graph structure.

Because trust emerges through relationships between:

Human ↔ AI
Agent ↔ Agent
Organization ↔ Organization

GNNs can learn from:

Node features such as:

Decision Quality
Failure History
Boundary Violations
Human Approval Rate
Escalation Frequency
Contribution Score

and edge features such as:

Trust Strength
Collaboration Frequency
Knowledge Sharing
Responsibility Propagation
Influence

Compressing the Entire Graph for Evaluation

An important point is that:

GNNs do not evaluate nodes and edges independently.

Instead, GNNs learn:

the surrounding relationship structure itself.

This means evaluation is based not only on:

what an individual Agent has achieved,

but also on:

Who it coordinated with
What organizations it is connected to
What decisions it influenced
What failures and improvement histories surround it

In other words:

GNNs compress large Trust Graphs into evaluatable representations.

For example, instead of reducing an Agent to a single score, GNNs can represent it as a:

Trust Embedding

that contains:

Relationships
Decision histories
Responsibility structures
Influence ranges

Using these embeddings, systems may evaluate:

Which domains an Agent is trustworthy in
How risky it becomes during abnormal situations
Which organizations it collaborates effectively with
Under which boundary conditions caution is required

In this sense, GNN-based Trust evaluation is:

a method for compressing Trust Graph structures into decision-usable representations without losing the graph itself.

Trust Propagation

Another critical concept is:

Trust Propagation.

Trust does not exist only inside isolated nodes.

It propagates through relationships.

For example:

If an Agent continuously collaborates with a highly trusted Organization,

its own trust level may increase.

Because long-term collaboration with trustworthy organizations suggests:

Consistent quality
Responsible judgment
Stable coordination capability
Sustained performance

Conversely:

If an Agent is strongly connected to high-risk networks or problematic Agent groups,

its risk level may increase.

Even if that Agent has not directly caused problems itself, what matters is:

What relationship structures it operates within
What decisions influence it
What responsibility chains it belongs to

This means Trust evaluation must consider not only:

the individual Agent’s history,

but also:

the surrounding trust structure.

This idea resembles concepts such as:

PageRank
Reputation Propagation
Graph Centrality

The important point is that:

Trust is not a static personal score.

It is a dynamic value that forms, propagates, and updates across networks.

Dynamic Trust

Another important point is that:

Trust is dynamic.

Even if an entity achieves high Trust once, that Trust is not guaranteed permanently.

Likewise, a single failure does not necessarily destroy Trust forever.

Trust continuously changes through:

Decisions
Coordination
Failures
Corrections
Escalations
Human Review

For example:

Even if an Agent fails once, Trust may recover if it later:

Clarifies the cause
Improves its decision process
Strengthens boundary conditions
Enhances human review

On the other hand:

Even apparently successful systems may gradually lose Trust if they:

Hide risks
Fail to record failures
Avoid human review

This means Trust evaluation must consider not only:

the current state,

but also:

how Trust changes over time.

Temporal Graphs

This is where:

Temporal Graphs

become important.

A Temporal Graph treats a Trust Graph not as a fixed network, but as:

a graph evolving over time.

This allows systems to learn:

When coordination occurred
When failures happened
When improvements were made
What decisions increased Trust
What actions reduced Trust

along a temporal axis.

Using Temporal Graphs, GNNs may learn not only:

the current value of Trust,

but also:

the trajectory of Trust itself.

For example:

Is this Agent’s Trust recently increasing?
Does it improve after failures?
Does Trust decline under specific conditions?
What relationships contribute to Trust recovery?

Dynamic Trust therefore means:

Trust should not be treated as a fixed score,

but as a continuously evolving trust state shaped by:

decision histories, failures, corrections, coordination, and responsibility handling.

Future Trust Evaluation Becomes a “Two-Layer Structure”

An important point is that:

Trace-based evaluation

and

Quantified evaluation

are not opposing approaches.

Instead, future Trust evaluation will likely become:

a two-layer structure.

Layer 1: Decision Trace / Trust Graph

The first layer is:

Decision Trace / Trust Graph.

This layer preserves:

raw histories

before compressing them into numerical values.

It records:

Who made what decision and when
What information was used
Who coordinated with whom
What boundaries were checked
Where human review occurred
What outcomes happened
How failures were handled

The role of this layer is:

to explain why trust exists.

In other words:

it preserves the foundation of Trust itself.

Layer 2: GNN-based Trust Scoring

The second layer is:

GNN-based Trust Scoring.

This layer abstracts and quantifies Trust using the complex histories stored within Decision Traces and Trust Graphs.

Since humans cannot manually read every trace in large-scale systems, GNNs learn from:

Relationships
Decision histories
Coordination histories
Failure histories
Responsibility handling
Influence ranges

and convert them into:

Scores
Embeddings
Evaluatable features

This enables:

Comparison
Ranking
Risk detection
Recommendation
Authority allocation
Automated decision support

Why the Two-Layer Structure Is Necessary

If Trust is represented only by scores:

the reason behind the evaluation becomes unclear.

But if everything remains only as raw traces:

large-scale systems become too slow to evaluate.

Therefore future systems require:

Explainability through traces
and
Scalability through GNN-based abstraction.

This resembles the relationship between:

Accounting Ledgers
and
Credit Scores.

Accounting ledgers preserve detailed transaction histories.

Credit scores summarize those histories into simplified indicators.

Credit scores alone lack explanation.

Ledgers alone are difficult to use for immediate decisions.

Both are necessary.

Trust evaluation follows the same structure.

Decision Trace / Trust Graph preserves the foundation of Trust.

GNN-based Trust Scoring transforms that foundation into scalable evaluation structures.

Future Trust evaluation therefore emerges from combining:

Explainable histories
and
Quantified evaluation.

Connection to Decision Trace Model (DTM)

This is where:

Decision Trace Model (DTM)

becomes extremely important.

DTM views decision-making not merely as outcomes, but as flows involving:

What happened
What signals were recognized
How decisions were made
What boundaries were checked
Where humans intervened
What actions were executed
How results were recorded

Its core structure is:

Event → Signal → Decision → Boundary → Human → Execution → Log

This structure is highly important for Trust evaluation.

Because Trust cannot be evaluated solely based on success or failure.

What truly matters is:

What situations were considered
What information was used
What risks were checked
Where escalation occurred
What responsibility boundaries existed
How outcomes were recorded and improved upon

DTM already contains the structure necessary for this kind of Trust evaluation.

Furthermore, DTM can preserve:

Failure Trace
Boundary Violations
Human Escalation
Coordination History

This means DTM can trace:

Why failures occurred
Which boundaries were crossed
Where human judgment became necessary
Who coordinated with whom
How corrections were made afterward

These traces naturally become inputs for:

Trust Graphs
and
GNN-based Trust Scoring.

DTM therefore has the potential to support both:

Trace-based evaluation
and
Quantified evaluation.

In that sense, DTM is not merely a decision model.

It may become a foundational component of future Trust Infrastructure.

Trust Shifts from “Personality” to “Decision Runtime”

Traditionally, Trust depended heavily on:

Personality
Titles
Brands
Authority

People trusted others because:

“They seem sincere.”
“They belong to a respected organization.”
“That brand feels reliable.”
“That authority approved it.”

Of course, these factors will not disappear completely.

However, in the AI era, they become insufficient.

Because AI can generate enormous amounts of:

Information
Proposals
Judgments
Content

making surface-level impressions increasingly unreliable.

What becomes important instead is:

How decisions were actually made.

This includes:

What information was considered
What situations were taken into account
What boundaries were checked
Where humans intervened
What judgments were made
How outcomes were handled

Trust therefore shifts toward:

decision history itself.

In other words:

Trust increasingly becomes:

Trust = Decision Runtime History

The trustworthiness of a person, AI, Agent, or organization becomes defined by:

how they make decisions,
how they execute them,
how they correct mistakes,
and how they accept responsibility over time.

Future Trust evaluation therefore requires both:

Trace-based Trust
and
Quantified Trust.

One preserves explainable histories.

The other enables scalable evaluation using GNNs and large Trust Graphs.

Trust is no longer merely about personality or authority.

It becomes something formed through:

the accumulated history of decision-making within a runtime structure.

That may be one of the most important transformations brought by the age of AI.

Chinoba — Runtime Society and Coordination Systems:
chinoba.org