Introducing Tessera: the safest place to borrow against tokenized stocks

Today we're introducing Tessera: a protocol for borrowing USDC against tokenized stocks, with an autonomous agent watching every position around the clock to head off liquidations before they happen. This post explains what we're building, why the problem is real, why now is the moment, and — just as importantly — exactly what is live today and what is not.

The problem: 24/7 collateral, a market that sleeps

Tokenized stocks — on-chain tokens that track real equities like Apple, Tesla, or the S&P 500 — trade every hour of every day. The companies and markets behind them do not. The underlying equity market is open roughly 32 hours a week; the token trades all 168. That mismatch is the whole problem.

When you borrow against an asset, lenders need a cushion: if your collateral falls in value, your loan can be liquidated — sold off to repay the debt — once it crosses a safety line. In normal markets you can watch that line and act. But a tokenized stock can gap — jump in price with no trading in between — over a weekend or after a midnight earnings release, when no human is awake and traditional markets are shut. Positions that looked safe at bedtime are liquidated before morning. The borrower never had a chance to react.

The collateral trades 24/7. The people who own it, and the market that prices it, do not. Tessera exists to close that gap.

The answer: an AI risk layer that never sleeps

Tessera has two sides, like any healthy lending market. Lenders supply USDC and earn yield from borrower interest. Borrowers post tokenized-stock collateral and draw USDC against it — to get liquidity without selling their position. Standard so far. What's different is the layer sitting on top of every borrow.

We call it the Watcher — an autonomous agent that monitors each borrower's health factor continuously and steps in before a gap turns into a forced liquidation. The health factor is the single number that matters here: it's your risk-weighted collateral value divided by your debt, scaled so that 1.0 is the liquidation line. Above 1.0 you're safe; at or below it, your position can be liquidated.

What the Watcher does

• Watches every borrower's health factor around the clock, re-checking roughly every 10 seconds.
• Sends plain-English alerts before a position becomes dangerous — not after.
• With your explicit opt-in, auto-repays from USDC you have pre-approved, reducing your debt to pull the health factor back up before the liquidation line is reached.
• Stamps an on-chain heartbeat as it works, so a permissionless backstop can open only if the agent goes truly silent (over 15 minutes on testnet) — protection that doesn't depend on us being online.

What the Watcher does not do — by design

Trust in a system that touches your money comes from its limits, not its promises. So we are precise about what the Watcher cannot do:

• It never custodies your funds. It can only reduce your own debt, using an allowance you set — and can revoke at any time. Revoking is the single kill switch.
• It does not use a language model to decide whether to move money. A deterministic core makes every financial decision; the language model only writes the human-readable copy you read in alerts.
• It is bounded by hard, on-chain caps: at most 10,000 USDC per user per transaction and 25,000 USDC per user per day. The limits live in the contract, not in a config file we control.
• It cannot guarantee protection. A severe enough overnight gap can still liquidate a position. We will never pretend otherwise.

Conservative by default

Because overnight gaps are the core risk, our risk parameters are deliberately cautious — more conservative than a typical crypto money market. Each asset has a max LTV (the most you can borrow against it) and a liquidation threshold (the point at which liquidation can begin), both set with gap risk in mind:

A few more parameters that shape the system: the liquidator bonus starts at 5% and ramps with depth; the close factor is 50%, so a single liquidation can clear at most half a position — except below a health factor of 0.95, where a full close is allowed. The minimum debt is 100 USDC to avoid uneconomical dust positions. And a reserve factor of 15% of borrow interest is routed to an on-chain reserve that serves as both protocol revenue and a first-loss buffer.

Why now

Tokenized equities are moving from a niche experiment to real infrastructure, and the rails to issue and trade them on-chain are arriving faster than the risk tooling around them. As more people hold tokens that trade continuously against a market that doesn't, the overnight-gap problem stops being theoretical and starts liquidating real positions. The safety layer needs to exist before the volume does — not after the first bad weekend.

We also chose our chain for a concrete engineering reason. Tessera's vault is large because it is safety-hardened, and it exceeds the contract-size limit of a standard L2. Robinhood Chain — an Arbitrum Orbit L2 — has a larger code-size limit that holds the full vault without us stripping out safety logic to fit. The vault and its supporting contracts are written in Rust via Arbitrum Stylus, which gives us the headroom and the gas efficiency to run conservative, frequently-checked risk logic on-chain.

What's actually live today

Everything below is running on Robinhood Chain testnet right now, end to end:

• The Stylus (Rust) vault — supply, borrow, repay, and liquidation logic with the conservative parameters above.
• A PriceGuard contract — an oracle-policy layer that governs how prices are allowed to move into the system.
• A Lens — a read-only contract that surfaces clean, structured position and market data to the app.
• The Watcher — the TypeScript agent doing live health-factor monitoring, alerting, and opt-in auto-repay within its on-chain caps and heartbeat backstop.
• All of it open-source, so the claims in this post can be checked against the code.

What's next

Our path is gated, not hyped. Before real funds are ever involved we need to clear the work that justifies that trust: a licensed production price feed in place of the testnet mock, a security audit, and the operational hardening that turns a working testnet protocol into something people can responsibly depend on. We'll name each of these as a gate as we reach it — and we'll keep building in the open so progress is visible, not announced.

The long-term vision is straightforward: become the autonomous AI risk layer for tokenized real-world-asset lending. Tokenized assets that trade continuously need risk infrastructure that does the same. That's the durable problem, and it's the one we intend to keep solving.

If the problem resonates — you hold tokenized stocks and want liquidity without getting liquidated overnight, or you want to lend USDC into a market with a real safety story — follow along as we build. The code is open, the parameters are public, and the testnet is live.

Tessera — the safest place to borrow against tokenized stocks.