Forge Pool

Appearance

Forge Pool Operator Guide ​

Operating the Planetary Execution Layer ​

Forge Pool is a distributed deterministic execution system.

This guide explains how to integrate, operate, and extend the system across:

  • API clients
  • primitive families and profiles
  • orchestration layers
  • node operators
  • enterprise environments

This is not a marketing overview.
It is an operating manual for the public execution system.

What Forge Pool Is (Operational Context) ​

Forge Pool executes probabilistic and deterministic workloads across a globally distributed mesh of agents while preserving:

  • deterministic semantics
  • replay guarantees
  • audit integrity
  • verifiable aggregation
  • workload isolation

Execution is governed by the Kernel Execution Contract.

If you are unfamiliar with the execution model:

→ Start with: Execution Model

Who This Guide Is For ​

This guide is written for:

  • engineers integrating via API
  • quant teams building Monte Carlo or ensemble pipelines
  • architects designing distributed execution flows
  • node operators contributing compute
  • Studio users composing multi-step graphs
  • enterprise teams deploying internal execution clusters

System Mental Model ​

Before using Forge Pool, internalize this:

  1. Web Core governs identity, billing, and policy.
  2. Hub enforces deterministic orchestration.
  3. Agents execute isolated shards.
  4. Primitive families and profiles define execution semantics.
  5. Aggregation reduces results deterministically.
  6. Memory surfaces preserve execution artifacts and state references.

Execution truth emerges from structure, not from any single machine.

For architecture depth:

→ Architecture

Guide Structure ​

The sections below are ordered by operational entry path.

1. Quickstart ​

Execute your first deterministic workload.

  • organization creation
  • API key generation
  • first ops/execute call
  • reading results
  • understanding seeds

→ Quickstart

2. Core Concepts ​

Understand the underlying execution model:

  • primitive families (mc@1, graph@1, tensor@1, etc.)
  • profiles (insurance.v1, eta.v1, matmul.v1)
  • determinism and replay
  • sharding and verification
  • policy routing
  • aggregation mechanics

→ Concepts

3. Clients Guide ​

For application developers integrating compute:

  • auth model
  • execution lifecycle
  • policy configuration
  • billing modes
  • replay workflows
  • error handling patterns

→ Clients

4. Providers Guide ​

For node operators contributing compute:

  • installing an Agent
  • node identity
  • token and trust model
  • policy constraints
  • verification modes
  • observability and monitoring
  • payout lifecycle

→ Providers

5. Studio Guide ​

Visual composition layer:

  • building execution graphs
  • using adapters
  • composing multi-step pipelines
  • managing artifacts
  • triggering deterministic runs

→ Studio

6. HQ, Observability, and Security ​

  • HQ control-plane orientation
  • monitoring execution
  • trace inspection
  • replay validation
  • audit workflows
  • isolation guarantees

→ HQ → Observability → Security

If you want the shortest path to operational fluency:

  1. Quickstart
  2. Kernel Execution Model
  3. Concepts
  4. Clients Guide
  5. Architecture

Operational Doctrine ​

Forge Pool does not produce single-point “answers.”

It executes workloads, preserves structural execution truth, and returns reproducible outputs with replay-grade metadata.

If you understand that, the rest becomes mechanical.

Proceed to Quickstart.