VELA — Autonomous DeFi Portfolio Manager

VELA is a non-custodial AI-agent-powered portfolio manager built on Arbitrum. Users deposit USDC into an ERC-4626 smart vault, set a strategy in plain English, and three specialized AI agents manage their capital 24/7 — farming yield on Aave V3, rebalancing positions, and defending against risk — without a single wallet popup or manual transaction.

The problem VELA solves:

Every DeFi user with idle capital faces the same reality: yield opportunities exist across Aave, Uniswap, and stablecoin pools — but capturing them requires monitoring 24/7, rebalancing constantly, and executing dozens of transactions per week. Most people either leave capital doing nothing or manage positions manually and still miss the windows. The few automated solutions that exist are custodial — you hand over your keys.

VELA solves this without taking custody of a single token.

How it works:

1. Connect wallet and deposit USDC into the VELA Smart Vault (ERC-4626, Arbitrum Sepolia)

2. Choose a strategy — Stable Income, Balanced Growth, Aggressive Yield — or write custom rules in plain English

3. Three AI agents powered by Groq (Llama 3.3 70B) activate and manage your portfolio autonomously

4. Watch every agent decision logged in real time on the dashboard and permanently on Arbitrum

5. Withdraw at any time — no lockups, no approval needed

   ---

The Three Agents:

🔵 VELA Scout — Market Intelligence Reads Chainlink ETH/USD price feeds, Aave V3 reserve APY rates, gas prices, and vault state every cycle. Produces a structured market assessment with sentiment, risk level, opportunity score, and allocation recommendation.

🟢 VELA Allocator — Portfolio Execution Receives Scout's market report, evaluates it against the user's active strategy, decides whether to deploy capital to Aave or rebalance, and executes real onchain transactions. Every transaction carries a full LLM-generated reasoning string committed permanently to VelaAgentRegistry on Arbitrum.

🟡 VELA Sentinel — Risk Guardian Runs independently every 2 minutes. Monitors ETH price movement, Aave protocol health, and vault exposure. Can trigger an emergency exit that pulls all funds from Aave back to liquid USDC instantly if catastrophic conditions are detected.

What makes VELA genuinely different:

Unlike most hackathon DeFi projects that wire a UI to a smart contract, VELA's agents actually execute. The Allocator calls agentDeployToAave() with a real transaction on Arbitrum Sepolia, and that transaction permanently carries the LLM's reasoning for the decision. Any judge can open VelaAgentRegistry on Arbiscan and read every decision the agents have ever made — agent address, action type, amount, full reasoning, timestamp.

Non-custodial is enforced at the smart contract level: agents are registered wallets with scoped permissions. They can deploy to Aave and log rebalance decisions. They cannot transfer user funds to external addresses — this is not policy, it is code.

Live App: https://vela-ten-roan.vercel.app
GitHub: https://github.com/0xkinno/vela

Smart Contracts (Arbitrum Sepolia):

Architecture:

User Interface (React + Vite + Wagmi)
        │
        │ WebSocket + REST
        ▼
Agent Runner (Node.js — Railway)
├── VELA Scout     → reads Chainlink + Aave → market report
├── VELA Allocator → evaluates strategy → executes onchain txns
└── VELA Sentinel  → monitors risk → emergency exit if needed
        │
        │ viem + agent private key
        ▼
Arbitrum Sepolia
├── VelaVault.sol       — ERC-4626 non-custodial vault
├── VelaAgentRegistry.sol — agent auth + permanent execution logs
├── VelaStrategy.sol    — user strategy storage + 3 presets
├── Aave V3             — yield source
└── Chainlink           — price feeds

Agent Decision Flow:

Every 5 minutes:

Scout reads → ETH price, Aave APY, vault TVL, gas price
                    │
                    ▼
