Decision Trace Model with GNN — Making Decision-Making a Learnable Structure —

In recent years, AI systems have evolved from simple predictive models into systems that generate decisions.

At the center of this evolution lies the Decision Trace Model.

What is the Decision Trace Model?

The Decision Trace Model represents the decision-making process of AI as a structured flow consisting of:

Event (what happened)
Signal (features / interpretation)
Decision (what to choose)
Boundary (constraints / stopping conditions)
Human / Execution (action / human intervention)
Log (record)

This is a design that explicitly represents the flow of decision-making within AI systems.

The Problem: How is this structure created?

In many existing systems:

Rules are manually written
Relationships are implicit
Decision connections are black-box

In other words:

👉 The structure exists, but it is not learned

Learning Structure with GNN

This is where Graph Neural Networks (GNNs) become critical.

GNNs are models that learn:

👉 relationships themselves

The Decision Trace Model inherently has a graph structure.

Representing Decision Trace as a Graph

Node Design

Each component becomes a node:

Event node
Signal node
Decision node
Boundary node
Human node
Log node

Edge Design

Relationships are represented as edges:

Event → Signal (feature extraction)
Signal → Decision (decision generation)
Decision → Boundary (constraint application)
Boundary → Execution (permission to act)
Decision → Log (recording)

This transforms the entire decision process into a graph

GNN Model Design

There are various GNN models applicable to the Decision Trace Model.

① GraphSAGE (Base Model)

GraphSAGE is the most practical choice because:

It supports new nodes (new decisions)
It works well with dynamic graphs
It scales to large datasets

Update Equation

[
h_v^{(k+1)} = \sigma \left( W \cdot \mathrm{concat} \left( h_v^{(k)}, \mathrm{AGG} \left( { h_u^{(k)} \mid u \in \mathcal{N}(v) } \right) \right) \right)
]

This means:

Each node updates its representation by incorporating its neighborhood context

② GAT (Attention-Based Model)

A more advanced model is the Graph Attention Network (GAT).

Key Features:

Assigns weights to important relationships
Reduces noise
Improves interpretability

This allows:

Strong signals (e.g., risk indicators) to dominate
Weak features to be ignored

③ Heterogeneous GNN (R-GCN)

Since Decision Trace contains different types of nodes and edges,
Heterogeneous GNNs are essential.

Node Types:

Event
Signal
Decision
Boundary
Human

Edge Types:

triggers
influences
constrains
executes

Update Equation

[
h_v^{(k+1)} =
\sigma\left(
\sum_{r \in \mathcal{R}}
\sum_{u \in \mathcal{N}r(v)}
\frac{1}{c{v,r}}
W_r^{(k)} h_u^{(k)}
+
W_0^{(k)} h_v^{(k)}
\right)
]

This separates the influence of different relationship types

Learning Task Design

In the Decision Trace Model, GNN is not just for node classification.

It is used to learn the decision structure itself.

① Decision Prediction

Predict the next decision.

Description:
Predict which decision will be selected based on Event and Signal.
This forms the basis for reproducing and automating decision-making.

Input:

Event (user actions, transactions, sensor data, etc.)
Signal (scores, inferred features, anomaly levels)
Context (history, environment, user attributes)

Output:

Decision
Decision Probability
Optional: Decision Explanation

② Risk Detection

Detect whether a decision is risky.

Description:
Evaluate whether a decision involves risk, similar to anomaly or fraud detection.

Input:

Decision
Related Signals (risk score, anomaly indicators)
Context

Output:

Risk Score
Risk Label (High / Medium / Low)
Optional: Risk Explanation

③ Boundary Violation Prediction

Predict violations of constraints.

Description:
Check whether a decision violates rules or policies.

Input:

Decision
Boundary (rules, constraints)
Context

Output:

Violation Probability
Violation Flag
Violated Rules

④ Policy Optimization

Learn optimal decision-making strategies.

Description:
Determine which decision leads to the best outcome.

Input:

State (Event + Signal + Context)
Candidate Decisions
Reward Signal

Output:

Optimal Decision
Policy (state → decision mapping)
Value / Q-value

Implementation Example (PyTorch Geometric)

Below is a basic GraphSAGE implementation for Decision Trace:

import torch
import torch.nn.functional as F
from torch_geometric.nn import SAGEConv


class DecisionGNN(torch.nn.Module):
    def __init__(self, in_channels, hidden_channels, out_channels):
        super().__init__()

        self.conv1 = SAGEConv(in_channels, hidden_channels)
        self.conv2 = SAGEConv(hidden_channels, hidden_channels)
        self.classifier = torch.nn.Linear(hidden_channels, out_channels)

    def forward(self, x, edge_index):
        x = self.conv1(x, edge_index)
        x = F.relu(x)
        x = F.dropout(x, p=0.3, training=self.training)

        x = self.conv2(x, edge_index)
        x = F.relu(x)

        logits = self.classifier(x)
        return logits

What This Model Does

This model updates node representations by incorporating relationships from neighboring nodes.

Process:

Assign initial node features
Aggregate neighbor information via GraphSAGE
Update representations
Perform prediction

Core Insight: Decision Trace × GNN

The essence of this approach is:

Transforming decision-making into a learnable structure

Traditional Approaches

Rule-Based Systems

Explicit but rigid
Hard to adapt

Black-Box Models

Learnable but opaque
Not controllable

New Approach

Structure → Explicit (Decision Trace)
Relationships → Learned (GNN)
Decisions → Controllable (DSL / Behavior Tree)

Decision-making becomes:

Structured knowledge instead of code or black-box outputs

Critical Limitation of GNN

GNN can:

Learn relationships
Detect patterns

But cannot:

Define meaning boundaries

Example: Fraud Detection

GNN can learn:

A user sending money to multiple countries
Multiple accounts from one device
High-frequency transactions

It detects patterns

But cannot decide:

Should we block at risk > 0.8?
Should VIP users be exempt?
How to handle nighttime transactions?

The Four Required Layers

Ontology

Defines meaning:

Transaction
User
Risk
Device

DSL

Defines rules:

IF risk_score > 0.8 THEN block_transaction
IF user_type == VIP THEN allow_override

Behavior Tree

Controls execution flow:

Check Risk
  ↓
Check VIP
  ↓
Apply Policy
  ↓
Execute

GNN

Learns relationships:

Which signals matter
What patterns indicate risk

Integrated Flow

Event → GNN → Signal → DSL → Behavior Tree → Decision

Key Insight

GNN → discovers relationships
DSL → defines decisions
Behavior Tree → controls execution
Ontology → defines meaning

Only when all four are combined:

A controllable AI decision system emerges

Final Architecture

Ontology (meaning)
DSL (rules)
Behavior Tree (control)
GNN (learning)
Decision Ledger (recording)

This can be seen as:

An Operating System for Decision-Making AI

Conclusion

To realize the Decision Trace Model:

Represent decisions as graphs
Learn relationships with GNN
Control via Ontology and Boundary

👉 The key idea is:

Do not let AI make decisions blindly
Instead, design the decision structure and make it learnable

If you’re interested in deeper technical details of GNNs,
please refer to the Graph Neural Network section in this blog.

Deux Ex Machina

AIシステム設計・意思決定構造の設計を専門としています。
Ontology・DSL・Behavior Treeによる判断の外部化、マルチエージェント構築に取り組んでいます。

Specialized in AI system design and decision-making architecture.
Focused on externalizing decision logic using Ontology, DSL, and Behavior Trees, and building multi-agent systems.