Autonomous on Base Mainnet

Your agent's security guard. Paid in USDC.

Three-state screening. Gemini-advised evidence analysis. Deterministic authorization. Two payment surfaces. Zero humans.

Agent Wallets Gateway CLI x402 Skills Gemini 2.5
Live autonomous operations since Aug 9, 2026 - intent value screened, not funds held
0 Screened
0 Approved
0 STEP_UP
0 Blocked
$0 Protected
--
Uptime
01
Agent requests payment
02
Deterministic risk check
03 STEP_UP
Treasury buys evidence
$0.02 USDC autonomous
04
Validator signs verdict
Ed25519 · team-operated
05 Authorized
Payment releases
$50.00 USDC paid
or Blocked
Payment blocked
$0.00 reached attacker
smart_toy
Enterprise
$0.05
account_balance
Treasury
$0.02
verified_user
Validator
shield
Carrier
$0.25
account_balance
Treasury
Earned
Evidence spend
Margin
Gemini 2.5 (advisory — never the final authorizer) STEP_UP reasoning Policy synthesis Scope negotiation Governance agents
info Hackathon demo only — this visualization is for judges evaluating the Circle Agentic Economy Prize. In production, the API operates headlessly via POST /api/agent/handle.

Autonomous Agent Loop

Three agents. Two payments. Zero humans. Watch the full enforcement + carrier evidence loop execute in real time.

Enterprise Agent
wallet: 0x5c34...431a2
Payment Intent
Waiting...
Enforcement
Carrier Feedback
Verigate
treasury: 0x0c74...44d
Risk Assessment
Circuit Breaker
Payment Surfaces
Checks:
Pulls:
Carrier Agent
id: reference-carrier-demo
Decision Events
Listening...
Evidence Pull
Assessment
Step-by-step timeline
Executing autonomous loop...

Security Treasury Live

Watch Verigate earn USDC for verification and spend USDC to contain threats. Real transactions on Base Sepolia.

terminal Execution Log
receipt_long Receipt Inspector
link Chain Integrity

Security Treasury

Three Circle Agent Wallets: Customer ops wallet, Verigate Security Treasury, and Evidence Validator. Each with independent spending policies.

USDC CircleCircle Agent Stack Base L2
Total Governed
--
USDC on Base
Active Wallets
--
loading
Pending Txs
0
all settled
Network
--
--

Managed Wallets

Loading wallets from Circle...
Wallet Roles in the Security Economy
Customer Agent
Pays Verigate for protection
$0.05 per verification
$0.02 per compliance report
$0.10 per incident report
Verigate Treasury
Earns and spends USDC autonomously
Max $0.02/incident spend
$1.00/day spending cap
Allowlisted recipients only
Evidence Validator
Separately keyed, deployed, and signed; currently team-operated
$0.02 per validation
Separate wallet + Ed25519 signing key
x402-compatible endpoint

Security Agent Network

6 Active Nodes | Verigate Security Treasury active

Download PDF Report

Proof Explorer

Every receipt Verigate earned USDC for. Tamper-evident, independently verifiable.

Network Live

Recent Receipts

0 receipts
Receipt ID Decision Tx Hash Seq
No receipts yet. Run a demo to generate receipts.

Verification Detail

verified

Select a receipt to view verification details

security
Chain Integrity Summary
State: Awaiting Data
Merkle Root
--

Evidence Vault

Cryptographically signed evidence bundles designed for underwriting, claims review, and audit workflows. Every bundle is independently verifiable.

Bundles Stored
--
On Google Cloud Storage
Signature Integrity
verified All Verified
Ed25519 signatures + Merkle proofs
Anchor Chain
Base Sepolia
Public key anchored on-chain
inventory_2 Proof Bundles
folder_open

No proof bundles yet

Run a demo to generate your first bundle

info All bundles are stored on Google Cloud Storage and independently verifiable using the public key anchored on Base Sepolia. Each bundle contains receipts, Merkle proofs, compliance reports, and isolation records.

