Welcome to ZeroQuant

ZeroQuant is an AI-native DeFi vault platform that enables autonomous asset management through intelligent agents. Build, deploy, and manage trading strategies that execute themselves using natural language commands.

What is ZeroQuant?

ZeroQuant provides secure, programmable vaults (Upgradeable Vault Accounts) that AI agents can control to execute DeFi operations. Think of it as Account Abstraction meets AI Agents — your trading strategies can make decisions and execute transactions autonomously while you maintain full control through permission management.

Key Features

• AI-Native Design - First-class support for LangChain, Python AI agents, and Mastra framework
• Battle-Tested Security - Built with OpenZeppelin contracts and comprehensive permission system
• Gas Optimized - Batch operations and L2-optimized execution
• Developer Friendly - TypeScript SDK with full type safety and Python SDK with async support
• Multi-Chain - Deploy on any EVM-compatible network
• Transparent - All operations on-chain with full audit trail

Quick Start

Get started in under 5 minutes:

# Install the SDK
npm install @zeroquant/sdk ethers@6

# Or use Python
pip install zeroquant

Create Your First Vault

TypeScript

import { ZeroQuantClient } from '@zeroquant/sdk';
import { ethers } from 'ethers';

const provider = new ethers.JsonRpcProvider(process.env.RPC_URL);
const signer = new ethers.Wallet(process.env.PRIVATE_KEY, provider);

const client = new ZeroQuantClient(
  provider,
  {
    owner: signer.address,
    factoryAddress: '0x...',
    permissionManager: '0x...'
  },
  signer
);

// Create a new vault
const vaultAddress = await client.createVault(123);
console.log(`Vault created at: ${vaultAddress}`);

Python

from zeroquant import ZeroQuantClient, VaultConfig

config = VaultConfig(
    owner=owner_address,
    factory_address=factory_address,
    permission_manager=permission_manager
)

client = ZeroQuantClient(
    provider=rpc_url,
    config=config,
    private_key=private_key
)

# Create a new vault
vault_address = await client.create_vault(123)
print(f"Vault created at: {vault_address}")

Use Cases

Autonomous Trading

Deploy AI agents that analyze market conditions and execute trades automatically:

• Automated arbitrage bots
• Market-making strategies
• Technical analysis-based trading
• Sentiment-driven strategies

Yield Optimization

Maximize returns by automatically moving assets between protocols:

• Auto-compounding yield farms
• Dynamic liquidity provision
• APY chasing strategies
• Risk-adjusted yield optimization

Portfolio Management

Let AI manage your crypto portfolio:

• Automated rebalancing
• Risk management
• Tax-loss harvesting
• Multi-strategy diversification

Architecture

┌─────────────────────────────────────────────┐
│           AI Agent Layer                    │
│  (LangChain, Python, Mastra)               │
└────────────────┬────────────────────────────┘
                 │
┌────────────────▼────────────────────────────┐
│           SDK Layer                         │
│  (@zeroquant/sdk, zeroquant)               │
└────────────────┬────────────────────────────┘
                 │
┌────────────────▼────────────────────────────┐
│        Smart Contract Layer                 │
│  (UVAFactory, UVAAccount, Intents)         │
└────────────────┬────────────────────────────┘
                 │
┌────────────────▼────────────────────────────┐
│           Blockchain                        │
│  (Ethereum, Arbitrum, Optimism, etc.)      │
└─────────────────────────────────────────────┘

Why ZeroQuant?

For Developers

• Type-Safe SDK - Full TypeScript support with comprehensive type definitions
• Python Support - Native async/await with Pydantic models
• Rich Documentation - Comprehensive guides, API references, and examples
• Active Development - Regular updates and improvements

For Traders

• Autonomous Execution - Set strategies once, let agents execute
• Risk Management - Fine-grained permission controls
• Transparency - All operations on-chain and auditable
• Gas Efficient - Batch operations save on transaction costs

For AI Researchers

• Pre-built Tools - LangChain tools ready to use
• Flexible Integration - Works with any AI framework
• State Management - Built-in memory for agent context
• Real-World Impact - Test strategies with real assets

Next Steps

Learn the Basics

Understand vaults, permissions, and intents

SDK Overview →

Build with AI

Integrate with LangChain, Python, and Mastra

AI Agents →

---

Ready to build the future of autonomous DeFi? Let's get started.