Forge Pool

Appearance

Cursor Integration ​

Cursor can connect directly to Forge Pool through the native MCP server.

Once connected, Cursor agents can:

  • discover Forge capabilities
  • inspect execution contracts
  • execute deterministic workloads
  • retrieve compact results
  • analyze uncertainty distributions
  • preserve replay metadata
  • assist Studio-oriented orchestration workflows

Forge MCP transforms Cursor from a coding assistant into an execution client for deterministic probabilistic workloads.

Why Cursor ​

Cursor is one of the most widely adopted AI development environments.

By connecting Cursor to Forge Pool, agents gain access to an execution substrate capable of:

  • Monte Carlo simulation
  • scenario exploration
  • graph propagation
  • ensemble reasoning
  • uncertainty analysis
  • replay-aware execution

Rather than generating answers alone, agents can execute workloads and reason over resulting evidence.

Requirements ​

Before connecting Cursor, ensure you have:

  • a Forge Pool account
  • a Forge project
  • a project-scoped token
  • a recent Cursor version with MCP support enabled

Recommended token type:

txt
fpak_...

Project-scoped tokens provide:

  • deterministic routing
  • isolated execution context
  • project attribution
  • safer billing boundaries
  • simplified credential management

MCP Endpoint ​

Forge Pool MCP endpoint:

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

Authentication:

txt
Authorization: Bearer fpak_...

Configure Cursor ​

Create or update:

txt
~/.cursor/mcp.json

Example configuration:

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

Replace the example token with your actual project token.

Restart Cursor ​

After modifying the MCP configuration:

  1. Save the file.
  2. Fully close Cursor.
  3. Reopen Cursor.
  4. Reopen your workspace.

Cursor loads MCP servers during startup.

Verify Connection ​

Open:

txt
Settings → Tools & MCP

You should see:

txt
forge

with a healthy connection indicator.

A successful connection means Cursor can communicate with the Forge MCP server.

Verify Tool Availability ​

Open a new Cursor Agent chat and ask:

txt
Use Forge MCP.

List available Forge tools.

Typical tools include:

txt
forge_capabilities_list
forge_capabilities_search
forge_capability_describe

forge_execute
forge_run_status
forge_run_result

If these tools appear, Cursor is correctly connected.

Important: Agent Mode vs Codex Mode ​

Cursor may expose different tool surfaces depending on the active execution mode.

A green MCP indicator confirms that the Forge server is connected.

However, tool visibility can still depend on:

  • Agent mode
  • Codex mode
  • MCP settings
  • workspace context
  • Cursor version

If Forge tools do not appear:

  1. Verify Forge is connected.
  2. Restart Cursor.
  3. Open a new Agent session.
  4. Ask Cursor to list available MCP tools.

This behavior is controlled by Cursor rather than Forge.

Cursor agents should follow:

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

This minimizes invalid payloads and improves deterministic behavior.

Capability Discovery ​

Recommended prompt:

txt
Use Forge MCP.

Search for insurance catastrophe loss capabilities.

Return the five most relevant direct execution profiles.

Do not execute anything yet.

Expected MCP tool:

txt
forge_capabilities_search

Agents should discover capabilities before attempting execution.

Capability Inspection ​

After selecting a capability:

txt
Use Forge MCP.

Describe the most relevant capability.

Summarize required arguments and provide a minimum valid payload.

Do not execute.

Expected MCP tool:

txt
forge_capability_describe

Capability contracts should always be inspected before payload construction.

Building Execution Payloads ​

After inspecting the contract, Cursor 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.

Capability-specific contracts remain authoritative.

Safe Execution ​

Recommended prompt:

txt
Use Forge MCP.

Build a valid payload.

Execute it in test mode.

Retrieve compact results.

Expected tools:

txt
forge_execute
forge_run_result

Recommended billing mode:

json
{
  "billing": {
    "mode": "test"
  }
}

Test mode should be used during exploration and validation.

Example End-to-End Prompt ​

txt
Use Forge MCP.

1. Search for insurance catastrophe loss 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 spread, tail risk, and replay metadata.

This workflow mirrors the recommended Forge execution lifecycle.

Understanding Results ​

Forge Pool returns distributions rather than single predictions.

Cursor should focus on:

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

The average alone rarely captures the most important signal.

Replay Metadata ​

Many Forge workloads return replay-aware metadata.

Cursor should preserve:

  • job_id
  • trace_id
  • request_id
  • replay tokens
  • execution identifiers

Replay metadata enables:

  • auditability
  • governance review
  • deterministic verification
  • reproducibility
  • scenario comparison

Replay information should be treated as part of the result surface.

Studio-Oriented Workflows ​

Forge MCP may expose Studio-oriented tools.

These allow Cursor to:

  • discover Studio templates
  • inspect orchestration graphs
  • assist workboard creation
  • review graph structure
  • prepare template imports

Agents assist orchestration.

The Forge runtime remains authoritative.

Security Recommendations ​

Use project-scoped tokens.

Do not:

  • paste tokens into prompts
  • commit tokens into repositories
  • share production tokens between environments

Recommended:

  • separate development tokens
  • separate staging tokens
  • separate production tokens
  • periodic token rotation

Immediately revoke exposed credentials.

Troubleshooting ​

Forge Does Not Appear ​

Verify:

txt
Settings → Tools & MCP

Check:

  • MCP configuration file
  • JSON validity
  • Cursor version
  • full application restart

MCP Tools Do Not Appear ​

Verify:

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

and:

txt
Authorization: Bearer fpak_...

Then:

  • restart Cursor
  • open a fresh Agent session
  • request available MCP tools

Authentication Errors ​

Confirm:

txt
Authorization: Bearer fpak_...

and ensure the token is active.

Project-scoped tokens are recommended.

Cursor Guesses Payload Fields ​

Ask Cursor:

txt
Use forge_capability_describe before constructing the payload.

Do not invent profile-specific arguments.

Capability contracts are the source of truth.

Results Are Too Large ​

Request compact results:

txt
Retrieve compact results only.

or:

json
{
  "format": "compact"
}

Compact results are optimized for AI-assisted reasoning.

Best Practices ​

Cursor agents should:

  • search before execution
  • inspect contracts before payload construction
  • execute in test mode first
  • preserve replay metadata
  • analyze uncertainty explicitly
  • explain tail risk

Cursor agents should not:

  • invent capability identifiers
  • guess arguments
  • skip contract inspection
  • suppress validation feedback
  • execute production workloads without approval

Next ​

Learn the Forge MCP architecture:

→ Native MCP Server

Continue with:

→ Claude Desktop

→ Claude Code

→ Windsurf

→ VS Code

Or return to:

→ Agent Quickstart

Deterministic execution infrastructure for distributed compute.

Copyright © 2026 Forge Pool