In an on-chain money market you are liquidated the instant your Health Factor crosses the threshold — usually during a fast price drop, when nobody reacts in time. The penalty goes to the liquidator, not to you.

Positions are lost not because the borrower is insolvent, but because they were away from the keyboard.

Paboxo is an isolated-pair lending protocol. createLendingPool is a public function: anyone can open a market for any collateral / borrow pair with its own risk curve — no governance vote, no allowlist. The only requirement is that both tokens have a registered price feed. Suppliers deposit the borrow token and earn interest. Borrowers post collateral into a Position contract that belongs to them alone.

On top of that sits the part that makes Paboxo different: an opt-in, non-custodial AI keeper that watches your Health Factor and acts inside your own position before the liquidator can.

In Paboxo the payment, the AI, and the DeFi mechanic are one verifiable flow:

Every core contract is source-verified on Blockscout. Every claim below has a link.

A price moves. The protocol notices. The AI acts before the liquidator can.

flowchart LR
    A["📉 <b>Price drops</b><br/>oracle-cron pushes<br/>the new price on-chain"]
    B["🔄 <b>Pool re-pegs</b><br/>market-maker resets the<br/>DODO guide price to match"]
    C["🤖 <b>Agent reacts</b><br/>health factor crosses 1.15<br/>agent sizes the fix"]
    D["🛡️ <b>Collateral rotates</b><br/>inside your own Position<br/>HF restored above 1.30"]
    E["✅ <b>No liquidation</b><br/>you keep your position<br/>and your exposure"]

    A --> B --> C --> D --> E

    style A fill:#3d1f1f,stroke:#f85149,color:#f0f6fc
    style B fill:#1c2128,stroke:#6e7681,color:#f0f6fc
    style C fill:#0d2b4e,stroke:#1f6feb,color:#f0f6fc
    style D fill:#0f2d1c,stroke:#2ea043,color:#f0f6fc
    style E fill:#0f2d1c,stroke:#2ea043,color:#f0f6fc

The same story, call by call — including the HSP gate the keeper cannot skip:

sequenceDiagram
    autonumber
    actor U as 👤 User
    participant FE as paboxo-fe
    participant HSP as 💳 HSP
    participant LP as LendingPool<br/>+ Router
    participant POS as Position<br/>(user-owned)
    participant DEX as DODO V2<br/>DPP
    participant K as ⚙️ Keepers
    participant AI as 🤖 Rebalance Agent

    rect rgba(128, 142, 158, 0.12)
    Note over U,POS: Open a position
    U->>FE: supply collateral, borrow pxUSDT
    FE->>LP: supplyCollateral() · borrowDebt()
    LP->>POS: deploy & custody collateral
    LP-->>FE: HF = 1.42 ✅
    end

    rect rgba(219, 171, 10, 0.14)
    Note over U,LP: Pay to protect
    U->>HSP: pay fee in USDC.e — from your own wallet
    HSP-->>U: ACCEPT receipt + decision trace
    U->>LP: approveRebalanceDelegation(keeper)
    end

    rect rgba(248, 81, 73, 0.13)
    Note over K,DEX: The market moves against you
    K->>LP: setPrice() — collateral drops
    K->>DEX: resetDODOPrivatePool() — re-peg to oracle
    end

    rect rgba(31, 111, 235, 0.14)
    Note over AI,POS: The agent acts before the liquidator
    AI->>LP: read health factor
    LP-->>AI: HF = 1.09 ⚠️ (below 1.15)
    AI->>HSP: HSPVerifier — re-check the signed mandate
    HSP-->>AI: ✅ ACCEPT — payer, recipient, token, chainId
    AI->>AI: size the fix — deterministic math
    AI->>LP: rebalancePosition() — simulated first
    LP->>POS: rotate collateral
    POS->>DEX: swap at the re-pegged price
    DEX-->>POS: proceeds stay in the Position
    LP-->>AI: HF = 1.31 ✅ restored
    end

    rect rgba(46, 160, 67, 0.14)
    Note over AI,U: You never got liquidated
    AI->>FE: DGRID explanation — "why I did this"
    FE-->>U: position safe · funds never left
    end

The LLM explains the decision. It never makes it.

