Documentation

SWAN is a non-custodial, autonomous wealth protocol on Robinhood Chain that continuously manages your tokenized real-world assets (equities and crypto) plus a USDG yield base. It earns a variable USDG yield on Morpho on every idle dollar and moves to safety on its own when markets turn, all inside limits you sign, in a wallet only you control.

Introduction #

Most portfolios do nothing while you sleep. Cash sits idle, risk assets ride out every drawdown, and the disciplined moves, trimming into danger, re-entering when it clears, are exactly the ones humans are worst at making unemotionally.

SWAN turns a portfolio into a rules-based, always-on index. You define a policy once, a target mix, a safety floor, how aggressively to shelter and how gradually to re-enter. An AI agent then watches the market 24/7 and rebalances your vault inside those limits, on decentralized markets that never close. It never takes custody: your assets live in a contract only your wallet can withdraw from.

How SWAN works #

SWAN is built in three layers that sit on top of each other inside your vault:

1 · Yield-bearing base

Every dollar you deposit is put to work immediately. Base capital is supplied to Morpho lending vaults on Robinhood Chain, targeting roughly 7% APY on dollar-backed assets. The interest-bearing receipt tokens become the collateral foundation the growth sleeves are built on, nothing sits idle.

2 · Growth sleeves

On top of the base, the agent holds a target mix across three sleeves, equities (tokenized stocks & ETFs), crypto (ETH, BTC) and USDG (a dollar base supplied to Morpho). The split is set by your chosen strategy and is what the agent steers back toward as prices drift.

3 · Flight to safety

Continuously, the agent computes the SWAN Score, a composite read on market regime. When the score crosses your shelter threshold, the agent rotates risk assets into USDG on Morpho (safe yield), in stages. When the regime clears, it rebuilds risk gradually. Exiting is only 20% of the job; the disciplined re-entry is where long-term returns are actually made.

// the agent runs this continuously, per vault
const score = swanScore()                 // 0-100 regime read
const target = policy.targetFor(score)      // your mix, adjusted for regime
const drift  = current.vs(target)

if (Math.abs(drift) > policy.band && cooldownElapsed())
  vault.rebalance(...)                       // one Uniswap swap, inside your caps

Quickstart #

Creating your first vault takes about two minutes. You'll need a wallet (MetaMask, Rabby, or any EIP-1193 wallet) on Robinhood Chain, and a little ETH for gas.

1. Connect your wallet. Open the app and connect on Robinhood Chain. No wallet handy? Use “Explore in demo mode” to look around first.
2. Pick an amount and a strategy. Choose how much to fund and one of the presets, Preserver, Balanced or Growth (see Strategies).
3. Set your autonomy level. Advisor, Copilot or Autopilot, how much the agent may do on its own (see Autonomy levels).
4. Sign & deploy. One signature writes your policy; one transaction deploys your vault and funds it. Creating the vault costs a few cents of ETH in gas, separate from your deposit.
5. You're live. If you chose Autopilot, the agent is appointed at creation and starts managing immediately. Watch it from your dashboard; withdraw or revoke anytime.

The SWAN Score #

The SWAN Score is a single number from 0 to 100 that estimates how dangerous the current market regime is. Low is calm; high is stormy. It's a composite, deliberately not a single price trigger, so it's slow to panic and hard to whipsaw.

What it measures

Regime bands

Flight to safety #

“Flight to safety” is SWAN's core behavior, and it's what separates it from a stop-loss. A stop-loss is a single price trigger that fires once, blind to context, usually into the worst liquidity of the day. SWAN's flight-to-safety:

• De-risks in stages as the regime deteriorates, rather than dumping everything at one price.
• Earns yield on what it shelters, value rotates into USDG supplied to Morpho lending, not idle cash.
• Avoids whipsaw with hysteresis, separate shelter and re-entry thresholds mean it doesn't churn on noise.
• Re-enters gradually when the regime clears, on the schedule your policy sets.

Vaults #

A vault is your own on-chain account, a smart contract deployed for your wallet with a policy the agent must obey. Most people run more than one: a cautious core, a braver satellite.

Creating a vault

From the app, choose an amount and a strategy, set your autonomy level, then sign and deploy. Under the hood, the factory deploys a fresh SwanVault owned by your wallet, with the token whitelist and Uniswap router preconfigured. If you fund with ETH, it's wrapped to WETH inside the vault in the same transaction.

Funding & withdrawing

Add funds anytime by sending WETH, USDG or ETH to your vault's address, or via the Deposit action. Only you can withdraw: withdrawToken and withdrawETH are onlyOwner and send straight back to your wallet. There are no lockups and no exit fees.

Closing a vault

A vault is a contract, so it can't be erased from the chain, but you can empty and retire it. The app's Delete vault action withdraws every asset back to your wallet (one approval per asset), revokes the agent, and removes the vault from your dashboard. The now-empty contract remains on-chain but holds nothing.

Strategies #

Strategies are presets for your target mix and how aggressively you shelter and re-enter. Pick one as a starting point, then fine-tune the policy.

Custom policy

Beyond the presets you control: the target mix, a safety floor (minimum % always in USDG), the shelter threshold (the SWAN Score at which de-risking begins), re-entry speed, and the asset whitelist, the agent can trade nothing outside it.

Autonomy levels #

You choose how much the agent may do on its own. All three stay inside your policy and caps, the difference is who presses “go”.

