Generic MCP Clients

Forge Pool exposes a native MCP server that can be consumed by any MCP-compatible client.

This guide is intended for:

custom AI agents
internal enterprise assistants
orchestration platforms
AI infrastructure teams
platform engineering teams
agent framework developers
MCP client implementers
system integrators

If your client can communicate with a remote MCP server, it can communicate with Forge Pool.

Overview

Forge Pool exposes deterministic execution capabilities through a native MCP interface.

Unlike traditional AI systems, Forge does not primarily return generated answers.

Forge executes workloads.

Through MCP, agents can:

discover capabilities
inspect execution contracts
execute workloads
retrieve results
analyze uncertainty
preserve replay metadata
assist orchestration workflows

The MCP layer acts as the execution gateway into the Forge runtime.

MCP Endpoint

Production endpoint:

txt

https://api.forgepool.io/mcp

Authentication:

txt

Authorization: Bearer fpak_...

Recommended token type:

txt

fpak_...

Project-scoped tokens provide:

deterministic routing
isolated execution context
cleaner governance boundaries
project attribution
safer billing controls

Protocol Model

Forge exposes a native MCP server over HTTP.

Compatible MCP clients may communicate using standard MCP tool discovery and invocation workflows.

From the client perspective:

txt

connect
↓
discover tools
↓
invoke tools
↓
retrieve responses

The Forge MCP server manages:

capability discovery
execution routing
validation
replay metadata
billing enforcement
project attribution

Available Tool Categories

Forge MCP exposes three major categories of functionality.

Capability Discovery

txt

forge_capabilities_list
forge_capabilities_search
forge_capability_describe

These tools allow agents to discover and inspect the Forge execution surface.

Execution

txt

forge_execute
forge_run_status
forge_run_result

These tools allow agents to:

construct workloads
execute workloads
retrieve results
inspect execution state

Studio-Oriented Orchestration

txt

forge_studio_templates_list
forge_studio_template_describe
forge_studio_template_import

These tools expose orchestration-aware workflows used by Forge Studio.

Recommended Execution Lifecycle

Forge clients should follow:

txt

search
↓
describe
↓
build
↓
execute
↓
retrieve
↓
analyze

This workflow minimizes invalid payloads and improves execution reliability.

Agents should avoid direct execution without first inspecting capability contracts.

Discovery Example

A user asks:

txt

Find insurance loss simulation capabilities.

The client should:

call forge_capabilities_search
inspect returned capabilities
select the most relevant capability
call forge_capability_describe

before constructing a payload.

Contract-Driven Execution

Forge capabilities define explicit execution contracts.

Agents should construct payloads from:

required arguments
optional arguments
validation rules
minimum valid payloads
example payloads

returned by:

txt

forge_capability_describe

Agents should not invent profile-specific arguments.

The contract is authoritative.

Safe Execution

Initial execution should use:

json

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

Recommended lifecycle:

txt

small test run
↓
inspect result shape
↓
validate assumptions
↓
increase execution scope if necessary

This minimizes unnecessary resource consumption.

Result Retrieval

Results are typically retrieved through:

txt

forge_run_result

Recommended format:

json

{
  "format": "compact"
}

Compact results are optimized for:

AI reasoning
context efficiency
uncertainty interpretation

while preserving critical execution metadata.

Understanding Forge Outputs

Forge returns uncertainty-aware outputs.

Typical result surfaces include:

summary statistics
quantiles
histograms
scenario rankings
graph metrics
replay metadata
execution metrics
trace identifiers

Clients should not reduce results to a single number.

The uncertainty surface is part of the result.

Replayability

Replayability is a core Forge property.

Clients should preserve:

job_id
trace_id
request_id
replay tokens
execution metadata

Replay enables:

deterministic verification
governance review
auditability
reproducibility
debugging
scenario comparison

Replay metadata should be treated as first-class output.

Enterprise Integration Pattern

A typical enterprise architecture:

txt

User
↓
AI Agent
↓
Forge MCP
↓
Capability Discovery
↓
Execution
↓
Replay-Aware Results
↓
Decision Support

Or:

txt

Internal Platform
↓
Agent Runtime
↓
Forge MCP
↓
Execution Layer
↓
Result Retrieval
↓
Evidence Surface

Forge MCP is designed to integrate cleanly into existing enterprise stacks.

Multi-Agent Systems

Forge MCP works well inside multi-agent architectures.