Every number that moves money — health factor, swap size, which lever to pull — is deterministic scaled-integer math, enforced on-chain. The language model receives that finished decision and is instructed, in its system prompt, that it must not change it. Its only job is to tell you why, in a sentence you can read.

An LLM that can hallucinate prose is useful. An LLM that can hallucinate a swap size is a liability. Paboxo gives it the first job and structurally denies it the second.

Three levers, all constrained on-chain:

How it decides. Every 60 seconds the agent reads live health factors from IsHealthy. A position is at risk when 1.0 ≤ HF < 1.15. It sizes an action to restore HF ≥ 1.30. Below 1.0 it does nothing — that position belongs to liquidation, and the agent knows the difference.

How it stays safe. Every write, from every keeper, passes through one mandatory safety guard: a dry-run gate, a gas ceiling, a per-cycle action cap, and absolute price bounds. There is no send path that bypasses it. Every action is simulated before execution, and the keeper runs dry-run by default — production execution is a deliberate switch, and for judging safety the demo runs in verify-and-simulate mode.

Your funds never leave your Position. Delegation is one on-chain call (approveRebalanceDelegation); revoking it is another. The keeper cannot move your collateral out, cannot borrow against it, and cannot touch a position that has not opted in.

Watch it think:

curl https://paboxo-api.staifdev.codes/api/cycles     # every cycle it has run
curl https://paboxo-api.staifdev.codes/api/actions    # every decision, with its plain-language reason

Built as a Mastra Workflow — buildWatchlist → readHealth → filterAtRisk → decide → explain → execute → report — reasoning through DGRID AI. If the model is unreachable the agent falls back to a deterministic template and keeps running. The loop never stops because the AI had a bad day.

HSP sits on the protocol's authorization path, not as a bolt-on.

1. You click Enable protection and pay a fee in USDC.e through HSP — a real on-chain settlement from your own wallet, zero custody, on mainnet 177.
2. HSP returns a verified ACCEPT receipt with a decision trace.
3. You grant rebalance-delegation to the keeper on-chain.
4. The keeper independently re-verifies that receipt (HSPVerifier, bound to the signed mandate) before it acts.

The keeper refuses to protect a position without cryptographic proof of payment. No subscription database, no off-chain flag to spoof.

HSP is a hackathon sandbox (pre-1.0). The integration is real on mainnet 177; the adapter and coordinator are the organizer's sandbox deployment.

Supply into a HashKey pool from Base. Borrow pxUSDT that bridges to another chain. Burn & mint pools on both lanes.

Not a bridge we wrote. Not a mock. Here is the message on the CCIP explorer — ExecutionStateChanged = SUCCESS.

You do not have to take any of this on faith. The whole loop is live, and you can walk it end to end.

Step 6 is the one worth staying for. Most protocols show you a liquidation after it has happened. This one shows you the reasoning before it would have.

These are the live values on every market. Don't take our word for it — read them off the chain:

cast call <pool> "router()(address)" --rpc-url https://mainnet.hsk.xyz
cast call <router> "ltv()(uint256)"  --rpc-url https://mainnet.hsk.xyz   # 7e17 = 70%

We would rather you read this than discover it.

• Non-custodial. The keeper never holds user funds. It acts only inside a position the user delegated, and only after an independently-verified HSP ACCEPT.
• Deterministic gates, AI for explanation. The LLM never controls funds — it explains a decision the contracts enforce.
• Dry-run by default. Production execution is a deliberate switch. The demo runs in verify-and-simulate mode.
• Not a solvency guarantee. In an extreme single-block crash the keeper may not prevent liquidation. It reduces avoidable, slow-drift liquidations — it does not promise to eliminate all of them.

Paboxo targets borrowers who keep collateralized positions open but cannot monitor liquidation risk 24/7. Monetization is an opt-in protection fee paid through HSP, per protected position. Because the keeper only acts after verifying an on-chain payment, the protocol needs no off-chain subscription database. The same mechanism extends to tiered protection, market-maker-sponsored protection, or DAO-funded protection for strategic markets.

Everything runs against HashKey Chain mainnet 177 (https://mainnet.hsk.xyz).

A pnpm workspace monorepo. Shared toolchain: Node ≥ 22 · pnpm 11.6 · TypeScript 5.7 (run directly via tsx, no build step) · Biome 2.5 (lint + format, not ESLint/Prettier) · Vitest 2.1.