Forge Pool

Appearance

Agent Quickstart ​

This guide shows how to connect an AI agent to Forge Pool and execute deterministic probabilistic workloads in minutes.

Forge Pool is designed for both:

  • human operators
  • autonomous AI agents

What You Will Do ​

In this guide, you will:

  • connect an agent to Forge Pool
  • discover available capabilities
  • inspect execution contracts
  • execute a probabilistic workload
  • retrieve compact results
  • interpret distributions and tail risk

Step 1: Get a Token ​

Generate a project-scoped token:

txt
fpak_...

Project tokens provide:

  • direct execution context
  • isolated billing scope
  • deterministic project routing

Project-scoped tokens are strongly recommended for agent execution.

Step 2: Call MCP ​

Endpoint:

txt
POST https://api.forgepool.io/v1/mcp

All agent interactions happen through this single MCP endpoint.

MCP Request Structure ​

Every request follows the same structure:

json
{
  "tool": "forge.execute",
  "input": { ... }
}

Important:

  • always use tool and input
  • do not use params
  • use capability identifiers exactly as returned

How Agents Interact with Forge Pool ​

Agents do not interact with multiple APIs.

Instead, they operate through a closed execution loop:

  1. discover capabilities
  2. inspect execution contracts
  3. execute workloads
  4. retrieve results
  5. interpret distributions

This allows agents to iteratively converge toward valid deterministic execution.

Step 3: Discover Capabilities ​

json
{
  "tool": "forge.capabilities.list",
  "input": {}
}

This returns all execution capabilities available to the token.

Agents should always begin with capability discovery.

Step 4: Describe a Capability ​

json
{
  "tool": "forge.capability.describe",
  "input": {
    "capability_id": "forge.primitive.mc.v1"
  }
}

This returns:

  • schema
  • execution contract
  • validation requirements
  • example payloads
  • execution guidance

Agents should always inspect capability contracts before execution.

Step 5: Execute a Workload ​

json
{
  "tool": "forge.execute",
  "input": {
    "payload": {
      "ctx": {
        "billing": {
          "mode": "test"
        }
      },
      "op": {
        "name": "mc",
        "version": 1,
        "profile": "insurance.loss.v1"
      },
      "policy": {
        "target": "cpu",
        "verify": "none",
        "min_agents": 1,
        "max_agents": 4
      },
      "args": {
        "iterations": 100000
      }
    }
  }
}

This:

  • executes a deterministic workload
  • distributes execution across agents
  • returns a job_id
  • emits replayable execution metadata

Validation and Agent Self-Correction ​

Forge Pool returns structured validation feedback.

Example:

json
{
  "error": {
    "code": "validation_error",
    "message": "The horizon_days field is required."
  }
}

Agents can use this information to:

  • inspect missing fields
  • adapt payloads
  • retry safely
  • converge toward valid execution

This enables iterative execution refinement without requiring manual intervention.

Step 6: Fetch Results ​

json
{
  "tool": "forge.run.result",
  "input": {
    "job_id": "...",
    "format": "compact"
  }
}

Compact results typically include:

  • summary statistics
  • quantiles
  • histogram data
  • execution metrics
  • replay tokens

Step 7: Interpret Results ​

Forge Pool returns distributions, not single outputs.

Agents should focus on:

  • mean (expected value)
  • percentiles (risk bounds)
  • tail behavior (extreme outcomes)
  • standard deviation (uncertainty spread)
  • distribution shape

Example Prompt ​

txt
Use Forge Pool via MCP.

1. Discover capabilities
2. Describe a Monte Carlo primitive
3. Execute a safe workload in test mode
4. Fetch compact results
5. Explain expected value, tail risk, and variability

Distribution-First Execution ​

Traditional systems often return:

  • single predictions
  • static outputs
  • opaque calculations

Forge Pool instead returns:

  • distributions
  • scenario surfaces
  • replayable execution results
  • deterministic execution metadata

This enables:

  • tail-risk analysis
  • scenario comparison
  • uncertainty exploration
  • auditable reasoning

Real-World Use Cases ​

Agents connected to Forge Pool can:

  • simulate financial portfolios
  • evaluate insurance loss distributions
  • compare stress scenarios
  • analyze uncertainty surfaces
  • generate decision-support outputs
  • reason about tail exposure

What You Get ​

  • deterministic execution
  • replayable workloads
  • distributed compute orchestration
  • compact execution outputs
  • distribution-first analysis

Final Note ​

Forge Pool does not provide isolated AI answers.

It provides deterministic execution over uncertainty spaces.

Next ​

  • integrate Forge MCP into agent workflows
  • build scenario comparison pipelines
  • combine execution with Studio workboards
  • generate replayable evidence packs

→ Continue to advanced integrations and execution scenarios.