Integrations

Forge Pool is designed to be embedded directly into real systems.

It exposes one execution substrate through multiple access surfaces:

MCP for AI agents
API for applications and backend systems
Studio for human operators and visual orchestration

All surfaces ultimately route into the same Forge execution core.

The difference is not what Forge computes.

The difference is how execution is initiated, composed, governed, and inspected.

Integration Surfaces

Surface	Primary User	Purpose
MCP	AI agents	Discover, describe, execute, retrieve, and analyze workloads
API	Applications and systems	Programmatic execution and integration
Studio	Human operators	Visual orchestration, workflow composition, and analysis

Forge Pool does not expose disconnected tools.

It exposes deterministic execution capability through different interfaces.

Native MCP Server

Forge Pool exposes a native MCP server for compatible AI agents.

Endpoint:

txt

https://api.forgepool.io/mcp

Authentication:

txt

Authorization: Bearer fpak_...

The MCP server allows agents to:

list capabilities
search the capability registry
inspect execution contracts
execute deterministic workloads
retrieve compact results
analyze distributions
preserve replay metadata
assist with Studio-oriented orchestration

MCP is the recommended surface for AI agent integration.

→ Native MCP Server

Agent Quickstart

Use the quickstart when you want to connect an AI agent and run the first safe test-mode workload.

The quickstart covers:

creating a project-scoped token
configuring an MCP client
discovering capabilities
describing contracts
executing in test mode
retrieving compact results
interpreting distributions

→ Agent Quickstart

Client Guides

Forge MCP can be connected to modern AI clients that support remote MCP servers.

Client-specific guides:

Each guide includes:

configuration location
MCP server configuration
authentication setup
verification steps
recommended prompts
troubleshooting notes

API Access

The Forge API is intended for backend systems, applications, automation pipelines, and enterprise integrations.

Use the API when you want to:

integrate Forge execution into an application
trigger workloads from backend systems
manage jobs programmatically
retrieve execution artifacts
build internal dashboards
connect Forge to existing enterprise systems

The API and MCP surfaces share the same execution core.

MCP is optimized for AI agents.

The API is optimized for systems.

→ API

Studio Access

Forge Studio is the visual orchestration surface for Forge Pool.

Studio allows human operators to:

compose execution graphs
connect adapters
configure workloads
run analysis flows
inspect outputs
create reusable workboards
review replay-aware evidence

Studio is not a separate execution system.

It is a human-facing orchestration layer over the Forge runtime.

→ Forge Studio

How the Surfaces Work Together

Forge integrations are designed to work together.

A common enterprise workflow:

txt

Human defines workflow in Studio
↓
Agent assists with capability selection through MCP
↓
System triggers execution through API
↓
Forge executes workload through Web Core, Hub, and Agent Mesh
↓
Results return as distributions, artifacts, traces, and replay metadata
↓
Human, system, or agent reviews the evidence

All access surfaces preserve the same core execution principles:

deterministic execution
replayability
explicit uncertainty
auditable outputs
capability contracts
validation-bound payloads
project-scoped execution context

Execution Model

Forge integrations are based on a consistent execution model:

txt

capability
↓
contract
↓
payload
↓
execution
↓
result
↓
replay

Agents and applications should not treat Forge as a black-box answer generator.

They should treat Forge as an execution system.

The correct integration pattern is:

Discover what Forge can execute.
Inspect the contract.
Build a valid payload.
Execute safely.
Retrieve results.
Interpret distributions.
Preserve replay metadata.

Authentication Model

Forge integrations use bearer-token authentication.

Recommended token type:

txt

fpak_...

Project-scoped tokens are recommended because they provide:

clear project ownership
direct execution context
safer billing boundaries
easier revocation
cleaner audit trails

Use tokens through an authorization header:

txt

Authorization: Bearer fpak_...

Do not paste tokens into AI prompts.

Do not commit tokens into repositories.

Rotate tokens regularly.

Use separate tokens for development, demos, and production environments.

Distribution-First Outputs

Forge Pool returns distributions, not single predictions.

Depending on the workload, outputs may include:

mean
median
quantiles
confidence bands
histograms
scenario rankings
graph metrics
stress surfaces
replay tokens
execution traces
audit metadata

Agents, applications, and human operators should interpret the full uncertainty surface.

The most important signal is often in the tail, not the average.

Replay and Evidence

Replayability is a core property of Forge execution.

Every serious integration should preserve:

job identifiers
trace identifiers
request identifiers
replay tokens
execution metadata
result artifacts

This enables:

governance review
scenario comparison
auditability
deterministic verification
regulatory traceability
reproducible analysis

Forge integrations should be designed around evidence, not transient outputs.

Choosing the Right Surface

Use MCP when:

an AI agent is driving the workflow
the agent needs to discover capabilities
the agent needs to inspect contracts
the agent needs to execute and analyze workloads
the workflow is conversational or agent-assisted

Use API when:

an application is triggering workloads
execution is part of a backend process
you need programmatic control
you are integrating Forge into existing systems

Use Studio when:

humans are composing workflows visually
you need reusable workboards
you want to inspect outputs interactively
you are building repeatable analysis flows

Most advanced deployments use more than one surface.

Example Integration Patterns

AI Agent Risk Analysis

txt

Cursor / Claude / Windsurf
↓
Forge MCP
↓
Capability discovery
↓
Contract inspection
↓
Test-mode execution
↓
Compact result analysis

Enterprise Application Execution

txt

Internal application
↓
Forge API
↓
Canonical execution payload
↓
Forge runtime
↓
Result and artifact retrieval

Human-in-the-Loop Workboard

txt

Forge Studio
↓
Workboard graph
↓
Adapter and primitive blocks
↓
Execution
↓
Output surfaces and replay

Agent-Assisted Studio Flow

txt

AI agent
↓
MCP Studio tools
↓
Template discovery
↓
Graph inspection
↓
Human approval
↓
Studio import
↓
Execution through Forge runtime

Recommended Starting Point

If you are new to Forge integrations:

Start with Agent Quickstart.
Configure your preferred MCP client.
Search capabilities.
Describe a capability.
Execute a safe test-mode workload.
Retrieve compact results.
Review replay metadata.

For direct system integration, start with the API documentation.

For visual orchestration, start with Forge Studio.

Integration Principles

Forge integrations follow these principles:

execution before inference
contracts before payloads
distributions before point estimates
replay before trust
validation before automation
human authorization before production execution
evidence before recommendation

These principles apply across MCP, API, and Studio.

Connect an AI agent:

→ Agent Quickstart

Understand the MCP server:

→ Native MCP Server

Configure a client:

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

Integrations ​

Integration Surfaces ​

Native MCP Server ​

Agent Quickstart ​

Client Guides ​

API Access ​

Studio Access ​

How the Surfaces Work Together ​

Execution Model ​

Authentication Model ​

Distribution-First Outputs ​

Replay and Evidence ​

Choosing the Right Surface ​

Example Integration Patterns ​

AI Agent Risk Analysis ​

Enterprise Application Execution ​

Human-in-the-Loop Workboard ​

Agent-Assisted Studio Flow ​

Recommended Starting Point ​

Integration Principles ​

Next ​