PactCompute — Agent Compute Services

Complete compute infrastructure from code execution to VM hosting for AI Agents, enabling autonomous purchase, configuration, and use of compute resources.

┌─────────────────────────────────────────────────────────────────┐
│                  PactCompute Service Architecture                │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│     ┌─────────────────┐         ┌─────────────────┐             │
│     │   Serverless    │         │ Container Service│            │
│     │Functions-as-Svc │         │   Docker/K8s    │            │
│     ├─────────────────┤         ├─────────────────┤             │
│     │ • Pay per exec  │         │ • Persistent    │             │
│     │ • ms cold start │         │ • Auto-scaling  │             │
│     │ • Multi-language│         │ • Port exposure │             │
│     └─────────────────┘         └─────────────────┘             │
│                                                                  │
│     ┌─────────────────┐         ┌─────────────────┐             │
│     │    Linux VM     │         │ GPU Acceleration│             │
│     │ Virtual Machine │         │AI Inference/Train│            │
│     ├─────────────────┤         ├─────────────────┤             │
│     │ • Full root     │         │ • CUDA/ROCm    │             │
│     │ • Custom env    │         │ • HPC          │             │
│     │ • SSH/SFTP      │         │ • Per GPU-hour │             │
│     └─────────────────┘         └─────────────────┘             │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

Dual Token Payment Mode

PactCompute is the first application in the PACT ecosystem to support dual tokens, balancing stability and ecosystem incentives:

Payment Method	Price Coefficient	Advantage	Use Case
USDC	1.0x (standard)	Price stable, no exchange risk	New users, budget-sensitive Agents

Billing Example:

Service: Medium VM (2 core 4GB)
Standard Price: $0.10/hour (USDC)
Payment Choice:
- USDC payment: $0.10/hour × 24 hours = $2.40/day

Resource Pricing Table

Resource Type	Configuration	USDC Price
Serverless	1GB memory, 100ms	$0.00001/call
Container - Small	1 core 2GB	$0.05/hour
Container - Medium	2 core 4GB	$0.10/hour
Container - Large	4 core 8GB	$0.20/hour
VM - Small	2 core 4GB 50GB	$0.10/hour
VM - Medium	4 core 8GB 100GB	$0.25/hour
VM - Large	8 core 16GB 200GB	$0.50/hour
GPU - T4	16GB VRAM	$0.60/hour
GPU - A100	40GB VRAM	$2.50/hour

Technical Capabilities

1. Serverless Functions

Features:
- Support Python, Node.js, Go, Rust
- Auto-scaling (0 → 1000+ concurrent)
- Built-in dependency management
- HTTP/WebSocket triggers
- Scheduled tasks (Cron)

Billing Unit:
- GB-seconds (memory × time)
- Request count

2. Container Services

Features:
- Support any Docker image
- Persistent storage volumes
- Environment variables and secrets management
- Load balancing
- Auto health checks

Billing Unit:
- Per hour
- Includes network traffic (50GB/month)

3. Linux Virtual Machines

Features:
- Ubuntu 22.04 / Debian 12
- Full root privileges
- Public IP address
- SSH key access
- Snapshots and backups

Billing Unit:
- Per hour
- Storage per GB/month

4. GPU Computing

Features:
- NVIDIA T4 / A100
- CUDA 12.x / PyTorch / TensorFlow
- Jupyter Notebook environment
- Pre-installed AI frameworks

Billing Unit:
- Per GPU-hour
- Includes base storage

X402 Protocol Integration

PactCompute deeply integrates the X402 gasless payment protocol:

1

Agent requests compute resources via SDK:

• Select payment method: USDC

• No manual gas payment needed

2

X402 protocol handles payment:

• Meta-transaction

• Relayer sponsors gas

• Smart contract deducts from Agent balance

3

Compute resources allocated:

• < 10s startup (Container/VM)

• < 1s startup (Serverless)

• Agent receives access credentials

4

Pay-as-you-go, auto settlement:

• Hourly settlement

• Auto-pause on insufficient balance

• Auto-resume after top-up

Comparison with Traditional Cloud:

Feature	Traditional Cloud (AWS/GCP)	PactCompute
Registration	Credit card, KYC required	Agent wallet = registration
Payment	Credit card, monthly billing	Crypto, real-time settlement
Gas Fees	N/A	X402 sponsored, transparent
Min Billing	Per minute/hour	Per second (Serverless)
Agent-Friendly	❌ Designed for humans	✅ Agent-first design

Synergy with PactTasks

Compute tasks can seamlessly combine with physical tasks:

Scenario: Agent needs to analyze on-site photos

Traditional Flow:
1. Agent publishes physical task → Worker takes photos → Agent downloads
2. Agent runs analysis on own server → Time-consuming

PactCompute Flow:
1. Agent creates Serverless function (image analysis)
2. Agent publishes physical task, sets callback
3. Worker uploads photo → Auto-triggers Serverless
4. Analysis results return directly to Agent

Advantage: One-stop service, no need for Agent to build own infrastructure