Allocator checks → drift vs strategy target?
                    risk level LOW or MEDIUM?
                    minimum 10% liquid maintained?
                    │
              ┌─────┴──────┐
              ▼            ▼
          EXECUTE        HOLD
          onchain tx      log reasoning only
          + reasoning
                    │
                    ▼
         VelaAgentRegistry.validateAndLog()
         Reasoning → permanent Arbitrum record

Every 2 minutes (Sentinel):
ETH drop > 20%? Aave APY = 0? → EMERGENCY EXIT → all funds → USDC

Strategy System:

Custom example: "Keep 60% in stablecoins during high volatility. Exit to USDC if ETH drops 15% in 24h. Never allocate more than 20% to a single pool."

Tech Stack:

VELA was built from scratch during the buildathon — zero prior codebase.

Week 1 — Smart Contract Foundation

Designed and deployed three production Solidity contracts to Arbitrum Sepolia:

• VelaVault.sol — ERC-4626 non-custodial vault with full deposit, withdrawal, and share accounting. Integrated with Aave V3 Pool interface for real yield deployment. Agent permission system built in — agents can only operate within vault bounds, cannot withdraw to external addresses.

• VelaAgentRegistry.sol — On-chain agent authentication and permanent execution log. Every agent action validated here before execution. Per-transaction value caps enforced. Full log history queryable by anyone on Arbiscan.

• VelaStrategy.sol — User strategy storage with three preset templates (Stable Income, Balanced Growth, Aggressive Yield) and fully custom plain-English strategies. Agents read active strategy before every decision cycle.

All contracts compiled with Solidity 0.8.24 (EVM: Cancun), OpenZeppelin v5, and deployed via Hardhat.

Week 2 — AI Agent System

Built three autonomous Node.js agents powered by Groq (Llama 3.3 70B):

• Scout reads Chainlink price feeds, Aave V3 reserve APY, vault metrics, and gas prices. Outputs structured JSON market assessment every 5 minutes.

• Allocator receives Scout's report, evaluates it against the user's strategy, decides whether to execute, and calls the vault contracts directly via viem. Every executed transaction includes a full LLM-generated reasoning string stored permanently onchain.

• Sentinel runs every 2 minutes independently, monitors ETH price movement and protocol health, and can trigger emergency exit.

Agent server runs Express + WebSocket, broadcasting every decision to the frontend dashboard in real time.

Week 3 — Frontend + Integration

Built complete React + Vite frontend with Wagmi v2 wallet integration:

• Landing page with live agent feed (real-time WebSocket log updating every ~2 seconds)

• Dashboard with portfolio metrics, agent status cards, live decision feed, and portfolio chart

• Smart Vault page with deposit/withdraw flow, ERC-4626 share accounting, and live vault metrics from Arbitrum

• Strategy page with preset selector, custom instruction textarea, risk parameter controls, and allocation preview

• Agent Logs page with full onchain decision history, per-agent filtering, and CSV export

Multi-wallet modal supporting MetaMask, Rabby, OKX Wallet, Coinbase Wallet, and WalletConnect.

Frontend deployed to Vercel.
Agent runner deployed to Railway.

What actually works end-to-end today:

• Connect wallet on Arbitrum Sepolia

• View live vault metrics read directly from deployed contracts

• Agent cycle runs every 5 minutes - Scout → Allocator → Sentinel

• Every agent decision appears in the live feed and in Agent Logs

• Agents have executed real onchain rebalance log transactions on Arbitrum Sepolia

• Deposit and withdraw flow wired to VelaVault contract

• Strategy page saves to VelaStrategy contract

Not yet raised. Solo bootstrapped build.

VELA is currently focused on protocol validation, testnet deployment, and buildathon feedback.
Open to Arbitrum ecosystem grants and early conversations with DeFi-focused investors post-buildathon.

The protocol addresses a clear and large market: every DeFi user with idle capital who lacks the time or expertise to actively manage yield positions.
The non-custodial architecture and onchain transparency make it fundable; no trust assumptions, fully auditable.