P
Privos
Live on Arbitrum One — Powered by Aave V3

The DeFi wallet built for agents

Self-custody lending wallet on Aave V3 with ERC-4337 account abstraction. Give your Claude, GPT, or custom agent a DeFi wallet with scoped keys, spending policies, and MCP tools.

Works with:Claude MCPOpenAI AgentsLangChainCrewAIAutoGPTCustom Agents
Start BuildingExplore Features
9
MCP Tools
10
Policy Constraints
$0
Gas Fees
< 1s
API Response

Features

Everything an agent needs

Six modules designed for autonomous DeFi operations, all policy-gated and auditable.

Authentication

Agent Delegation Keys

Create scoped API keys for AI agents with read, trade, or full-access permissions. Keys are SHA-256 hashed, auto-expire, and instantly revocable.

Safety

Spending Policies

10 programmable constraints including daily limits, asset whitelists, health factor floors, LTV caps, and time windows. "Most restrictive wins" merging.

Automation

Autonomous Execution

Auto-repay when health factor drops, auto-rebalance for better yields, and auto-compound earnings. All policy-gated and fully auditable.

AI Native

MCP Server

9 tools and 2 resources for the Model Context Protocol. Any MCP-compatible AI agent can read positions, check health, and build transactions.

M2M Commerce

x402 Payments

HTTP 402 Payment Required protocol for machine-to-machine commerce. Agents pay USDC on Arbitrum for premium analytics and strategy generation.

Multi-Chain

Cross-Chain Bridging

Bridge USDC and ETH from Base to Arbitrum via Stargate V2. Deposit from Coinbase directly into your Aave positions with a single flow.

Use Cases

Built for agent developers

Whether you're building an MCP tool, a trading bot, or an agent swarm — Privos gives your agents a DeFi wallet with guardrails.

MCP Agent Developers

Connect any MCP-compatible agent (Claude, Cursor, Windsurf) to DeFi via 9 tools and 2 resources. Read positions, check health, build transactions.

Claude Desktop with MCPCursor IDE agentsCustom MCP clients

Autonomous Trading Bots

Build yield-farming bots that auto-compound, auto-rebalance, and auto-repay. Spending policies keep them within your risk tolerance.

Yield optimization agentsHealth factor guardiansRebalancing strategies

AI Agent Frameworks

LangChain, CrewAI, AutoGPT, and OpenAI Agents SDK all work via the REST API. Authenticate with X-Agent-Key and use any endpoint.

LangChain tool integrationCrewAI DeFi crewsOpenAI function calling

Machine-to-Machine Payments

Agents pay for premium analytics via x402 (HTTP 402). USDC on Arbitrum, single-use receipts, no subscriptions. True agent-native commerce.

Pay-per-call analyticsStrategy generationCross-agent billing

How It Works

From key creation to autonomous DeFi

01

User creates an agent key

The wallet owner authenticates with Privy (Google, Apple, or Email) and creates a delegation key with specific scopes and limits. The raw key is shown once.

POST /agent/keys
{
  "name": "My AI Agent",
  "scopes": ["trade"],
  "maxDailySpendUsd": 500,
  "allowedAssets": ["USDC", "WETH"],
  "expiresInDays": 7
}
02

Agent authenticates with the key

The agent includes the key in the X-Agent-Key header. The API validates scope, checks policies, and populates the session transparently.

curl -H "X-Agent-Key: prv_agent_a1b2..." \
  https://api.privos.app/aave/positions

// Or use MCP tools:
check_health({
  wallet_address: "0x..."
})
03

Agent operates within guardrails

Every operation passes through the policy engine. 10 constraint types are merged using "most restrictive wins." Clear allow/deny with reasons.

{
  "allowed": true,
  "warnings": [
    "Daily spend at 80% of $500 limit"
  ],
  "evaluatedPolicies": [
    "Conservative", "agent-key:uuid"
  ]
}
04

Autonomous execution protects assets

The engine runs every 60 seconds. Auto-repay on low health, auto-rebalance for better yields, auto-compound earnings. All policy-gated.

{
  "executionType": "auto_repay",
  "status": "completed",
  "healthFactorBefore": "1.15",
  "healthFactorAfter": "1.85",
  "description": "Repaid 500 USDC"
}

Security

Five layers of defense

Self-custody preserved at every layer. The API never holds private keys. All transactions are unsigned data that your ERC-4337 wallet signs.

1TransportHTTPS (TLS 1.3 via Cloudflare)
2IdentityAgent key (SHA-256) or Privy JWT
3Scoperead / trade / full-access hierarchy
4Policy10-constraint spending policy engine
5AuditEvery action logged and traceable

Key Security Properties

  • Agent keys stored as SHA-256 hashes (never plaintext)
  • Keys auto-expire (max 30 days) and are instantly revocable
  • Daily spending limits enforced at key and policy level
  • Webhook replay protection (5-min timestamp window)
  • x402 receipts are single-use (replay-proof)
  • Circuit breaker prevents RPC failure cascades
  • Autonomous execution has mutex, cooldowns, and pause/resume

Architecture

Agent infra meets DeFi infra

Model Context Protocol

9 tools + 2 resources. The open standard for connecting AI agents to external systems. First-class MCP server built in.

Aave V3

The largest DeFi lending protocol. Supply, borrow, and earn yield with $10B+ in battle-tested smart contracts on Arbitrum.

ERC-4337

Account abstraction via ZeroDev. Smart wallets with gasless transactions, batched operations, and programmable access control.

Arbitrum One

Ethereum L2 rollup. Same security guarantees, 10x lower gas costs. Where agents execute DeFi transactions.

x402 Protocol

HTTP 402 Payment Required for machine-to-machine commerce. Agents pay with USDC, no accounts needed. The internet's native paywall.

Base + Stargate

Coinbase's L2 chain bridged via Stargate V2. Deposit USDC or ETH from Coinbase directly into your Aave positions.

Give your agent a wallet

Create an agent key, connect via MCP or REST API, and let your agent supply, borrow, and earn yield on Aave — all within the guardrails you define.

Read the DocsAPI Reference