Compliance & Audit

Verigate earns $0.02 USDC per compliance report. Automated regulatory analysis powered by Gemini over real USDC spend data.

Internal readiness assessment - not certification. Scores reflect control coverage, not regulatory approval.
policy EU AI Act Compliance
-- /100
check_circleHuman oversight documented
check_circleTransparency requirements met
check_circleRisk assessment complete
check_circleRecord-keeping verified
check_circleData governance enforced
Run a demo to generate audit
shield NIST AI RMF
Govern--%
Map--%
Measure--%
Manage--%
Run a demo to generate scores
Verification
Run a demo to generate verification results.
Auditor Report
Run a demo to generate compliance report.

Audit Trail

Run a demo or load data to populate the audit trail.

Export & Verification

download

Export Receipt Chain

Download the complete hash-linked receipt chain as JSON for offline verification.

picture_as_pdf

Generate PDF Report

Gemini-generated compliance narrative over real USDC spend data. EU AI Act + NIST AI RMF aligned.

Generate PDF
gavel

Dispute Resolution Kit

Self-contained proof chain for third-party arbiters. Zero trust, zero network access needed.

Export Kit

Quick Start

Base URL: verigate.cloud download OpenAPI Spec

Screen any agent payment before it executes. One POST, one response. Three possible verdicts:

APPROVE STEP_UP DENY

Verigate scores risk, checks sanctions, detects prompt injection, evaluates behavioral anomalies, and returns a signed receipt. On uncertain cases (STEP_UP), it autonomously purchases independent evidence before deciding.

Every decision produces an Ed25519-signed, hash-linked receipt anchored to BASE mainnet.

Request
POST
# Screen a payment before executing
curl -X POST https://verigate.cloud/api/check \
  -H "Content-Type: application/json" \
  -d '{
    "payee": "0x742d35Cc6634C0532925a3b8",
    "amount": "12.50",
    "service": "market-data-api",
    "reason": "Fetch latest ETH price data"
  }'
Response
200 OK
{
  "decision": "APPROVE",
  "score": 12,
  "band": "LOW",
  "confidence": 0.95,
  "rationale": "Low risk — known vendor, within cap",
  "contributions": [
    {"category": "novel_counterparty", "weight": 12}
  ],
  "enforcement": {"status": "OK"}
}

Authentication

Verigate is currently in open beta. No API key required. All endpoints accept unauthenticated requests.

Payment is per-call via USDC on Base. The screening fee ($0.05) is collected either upstream via x402 Gateway nanopayments or via direct wallet transfer.

Production
API keys and rate limiting will be available when Verigate exits beta. Payment via x402 Gateway nanopayments provides implicit authentication.
x402 Payment Flow
# Step 1: Call endpoint — get 402 + payment requirements
curl https://verigate.cloud/x402/security-check

# Step 2: Pay via Circle Gateway (gas-free)
circle services pay \
  https://verigate.cloud/x402/security-check \
  --address 0xYOUR_WALLET \
  --chain BASE-SEPOLIA

# Step 3: Endpoint returns security verdict

Screen Payment

POST /api/check

Submit a payment intent for risk assessment. Returns a verdict, risk breakdown, enforcement state, and signed receipt.

Request Body
payeestringrequired
Destination wallet address (0x...)
amountstringrequired
USDC amount (e.g. "12.50")
servicestringoptional
Service being paid for
reasonstringoptional
Why the agent is making this payment
tierstringoptional
"screening" ($0.05, default) or "governance" ($0.15)
session_idstringoptional
Session ID for circuit breaker tracking
Response Fields
decisionstring
APPROVE | STEP_UP | DENY
scoreinteger
Risk score 0-100
bandstring
LOW | MEDIUM | HIGH | CRITICAL
contributionsarray
Risk factor breakdown with category, weight, detail
governanceobject
Forensic intel + policy recommendations (on DENY)
enforcementobject
Circuit breaker state: OK | THROTTLED | SUSPENDED
Request
POST
curl -X POST https://verigate.cloud/api/check \
  -H "Content-Type: application/json" \
  -d '{
    "payee": "0x9a1B2c3D4e5F6789...",
    "amount": "8.00",
    "service": "analytics-subscription",
    "reason": "Monthly renewal",
    "tier": "governance"
  }'
