Qevor is an agent-first, multi-chain payment workspace for teams, communities, and autonomous agents. It lets users create payment links, send wallet transfers, import CSV batch payouts, review transaction history, and route payment operations through an AI safety copilot before funds move.

Qevor currently supports Mantle Sepolia, Mantle Mainnet, and Arc Testnet. Mainnet execution is guarded behind stricter policy, approval, and treasury controls.

• Agent-first payments: users describe a payout goal and Qevor prepares a reviewable operation plan.
• Human approval by default: the copilot can draft, validate, and route payments, but it cannot bypass approval gates.
• Mantle payment rail: Mantle Sepolia and Mantle Mainnet MNT transfers, CSV batch payouts, receipts, and explorer links.
• Payment links: shareable requests for exact amounts across supported rails.
• Subscriptions and recurring payments: schedule repeat payments for retainers, dues, subscriptions, payroll, and recurring invoices.
• Wallet history: recent direct sends, payment links, batch requests, receipts, and batch payouts are visible from the wallet dashboard.
• AI safety copilot: scans payment drafts for duplicate recipients, invalid addresses, risky amounts, wrong-chain intent, and suspicious CSV rows.
• Agent operation history: agent-assisted batches are recorded with status, recipients, amounts, and receipt access.
• Byreal-compatible execution preflight: Qevor calls a Mantle adapter before agent execution so external agent tooling can approve or block risky operations.
• Escrow-backed agent execution: QevorAgentEscrow provides the Mantle contract surface for policy-controlled agentic payment execution, with balances scoped per user wallet.
• ERC-8004 agent identity: the Mantle agent escrow can be attached as Qevor's ERC-8004 agent wallet, with an agent URI, registry address, and agent ID recorded on-chain.

Qevor is split into three main layers:

1. Frontend app: React, TypeScript, Vite, Tailwind, Dynamic wallet auth, and the payment workspace UI.
2. Qevor API: Express service for copilot planning, skill endpoints, Byreal preflight, and production server functions.
3. Executor service: background worker that polls Supabase, checks policy, calls Byreal preflight, and executes approved agent batches.

Key docs:

• Agent stack architecture
• VPS deployment guide
• Integration notes

• App: https://qevor.xyz
• API: https://api.qevor.xyz
• Mantle Sepolia escrow: 0xf0e6f301D2036b0A0c94808dc945ed764e5a35c4
• Mantle Mainnet escrow: pending guarded deployment
• Contract: contracts/QevorAgentEscrow.sol
• Networks: Mantle Sepolia, Mantle Mainnet-ready, Arc Testnet
• Mainnet guardrail: use the dedicated mainnet deploy script and keep strict approval, policy, and treasury limits enabled.

The deployed escrow contract is the Mantle contract that underpins Qevor's agentic payment rail. It can execute approved payments, record blocked/cosign/failed decisions, enforce replay protection, enforce per-user payment limits, validate owner signatures through ERC-1271, and link decisions to Qevor's ERC-8004 agent identity after setAgentIdentity(identityRegistry, agentId, agentURI) is configured. MNT sent through the escrow is accounted with balanceOf(userWallet), so one user's deposit does not appear in another user's dashboard.

• Frontend: React, TypeScript, Vite
• UI: Tailwind CSS, shadcn/ui, Radix UI, lucide-react
• Wallets: Dynamic Labs, wagmi, viem
• Database: Supabase
• Agent API: Express, Zod
• AI copilot: Anthropic Claude, with OpenAI fallback support
• Execution: Mantle Sepolia RPC, viem, optional Byreal-compatible preflight adapter
• Contracts: Solidity, Foundry
• Hosting: VPS with Caddy or any static host plus API process manager

Byreal is used as Qevor's agent execution preflight layer for Mantle operations.

The official Byreal CLI is Solana-focused, so Qevor does not pretend that Byreal directly signs Mantle transfers. Instead, Qevor uses a Byreal-compatible Mantle adapter at server/src/executor/qevor-byreal-preflight.ts. This lets Qevor plug into the Byreal Skills / agent workflow pattern while keeping Mantle execution native and safe.

