Forge Guide
Welcome to the Forge execution system.
This guide is designed to help you evaluate, understand, integrate, and operate Forge from your very first execution through production deployment.
Unlike traditional API documentation, this guide follows the same progression as the runtime itself.
You will not begin by learning individual components.
You will begin by executing a workload, inspecting its execution evidence, understanding how computational trust is established, and only then explore the architecture that makes those guarantees possible.
What Forge Is
Forge is a deterministic execution system for distributed computational workloads.
Rather than treating distributed compute as opaque infrastructure, Forge preserves execution as durable computational evidence.
Every execution is defined by an immutable execution contract, orchestrated through deterministic runtime semantics, verified according to explicit execution policies, and preserved for replay and audit.
Execution therefore produces more than results.
It produces reproducible computational evidence.
Who This Guide Is For
This guide is intended for:
- software engineers integrating Forge through the public API
- architects evaluating distributed execution systems
- quantitative teams executing large-scale simulations
- platform engineers operating private Forge deployments
- infrastructure teams contributing execution capacity
- researchers evaluating reproducibility and replay
No prior knowledge of Forge is assumed.
Recommended Evaluation Journey
The fastest way to understand Forge is not by reading architecture documents.
It is by executing a workload.
We recommend following the documents below in order.
1. Your First Execution
Run your first distributed execution in a few minutes.
You will:
- create a project
- execute a workload
- inspect execution evidence
- understand replay
- observe deterministic execution
→ Quickstart
2. Understand the Runtime
Once you have executed a workload, learn how the runtime produced it.
Topics include:
- execution contracts
- jobs and shards
- deterministic planning
- aggregation
- replay
- verification
- execution evidence
→ Core Concepts
3. Integrate Forge
Learn how applications communicate with the execution runtime.
Topics include:
- authentication
- execution contracts
- execution policies
- replay metadata
- production integration
- operational best practices
→ Clients Guide
4. Contribute Execution Capacity
Learn how execution nodes participate in the runtime.
Topics include:
- node registration
- agent installation
- trust boundaries
- verification participation
- operational reliability
- provider economics
→ Providers Guide
5. Compose Execution Systems
Forge Studio allows execution systems to be composed visually while preserving the same execution semantics as the public API.
Topics include:
- execution graphs
- adapters
- primitives
- orchestration
- artifacts
- replay
→ Studio Guide
6. Operate the Runtime
Learn how to observe, govern, and secure execution.
Topics include:
- HQ
- observability
- execution transparency
- replay inspection
- governance
- security
→ HQ
→ Observability
→ Security
Learn the Architecture
Once you understand how execution behaves operationally, explore the runtime architecture in depth.
Recommended order:
- Architecture Overview
- Execution Model
- Scheduler
- Agent Kernel
- Aggregation
- Scaling
- Transport Architecture
- Storage Architecture
- Network Architecture
The architecture documentation explains how the runtime works.
The guide explains how to use it.
Understand Computational Trust
Forge intentionally separates execution architecture from execution trust.
After becoming familiar with the runtime, continue with the Trust Layer.
Recommended order:
- Trust Layer
- Verification
- Heterogeneous Execution
- Limitations
Together these documents define the execution doctrine of the Forge runtime.
Practical Mental Model
A useful way to approach Forge is:
Question
│
▼
Execution Contract
│
▼
Distributed Execution
│
▼
Execution Evidence
│
▼
Verification
│
▼
Replay
│
▼
Computational TrustEvery major section of the documentation corresponds to one stage of this execution lifecycle.
Documentation Philosophy
Forge documentation is organized around execution rather than components.
The goal is not to describe every subsystem independently.
The goal is to explain how independent systems cooperate to preserve reproducible computational truth across distributed infrastructure.
Architecture explains the runtime.
The Trust Layer explains why its guarantees are meaningful.
The Guide explains how to experience those guarantees yourself.
Next Step
If this is your first time using Forge, begin with Quickstart.
Your first execution will introduce the execution contract, deterministic planning, replay, verification, and execution evidence through a working system rather than abstract concepts.
From there, the remaining documentation builds naturally on practical experience.