VS Code Integration

VS Code can connect directly to Forge Pool through MCP-compatible extensions, agent runtimes, and AI coding assistants.

Once connected, VS Code-based agents can:

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

Forge MCP transforms AI assistants from answer generators into execution-aware operators.

---

Why VS Code

Many engineering teams standardize on VS Code as their primary development environment.

Connecting Forge Pool through MCP enables:

• interactive exploration
• research workflows
• engineering automation
• agent-assisted execution
• probabilistic analysis
• replay-aware investigation

without leaving the development environment.

---

Requirements

Before connecting VS Code, ensure you have:

• a Forge Pool account
• a project
• a project-scoped token
• a VS Code MCP-compatible client or extension

Recommended token type:

fpak_...

Project-scoped tokens provide:

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

---

MCP Endpoint

Forge Pool MCP endpoint:

https://api.forgepool.io/mcp

Authentication:

Authorization: Bearer fpak_...

---

Generic MCP Configuration

Most VS Code MCP clients use a configuration similar to:

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

Refer to your MCP extension documentation for the exact configuration location.

---

Verify Connection

Ask your agent:

Use Forge MCP.

List available Forge tools.

Expected Forge tools:

forge_capabilities_list
forge_capabilities_search
forge_capability_describe

forge_execute
forge_run_status
forge_run_result

If these tools appear, Forge MCP is connected successfully.

---

Recommended Workflow

VS Code agents should follow:

search
↓
describe
↓
build
↓
execute
↓
retrieve
↓
analyze

This minimizes execution errors and improves deterministic behavior.

---

Discovery Workflow

Example:

Use Forge MCP.

Search for catastrophe loss capabilities.

Return the five most relevant direct execution profiles.

Do not execute anything.

Expected tool:

forge_capabilities_search

---

Contract Inspection Workflow

Example:

Use Forge MCP.

Describe the most relevant catastrophe loss capability.

Summarize required arguments and provide a minimum valid payload.

Do not execute.

Expected tool:

forge_capability_describe

---

Safe Execution Workflow

Example:

Use Forge MCP.

Execute the capability in test mode.

Retrieve compact results.

Expected tools:

forge_execute
forge_run_result

Recommended billing mode:

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

---

Example End-to-End Prompt

Use Forge MCP.

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

---

Working with Copilot and Agent Extensions

Many VS Code users interact with Forge through:

• GitHub Copilot
• MCP-enabled assistants
• internal enterprise agents
• custom orchestration plugins

The recommended execution lifecycle remains:

discover
↓
describe
↓
execute
↓
retrieve
↓
analyze

regardless of the agent implementation.

---

Replay-Aware Analysis

Forge workloads frequently return replay metadata.

VS Code agents should preserve:

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

These identifiers support:

• governance review
• deterministic verification
• reproducibility
• auditability
• debugging

---

Understanding Results

Forge returns uncertainty distributions.

Agents should analyze:

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

Avoid reducing the output to a single number.

---

Studio-Oriented Workflows

Forge MCP may expose Studio-oriented tools.

These allow VS Code agents to:

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

Agents assist orchestration.

Forge remains the execution authority.

---

Security Recommendations

Use project-scoped tokens.

Recommended:

• separate development credentials
• separate production credentials
• regular token rotation
• immediate revocation of exposed tokens

Do not:

• commit tokens
• hardcode tokens
• place tokens in prompts

---

Troubleshooting

MCP Tools Do Not Appear

Verify:

https://api.forgepool.io/mcp

and:

Authorization: Bearer fpak_...

Restart VS Code after configuration changes.

---

Authentication Errors

Check:

• token validity
• token scope
• authorization header formatting
• token expiration

---

Invalid Payload Construction

Ask the agent:

Use forge_capability_describe before constructing payloads.
Do not guess profile-specific arguments.

Capability contracts remain authoritative.

---

Best Practices

VS Code agents should:

• discover before execution
• inspect contracts before payload construction
• execute in test mode first
• preserve replay metadata
• explain uncertainty clearly

VS Code 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:

→ Generic MCP Clients

Or return to:

→ Agent Quickstart