Response — DENY (governance tier)
DENY
{
  "decision": "DENY",
  "score": 95,
  "band": "CRITICAL",
  "confidence": 0.98,
  "contributions": [
    {"category": "injection", "weight": 30},
    {"category": "amount_outlier", "weight": 20}
  ],
  "governance": {
    "tier": "governance",
    "fee": "$0.15",
    "forensic": {
      "severity": "CRITICAL",
      "root_cause": "Prompt injection via...",
      "attack_vector": "tool_output_poisoning",
      "containment_actions": ["..."],
      "estimated_loss_prevented": "$50.00"
    },
    "recommendations": {
      "policy_changes": [{
        "change": "add_to_blocklist",
        "rationale": "Known attack addr..."
      }]
    }
  },
  "enforcement": {
    "status": "OK",
    "denials_in_window": 1
  }
}

Response Types

Six possible response shapes depending on the verdict and enforcement state.

Type What triggers it Key fields Cost
APPROVE Low risk, no uncertainty decision + risk + receipt $0.05
STEP_UP → APPROVE Uncertain, evidence confirmed safe + step_up.validator_verdict + gemini_reasoning $0.07
STEP_UP → DENY Uncertain, evidence confirmed dangerous + governance + settlement proof $0.07
DENY High risk, unambiguous + governance intel + receipt $0.05
REPLAY Same denied intent re-submitted replay: true + enforcement $0.00
BREAKER 5 denials → throttle, 10 → suspend enforcement.status: SUSPENDED $0.00
POST /api/agent/handle

Event-driven agent endpoint. Submit a payment event and Verigate evaluates economic rationality: is the evidence worth buying?

Body
payeestringrequired
amountstringrequired
servicestringoptional

Returns economic rationality stats at GET /api/agent/stats

Request
POST
curl -X POST https://verigate.cloud/api/agent/handle \
  -H "Content-Type: application/json" \
  -d '{
    "payee": "0x742d35Cc...",
    "amount": "0.50",
    "service": "price-feed"
  }'
POST /api/synthesize-policy

Natural language to Circle wallet policy. Describe what you want in plain English, Gemini generates a structured Circle-compatible policy.

Body
descriptionstringrequired
Natural language policy description
Request
POST
curl -X POST https://verigate.cloud/api/synthesize-policy \
  -H "Content-Type: application/json" \
  -d '{
    "description": "Allow up to $10 per tx,
     max 5 tx per hour, only to known
     vendors on the allowlist"
  }'
POST /api/negotiate-scope

Cross-agent scope negotiation. Two agents propose their policies, Gemini negotiates a mutually acceptable scope.

Body
agent_a_policystringrequired
agent_b_policystringrequired
Request
POST
curl -X POST https://verigate.cloud/api/negotiate-scope \
  -H "Content-Type: application/json" \
  -d '{
    "agent_a_policy": "Max $5/tx, data APIs only",
    "agent_b_policy": "Max $20/tx, any service"
  }'
POST /api/carrier/pull $0.25

x402-paid proof pull. Carrier agents pay $0.25 USDC for the full signed evidence bundle. Requires a valid consent grant and payment proof.

Body
carrier_idstringrequired
bundle_refstringrequired
tx_hashstringrequired
x402 settlement tx proving $0.25 payment
purposestringoptional
Default: "underwriting"
Request
POST
curl -X POST https://verigate.cloud/api/carrier/pull \
  -H "Content-Type: application/json" \
  -d '{
    "carrier_id": "carrier-agent-1",
    "bundle_ref": "bundle_abc123",
    "tx_hash": "0xdfcd6729a28fe...",
    "purpose": "underwriting"
  }'