The agent #

The agent is SWAN's off-chain brain. It's an always-on service that, each tick (about every 10 minutes):

1. computes the live SWAN Score from market data;
2. discovers the vaults that have appointed its key;
3. reads each vault's real on-chain balances;
4. computes the target allocation from the vault's policy and the score;
5. if the vault has drifted past its band and the on-chain cooldown has elapsed, submits one rebalance(), a real Uniswap swap the vault executes on itself.

The agent key is powerful only in a narrow way: it can call rebalance() within the vault's hard caps, and nothing else. It cannot withdraw a cent. Losing the agent key is not the same as losing funds, the worst case is the vault stops rebalancing until you appoint a new agent or manage it manually.

Non-custody model #

SWAN is non-custodial by construction. Your assets are held in a SwanVault contract deployed for your address. SWAN's contract receives delegated trading rights only, scoped to a whitelist of assets and a single DEX venue, capped by your intent, and revocable in one transaction.

Control boundary #

Three parties, three roles, and the contract is the police.

The on-chain caps that back this up:

Yield & risk #

The base lending layer is USDG supplied to Morpho lending on Robinhood Chain. That is the yield foundation of the portfolio, variable and set by market conditions, and not a guaranteed or insured rate.

The growth sleeves, tokenized equities and crypto, carry normal market risk. That's precisely the part SWAN's flight-to-safety logic actively manages, but it does not remove it. Nothing here is FDIC or SIPC coverage, and no strategy removes market risk entirely.

Network & addresses #

SWAN runs on Robinhood Chain mainnet.

SwanVault contract #

Each vault is an instance of SwanVault, owned by the wallet that created it. Owner-only functions manage funds and policy; the appointed agent may only call rebalance.

Owner functions

Agent function

// callable only by the appointed agent, only within the caps below
function rebalance(
  address tokenIn,
  address tokenOut,
  uint24  fee,
  uint256 amountIn,
  uint256 minOut
) external returns (uint256 amountOut);

View functions

owner(), agent(), paused(), maxTradeBps(), cooldown(), lastTradeAt(), allowedToken(address).

Factory contract #

SwanVaultFactory is the single, permissionless front door. It has no admin and takes no fees, anyone can deploy a vault they own.

const factory = new ethers.Contract(FACTORY, ABI, signer)
const tx = await factory.createVaultWithETH(
  policyHash,                 // keccak256 of your EIP-712 policy
  "0x6610d6d1848908F82a61bf4dC85514Fbd89A0F8f", // SWAN agent, or 0x0 for none
  { value: ethers.parseEther("0.02") }
)
const rc = await tx.wait()          // VaultCreated → your new vault address

Policy & EIP-712 #

Your policy, target mix, thresholds, re-entry, autonomy, is expressed as structured data and signed by your wallet with EIP-712 typed-data signing. The signature is free and gasless and moves nothing; it proves you authored the policy. The vault stores only the keccak256 hash of the policy on-chain, so anyone can verify a policy against its hash and recover your address from the signature.

Rebalance mechanics #

When the agent rebalances, the vault performs the swap on itself through the immutable Uniswap router. Every call is bounded:

• Direction & size come from the drift between current and target allocation, the agent moves a fraction of the gap, never the whole balance.
• Per-trade cap (maxTradeBps) hard-limits amountIn to a share of the input balance.
• Cooldown (cooldown vs lastTradeAt) blocks trades that are too frequent.
• Slippage floor (minOut) is derived from the live pool price; the swap reverts if it can't be met.
• Whitelist: both tokenIn and tokenOut must be allowed, or the call reverts.

Proceeds always stay inside the vault, there is no path for a rebalance to send value anywhere but back into your vault's own balance.

FAQ #

Is SWAN custodial?

No. Assets live in a vault contract deployed for your address; SWAN's contract receives delegated trading rights only, scoped to a whitelist and a single DEX, capped by your intent, and revocable in one transaction. It can rebalance; it cannot withdraw to any other address.

Isn't this just a fancy stop-loss?

No, the difference is the whole product. A stop-loss is a single price trigger that fires once, blind to context. SWAN runs a continuous composite score, de-risks in stages, earns yield on what it shelters, avoids whipsaw with hysteresis, and re-enters gradually. The disciplined re-entry is where long-term returns are made.

What if the agent goes offline?

Nothing dangerous. The agent can only trigger rebalances; it isn't required for your funds to exist or exit. If it disappears, your vault simply goes static, assets stay in your wallet, base yield keeps accruing, and you can withdraw or trade manually anytime.

How is this different from a robo-advisor?

Three ways: robo-advisors hold custody (SWAN never does); they rebalance on a calendar during market hours (SWAN responds to conditions in real time, because tokenized stocks trade 24/7 on-chain); and they leave cash idle (SWAN's base earns a variable Morpho lending yield from deposit).

Where does the base yield come from?

The base sleeve is USDG supplied to Morpho lending on Robinhood Chain, targeting roughly 7% (variable, set by market conditions). The growth sleeves carry normal market risk, that's the part flight-to-safety manages. This is on-chain lending, not a bank deposit, and is not FDIC/SIPC coverage.

Glossary #

Links #

• SWAN app, create and manage vaults.
• swanprotocol.xyz, the main site.
• Robinhood Chain explorer, verify contracts and transactions.