ai.geodesiclabs/governance-platform

{
  "checks": {
    "action_safety_probe": {
      "details": {
        "auth_present": false,
        "confirmation_signals": [],
        "safeguard_count": 0,
        "summary": {
          "bulk_access_tools": 0,
          "capability_distribution": {},
          "destructive_tools": 0,
          "egress_tools": 0,
          "exec_tools": 0,
          "high_risk_tools": 0,
          "risk_distribution": {
            "critical": 0,
            "high": 0,
            "low": 0,
            "medium": 0
          },
          "secret_tools": 0,
          "tool_count": 0
        }
      },
      "latency_ms": null,
      "status": "ok"
    },
    "advanced_capabilities_probe": {
      "details": {
        "capabilities": {
          "completions": false,
          "elicitation": false,
          "prompts": false,
          "resource_links": false,
          "resources": false,
          "roots": false,
          "sampling": false,
          "structured_outputs": false
        },
        "enabled": [],
        "enabled_count": 0,
        "initialize_capability_keys": [
          "experimental",
          "prompts",
          "resources",
          "tools"
        ]
      },
      "latency_ms": null,
      "status": "missing"
    },
    "connector_publishability_probe": {
      "details": {
        "blockers": [
          "tools_list",
          "server_card",
          "tool_surface"
        ],
        "criteria": {
          "action_safety": true,
          "auth_flow": true,
          "connector_replay": true,
          "initialize": true,
          "protocol_version": true,
          "remote_transport": true,
          "request_association": true,
          "server_card": false,
          "session_resume": true,
          "step_up_auth": true,
          "tool_surface": false,
          "tools_list": false,
          "transport_compliance": true
        },
        "high_risk_tools": 0,
        "tool_count": 0,
        "transport": "streamable-http"
      },
      "latency_ms": null,
      "status": "error"
    },
    "connector_replay_probe": {
      "details": {
        "reason": "no_tools"
      },
      "latency_ms": null,
      "status": "missing"
    },
    "determinism_probe": {
      "details": {
        "reason": "tools_list_unavailable"
      },
      "latency_ms": null,
      "status": "missing"
    },
    "initialize": {
      "details": {
        "headers": {
          "content-type": "text/event-stream",
          "mcp-session-id": "ef9e6c1308e048abadf095f562f7a8ec"
        },
        "http_status": 200,
        "payload": {
          "id": 1,
          "jsonrpc": "2.0",
          "result": {
            "capabilities": {
              "experimental": {},
              "prompts": {
                "listChanged": false
              },
              "resources": {
                "listChanged": false,
                "subscribe": false
              },
              "tools": {
                "listChanged": false
              }
            },
            "instructions": "GeodesicAI is a deterministic governance and computation platform for AI agents. It does three things:\n\n1. GOVERNANCE \u2014 Validate agent outputs against Blueprint rules before execution. Catches math errors, field inconsistencies, and constraint violations. Returns PASS, FAIL, or REVIEW with repair suggestions and a tamper-proof determinism hash. Requires a Blueprint (governance contract). Use load_rule_pack for fast onboarding or create_blueprint to define custom rules.\n\n2. DISCOVERY \u2014 Find structural patterns in batches of data without machine learning. Detect anomalies, classify structural types, track drift across data streams. No Blueprint required.\n\n3. DETERMINISTIC COMPUTATION \u2014 Route computable problems to the platform's deterministic solvers (geometry, feasibility, constraint satisfaction, spectral analysis, structural reasoning) without consuming LLM tokens. Queries outside the deterministic envelope return a structured response indicating they're outside scope; the caller can route them to their own tooling. No Blueprint required.\n\nNo machine learning. No probabilistic inference in the validation pipeline. Every result is structurally provable and fully traceable.\n\nMental model: Other tools do something. GeodesicAI decides if it should be allowed to happen.\n\nDOCUMENTATION \u2014 For the full user guide covering all tools, Blueprint design, Trajectory mode, and demo walkthroughs, read the 'user_guide' resource (geodesicai://docs/user-guide), or fetch https://app.geodesiclabs.ai/static/GeodesicAI_User_Guide.pdf. For Blueprint design specifics, invoke the 'blueprint_guide' prompt. To turn a validation result into plain English using your own LLM, invoke the 'explain_result' prompt.\n\nSign up at geodesiclabs.ai for an API key.",
            "protocolVersion": "2025-03-26",
            "serverInfo": {
              "name": "GeodesicAI",
              "version": "1.27.0"
            }
          }
        },
        "url": "https://app.geodesiclabs.ai/mcp"
      },
      "latency_ms": 96.05,
      "status": "ok"
    },
    "interactive_flow_probe": {
      "details": {
        "oauth_supported": false,
        "prompt_available": false,
        "risk_hits": [],
        "safe_hits": []
      },
      "latency_ms": null,
      "status": "missing"
    },
    "oauth_authorization_server": {
      "details": {
        "reason": "no_authorization_server"
      },
      "latency_ms": null,
      "status": "missing"
    },
    "oauth_protected_resource": {
      "details": {
        "error": "Client error '404 Not Found' for url 'https://app.geodesiclabs.ai/.well-known/oauth-protected-resource'\nFor more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/404",
        "url": "https://app.geodesiclabs.ai/.well-known/oauth-protected-resource"
      },
      "latency_ms": 175.03,
      "status": "error"
    },
    "official_registry_probe": {
      "details": {
        "direct_match": true,
        "official_peer_count": 1,
        "registry_identifier": "ai.geodesiclabs/governance-platform",
        "registry_source": "official_registry"
      },
      "latency_ms": null,
      "status": "ok"
    },
    "openid_configuration": {
      "details": {
        "reason": "no_authorization_server"
      },
      "latency_ms": null,
      "status": "missing"
    },
    "probe_noise_resilience": {
      "details": {
        "headers": {
          "content-type": "text/plain; charset=utf-8"
        },
        "http_status": 200,
        "url": "https://app.geodesiclabs.ai/robots.txt"
      },
      "latency_ms": 171.16,
      "status": "ok"
    },
    "prompt_get": {
      "details": {
        "reason": "not_advertised"
      },
      "latency_ms": null,
      "status": "missing"
    },
    "prompts_list": {
      "details": {
        "error": "Client error '400 Bad Request' for url 'https://app.geodesiclabs.ai/mcp'\nFor more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/400",
        "headers": {
          "content-type": "application/json",
          "mcp-session-id": "d41e13e5ccd74394924bbbf638d4d1ec"
        },
        "http_status": 400,
        "payload": {},
        "reason": "not_advertised",
        "url": "https://app.geodesiclabs.ai/mcp"
      },
      "latency_ms": 173.97,
      "status": "missing"
    },
    "protocol_version_probe": {
      "details": {
        "claimed_version": "2025-03-26",
        "lag_days": 244,
        "latest_known_version": "2025-11-25",
        "releases_behind": 2,
        "validator_protocol_version": "2025-03-26"
      },
      "latency_ms": null,
      "status": "warning"
    },
    "provenance_divergence_probe": {
      "details": {
        "direct_official_match": true,
        "drift_fields": [],
        "metadata_document_count": 1,
        "registry_homepage": null,
        "registry_repository": null,
        "registry_title": null,
        "registry_version": null,
        "server_card_homepage": null,
        "server_card_repository": null,
        "server_card_title": null,
        "server_card_version": null
      },
      "latency_ms": null,
      "status": "ok"
    },
    "request_association_probe": {
      "details": {
        "reason": "no_request_association_capabilities_advertised"
      },
      "latency_ms": null,
      "status": "missing"
    },
    "resource_read": {
      "details": {
        "reason": "not_advertised"
      },
      "latency_ms": null,
      "status": "missing"
    },
    "resources_list": {
      "details": {
        "error": "Client error '400 Bad Request' for url 'https://app.geodesiclabs.ai/mcp'\nFor more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/400",
        "headers": {
          "content-type": "application/json",
          "mcp-session-id": "c9b4d4819ae3438f985aca315fe2daa7"
        },
        "http_status": 400,
        "payload": {},
        "reason": "not_advertised",
        "url": "https://app.geodesiclabs.ai/mcp"
      },
      "latency_ms": 181.88,
      "status": "missing"
    },
    "server_card": {
      "details": {
        "error": "Client error '404 Not Found' for url 'https://app.geodesiclabs.ai/.well-known/mcp/server-card.json'\nFor more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/404",
        "url": "https://app.geodesiclabs.ai/.well-known/mcp/server-card.json"
      },
      "latency_ms": 190.55,
      "status": "error"
    },
    "session_resume_probe": {
      "details": {
        "headers": {
          "content-type": "text/event-stream",
          "mcp-session-id": "ef9e6c1308e048abadf095f562f7a8ec"
        },
        "http_status": 200,
        "payload": {
          "id": 301,
          "jsonrpc": "2.0",
          "result": {
            "tools": [
              {
                "description": "\n    Validate structured data against a Blueprint's rules. Returns PASS, FAIL, or REVIEW.\n\n    The platform checks mathematical accuracy (do the numbers add up?),\n    structural consistency (do the fields satisfy all constraints?), and\n    semantic plausibility (do the values make sense in context?).\n\n    Every result includes a determinism hash \u2014 the same input with the same\n    Blueprint always produces the same result. Auditable, replayable, legally defensible.\n\n    A Blueprint is required for meaningful validation. Without one, use\n    create_blueprint or load_rule_pack to define your governance rules first.\n\n    Args:\n        api_key: GeodesicAI API key (starts with gai_)\n        structured_data: The data to validate (key-value pairs)\n        blueprint: Name of the Blueprint to validate against. Use list_blueprints to see options.\n    ",
                "inputSchema": {
                  "properties": {
                    "api_key": {
                      "title": "Api Key",
                      "type": "string"
                    },
                    "blueprint": {
                      "default": "default",
                      "title": "Blueprint",
                      "type": "string"
                    },
                    "structured_data": {
                      "additionalProperties": true,
                      "title": "Structured Data",
                      "type": "object"
                    }
                  },
                  "required": [
                    "api_key",
                    "structured_data"
                  ],
                  "title": "validateArguments",
                  "type": "object"
                },
                "name": "validate"
              },
              {
                "description": "\n    Validate structured data and automatically compute repairs if it fails.\n    Single call that combines validate + repair.\n\n    If PASS: returns the validated data with determinism hash.\n    If FAIL: returns the failure details AND a repaired payload with\n    field-by-field corrections and confidence scores. The agent can\n    inspect the repairs and resubmit the corrected data.\n    If REVIEW: returns the flagged data with review reasoning.\n\n    This is the recommended starting point for most agent integrations.\n\n    Args:\n        api_key: GeodesicAI API key (starts with gai_)\n        structured_data: The data to validate (key-value pairs)\n        blueprint: Name of the Blueprint to validate against. Use list_blueprints to see options.\n    ",
                "inputSchema": {
                  "properties": {
                    "api_key": {
                      "title": "Api Key",
                      "type": "string"
                    },
                    "blueprint": {
                      "default": "default",
                      "title": "Blueprint",
                      "type": "string"
                    },
                    "structured_data": {
                      "additionalProperties": true,
                      "title": "Structured Data",
                      "type": "object"
                    }
                  },
                  "required": [
                    "api_key",
                    "structured_data"
                  ],
                  "title": "validate_and_repairArguments",
                  "type": "object"
                },
                "name": "validate_and_repair"
              },
              {
                "description": "\n    Create a Blueprint \u2014 a governance contract that defines validation rules.\n\n    A Blueprint tells the platform what \"correct\" means for your data: which\n    fields exist, what math must hold between them, and what value ranges\n    are acceptable. Without a Blueprint, the platform has nothing to validate against.\n\n    If you don't know what rules to define, use load_rule_pack to start from\n    a prebuilt template, or use discover_patterns to find rules from your data.\n\n    Use the blueprint_guide prompt for the complete reference of all available\n    rule types, constraint types, and configuration options.\n\n    Args:\n        api_key: GeodesicAI API key (starts with gai_)\n        customer_name: Organization or project name (used for folder naming)\n        workflow_name: Unique identifier for this Blueprint (used as the 'blueprint' parameter in validate)\n        mode: \"observe\" (platform checks agent's work) or \"enforce\" (platform computes derived fields)\n        extracted_fields: Fields the agent extracts from source data (e.g. [\"vendor\", \"qty\", \"unit_cost\"])\n        derived_fields: Fields computed from other fields (e.g. [\"subtotal\", \"total\"])\n        derivation_rules: Math rules defining field relationships. Available types: \"add\" (target = a + b), \"subtract\" (target = a - b), \"multiply\" (target = a \u00d7 b), \"divide\" (target = a \u00f7 b), \"round\" (round field to N places), \"copy\" (copy source to target), \"items_multiply\" (per-item a \u00d7 b in a list), \"items_sum\" (sum a field across list items). Each rule requires \"type\" and the relevant fields. See blueprint_guide prompt for full schema.\n        formal_constraints: Value bounds and ratio constraints. Available types: \"magnitude_anchor\" (field within min/max range, requires \"field\", \"min\", \"max\"), \"relative_anchor\" (ratio a/b within tolerance, requires \"a\", \"b\", \"expected_ratio\", \"tolerance\"), \"max_action_threshold\" (trigger action if field exceeds threshold, requires \"field\", \"threshold\", \"action\"). See blueprint_guide prompt for full schema.\n        semantic_checks: Domain-specific validation checks\n        require_math: Validate mathematical relationships (default true)\n        require_consistency: Check internal consistency (default true)\n        require_coherence: Check structural coherence (default true)\n        require_provenance: Require agents to report extraction source locations\n        require_high_assurance: Strictest validation \u2014 feasibility, spectral, and global consistency required\n        enable_anomaly_detection: Geometric fingerprinting to detect structural outliers\n        enable_drift_tracking: Monitor pattern stability across batches\n    ",
                "inputSchema": {
                  "properties": {
                    "api_key": {
                      "title": "Api Key",
                      "type": "string"
                    },
                    "customer_name": {
                      "title": "Customer Name",
                      "type": "string"
                    },
                    "derivation_rules": {
                      "default": null,
                      "items": {},
                      "title": "Derivation Rules",
                      "type": "array"
                    },
                    "derived_fields": {
                      "default": null,
                      "items": {},
                      "title": "Derived Fields",
                      "type": "array"
                    },
                    "enable_anomaly_detection": {
                      "default": false,
                      "title": "Enable Anomaly Detection",
                      "type": "boolean"
                    },
                    "enable_drift_tracking": {
                      "default": false,
                      "title": "Enable Drift Tracking",
                      "type": "boolean"
                    },
                    "extracted_fields": {
                      "default": null,
                      "items": {},
                      "title": "Extracted Fields",
                      "type": "array"
                    },
                    "formal_constraints": {
                      "default": null,
                      "items": {},
                      "title": "Formal Constraints",
                      "type": "array"
                    },
                    "mode": {
                      "default": "observe",
                      "title": "Mode",
                      "type": "string"
                    },
                    "require_coherence": {
                      "default": true,
                      "title": "Require Coherence",
                      "type": "boolean"
                    },
                    "require_consistency": {
                      "default": true,
                      "title": "Require Consistency",
                      "type": "boolean"
                    },
                    "require_high_assurance": {
                      "default": false,
                      "title": "Require High Assurance",
                      "type": "boolean"
                    },
                    "require_math": {
                      "default": true,
                      "title": "Require Math",
                      "type": "boolean"
                    },
                    "require_provenance": {
                      "default": false,
                      "title": "Require Provenance",
                      "type": "boolean"
                    },
                    "semantic_checks": {
                      "default": null,
                      "items": {},
                      "title": "Semantic Checks",
                      "type": "array"
                    },
                    "workflow_name": {
                      "title": "Workflow Name",
                      "type": "string"
                    }
                  },
                  "required": [
                    "api_key",
                    "customer_name",
                    "workflow_name"
                  ],
                  "title": "create_blueprintArguments",
                  "type": "object"
                },
                "name": "create_blueprint"
              },
              {
                "description": "\n    List Blueprints owned by the calling account.\n\n    Returns each Blueprint's name, workflow identifier, mode, and\n    field/rule/constraint counts. Use the workflow_name as the\n    'blueprint' parameter when calling validate.\n\n    Blueprint modes \u2014 important for agents that summarize results:\n      - \"observe\" (Observation mode): the platform validates data\n        against the Blueprint's rules and returns PASS, FAIL, or\n        REVIEW with repair suggestions. Validation is detection-only;\n        the caller decides what to do with the result.\n      - \"enforce\" (Execution mode): the platform performs the same\n        validation AND authorizes downstream side effects. Side\n        effects are blocked if validation fails. In this mode, rules\n        that compute derived values (like totals) publish the\n        platform's computed result as authoritative, so downstream\n        consumers see the canonical value rather than the agent's.\n\n    Both modes run the same rule checks. The difference is what\n    happens after validation, not during it.\n\n    Scope: only Blueprints created by the calling account are returned.\n    Use validate / repair / etc. with the workflow_name to operate on them.\n\n    Args:\n        api_key: GeodesicAI API key (starts with gai_)\n    ",
                "inputSchema": {
                  "properties": {
                    "api_key": {
                      "title": "Api Key",
                      "type": "string"
                    }
                  },
                  "required": [
                    "api_key"
                  ],
                  "title": "list_blueprintsArguments",
                  "type": "object"
                },
                "name": "list_blueprints"
              },
              {
                "description": "\n    Compute the nearest valid point on the constraint manifold.\n\n    Given structured data with errors, missing values, or inconsistencies,\n    returns field-by-field repair suggestions with geometric confidence scores.\n    Uses algebraic projection for linear constraints and iterative geodesic\n    projection for nonlinear constraints.\n\n    Can accept rules directly or load them from a Blueprint.\n\n    Args:\n        api_key: GeodesicAI API key (starts with gai_)\n        structured_data: The data to repair (key-value pairs)\n        derivation_rules: Math rules (optional if blueprint is provided)\n        formal_constraints: Constraints (optional if blueprint is provided)\n        blueprint: Load rules from this Blueprint instead of specifying them directly\n    ",
                "inputSchema": {
                  "properties": {
                    "api_key": {
                      "title": "Api Key",
                      "type": "string"
                    },
                    "blueprint": {
                      "default": null,
                      "title": "Blueprint",
                      "type": "string"
                    },
                    "derivation_rules": {
                      "default": null,
                      "items": {},
                      "title": "Derivation Rules",
                      "type": "array"
                    },
                    "formal_constraints": {
                      "default": null,
                      "items": {},
                      "title": "Formal Constraints",
                      "type": "array"
                    },
                    "structured_data": {
                      "additionalProperties": true,
                      "title": "Structured Data",
                      "type": "object"
                    }
                  },
                  "required": [
                    "api_key",
                    "structured_data"
                  ],
                  "title": "repairArguments",
                  "type": "object"
                },
                "name": "repair"
              },
              {
                "description": "\n    Check whether a set of constraints can be simultaneously satisfied.\n\n    Uses the twist-compression operator to detect structural obstructions \u2014\n    fundamental conflicts in the constraint system that cannot be resolved\n    by adjusting any single field. Returns obstruction type, magnitude,\n    and the specific constraint interactions causing the conflict.\n\n    Fast pre-check before running full validation.\n\n    Args:\n        api_key: GeodesicAI API key (starts with gai_)\n        constraints: List of derivation rules and formal constraints to check\n        field_values: Current field values (numeric key-value pairs)\n    ",
                "inputSchema": {
                  "properties": {
                    "api_key": {
                      "title": "Api Key",
                      "type": "string"
                    },
                    "constraints": {
                      "items": {},
                      "title": "Constraints",
                      "type": "array"
                    },
                    "field_values": {
                      "additionalProperties": true,
                      "title": "Field Values",
                      "type": "object"
                    }
                  },
                  "required": [
                    "api_key",
                    "constraints",
                    "field_values"
                  ],
                  "title": "check_feasibilityArguments",
                  "type": "object"
                },
                "name": "check_feasibility"
              },
              {
                "description": "\n    Deterministic forward reasoning \u2014 show what valid states are reachable.\n\n    Given the current data state, generates candidate next states by\n    applying Blueprint rules, then ranks them by structural quality\n    (lowest drift, highest confidence, shortest path, or lowest risk).\n\n    Args:\n        api_key: GeodesicAI API key (starts with gai_)\n        api_key: GeodesicAI API key (starts with gai_)\n        structured_data: Current data state\n        blueprint: Blueprint to use for rules and constraints\n        max_depth: How many steps ahead to forecast (1-10)\n        max_branches: Maximum branches per step (1-10)\n        rank_by: Ranking criterion \u2014 \"drift\" (most stable), \"confidence\" (highest geometric confidence), \"shortest\" (fewest changes), \"risk\" (lowest risk)\n    ",
                "inputSchema": {
                  "properties": {
                    "api_key": {
                      "title": "Api Key",
                      "type": "string"
                    },
                    "blueprint": {
                      "default": "default",
                      "title": "Blueprint",
                      "type": "string"
                    },
                    "max_branches": {
                      "default": 5,
                      "title": "Max Branches",
                      "type": "integer"
                    },
                    "max_depth": {
                      "default": 3,
                      "title": "Max Depth",
                      "type": "integer"
                    },
                    "rank_by": {
                      "default": "drift",
                      "title": "Rank By",
                      "type": "string"
                    },
                    "structured_data": {
                      "additionalProperties": true,
                      "title": "Structured Data",
                      "type": "object"
                    }
                  },
                  "required": [
                    "api_key",
                    "structured_data"
                  ],
                  "title": "forecastArguments",
                  "type": "object"
                },
                "name": "forecast"
              },
              {
                "description": "\n    Feed a batch of structured data to discover patterns deterministically.\n    No Blueprint required \u2014 discovers rules from the data itself.\n\n    Analyzes the batch using motif discovery, structural routing, and\n    geometric fingerprinting. Returns candidate validation rules with\n    confidence scores, structural type classifications, and anomaly counts.\n    Source data is never stored \u2014 only statistical summaries persist.\n\n    Discovered rules can be promoted into Blueprints using approve_rule.\n\n    Args:\n        api_key: GeodesicAI API key (starts with gai_)\n        documents: List of structured data objects to analyze\n        api_key: GeodesicAI API key (starts with gai_)\n        blueprint: Namespace for this discovery session\n    ",
                "inputSchema": {
                  "properties": {
                    "api_key": {
                      "title": "Api Key",
                      "type": "string"
                    },
                    "blueprint": {
                      "default": "default",
                      "title": "Blueprint",
                      "type": "string"
                    },
                    "documents": {
                      "items": {},
                      "title": "Documents",
                      "type": "array"
                    }
                  },
                  "required": [
                    "api_key",
                    "documents"
                  ],
                  "title": "discover_patternsArguments",
                  "type": "object"
                },
                "name": "discover_patterns"
              },
              {
                "description": "\n    Find the shortest path from an invalid state to a valid one.\n\n    Given data that fails validation, computes a sequence of minimal\n    field changes that would bring the data into compliance with the\n    Blueprint's rules and constraints.\n\n    Args:\n        structured_data: Current (invalid) data state\n        blueprint: Blueprint defining the valid constraint space\n        max_depth: Maximum repair steps to search (1-10)\n        rank_by: Ranking criterion \u2014 \"shortest\", \"drift\", \"confidence\", \"risk\"\n    ",
                "inputSchema": {
                  "properties": {
                    "api_key": {
                      "title": "Api Key",
                      "type": "string"
                    },
                    "blueprint": {
                      "default": "default",
                      "title": "Blueprint",
                      "type": "string"
                    },
                    "max_depth": {
                      "default": 4,
                      "title": "Max Depth",
                      "type": "integer"
                    },
                    "rank_by": {
                      "default": "shortest",
                      "title": "Rank By",
                      "type": "string"
                    },
                    "structured_data": {
                      "additionalProperties": true,
                      "title": "Structured Data",
                      "type": "object"
                    }
                  },
                  "required": [
                    "api_key",
                    "structured_data"
                  ],
                  "title": "repair_pathArguments",
                  "type": "object"
                },
                "name": "repair_path"
              },
              {
                "description": "\n    Compare outcomes under different rule sets.\n\n    Given the same data, runs trajectory analysis under two different\n    sets of rules/constraints and shows how the valid state space differs.\n    Useful for what-if analysis: \"what happens if I change this rule?\"\n\n    Args:\n        api_key: GeodesicAI API key (starts with gai_)\n        structured_data: Data to analyze\n        blueprint: Primary Blueprint (rule set A)\n        rules_b: Alternative derivation rules (rule set B)\n        constraints_b: Alternative constraints (rule set B)\n    ",
                "inputSchema": {
                  "properties": {
                    "api_key": {
                      "title": "Api Key",
                      "type": "string"
                    },
                    "blueprint": {
                      "default": "default",
                      "title": "Blueprint",
                      "type": "string"
                    },
                    "constraints_b": {
                      "default": null,
                      "items": {},
                      "title": "Constraints B",
                      "type": "array"
                    },
                    "rules_b": {
                      "default": null,
                      "items": {},
                      "title": "Rules B",
                      "type": "array"
                    },
                    "structured_data": {
                      "additionalProperties": true,
                      "title": "Structured Data",
                      "type": "object"
                    }
                  },
                  "required": [
                    "api_key",
                    "structured_data"
                  ],
                  "title": "counterfactualArguments",
                  "type": "object"
                },
                "name": "counterfactual"
              },
              {
                "description": "\n    Deep anomaly analysis with geometric proof. No Blueprint required.\n\n    Explains WHY data is anomalous using three independent methods:\n    1. Structural fingerprinting \u2014 distance from the learned manifold\n    2. Cluster analysis \u2014 deviation from structural type centroids\n    3. Twist-compression obstruction \u2014 fundamental constraint conflicts\n\n    Returns a human-readable geometric proof of anomaly, not just a flag.\n\n    Args:\n        structured_data: The data to analyze for anomalies\n    ",
                "inputSchema": {
                  "properties": {
                    "api_key": {
                      "title": "Api Key",
                      "type": "string"
                    },
                    "structured_data": {
                      "additionalProperties": true,
                      "title": "Structured Data",
                      "type": "object"
                    }
                  },
                  "required": [
                    "api_key",
                    "structured_data"
                  ],
                  "title": "analyze_anomalyArguments",
                  "type": "object"
                },
                "name": "analyze_anomaly"
              },
              {
                "description": "\n    Create a multi-agent sequential execution chain.\n\n    Defines a pipeline where multiple agents process data in sequence.\n    Each stage is validated against the Blueprint before the next stage\n    can proceed. Repair suggestions propagate forward through the chain.\n\n    Args:\n        blueprint: Blueprint governing all stages\n        stages: List of stage definitions, e.g. [{\"stage_name\": \"extract\", \"agent_name\": \"PDF Scanner\"}, {\"stage_name\": \"validate\", \"agent_name\": \"QA Agent\"}]\n        ttl: Chain timeout in seconds (default 3600)\n    ",
                "inputSchema": {
                  "properties": {
                    "api_key": {
                      "title": "Api Key",
                      "type": "string"
                    },
                    "blueprint": {
                      "title": "Blueprint",
                      "type": "string"
                    },
                    "stages": {
                      "items": {},
                      "title": "Stages",
                      "type": "array"
                    },
                    "ttl": {
                      "default": 3600,
                      "title": "Ttl",
                      "type": "integer"
                    }
                  },
                  "required": [
                    "api_key",
                    "blueprint",
                    "stages"
                  ],
                  "title": "create_chainArguments",
                  "type": "object"
                },
                "name": "create_chain"
              },
              {
                "description": "\n    Submit data for a chain stage. The platform validates the data\n    using the chain's Blueprint, then advances the chain if validation passes.\n\n    The response includes the next stage info and any accumulated\n    repair suggestions from prior stages.\n\n    Args:\n        api_key: GeodesicAI API key (starts with gai_)\n        chain_id: Chain identifier from create_chain\n        stage: Stage name to submit for\n        structured_data: Data for this stage\n    ",
                "inputSchema": {
                  "properties": {
                    "api_key": {
                      "title": "Api Key",
                      "type": "string"
                    },
                    "chain_id": {
                      "title": "Chain Id",
                      "type": "string"
                    },
                    "stage": {
                      "title": "Stage",
                      "type": "string"
                    },
                    "structured_data": {
                      "additionalProperties": true,
                      "title": "Structured Data",
                      "type": "object"
                    }
                  },
                  "required": [
                    "api_key",
                    "chain_id",
                    "stage",
                    "structured_data"
                  ],
                  "title": "submit_chain_stageArguments",
                  "type": "object"
                },
                "name": "submit_chain_stage"
              },
              {
                "description": "\n    Audit a handoff between two chain stages. Returns a context capsule\n    with verified facts from the prior stage and checks structural\n    compatibility of proposed data for the next stage.\n\n    Use this between chain stages to ensure Agent B receives only\n    verified data from Agent A, and that nothing was mutated in transit.\n\n    The context capsule contains:\n    - Verified fields and their values from the prior stage\n    - Determinism hash proving the prior stage's results\n    - Blueprint constraints the next stage must satisfy\n    - Compatibility verdict if proposed_data is provided\n\n    Args:\n        api_key: GeodesicAI API key (starts with gai_)\n        chain_id: Chain identifier from create_chain\n        from_stage: Stage name that completed (Agent A)\n        to_stage: Stage name about to start (Agent B)\n        proposed_data: Optional data Agent B intends to submit \u2014 checked for compatibility\n    ",
                "inputSchema": {
                  "properties": {
                    "api_key": {
                      "title": "Api Key",
                      "type": "string"
                    },
                    "chain_id": {
                      "title": "Chain Id",
                      "type": "string"
                    },
                    "from_stage": {
                      "title": "From Stage",
                      "type": "string"
                    },
                    "proposed_data": {
                      "additionalProperties": true,
                      "default": null,
                      "title": "Proposed Data",
                      "type": "object"
                    },
                    "to_stage": {
                      "title": "To Stage",
                      "type": "string"
                    }
                  },
                  "required": [
                    "api_key",
                    "chain_id",
                    "from_stage",
                    "to_stage"
                  ],
                  "title": "handoff_auditArguments",
                  "type": "object"
                },
                "name": "handoff_audit"
              },
              {
                "description": "\n    Promote a discovered rule into Blueprint-compatible format.\n\n    After running discover_patterns, use this to approve high-confidence\n    rules for inclusion in a Blueprint.\n\n    Args:\n        api_key: GeodesicAI API key (starts with gai_)\n        rule_id: ID of the discovered rule (from discover_patterns results)\n        blueprint: Discovery session namespace\n    ",
                "inputSchema": {
                  "properties": {
                    "api_key": {
                      "title": "Api Key",
                      "type": "string"
                    },
                    "blueprint": {
                      "default": "default",
                      "title": "Blueprint",
                      "type": "string"
                    },
                    "rule_id": {
                      "title": "Rule Id",
                      "type": "string"
                    }
                  },
                  "required": [
                    "api_key",
                    "rule_id"
                  ],
                  "title": "approve_ruleArguments",
                  "type": "object"
                },
                "name": "approve_rule"
              },
              {
                "description": "\n    Reject a discovered candidate rule.\n\n    Args:\n        api_key: GeodesicAI API key (starts with gai_)\n        rule_id: ID of the discovered rule to reject\n        blueprint: Discovery session namespace\n    ",
                "inputSchema": {
                  "properties": {
                    "api_key": {
                      "title": "Api Key",
                      "type": "string"
                    },
                    "blueprint": {
                      "default": "default",
                      "title": "Blueprint",
                      "type": "string"
                    },
                    "rule_id": {
                      "title": "Rule Id",
                      "type": "string"
                    }
                  },
                  "required": [
                    "api_key",
                    "rule_id"
                  ],
                  "title": "reject_ruleArguments",
                  "type": "object"
                },
                "name": "reject_rule"
              },
              {
                "description": "\n    Get auto-discovered structural type classifications.\n\n    After running discover_patterns, returns the structural categories\n    the platform identified in the data \u2014 without being told what\n    categories exist. Shows document counts, distinguishing fields,\n    and domain hints per type.\n\n    Args:\n        blueprint: Discovery session namespace\n    ",
                "inputSchema": {
                  "properties": {
                    "api_key": {
                      "title": "Api Key",
                      "type": "string"
                    },
                    "blueprint": {
                      "default": "default",
                      "title": "Blueprint",
                      "type": "string"
                    }
                  },
                  "required": [
                    "api_key"
                  ],
                  "title": "structural_typesArguments",
                  "type": "object"
                },
                "name": "structural_types"
              },
              {
                "description": "\n    Hodge-style decomposition of validation failures.\n\n    Splits the error between original and corrected values into three\n    orthogonal components:\n    - Exact: direct rule violations (a field breaks a specific math rule)\n    - Co-exact: constraint boundary violations (a field is at the edge of valid range)\n    - Harmonic: systemic structural errors (the overall data shape is wrong)\n\n    Identifies the primary failure type and contributing fields.\n\n    Args:\n        api_key: GeodesicAI API key (starts with gai_)\n        original_values: The original field values (numeric key-value pairs)\n        corrected_values: The corrected/expected field values\n        derivation_rules: Math rules (optional if blueprint provided)\n        formal_constraints: Constraints (optional if blueprint provided)\n        blueprint: Load rules from this Blueprint\n    ",
                "inputSchema": {
                  "properties": {
                    "api_key": {
                      "title": "Api Key",
                      "type": "string"
                    },
                    "blueprint": {
                      "default": null,
                      "title": "Blueprint",
                      "type": "string"
                    },
                    "corrected_values": {
                      "additionalProperties": true,
                      "title": "Corrected Values",
                      "type": "object"
                    },
                    "derivation_rules": {
                      "default": null,
                      "items": {},
                      "title": "Derivation Rules",
                      "type": "array"
                    },
                    "formal_constraints": {
                      "default": null,
                      "items": {},
                      "title": "Formal Constraints",
                      "type": "array"
                    },
                    "original_values": {
                      "additionalProperties": true,
                      "title": "Original Values",
                      "type": "object"
                    }
                  },
                  "required": [
                    "api_key",
                    "original_values",
                    "corrected_values"
                  ],
                  "title": "decompose_failureArguments",
                  "type": "object"
                },
                "name": "decompose_failure"
              },
              {
                "description": "\n    Compute a composite geometric confidence score from validation signals.\n    No Blueprint required \u2014 works on any validate result.\n\n    Combines six weighted signals into a single confidence score:\n    - Surface distance (how close to the constraint manifold)\n    - Geometric health (projection quality, regulator, closure)\n    - Anomaly score (structural fingerprint deviation)\n    - Stability score (batch drift)\n    - Motif compliance (pattern violations)\n    - Motif gate (enforcement decision)\n\n    Returns confidence level (high/medium/low) and a recommendation.\n\n    Typically called with the state_vector from a validate result.\n\n    Args:\n        api_key: GeodesicAI API key (starts with gai_)\n        state_vector: State vector dictionary (from validate results)\n    ",
                "inputSchema": {
                  "properties": {
                    "api_key": {
                      "title": "Api Key",
                      "type": "string"
                    },
                    "state_vector": {
                      "additionalProperties": true,
                      "title": "State Vector",
                      "type": "object"
                    }
                  },
                  "required": [
                    "api_key",
                    "state_vector"
                  ],
                  "title": "geometric_confidenceArguments",
                  "type": "object"
                },
                "name": "geometric_confidence"
              },
              {
                "description": "\n    Run structural realization analysis on a payload.\n\n    Embeds the payload via the Blueprint's declared embedding schema,\n    projects it onto the Blueprint's reference subspace, and returns\n    a realization score, residual, projection angle, and full report.\n\n    The Blueprint must include a `realization` configuration block\n    (see RealizationConfig in Platform_Agent.realization.schema). If\n    no realization config is present, the report status is \"skipped\"\n    and the payload is treated as unconstrained by the realization\n    layer.\n\n    For Blueprints using basis mode \"auto\", the first N payloads\n    bootstrap the reference subspace; until the bootstrap pool is\n    full, the report status is \"skipped\". After bootstrap, every\n    subsequent payload is projected against the locked subspace and\n    receives a real score.\n\n    Args:\n        api_key: GeodesicAI API key (starts with gai_)\n        structured_data: payload to analyze\n        blueprint: Blueprint name (defaults to \"default\")\n\n    Returns:\n        dict with keys:\n          status:              \"pass\" | \"review\" | \"skipped\"\n          realization_score:   float in [0, 1], higher = better fit\n          residual:            ||v - P_U(v)||\n          angle_degrees:       angle between v and P_U(v)\n          in_subspace:         bool \u2014 residual < tolerance\n          basis_mode:          \"vectors\" | \"auto\" | \"uninitialized\"\n          basis_dimension:     k of the reference subspace\n          vector_dimension:    D of the embedded payload\n          report:              full RealizationReport dict (may include\n                               invariance/stability stacks if enabled)\n    ",
                "inputSchema": {
                  "properties": {
                    "api_key": {
                      "title": "Api Key",
                      "type": "string"
                    },
                    "blueprint": {
                      "default": "default",
                      "title": "Blueprint",
                      "type": "string"
                    },
                    "structured_data": {
                      "additionalProperties": true,
                      "title": "Structured Data",
                      "type": "object"
                    }
                  },
                  "required": [
                    "api_key",
                    "structured_data"
                  ],
                  "title": "check_realizationArguments",
                  "type": "object"
                },
                "name": "check_realization"
              },
              {
                "description": "\n    Check whether the data pattern has shifted since previous observations.\n\n    Works with or without a Blueprint. Monitors structural stability across\n    a stream of data. Detects regime changes when the data's geometric\n    embedding moves to a different region of the constraint space \u2014\n    indicating the source data's structure has fundamentally changed.\n\n    Call this repeatedly as new data arrives to track drift over time.\n\n    Args:\n        api_key: GeodesicAI API key (starts with gai_)\n        structured_data: New data point to check for drift\n        blueprint: Blueprint for geometric embedding context\n    ",
                "inputSchema": {
                  "properties": {
                    "api_key": {
                      "title": "Api Key",
                      "type": "string"
                    },
                    "blueprint": {
                      "default": "default",
                      "title": "Blueprint",
                      "type": "string"
                    },
                    "structured_data": {
                      "additionalProperties": true,
                      "title": "Structured Data",
                      "type": "object"
                    }
                  },
                  "required": [
                    "api_key",
                    "structured_data"
                  ],
                  "title": "check_driftArguments",
                  "type": "object"
                },
                "name": "check_drift"
              },
              {
                "description": "\n    Decide whether an action should be allowed to proceed.\n\n    Runs full validation, then applies the Blueprint's execution gate.\n    Returns a simple allow/block decision with reasoning.\n\n    Use this when your agent is about to take a real-world action (payment,\n    filing, API call, data write) and needs a deterministic go/no-go.\n\n    Different from validate: validate says \"is this data correct?\"\n    authorize_execution says \"should this action happen?\"\n\n    Args:\n        api_key: GeodesicAI API key (starts with gai_)\n        structured_data: The data associated with the action\n        blueprint: Blueprint governing this action type\n    ",
                "inputSchema": {
                  "properties": {
                    "api_key": {
                      "title": "Api Key",
                      "type": "string"
                    },
                    "blueprint": {
                      "title": "Blueprint",
                      "type": "string"
                    },
                    "structured_data": {
                      "additionalProperties": true,
                      "title": "Structured Data",
                      "type": "object"
                    }
                  },
                  "required": [
                    "api_key",
                    "structured_data",
                    "blueprint"
                  ],
                  "title": "authorize_executionArguments",
                  "type": "object"
                },
                "name": "authorize_execution"
              },
              {
                "description": "\n    Load a prebuilt Blueprint template for fast onboarding.\n\n    Rule Packs are ready-made governance configurations for common use cases.\n    Call with no pack_id to list all available packs. Call with a pack_id\n    to load the full configuration, then use create_blueprint to save it.\n\n    Available packs include templates for: invoice governance, timecard/payroll\n    governance, legal document governance, purchase order governance, and\n    insurance claims governance. Each includes field definitions, derivation\n    rules, constraints, and agent conditioning instructions.\n\n    Args:\n        api_key: GeodesicAI API key (starts with gai_)\n        pack_id: ID of the rule pack to load. Omit to list available packs.\n    ",
                "inputSchema": {
                  "properties": {
                    "api_key": {
                      "title": "Api Key",
                      "type": "string"
                    },
                    "pack_id": {
                      "default": null,
                      "title": "Pack Id",
                      "type": "string"
                    }
                  },
                  "required": [
                    "api_key"
                  ],
                  "title": "load_rule_packArguments",
                  "type": "object"
                },
                "name": "load_rule_pack"
              },
              {
                "description": "\n    Run validation and return the detailed execution trace.\n\n    Shows the exact sequence of validation nodes that ran, whether each was\n    deterministic, and the runtime of each node. Use for debugging, compliance\n    audits, or understanding exactly what the platform checked.\n\n    Args:\n        api_key: GeodesicAI API key (starts with gai_)\n        structured_data: The data to trace validation for\n        blueprint: Blueprint to validate against\n    ",
                "inputSchema": {
                  "properties": {
                    "api_key": {
                      "title": "Api Key",
                      "type": "string"
                    },
                    "blueprint": {
                      "default": "default",
                      "title": "Blueprint",
                      "type": "string"
                    },
                    "structured_data": {
                      "additionalProperties": true,
                      "title": "Structured Data",
                      "type": "object"
                    }
                  },
                  "required": [
                    "api_key",
                    "structured_data"
                  ],
                  "title": "get_execution_traceArguments",
                  "type": "object"
                },
                "name": "get_execution_trace"
              },
              {
                "description": "\n    Verify that two execution replay contracts represent the same deterministic result.\n\n    This is the programmatic proof of GeodesicAI's core promise: same input + same\n    rules = same result, every time. Given two replay contracts (e.g. from the\n    original execution and a re-run), this tool compares all component hashes and\n    reports whether the executions are byte-identical.\n\n    Use this to:\n    - Prove to an auditor that a decision from March 3rd matches a re-run today.\n    - Detect when a rule change has altered execution behavior (input hash matches\n      but canonical trace hash differs \u2192 the rules diverged).\n    - Confirm a Blueprint migration didn't change any observable outcomes.\n\n    Args:\n        api_key: GeodesicAI API key (starts with gai_)\n        contract_a: A replay contract dict (the `replay_contract` field from a\n                    prior validate/execute_task response)\n        contract_b: Another replay contract dict to compare against contract_a\n\n    Returns:\n        replay_match: bool \u2014 True if the top-level replay_hash matches (fully identical)\n        contract_version_match: bool\n        matches: dict of field_name \u2192 value, for every field that agreed\n        mismatches: dict of field_name \u2192 {expected, actual}, for every field that disagreed\n        summary: plain-English one-liner describing the result\n\n    Interpretation of mismatches:\n        - input_payload_hash: the two runs were fed different data\n        - template_version: the Blueprint was upgraded between runs\n        - solver_registry_hash: the platform itself changed between runs\n        - canonical_trace_hash: same inputs and rules but different execution path\n            (should never happen under determinism; indicates a platform bug)\n        - graph_hash: DAG topology changed between runs\n    ",
                "inputSchema": {
                  "properties": {
                    "api_key": {
                      "title": "Api Key",
                      "type": "string"
                    },
                    "contract_a": {
                      "additionalProperties": true,
                      "title": "Contract A",
                      "type": "object"
                    },
                    "contract_b": {
                      "additionalProperties": true,
                      "title": "Contract B",
                      "type": "object"
                    }
                  },
                  "required": [
                    "api_key",
                    "contract_a",
                    "contract_b"
                  ],
                  "title": "verify_replayArguments",
                  "type": "object"
                },
                "name": "verify_replay"
              },
              {
                "description": "\n    Report the calling account's plan, key usage, and limits.\n\n    Use this to introspect what the caller is allowed to do. Agents that hit\n    rate limits or key-count caps can call this to explain the limit to the\n    human and suggest upgrading if needed.\n\n    Args:\n        api_key: GeodesicAI API key (starts with gai_)\n\n    Returns:\n        plan: The user's current plan \u2014 one of pilot, trial, tier1, tier2, beta, enterprise\n        plan_label: Human-readable plan name (e.g. \"Personal Access\", \"Small Business\")\n        account_key_count: Number of account-level API keys currently issued\n        account_key_limit: Maximum account keys allowed on this plan\n        blueprint_count: Number of Blueprints owned by this user\n        blueprint_limit: Maximum Blueprints allowed on this plan\n        email: The user's email address (for reference in support)\n        user_id: Stable user identifier\n        trial_days_remaining: Days left on trial, if plan == \"trial\"; else null\n    ",
                "inputSchema": {
                  "properties": {
                    "api_key": {
                      "title": "Api Key",
                      "type": "string"
                    }
                  },
                  "required": [
                    "api_key"
                  ],
                  "title": "account_statusArguments",
                  "type": "object"
                },
                "name": "account_status"
              }
            ]
          }
        },
        "requested_protocol_version": "2025-03-26",
        "resumed": true,
        "session_id_present": true,
        "transport": "streamable-http",
        "url": "https://app.geodesiclabs.ai/mcp"
      },
      "latency_ms": 162.27,
      "status": "ok"
    },
    "step_up_auth_probe": {
      "details": {
        "auth_required_checks": [],
        "broad_scopes": [],
        "challenge_headers": [],
        "minimal_scope_documented": false,
        "oauth_present": false,
        "scope_specificity_ratio": 0.0,
        "step_up_signals": [],
        "supported_scopes": []
      },
      "latency_ms": null,
      "status": "missing"
    },
    "tool_snapshot_probe": {
      "details": {
        "reason": "no_tools"
      },
      "latency_ms": null,
      "status": "missing"
    },
    "tools_list": {
      "details": {
        "error": "Client error '400 Bad Request' for url 'https://app.geodesiclabs.ai/mcp'\nFor more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/400",
        "headers": {
          "content-type": "application/json",
          "mcp-session-id": "9151297e2f8b468fbbb05b783db3a63a"
        },
        "http_status": 400,
        "payload": {},
        "url": "https://app.geodesiclabs.ai/mcp"
      },
      "latency_ms": 166.04,
      "status": "error"
    },
    "transport_compliance_probe": {
      "details": {
        "bad_protocol_error": null,
        "bad_protocol_headers": {
          "content-type": "application/json",
          "mcp-session-id": "ef9e6c1308e048abadf095f562f7a8ec"
        },
        "bad_protocol_payload": {
          "error": {
            "code": -32600,
            "message": "Bad Request: Unsupported protocol version: 1999-99-99. Supported versions: 2024-11-05, 2025-03-26, 2025-06-18, 2025-11-25"
          },
          "id": "server-error",
          "jsonrpc": "2.0"
        },
        "bad_protocol_status_code": 400,
        "delete_error": null,
        "delete_status_code": 200,
        "expired_session_error": null,
        "expired_session_status_code": 404,
        "issues": [
          "missing_protocol_header"
        ],
        "last_event_id_visible": false,
        "protocol_header_present": false,
        "requested_protocol_version": "2025-03-26",
        "session_id_present": true,
        "transport": "streamable-http"
      },
      "latency_ms": 172.68,
      "status": "warning"
    },
    "utility_coverage_probe": {
      "details": {
        "completions": {
          "advertised": false,
          "live_probe": "not_executed",
          "sample_target": null
        },
        "initialize_capability_keys": [
          "experimental",
          "prompts",
          "resources",
          "tools"
        ],
        "pagination": {
          "metadata_signal": false,
          "next_cursor_methods": [],
          "supported": false
        },
        "tasks": {
          "advertised": false,
          "http_status": 400,
          "probe_status": "missing"
        }
      },
      "latency_ms": 89.46,
      "status": "missing"
    }
  },
  "failures": {
    "oauth_authorization_server": {
      "reason": "no_authorization_server"
    },
    "oauth_protected_resource": {
      "error": "Client error '404 Not Found' for url 'https://app.geodesiclabs.ai/.well-known/oauth-protected-resource'\nFor more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/404",
      "url": "https://app.geodesiclabs.ai/.well-known/oauth-protected-resource"
    },
    "openid_configuration": {
      "reason": "no_authorization_server"
    },
    "server_card": {
      "error": "Client error '404 Not Found' for url 'https://app.geodesiclabs.ai/.well-known/mcp/server-card.json'\nFor more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/404",
      "url": "https://app.geodesiclabs.ai/.well-known/mcp/server-card.json"
    },
    "tools_list": {
      "error": "Client error '400 Bad Request' for url 'https://app.geodesiclabs.ai/mcp'\nFor more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/400",
      "headers": {
        "content-type": "application/json",
        "mcp-session-id": "9151297e2f8b468fbbb05b783db3a63a"
      },
      "http_status": 400,
      "payload": {},
      "url": "https://app.geodesiclabs.ai/mcp"
    }
  },
  "remote_url": "https://app.geodesiclabs.ai/mcp",
  "server_card_payload": null,
  "server_identifier": "ai.geodesiclabs/governance-platform"
}