No payment
402
{
  "error": "Payment required: $0.25 USDC via x402. Provide tx_hash."
}

Python SDK

Drop-in screening for any Python agent. Works with LangChain, CrewAI, OpenAI function calling, or plain Python.

screen() Parameters
paymentdictrequired
Keys: to/payee, amount, service/purpose, from, currency
base_urlstringoptional
Default: VERIGATE_URL env or https://verigate.cloud
Returns
verdictstring
risk_scoreint
reasoningstring
signalslist
feestring
Python SDK
from verigate import screen

result = screen({
    "from": "procurement-agent",
    "to": "0x742d35Cc6634C053...",
    "amount": 500,
    "currency": "USDC",
    "purpose": "SaaS subscription renewal"
})

if result["verdict"] == "APPROVE":
    execute_payment()
elif result["verdict"] == "STEP_UP":
    # Verigate is buying evidence — wait
    wait_for_confirmation()
else:
    log_blocked(result["reasoning"])

Framework Integrations

Plug Verigate into your existing agent framework with one import.

LangChain
Tool
from verigate.integrations import VerigateToolkit

toolkit = VerigateToolkit(
    base_url="https://verigate.cloud"
)
agent = initialize_agent(
    tools=toolkit.get_tools(), llm=llm
)
CrewAI
Tool
from verigate.integrations import VerigateCrewTool

screen_tool = VerigateCrewTool(
    base_url="https://verigate.cloud"
)
agent = Agent(
    role="Purchasing Agent",
    tools=[screen_tool]
)
OpenAI Function Calling
Schema
from verigate.integrations import verigate_openai_schema

response = openai.chat.completions.create(
    model="gpt-4",
    tools=[verigate_openai_schema()],
    messages=messages
)
BlockRun / x402
Middleware
from verigate import screen

def x402_middleware(payment):
    v = screen(payment)
    if v["verdict"] != "APPROVE":
        raise BlockedPayment(v)
    return route(payment)

MCP Server

Connect Claude Desktop, Cursor, or any MCP-compatible client directly to Verigate. Tools available:

check_payment
Full risk assessment with decision
get_risk_score
Quick pre-flight risk check
get_receipt
Retrieve a signed receipt by hash
get_evidence_bundle
Full audit trail for underwriting
check_payment_x402
Production flow with Gateway settlement
get_gateway_status
Gateway facilitator connectivity
Claude Desktop
// claude_desktop_config.json
{
  "mcpServers": {
    "verigate": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://verigate.cloud/mcp"
      ]
    }
  }
}
Standalone
# Run as standalone MCP server (stdio)
python -m verigate.mcp_server

Three Products, Three Prices

Every piece of intelligence Verigate produces is a product someone pays for. Pay per use via USDC. No monthly minimums.

Screening
$0.05/ check

Decision + risk score + forensic summary + recommendation change types.

APPROVE / STEP_UP / DENY verdict
Risk score + per-signal contributions
Enforcement state (circuit breaker)
Ed25519-signed receipt
Replay detection (free re-denials)
Governance
Recommended
$0.15/ check

Everything in Screening, plus full forensic analysis and actionable recommendations with rationale.

Everything in Screening
Full forensic narrative
Attack vector + root cause analysis
Containment actions
Policy changes with rationale
Loss prevention estimate
Evidence
$0.25/ pull

Full signed proof bundle for carrier underwriting. Paid via x402 Gateway nanopayments.

Compliance report (EU AI Act + NIST)
ERC-8004 reputation event
Settlement binding + tx proof
Consent-gated access
Carrier self-wake investigation

How Payment Works

For Enterprise Agents

Call POST /api/check with tier: "screening" or tier: "governance". Fee is collected via x402 Gateway nanopayments (gas-free, sub-cent USDC) or direct wallet transfer.

For Carrier Agents

Call POST /api/carrier/pull with a tx_hash proving $0.25 USDC payment. Requires a valid consent grant. Returns the full signed evidence bundle.

