MODEL CONTEXT PROTOCOL

Give your AI agent a transaction safety layer.

PathGuard MCP lets MCP-compatible agents check crypto destinations and preflight transaction details before funds move. Get a risk score, actionable flags, and a clear decision inside the agent workflow.

Get started →Read API docs

01 / CONNECT

Add PathGuard MCP

Run it locally for development or connect through Streamable HTTP for remote agent platforms.

02 / PREFLIGHT

Check before sending

Use preflight_transaction to evaluate the destination and optional amount before an agent proceeds.

03 / DECIDE

Act on the signal

Use the decision, score, and flags to warn, require confirmation, or block a risky action.

TOOLS

Purpose-built tools for transaction safety

The standard PathGuard MCP server exposes six tools for transaction safety, community reporting, account usage, and authenticated profile access.

preflight_transaction

Preflight before sending

Run the PathGuard risk engine before a send and receive an ALLOW, REVIEW, or BLOCK decision with the supporting score and flags.

PRE-SEND SAFETY

check_transaction

Check one transaction

Scan a destination for known scam signals, invalid formats, new-address risk, suspicious similarity, and amount anomalies.

TRANSACTION SAFETY

check_transactions_batch

Check up to 1,000

Review up to 1,000 transactions in one call. The default MCP response is a compact summary; request detail_level="full" when you need every result.

TRANSACTION SAFETY

report_scam_address

Report a suspected scam

Submit a suspicious address and optional reason to PathGuard's community reporting system.

COMMUNITY SIGNAL

get_usage_status

Check API usage

Inspect the current plan, quota, and usage for the authenticated PathGuard account.

ACCOUNT

get_profile

Get account profile

Return a safe, opaque profile identifier and account context for the authenticated PathGuard user.

ACCOUNT

Available through Vybe Collect: PathGuard can be accessed by AI agents through Vybe's pay-per-call payment rail. See the Vybe Collect integration →

SETUP

Connect PathGuard to your agent

Choose local MCP when the client can run a server process. Use Streamable HTTP when the client or platform needs a remote HTTPS endpoint.

Local MCP

Use the public PathGuard MCP package in your development environment. Your API key stays with your client and authenticates requests to PathGuard.

PUBLIC REPOSITORY

View on GitHub →

INSTALL

git clone https://github.com/Utee/pathguard-mcp.git
cd pathguard-mcp
python -m pip install .

AUTHENTICATION

PATHGUARD_API_KEY=pg_your_key_here

Requirements: Python 3.10+ and mcp >= 2.0. See the repository README for client-specific MCP configuration.

Remote Streamable HTTP

For remote MCP clients, connect to the standard public PathGuard MCP endpoint over HTTPS.

CURRENT PRODUCTION ENDPOINT

https://pathguard-v2.up.railway.app/mcp/

Authentication: remote MCP uses OAuth. Sign in with an existing PathGuard account and provide that account's PathGuard API key on the PathGuard consent page to authorize the connection.

Key handling: the API key is used to verify and authorize your existing PathGuard account. It is not returned to the AI client or exposed through MCP tool calls. Never paste a PathGuard API key into an AI prompt or public repository.

A branded MCP hostname will be documented here when its production routing is finalized.

Remote OAuth: You need an existing PathGuard account and API key. The OAuth consent flow verifies that account and issues MCP access tokens; your raw API key is not passed to the AI client. Local MCP: the local server uses PATHGUARD_API_KEY directly.

PREFLIGHT

Make “before you send” part of the agent workflow.

preflight_transaction is the decision-oriented MCP tool for putting PathGuard directly before a signing or broadcast step.

Input

EXAMPLE

{
  "address": "0x0000000000000000000000000000000000000001",
  "chain": "EVM",
  "amount": 0.01
}

The tool uses the same transaction fields and production risk engine as the PathGuard preflight API.

Decision

EXAMPLE RESPONSE

{
  "decision": "REVIEW",
  "risk_score": 15,
  "flags": ["new_address"],
  "should_block": false,
  "recommendation": "Review the flagged risk signals before sending."
}

ALLOW: no risk signals. REVIEW: signals exist but PathGuard is not blocking. BLOCK: the risk assessment recommends blocking.

Important: PathGuard provides a safety signal only. It never signs, broadcasts, or transfers funds. Your agent or application remains responsible for authorization, signing, and final transaction execution.

SECURITY

Use PathGuard as a safety layer

PathGuard provides a risk signal before a transaction reaches your signing or broadcast step. It does not replace your own authorization controls and does not execute transactions.

Keep keys private

API keys authenticate access to your PathGuard account and associated context. Never expose them to end users or client-side applications.

Check before signing

Run preflight before the transaction reaches your signing or broadcast step.

Use the result as a signal

Combine PathGuard's decision, score, and flags with your own authorization, policy, and transaction controls.

Partner integrations

Private or partner-specific MCP integrations may use separate access controls. Their endpoints and credentials are not published in the public documentation.

Important: Treat the returned decision as a safety recommendation. Your application or agent remains responsible for deciding whether a transaction is ultimately authorized.

BUILD WITH PATHGUARD

Ready to integrate?

For API request schemas, preflight responses, risk flags, rate limits, pricing, and examples, continue to the full API reference.

Open API documentation →Back to PathGuard