Example:

txt

Planner Agent
↓
Capability Search
↓
Execution Agent
↓
forge_execute
↓
Analysis Agent
↓
Result Interpretation
↓
Reviewer Agent
↓
Governance Review

Each agent can interact with the same Forge execution surface while maintaining deterministic execution semantics.

Studio-Aware Integrations

Studio-oriented MCP tools allow agents to:

discover templates
inspect orchestration graphs
analyze workboards
prepare imports
assist workflow composition

This allows agents to participate in orchestration workflows without bypassing runtime controls.

Agents assist.

Forge executes.

Authentication Recommendations

Use project-scoped tokens.

Recommended practices:

development tokens
staging tokens
production tokens
periodic rotation
least-privilege allocation

Do not:

hardcode credentials
commit credentials
place credentials inside prompts

Immediately revoke exposed tokens.

Security Model

Forge MCP does not bypass Forge runtime controls.

All execution remains subject to:

authentication
validation
execution policy
billing policy
project attribution
result limits
runtime constraints

Clients should treat Forge MCP as a governed execution surface rather than an unrestricted compute endpoint.

Error Handling

Forge returns structured validation feedback.

Clients should:

inspect validation errors
revisit the capability contract
correct the payload
retry safely

Recommended behavior:

txt

validation
↓
correction
↓
retry

rather than:

txt

guess
↓
guess
↓
guess

Best Practices

Clients should:

search before execution
inspect contracts before building payloads
execute in test mode first
preserve replay metadata
surface uncertainty explicitly
retain traceability

Clients should not:

invent capability identifiers
guess payload structures
suppress validation feedback
discard replay information
execute production workloads without authorization

Example Agent Prompt

txt

Use Forge MCP.

Search for insurance catastrophe loss capabilities.

Describe the most relevant direct execution capability.

Build a minimum valid payload.

Execute in test mode.

Retrieve compact results.

Summarize expected value, uncertainty spread, tail risk, and replay metadata.

This workflow reflects the recommended Forge execution lifecycle.

Troubleshooting

No Tools Are Visible

Verify:

txt

https://api.forgepool.io/mcp

and:

txt

Authorization: Bearer fpak_...

Ensure the MCP client supports remote MCP servers.

Authentication Failures

Check:

token validity
token scope
authorization header formatting
token expiration

Invalid Payloads

Use:

txt

forge_capability_describe

before constructing payloads.

Capability contracts are authoritative.

Oversized Results

Use:

json

{
  "format": "compact"
}

when retrieving results.

Summary

Forge MCP provides a native execution surface for MCP-compatible AI systems.

Through a small set of capability, execution, and orchestration tools, agents can:

discover
inspect
execute
retrieve
analyze

while preserving deterministic execution, replayability, governance, and uncertainty awareness.

Forge is not an answer engine.

Forge is an execution system.

MCP is how agents access it.

Understand the MCP architecture:

→ Native MCP Server

Get started quickly:

→ Agent Quickstart

Configure a client:

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

Generic MCP Clients ​

Overview ​

MCP Endpoint ​

Protocol Model ​

Available Tool Categories ​

Capability Discovery ​

Execution ​

Studio-Oriented Orchestration ​

Recommended Execution Lifecycle ​

Discovery Example ​

Contract-Driven Execution ​

Safe Execution ​

Result Retrieval ​

Understanding Forge Outputs ​

Replayability ​

Enterprise Integration Pattern ​

Multi-Agent Systems ​

Studio-Aware Integrations ​

Authentication Recommendations ​

Security Model ​

Error Handling ​

Best Practices ​

Example Agent Prompt ​

Troubleshooting ​

No Tools Are Visible ​

Authentication Failures ​

Invalid Payloads ​

Oversized Results ​

Summary ​

Next ​

Generic MCP Clients

Overview

MCP Endpoint

Protocol Model

Available Tool Categories

Capability Discovery

Execution

Studio-Oriented Orchestration

Recommended Execution Lifecycle

Discovery Example

Contract-Driven Execution

Safe Execution

Result Retrieval

Understanding Forge Outputs

Replayability

Enterprise Integration Pattern

Multi-Agent Systems

Studio-Aware Integrations

Authentication Recommendations

Security Model

Error Handling

Best Practices

Example Agent Prompt

Troubleshooting

No Tools Are Visible

Authentication Failures

Invalid Payloads

Oversized Results

Summary

Next