Primitive Families
Primitive families organize the execution space of the Forge Pool execution platform.
Rather than exposing workload-specific APIs, Forge Pool partitions computation into a small number of stable execution families. Each family defines a distinct computational model while sharing the same public execution contract, deterministic execution doctrine, replay semantics, and verification model.
Primitive families are therefore execution semantics, not marketing categories or endpoint names.
Execution Taxonomy
Every workload executed by Forge Pool belongs to exactly one primitive family.
Each primitive family defines:
- computational semantics
- planning doctrine
- execution characteristics
- reduction semantics
- profile namespace
- versioned behavior
Execution profiles specialize a primitive family without changing the public execution contract.
Primitive Selection Model
Every execution request resolves through the same selection model.
Execution Contract
↓
Primitive Family
↓
Primitive Version
↓
Execution Profile
↓
Execution Parameters
↓
Execution Policy
↓
Distributed ExecutionThis model allows the execution platform to grow without introducing additional execution endpoints.
Current Execution Families
The following primitive families are part of the current canonical execution platform.
Monte Carlo (mc@1)
Purpose
Probabilistic simulation and distributed statistical computation.
Execution Characteristics
- independent sampling
- deterministic seed propagation
- convergence-aware execution
- deterministic reduction
- replay-compatible execution
Representative Profiles
finance.credit.loss_distribution_surface.v1finance.credit.ifrs9_ecl.v1insurance.scr.surface.v1
Reference:
Ensemble (ensemble@1)
Purpose
Consensus-oriented execution across multiple computational results.
Execution Characteristics
- multi-run aggregation
- reducer-driven execution
- confidence generation
- consensus evaluation
- deterministic reduction
Representative Profiles
finance.credit.ifrs9_review_board.v1insurance.board.risk.consensus.v1
Reference:
Graph (graph@1)
Purpose
Relationship-oriented execution across connected structures.
Execution Characteristics
- graph traversal
- dependency propagation
- relationship evaluation
- distributed graph processing
- deterministic graph reduction
Representative Profiles
finance.credit.cascading_failure_graph.v1insurance.counterparty.contagion.v1
Reference:
Search (search@1)
Purpose
Distributed retrieval, discovery, and ranking.
Execution Characteristics
- candidate generation
- distributed search
- relevance evaluation
- ranking
- deterministic search reduction
Representative Profiles
finance.system.systemic_fragility_search.v1finance.credit.scenario_set.discovery.v1
Reference:
Media (media@1)
Purpose
Distributed media transformation and media-aware execution.
Execution Characteristics
- image transformation
- preprocessing
- media normalization
- distributed media processing
- replay-compatible execution
Representative Profiles
vision.perspective.dewarp.v1vision.threshold.sweep.v1
Reference:
Runtime Guarantees
Every primitive family inherits the same platform guarantees.
- stable execution contract
- deterministic execution
- deterministic reduction
- replay compatibility
- execution evidence
- independent verification
- versioned semantics
Primitive families differ in computational behavior while sharing the same execution doctrine.
Families and Profiles
Primitive families define computational semantics.
Execution profiles define workload specialization.
For example:
Primitive Family
↓
Monte Carlo
Version
↓
1
Profile
↓
finance.credit.ifrs9_ecl.v1Profiles extend execution capabilities without introducing additional execution APIs.
Families and Adapters
Primitive families execute workloads.
Adapters translate domain-specific requests into canonical execution contracts.
Typical adapter responsibilities include:
- input normalization
- execution contract construction
- domain-specific validation
- output interpretation
Adapters never change execution semantics.
The canonical execution contract remains authoritative.
Platform Evolution
The Forge Pool execution platform is designed to expand through additional primitive families while preserving the same public execution contract.
Future primitive families extend the execution space rather than the API surface.
Tensor (tensor@1) — Platform Preview
Tensor represents the planned execution family for distributed numerical and AI-oriented computation.
Intended Purpose
- tensor-oriented computation
- embedding pipelines
- distributed numerical processing
- inference orchestration
- AI preprocessing and post-processing
The Tensor family follows the same execution contract, deterministic execution doctrine, replay model, and verification guarantees as every other primitive family.
Status
Platform Preview.
The execution model is defined, while public capability availability may expand over future platform releases.
Extensibility
New primitive families do not introduce new execution endpoints.
Instead, they extend the computational capabilities available through the existing execution contract.
This architectural approach preserves long-term API stability while allowing the execution platform to evolve continuously.
Relationship to Studio
Primitive families are directly reflected throughout Forge Studio.
Capability Explorer exposes available execution capabilities.
Block Registry maps executable building blocks to primitive families.
Studio workflows compose execution using the same canonical execution contract described throughout this documentation.
Continue in Forge Studio
To explore primitive families interactively:
- Browse available capabilities in Capability Explorer
- Inspect execution blocks in Block Registry
- Execute representative workloads
- Compare execution evidence across primitive families
- Verify deterministic execution and replay behavior
Trust should be established through independent verification rather than documentation alone.
Final Note
Primitive families organize the execution semantics of the Forge Pool platform.
They do not define different APIs.
Every primitive family—present and future—shares the same public execution contract while contributing new computational capabilities to the distributed execution platform.
This separation between execution semantics and API surface allows Forge Pool to evolve continuously without compromising compatibility, determinism, replay, or verification guarantees.