Current production configuration:

BYREAL_CLI_BIN=node
BYREAL_PREFLIGHT_ARGS=/opt/qevor/server/dist/executor/qevor-byreal-preflight.js
BYREAL_SOLANA_CLI_BIN=byreal-cli
QEVOR_BYREAL_MAX_PREFLIGHT_MNT=100
QEVOR_BYREAL_MAX_MAINNET_PREFLIGHT_MNT=1
QEVOR_BYREAL_REQUIRE_CLI=0

The flow is:

1. A user or agent asks Qevor to prepare a Mantle payment or batch.
2. Claude turns the intent into a structured Qevor payment plan.
3. Qevor policy checks run first: approval requirement, duplicate recipients, invalid addresses, amount limits, and chain checks.
4. Qevor calls the Byreal-compatible preflight adapter with JSON containing the chain, sender, recipient, amount, payment id, and policy decision.
5. The adapter returns structured JSON: { "allowed": true | false, "reason": "..." }.
6. If allowed, the user still approves the transaction or the executor continues only under policy.
7. Before an agent execution signs or calls QevorAgentEscrow, the executor calls the same Byreal preflight again.

Byreal therefore acts as a real execution-layer gate in Qevor: it can approve, warn, or block Mantle agent operations before funds move. It does not bypass Qevor policy, user approval, or contract limits.

Install dependencies:

npm install
cd server
npm install

Create a local frontend env file:

VITE_SUPABASE_URL=
VITE_SUPABASE_PUBLISHABLE_KEY=
VITE_SUPABASE_PROJECT_ID=
VITE_DYNAMIC_ENVIRONMENT_ID=
VITE_QEVOR_API_URL=http://localhost:4000

Create a local API env file in server/.env:

SUPABASE_URL=
SUPABASE_SERVICE_ROLE_KEY=
ANTHROPIC_API_KEY=
ANTHROPIC_COPILOT_MODEL=claude-sonnet-4-6
OPENAI_API_KEY=
OPENAI_COPILOT_MODEL=
BYREAL_CLI_BIN=node
BYREAL_PREFLIGHT_ARGS=dist/executor/qevor-byreal-preflight.js
QEVOR_BYREAL_MAX_PREFLIGHT_MNT=100
QEVOR_BYREAL_REQUIRE_CLI=0
MANTLE_SEPOLIA_RPC_URL=https://rpc.sepolia.mantle.xyz
MANTLE_MAINNET_RPC_URL=https://rpc.mantle.xyz
MANTLE_AGENT_PRIVATE_KEY=
MANTLE_AGENT_ESCROW_CONTRACT_ADDRESS=
MANTLE_MAINNET_AGENT_PRIVATE_KEY=
MANTLE_MAINNET_AGENT_ESCROW_CONTRACT_ADDRESS=

Run the frontend:

npm run dev

Run the API:

cd server
npm run dev

Build:

npm run build
cd server
npm run build

Qevor stores product and audit data in Supabase. Run the migrations in supabase/migrations/ before using payment links, receipts, batch payouts, agent wallets, and wallet history.

Core tables include:

• profiles
• payment_links
• batch_requests
• batch_payments
• receipts
• recurring_payments
• agent_wallets
• agent_policies
• agent_audit_log
• agent_cosign_queue

The Mantle agent rail is backed by contracts/QevorAgentEscrow.sol.

The escrow can be shared across users safely because deposits and spends are keyed by the connected wallet:

• depositFor(userWallet) credits only that user's agent balance.
• balanceOf(userWallet) is what the dashboard displays.
• executePayment(paymentId, userWallet, recipient, amount) can only debit that user's scoped balance.
• Daily spend tracking is also per user wallet.

Deployed Mantle Sepolia contract:

0xf0e6f301D2036b0A0c94808dc945ed764e5a35c4

Explorer:

https://explorer.sepolia.mantle.xyz/address/0xf0e6f301D2036b0A0c94808dc945ed764e5a35c4

