Skip to content
Helix
PricingDocsChangelog
Log inStart free
Documentation
Overview
Getting Started with HelixYour First Mission WalkthroughFocus Mode vs Console ModeDesktop & Mobile Companion Apps
5-Minute API QuickstartIntegrations & Autonomous ChannelsProduction Examples & Recipes
Helix Agent Overview & Autonomy TiersHelix AdvisorHelix OperatorHelix PhasesHelix Sandbox
Synthetic AI & Simulation WorkflowsDrop-In White-Label Agent EmbedsDeveloper & Embed Guide
Helix ArchitectureArchitecture & Technical GuideHybrid Compute Bridge & Custom MCPHelix MCP
MCP Providers & Cloud Connectors
REST, Gateway & MCP API ReferenceAuthentication, Keys & ScopesSDKs & Programmatic ClientsWebhooks, HMAC Verification & ReplayTroubleshooting & Error Playbook
Helix Security ArchitectureEnterprise Security, Secrets & GovernanceBilling, Compute Windows & Quotas
Developer PlatformDeveloper Console
Docs/Technical Reference/Hybrid Compute Bridge & Custom MCP

Hybrid Compute Bridge & Custom MCP

Enterprise infrastructure often lives behind private VPC security groups, internal Kubernetes clusters, or on-premise servers with zero public inbound ports. Helix connects to private environments safely using outbound-initiated bridges and cryptographically signs every external mutation.

1. Connecting Private Systems via Helix Bridge (hx_bridge_*)

The Helix Bridge agent runs inside your private network or workstation and dials outbound over TLS to https://launchverse.app — never requiring firewall holes or VPN bastions.

Quick Setup

  1. Generate a bridge token (hx_bridge_*) and allow-listed target URLs in Developer Console -> Environments or Desktop -> Local Bridge.
  2. Launch the bridge daemon inside your VPC or staging bastion:
BASH
curl -fsSL https://launchverse.app/bridge/helix-bridge.mjs -o helix-bridge.mjs

node helix-bridge.mjs \
  --url https://launchverse.app \
  --tunnel-id "$HELIX_TUNNEL_ID" \
  --token "$HX_BRIDGE_TOKEN" \
  --allow "http://10.0.4.12:8080,http://postgres-read-replica.internal:5432"
  1. Requests from the agent sandbox matching --allow route transparently over the authenticated tunnel; any unapproved host/IP is rejected before dialing.

2. Registering Custom MCP Servers

Extend specialists with first-class typed tools backed by your internal APIs using the Model Context Protocol (stdio, sse, or websocket).

Register via REST or Settings -> Integrations

Provide:

  • Name: Stable snake_case prefix (e.g., erp_billing)
  • Transport: sse, websocket, or stdio
  • Endpoint / Command + encrypted headers (AES-256-GCM)

When any conversation starts, Helix validates the manifest and includes your custom tools alongside built-in sandbox tools — governed by the exact same T0–T3 approval policy!

3. Verifying Ed25519 Signed Action Receipts Offline

Every external mutation or high-impact write records a hash-chained receipt signed by your workspace Ed25519 key. Public verification keys are published at:

GET https://launchverse.app/.well-known/helix-ledger-keys.json

Node.js / TypeScript Offline Verifier

TS
import { verify, createPublicKey } from "node:crypto";

export async function verifyReceiptOffline(receipt: {
  id: string;
  keyId: string;
  canonicalPayload: string;
  signatureBase64: string;
  prevHash: string;
}) {
  const res = await fetch("https://launchverse.app/.well-known/helix-ledger-keys.json");
  const { keys } = (await res.json()) as {
    keys: Array<{ kid: string; publicKeyPem: string }>;
  };
  const key = keys.find((k) => k.kid === receipt.keyId);
  if (!key) throw new Error(`Unknown ledger signing key: ${receipt.keyId}`);

  const pub = createPublicKey(key.publicKeyPem);
  const ok = verify(
    null,
    Buffer.from(receipt.canonicalPayload, "utf8"),
    pub,
    Buffer.from(receipt.signatureBase64, "base64"),
  );
  if (!ok) throw new Error(`Invalid Ed25519 signature for receipt ${receipt.id}`);
  return true;
}

Python Offline Verifier (cryptography)

PYTHON
import base64
import requests
from cryptography.hazmat.primitives.serialization import load_pem_public_key

def verify_receipt_offline(receipt: dict) -> bool:
    jwks = requests.get(
        "https://launchverse.app/.well-known/helix-ledger-keys.json", timeout=10
    ).json()
    match = next((k for k in jwks["keys"] if k["kid"] == receipt["keyId"]), None)
    if not match:
        raise ValueError(f"Key not found: {receipt['keyId']}")

    pub = load_pem_public_key(match["publicKeyPem"].encode("utf-8"))
    pub.verify(
        base64.b64decode(receipt["signatureBase64"]),
        receipt["canonicalPayload"].encode("utf-8"),
    )
    return True

Need server-side chain verification for an entire workspace? Call POST /api/ledger with {"action": "verify_chain"} using an hx_live_* key.

PreviousArchitecture & Technical GuideNext Helix MCP
Edit this page on GitHub&nearr;

Platform

How Helix worksSpecialist crewScreens & architectureSecurity & isolationSystem status

Products

Helix WorkspaceAI Staff & Role PacksEmbedded B2B2C StaffPricing & plans

Developers

Developer PlatformDeveloper ConsoleAPI ReferenceSDKs & CLIWebhooks & events

Resources

DocumentationQuickstart guideChangelogHelp Center

Solutions

Use casesCode migrationCVE remediationMulti-cloud ops

Company

About LaunchVerseCareersContact ussupport@launchverse.app

Legal

Privacy PolicyTerms of ServiceExternal status

Social

Sovereign agentic infrastructure engineered in Africa for global engineering teams.

Helix

AI Specialists & Assistants for Everyday Work.

© 2026 LaunchVerse (Helix). All rights reserved.Privacy·Terms·Security·Status