Graph
Overview
Graph is one of the core execution capability families provided by the Forge runtime.
This section contains canonical verification examples for Graph capabilities implemented by Forge. Every example is derived from maintained Primitive Profiles and executed through the production compute pipeline.
These documents are not graph theory tutorials.
They are executable capability specifications that allow evaluators to independently verify Graph execution, inspect runtime evidence, validate replay, and understand how dependency propagation behaves inside the Forge runtime.
Graph execution models relationships rather than isolated values.
Instead of exploring probability distributions or searching scenario spaces, Graph execution computes how state propagates across connected entities according to a deterministic execution contract.
Primitive Profile
Graph capabilities are implemented through the graph@1 primitive.
Each documented capability corresponds to a versioned Primitive Profile registered in the Forge execution registry.
Primitive
graph
Version
1
Profile
<profile-id>Representative profiles include:
finance.credit.cascading_failure_graph.v1insurance.counterparty.contagion.v1
Each profile defines its own graph semantics while sharing the same execution primitive.
Capability
Graph capabilities evaluate relationships between interconnected entities.
Typical execution models include:
- dependency propagation
- cascading failures
- contagion analysis
- exposure networks
- infrastructure relationships
- counterparty risk
- resource propagation
Unlike Monte Carlo or Search primitives, Graph execution computes structural behaviour over explicitly connected nodes and edges.
The runtime evaluates how changes introduced at one or more graph nodes propagate through the network under deterministic execution rules.
Canonical Contract
Execution uses the canonical Forge execution contract.
Primitive : graph
Version : 1
Profile : <profile-id>Requests are validated by the Canonical Execution Validator before entering the compute runtime.
The canonical payload contains:
op.name
op.version
op.profile
argsOptional execution fields include:
ctx
seed
policyThe graph topology and execution parameters are profile-specific.
Required Inputs
Graph profiles generally require:
- graph definition
- node set
- edge set
- propagation configuration
- execution objective
Additional required fields depend on the selected Primitive Profile.
Execution cannot begin until canonical validation succeeds.
Optional Inputs
Supported optional inputs vary by profile.
Common examples include:
- edge weights
- propagation thresholds
- recovery behaviour
- confidence values
- ownership metadata
- execution evidence
- replay configuration
- visualization preferences
Only fields declared by the profile contract should be submitted.
Canonical Smoke
A canonical Graph smoke verifies:
- profile discovery
- contract inspection
- minimum valid payload construction
- successful validation
- successful execution
- graph traversal
- propagation completion
- runtime evidence generation
- replay metadata availability
The maintained Smoke Suite remains the canonical executable source.
Verification Expectations
A successful Graph execution should demonstrate:
- primitive resolution
- profile resolution
- canonical validation
- successful graph construction
- deterministic propagation
- runtime evidence generation
- replay metadata availability
- artifact generation where supported
Successful execution should allow evaluators to inspect both the propagation result and the propagation process.
Runtime Evidence
Successful Graph execution exposes observable runtime evidence including:
- execution identifier
- primitive profile
- execution metadata
- node count
- edge count
- traversal summary
- propagation summary
- affected nodes
- replay metadata
- artifact references
The exact evidence surface depends on the selected profile.
Replay
Graph profiles support deterministic replay when executed using the same execution contract, runtime version, graph topology, and deterministic seed where applicable.
Replay confirms reproducible propagation behaviour rather than infrastructure identity.
Artifacts
Typical Graph artifacts include:
- propagation graph
- affected node list
- dependency summary
- traversal statistics
- propagation trace
- execution summary
- replay metadata
Artifacts provide observable evidence explaining how the execution reached its final state.
Applied Intelligence Modules
Graph capabilities are reused across multiple Forge Intelligence Modules including:
- Credit Intelligence
- Banking Intelligence
- Insurance Intelligence
- Reinsurance Intelligence
- Infrastructure Intelligence
- Climate Intelligence
- Critical Systems Intelligence
The computational primitive remains identical while each Primitive Profile defines its domain-specific graph semantics.
Related Documentation
- /examples/
- /verification/
- /verification/capability-verification
- /verification/replay-determinism
- /verification/artifact-inspection
- /api/kernel/execution-model
Verification Checklist
| Verification Surface | Status |
|---|---|
| Primitive resolved | ✓ |
| Profile resolved | ✓ |
| Contract inspected | ✓ |
| Required inputs identified | ✓ |
| Optional inputs bounded | ✓ |
| Canonical smoke available | ✓ |
| Runtime evidence inspected | ✓ |
| Artifacts inspected | ✓ |
| Replay verified | ✓ |
Final Principle
Graph capabilities are verified as deterministic relationship-execution contracts.
They demonstrate value not by computing an isolated result, but by exposing how state propagates through an explicitly defined network. Independent evaluators should be able to inspect the graph, verify the propagation process, replay the execution, and reproduce the resulting evidence using the same canonical execution contract.