Compile:

forge build

Deploy to Mantle Sepolia:

forge create contracts/QevorAgentEscrow.sol:QevorAgentEscrow \
  --rpc-url "$MANTLE_SEPOLIA_RPC_URL" \
  --private-key "$MANTLE_AGENT_PRIVATE_KEY" \
  --constructor-args "$MANTLE_ESCROW_EXECUTOR_ADDRESS" "$MANTLE_ESCROW_MAX_PAYMENT_WEI" "$MANTLE_ESCROW_DAILY_LIMIT_WEI"

Deploy to Mantle Mainnet:

$env:QEVOR_ALLOW_MAINNET_DEPLOY="I_UNDERSTAND_MAINNET_FUNDS_ARE_REAL"
$env:MANTLE_MAINNET_RPC_URL="https://rpc.mantle.xyz"
$env:MANTLE_MAINNET_DEPLOYER_PRIVATE_KEY="<fresh mainnet deployer key>"
$env:MANTLE_MAINNET_EXECUTOR_ADDRESS="<executor wallet address>"
$env:MANTLE_MAINNET_ERC8004_IDENTITY_REGISTRY_ADDRESS="<mantle erc-8004 identity registry>"
$env:MANTLE_MAINNET_ERC8004_AGENT_ID="<qevor agent id>"
$env:QEVOR_MAINNET_AGENT_URI="https://qevor.xyz/.well-known/erc8004/qevor-agent.json"
$env:MANTLE_MAINNET_ESCROW_MAX_PAYMENT_WEI="1000000000000000000"
$env:MANTLE_MAINNET_ESCROW_DAILY_LIMIT_WEI="5000000000000000000"
$env:FOUNDRY_FORGE_BIN="C:\Users\Admin\.foundry\bin\forge.exe"
.\deploy\deploy-mantle-mainnet.ps1

The mainnet script refuses to complete as a Qevor agent deployment unless the Mantle ERC-8004 registry address and Qevor agent ID are supplied. If you intentionally need an unregistered emergency deploy, set QEVOR_ALLOW_UNREGISTERED_MAINNET_AGENT=I_ACCEPT_UNREGISTERED_MAINNET_AGENT, but do not use that for the hackathon submission.

After the mainnet deploy succeeds, copy the deployed contract address into:

• VITE_MANTLE_MAINNET_AGENT_ESCROW_ADDRESS
• MANTLE_MAINNET_AGENT_ESCROW_CONTRACT_ADDRESS

Then rebuild the frontend and restart the API and executor.

After deployment:

1. Register the Qevor agent in Mantle's ERC-8004 identity registry using docs/erc8004-agent-registration.example.json.
2. Deploy the escrow with deploy/deploy-mantle-mainnet.ps1, supplying the registry address, Qevor agent ID, and agent URI.
3. Configure MANTLE_MAINNET_AGENT_ESCROW_CONTRACT_ADDRESS.
4. Register the escrow address as the Mantle agent wallet in Qevor.
5. Fund the escrow with MNT through depositFor(userWallet) or from the connected wallet.
6. Restart the API and executor.

External agents can integrate with Qevor through the protected skill API:

• GET /.well-known/qevor-agent-skills.json
• POST /api/skills/payment-safety-review
• POST /api/skills/batch-payment

Skill requests require:

x-qevor-agent-key: <server configured key>

Qevor can run without Vercel. The current production path is:

• qevor.xyz for the frontend
• api.qevor.xyz for the API
• Supabase for database persistence
• PM2 for qevor-api and qevor-executor
• Caddy or Nginx for HTTPS and reverse proxying

See deploy/README.md for the VPS runbook.

• Never commit private keys, API keys, Supabase service role keys, or executor secrets.
• Mainnet should remain guarded by stricter limits, allowlists, daily caps, and human approval unless a user deliberately enables a bounded autonomous policy.
• Agent execution must always pass policy checks and Byreal-compatible preflight before signing.
• The copilot prepares plans; it does not directly move funds.