Settlement

All payments settle in USDC on Base mainnet via Circle Agent Wallets. No gas fees. No monthly minimums. No signup. Pay per use.

Volume Pricing

Tier Screening Governance Evidence Target
Standard $0.05 $0.15 $0.25/pull Individual agents, dev testing
Volume $0.02 $0.08 $0.25/pull >1,000 checks/day, API contract
Enterprise Custom Custom Per-insured/period Carrier-integrated, SLA-backed
info Hackathon demo only - this page is for judges evaluating the Circle Agentic Economy Prize. github.com/4KInc/verigate

Verigate lets an agent pay a small, policy-limited USDC amount for evidence before deciding whether to release a larger, risky payment. Gemini helps interpret the evidence, deterministic controls make the decision, and Circle settles it.

Proof Path

1
Payment Intent Received
Enterprise agent submits a payment to an unfamiliar counterparty.
Artifact: intent_hash — SHA-256 of payee + amount + reason
2
Deterministic Risk Screening
OFAC/SDN sanctions check, amount anomaly detection, behavioral signals. Score ≥ 60 triggers STEP_UP.
Artifact: policy_hash — compiled Circle wallet policy · View policies
3
STEP_UP — Treasury Buys Evidence
Treasury autonomously spends $0.02 USDC to pay the validator for independent analysis. Bounded by spending policy.
Evidence Budget Guard
Evidence spend: $0.02
Max per check: $0.25
Protected value: $25–$4500
STEP_UP is economically justified: spending $0.02 to protect a payment 1,250–225,000× larger.
4
Validator Returns Signed Verdict
Gemini analyzes evidence context. Validator applies its own deterministic threshold to Gemini's structured output, then signs with Ed25519.
Artifact: Ed25519 signature over verdict + intent_hash
Validator Disclosure
Separately keyed, deployed, and signed; currently team-operated. Gemini is advisory/structured evidence analysis — never the final payment authorizer.
5
Protected Payment — Released or Blocked
APPROVE → payment executes via Circle. DENY → PAYMENT_BLOCKED, $0 reaches the attacker. Validator unavailable → fail-closed (blocked).
Artifact: protected_payment.status + funds_moved_to_attacker flag
6
Signed Receipt + On-Chain Proof
Hash-chained receipt binding intent, policy, verdict, and settlement. Independently verifiable.
Artifacts: receipt_hash (SHA-256) · verify_url · Treasury on Basescan open_in_new

Verify on Base Mainnet

Live operational history — real USDC transactions, independently verifiable. Treasury balances are intentionally minimized; historical proof is on-chain.

Run It Yourself

Autonomous STEP_UP
Full cycle: evidence purchase + validator + protected payment
Attack → $0 Loss
Sanctioned payee + injection attempt
Live Demo
Three-agent animated loop
Wallet Policies
Circle spending rules (live)
Screen a Payment
Payee
Amount (USDC)
Service
Reason
Disclosures
Validator: Separately keyed, deployed, and signed; currently team-operated.
Gemini: Advisory/structured evidence analysis; never the final payment authorizer.
Carrier revenue: Monetization rail and design-partner hypothesis; not revenue.
Compliance: Compliance mapping, not certification or legal compliance guarantee.
Evidence vault: Designed for underwriting, claims review, and audit workflows; not accepted by insurers/regulators.
Data: Basescan links are live mainnet history. Dashboard metrics are live operational data. Treasury balances are intentionally minimized; see on-chain history for proof.
Gemini advises; deterministic policy authorizes; Circle settles.
github.com/4KInc/verigate / BlockIntel, Inc. / Apache-2.0
verified

Public Receipt Verifier

Paste any Verigate receipt hash to independently verify its cryptographic integrity, chain position, and settlement binding.

Receipt Hash
Verification is performed server-side using the operator's Ed25519 public key.
Receipt hashes are available on the Receipts tab or from /proof/ pages.