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:

  • AI agents
  • copilots
  • research assistants
  • orchestration systems
  • autonomous workflows
  • human operators

Through the native MCP server, agents can discover capabilities, inspect execution contracts, execute workloads, and retrieve replayable results.

What You Will Accomplish ​

In this guide you will:

  • connect an AI agent to Forge Pool
  • authenticate using a project token
  • discover available capabilities
  • inspect execution contracts
  • execute a workload safely
  • retrieve compact results
  • interpret distributions and tail risk
  • understand replay metadata

The goal is not to generate an AI answer.

The goal is to perform deterministic execution over an uncertainty space.

Before You Begin ​

You will need:

  • a Forge Pool account
  • a project
  • a project-scoped token
  • an MCP-compatible AI client

Supported clients include:

  • Cursor
  • Claude Desktop
  • Claude Code
  • Windsurf
  • VS Code MCP clients
  • custom MCP clients

Step 1: Generate a Project Token ​

Create a project-scoped token.

Example:

txt
fpak_...

Project tokens are recommended because they provide:

  • isolated project execution
  • deterministic routing
  • safer billing boundaries
  • clearer audit ownership
  • simplified agent management

Treat tokens as secrets.

Never paste tokens into prompts.

Never commit tokens into source control.

Step 2: Connect Your Agent ​

Configure your MCP client to use:

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

Authentication:

txt
Authorization: Bearer fpak_...

Generic MCP configuration:

json
{
  "mcpServers": {
    "forge": {
      "url": "https://api.forgepool.io/mcp",
      "headers": {
        "Authorization": "Bearer fpak_..."
      }
    }
  }
}

Client-specific setup guides:

Each guide includes:

  • configuration location
  • MCP server configuration
  • authentication setup
  • verification steps
  • recommended prompts
  • troubleshooting guidance
  • security recommendations

Step 3: Verify Connectivity ​

Ask the agent:

txt
Use Forge MCP.

List the available Forge tools.

The agent should discover tools such as:

txt
forge_capabilities_list
forge_capabilities_search
forge_capability_describe

forge_execute
forge_run_status
forge_run_result

If these tools are visible, the MCP connection is working correctly.

Step 4: Discover Capabilities ​

The recommended starting point is capability discovery.

Ask:

txt
Use Forge MCP.

Search for Monte Carlo capabilities related to insurance loss.
Do not execute anything yet.

The agent should call:

txt
forge_capabilities_search

and return matching capabilities.

Agents should always search before execution.

Step 5: Inspect a Capability ​

After selecting a capability, ask the agent to inspect its contract.

Example:

txt
Use Forge MCP.

Describe the most relevant insurance loss capability.
Summarize required arguments and provide a minimum valid payload.
Do not execute yet.

The agent should call:

txt
forge_capability_describe

This step is important because Forge capabilities define their own execution contracts.

Agents should not guess payload fields.

Agents should build payloads from the returned contract.

Step 6: Build a Payload ​

After inspection, the agent can construct a valid payload.

Example:

json
{
  "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 is only an example.

Different capabilities require different arguments.

The capability description remains the source of truth.

Step 7: Execute in Test Mode ​

During exploration, agents should execute in:

txt
billing.mode = test

Example prompt:

txt
Use Forge MCP.

Execute the capability in test mode.
Use a safe iteration count.
Retrieve compact results afterward.

Test mode allows agents to validate workflows safely before production execution.

Step 8: Retrieve Results ​

After execution, agents should retrieve compact results.

Typical result surfaces include:

  • summary statistics
  • quantiles
  • histograms
  • execution metrics
  • replay metadata
  • trace identifiers

Compact results are optimized for AI-assisted reasoning.

Step 9: Interpret the Distribution ​

Forge Pool returns distributions rather than single predictions.

Agents should focus on:

  • expected value
  • median
  • P05
  • P50
  • P95
  • P99
  • uncertainty spread
  • tail behavior
  • scenario sensitivity

The mean alone is rarely sufficient.

Tail behavior often contains the most important signal.

Understanding Replay Metadata ​

Forge workloads are designed to be replayable.

Replayability enables:

  • auditability
  • governance review
  • reproducibility
  • scenario comparison
  • debugging
  • evidence generation

Agents should preserve:

  • job_id
  • trace_id
  • request_id
  • replay metadata

when summarizing results.

The most effective workflow is:

txt
search
↓
describe
↓
build
↓
execute
↓
retrieve
↓
analyze

This pattern allows agents to converge toward valid execution while remaining deterministic and auditable.

Example End-to-End Prompt ​

txt
Use Forge MCP.

1. Search for insurance loss Monte Carlo capabilities.
2. Select the most relevant direct execution capability.
3. Describe the capability.
4. Build a minimum valid payload.
5. Execute in test mode.
6. Retrieve compact results.
7. Summarize expected value, uncertainty, tail risk, and replay metadata.

Common Mistakes ​

Executing Before Describing ​

Bad:

txt
Execute an insurance loss workload.

Good:

txt
Search.
Describe.
Then execute.

Guessing Payload Fields ​

Bad:

txt
Invent missing arguments.

Good:

txt
Use forge_capability_describe first.

Ignoring Tail Risk ​

Bad:

txt
Only report the mean.

Good:

txt
Explain percentiles and tail behavior.

Skipping Replay Metadata ​

Bad:

txt
Return only the summary.

Good:

txt
Preserve replay information.

Real-World Use Cases ​

Forge-connected agents can:

  • evaluate insurance loss distributions
  • analyze reinsurance structures
  • compare capital scenarios
  • stress financial portfolios
  • explore graph propagation
  • simulate climate scenarios
  • analyze uncertainty surfaces
  • generate replayable evidence packs

Next Steps ​

Once basic execution works:

  • connect Forge to your preferred AI client
  • explore advanced capabilities
  • integrate Studio templates
  • build repeatable execution workflows
  • generate replay-aware evidence

For detailed MCP architecture and protocol guidance:

→ Native MCP Server

For client-specific setup instructions:

→ Cursor
→ Claude Desktop
→ Claude Code
→ Windsurf
→ VS Code

Deterministic execution infrastructure for distributed compute.

Copyright © 2026 Forge Pool