Forge Pool

Appearance

Quickstart ​

Run Your First Distributed Workload (10 Minutes) ​

In this guide you will:

  1. Create an organization and project
  2. Generate an API key
  3. Execute a distributed workload (mc@1)
  4. Verify determinism
  5. Inspect execution in HQ

No prior Forge Pool knowledge required.

Two Ways to Run Forge ​

You can execute workloads in two ways:

1. Direct API (this guide) ​

Use the Kernel API to run workloads programmatically.

2. Forge Studio (visual orchestration) ​

Compose the same execution graph visually:

→ Open Studio Guide

Both paths execute the same underlying system.

Step 1 — Create Organization & Project ​

  1. Open: https://forgepool.io/hq/dashboard

  2. Confirm your Organization

  3. Navigate to Projects → Create Project

  4. Name it (example: risk-dev)

Projects isolate:

  • API keys
  • billing
  • execution limits
  • workload history

Step 2 — Generate API Key ​

Inside your project:

  1. Open Settings → API Keys
  2. Click Create API Key
  3. Scope: compute
  4. Copy the key

All compute requests require:

bash
Authorization: Bearer <your_api_key>
Content-Type: application/json

Store the key securely.

Step 3 — Execute a Distributed Workload ​

Forge Pool executes workloads via a unified execution contract.

We will run:

  • Workload: mc@1
  • Profile: insurance.v1
  • Seed: explicit

Example ​

bash
curl -X POST https://api.forgepool.io/api/v0/ops/execute \
  -H "Authorization: Bearer <your_api_key>" \
  -H "Content-Type: application/json" \
  -d '{
    "ctx": {
      "job_id": "quickstart-001",
      "trace_id": "trace-quickstart-001",
      "billing": { "mode": "test" }
    },
    "op": {
      "name": "mc",
      "version": 1,
      "profile": "insurance.v1"
    },
    "seed": {
      "mode": "explicit",
      "value": "ROOT_SEED_QUICKSTART"
    },
    "policy": {
      "target": "cpu",
      "min_agents": 1,
      "max_agents": 10,
      "verify": "none"
    },
    "args": {
      "iterations": 1000000,
      "claim_freq": 2.0,
      "claim_severity_mu": 6.0,
      "claim_severity_sig": 1.0,
      "cat_prob": 0.02,
      "cat_mu": 10.0,
      "cat_sig": 1.5,
      "policy_limit": 50000,
      "aggregate_limit": 250000
    }
  }'

What You Just Triggered ​

You just executed a distributed probabilistic workload.

Forge Pool:

  • expanded your request into a space of possible outcomes
  • distributed computation across multiple agents
  • executed stochastic iterations in parallel
  • aggregated results deterministically
  • preserved a replayable execution trace

This is not a local computation.

It is a coordinated execution across the Forge runtime.

Example Response (Simplified) ​

json
{
  "ok": true,
  "job_id": "01K...",
  "status": "COMPLETED",
  "hub": {
    "metrics": {
      "wall_ms": 1200,
      "agents_used": 4,
      "shards": 4
    },
    "output": {
      "loss": {
        "mean": 1853.4,
        "p50": 1200.2,
        "p95": 5400.8,
        "max": 21000.0
      }
    },
    "replay": {
      "root_seed": "ROOT_SEED_QUICKSTART"
    }
  }
}

Forge does not return a single number.

It returns a distribution of outcomes.

Step 4 — Verify Determinism ​

Run the exact same request again with:

  • identical seed.value
  • identical args
  • identical op

The output distribution will match (within floating precision).

This confirms:

  • deterministic shard planning
  • deterministic execution
  • deterministic aggregation
  • reproducible replay

Forge Pool treats determinism as a first-class invariant.

Learn more:

→ Determinism → Replay

Step 5 — Inspect Execution in HQ ​

Open:

HQ → Jobs

Select your job ID.

You can inspect:

  • shard allocation
  • participating agents
  • execution duration
  • verification status
  • replay seed
  • billing record

This is the observability layer of Forge.

What Just Happened ​

You defined a probabilistic system and executed it across distributed infrastructure.

Forge Pool:

  1. accepted your execution contract
  2. expanded it into a space of possible outcomes
  3. distributed computation across agents
  4. executed millions of iterations
  5. aggregated results into a deterministic output
  6. preserved a replayable execution trace

You did not compute a single answer.

You computed a distribution of reality.

Same Execution in Studio ​

The same workload can be executed visually using Forge Studio.

Instead of writing a request, you compose:

  • input block
  • Monte Carlo primitive
  • output block

→ Open Studio Guide

This allows you to build full execution systems without writing code.

Next Steps ​

Understand the system in more depth:

Final Note ​

You just ran a distributed, deterministic computation across a planetary execution system.

Forge Pool is not computing answers.

It is computing the space of possible outcomes — and making it reproducible.