Reins

Let an AI agent trade without giving it the power to lose everything.

npx @r2rlabs/reins init      # adds a paper-trading Reins server to .mcp.json

See it at work: an AI agent trading Hyperliquid on paper, run 2.

The source is on GitHub: R2Rlabs/reins. Every limit in this README is a function you can read.

What Reins is

• Limits the agent can't argue with. Every order passes checks that live outside the model: position size, leverage, daily loss, which markets it may trade, and a stop-loss on every position. No prompt, clever reasoning or mistake gets around them.
• A record you can check. Every decision is logged with the reason the agent gave — including the orders it was refused, the times it chose to wait, and what the exchange did without it. You can compare what the agent said with what actually happened.
• Somewhere to rehearse. Paper trading on live Hyperliquid prices with realistic fills and fees, using the same tools and limits as live trading.
• Non-custodial. Your money stays in your own Hyperliquid account. Reins trades through an API wallet, which can place orders but cannot withdraw.
• Paid for openly. A small builder fee (2 bp) on live orders, shown up front.

What Reins is not

• Not a trading bot or a strategy. Reins doesn't decide what to trade and won't make an agent profitable. The demo agent is a test drive, not the product.
• Not an exchange, broker or custodian. It holds no funds and matches no orders; Hyperliquid does that.
• Not a promise against losses. Limits cap how much can go wrong. They don't make bad trades good, and stops can slip in fast markets.
• Not financial advice.
• Not something you have to take on trust. Not the agent's word, and not ours: every action is on the record.

Principles

1. Limits live outside the model.
2. The record outranks the reasoning.
3. Paper before real money.
4. Your keys, your funds.

Why this exists

Several open-source Hyperliquid MCP servers already exist. They are thin API wrappers: you hand them a private key and hope the model behaves. The gap is everything around that — the limits, the sandbox, the audit trail. That is what this repo is.

Status

Early, but real. 391 tests, no network calls in any of them.

Module	What it does
src/risk.ts	The risk engine — position cap, risk per trade, leverage cap, daily loss halt, allowlist, rate limit
src/client.ts	Hyperliquid REST client — orders, cancels, book, candles, fills, account state, builder code
src/mcp-server.ts	The agent-facing tools, each risk-checked and logged before anything is sent
src/paper.ts	Paper trading — live prices, simulated fills. See below
src/paper-store.ts	Persists a paper run across restarts
src/trading-client.ts	The interface live and paper both satisfy
src/decision-log.ts	Append-only record of every attempt and its stated reason
src/decision-log-file.ts	JSON Lines log on disk
src/bin/cli.ts	The reins command: serve (default), init, approve-builder, live-check, http and stats
src/bin/serve.ts	stdio entry point
src/bin/http.ts	reins http — the HTTP server: token, binding, JSON
src/http-api.ts	The same nine tools as HTTP routes, for bots that do not speak MCP
src/runtime.ts	The limits, client, log and banner both front doors share
src/init.ts	reins init — writes a paper-mode server entry into .mcp.json
src/builder-fee.ts	Reins' builder fee, and the approval live trading needs before it starts
src/approve-builder.ts	reins approve-builder — the user approves the builder fee in their own wallet
src/live-check.ts	reins live-check — proves the live exchange accepts what Reins sends
src/platform-stats.ts	— accounts, trades, volume and fees through Reins' builder code

All of it works end to end. Going live is now a matter of funding an account and setting REINS_MODE=live with a key.

Going live

REINS_MODE=live
REINS_NETWORK=testnet          # mainnet spends real money
REINS_ACCOUNT_ADDRESS=0x...    # your Hyperliquid account
REINS_PRIVATE_KEY=0x...        # an API wallet's key, not your account's; omit to stay read-only

On mainnet, approve Reins' 2 bp builder fee once, from the account's own wallet, before the first live session: npx @r2rlabs/reins approve-builder. Until the account has, live mode refuses to start and says so.

Use an API wallet, not your account's own key. Hyperliquid lets an account approve API wallets that can trade for it but cannot withdraw from it — create one on Hyperliquid's API page, signing the approval with your main wallet. Put its key in REINS_PRIVATE_KEY and your account's address in REINS_ACCOUNT_ADDRESS: orders are signed by the API wallet, while positions, fills and stops are read from the account, because under the API wallet's own address the account looks empty. The startup banner names both. Hyperliquid prunes API wallets that expire or are replaced; make a fresh one rather than reusing an old address.

This is the beginning of the README. Read the rest at the original. Read the full README ↗