Product overview
Reazy is a workspace for creating and monitoring rule-based trading agents for crypto and supported tokenized stocks. You define a strategy and its risk limits, evaluate them with a backtest and with paper trading, and watch a complete record of what the agent did and why.
Reazy is built for Robinhood Chain (chain ID 4663): its prices come from on-chain feeds on that network and its supported assets are tokens that exist there. Reazy has not deployed contracts of its own. Today every agent runs in paper mode: a server-side simulation with simulated fills. No funds are involved.
The application has ten areas: Overview, Agents, Reazy Studio (the creation flow), Strategy Lab (backtests), Vault, Liquidity, Payroll, Activity and Settings, plus this documentation and the status page.
Implemented and unavailable
The table is the summary; the status page checks the same items live.
| Capability | State | Notes |
|---|---|---|
| Wallet sign-in | Implemented | Sign-In with Ethereum (EIP-4361) with browser wallets. Signing in approves nothing. |
| Agents and versions | Implemented | Three templates, validated settings, immutable versions with effective times. |
| Market data | Implemented | Chainlink Data Feeds on Robinhood Chain: 36 assets plus USDG. |
| Historical data | Implemented | The same feeds, round by round, cached in the database. |
| Backtesting | Implemented | Chronological, next-price fills, fees, slippage, buy-and-hold benchmark. |
| Paper execution | Implemented | Durable worker, one evaluation per interval, atomic accounting, simulated fills. |
| Monitoring and exports | Implemented | Decisions, orders, fills, equity; CSV exports. |
| Liquidity monitoring | Read-only | Reads a Uniswap v3 position on Robinhood Chain. Plus a range calculator. |
| Payroll planning | Implemented | Recipients, schedules, funding requirement, CSV import and export. |
| Live execution | Unavailable | Needs a verified vault contract. None is deployed. |
| Reazy Vault | Unavailable | No contract in this repository or on chain. Requirements are listed below. |
| Automated liquidity rebalancing | Planned | Needs a vault and an execution adapter. |
| Payroll payments | Unavailable | Schedules stay drafts. Needs a funded vault and owner authorization. |
| AI strategy drafting | Not built | Strategies are configured by hand. No model is involved in any decision. |
Creating an agent
Open the app, connect a browser wallet and sign in. Your account is your wallet address. Then choose Build an Agent. Reazy Studio has six steps:
- Identity. A name, an optional description and a strategy template.
- Market. The data source (one is configured), up to 5 supported assets, the quote currency (USDG) and an evaluation interval (15 min, 1 h, 4 h, 1 day).
- Strategy. The template’s own parameters.
- Risk. A starting paper balance, six limits, the allowed venues and two cost assumptions.
- Review. A plain-language summary generated from your settings: rules, limits, permissions, execution mode, data dependencies, costs.
- Create. The agent is saved as a paper-mode draft. It does nothing until you start it.
Rules are never edited in place. Changing settings creates a new version with its own effective time; earlier versions stay visible on the agent page. A new version applies from the next evaluation, and its schedule and signal state start fresh.
On the agent page you can start, pause, create a new settings version, archive, and export orders, fills, decisions and equity history as CSV.
Strategy templates
Each template is deterministic: the same settings, time and prices always produce the same decision. No model, randomness or discretion is involved.
Scheduled DCA
Buys a fixed USDG amount on a fixed cadence (1 h, 4 h, 1 day, 1 week), measured from the moment the version takes effect. The first buy happens at the first evaluation. With several assets the amount is split equally. It never sells. A buy the limits reject is not retried, and missed periods are not bought back: after a gap there is one buy.
Moving-average crossover
At each evaluation the agent takes one price sample per evaluation interval (the last feed round written at or before the end of each interval) and computes a fast and a slow simple moving average. While fast is above slow it holds its target allocation; otherwise it holds cash. It trades only when that state changes, and on its first evaluation it aligns with the current state. With several assets the target is split equally and each asset has its own signal. It needs as many intervals of history as the slow average has periods.
Threshold rebalancing
Each asset has a target weight; the remainder is cash. When any asset is further from its target than the threshold (in percentage points of portfolio value), every asset is traded back to target, sells first. Inside the band the agent does nothing.
Backtest assumptions
A backtest replays recorded feed rounds for a date range (up to 365 days) with the same strategy, limit and accounting code the paper engine uses.
- No look-ahead. At each step the strategy sees only rounds written at or before that step.
- Next eligible price. An order decided at a step fills at the first round written strictly after it. While an order waits (over a weekend for a Stock Token, for example) the strategy is not evaluated again.
- Costs. Your slippage is applied against every fill and your fee is charged on every fill, on the strategy and on the benchmark alike.
- Stale steps are skipped by the same rule as paper trading.
- Benchmark. The starting capital split equally across the selected assets, bought at each asset’s first eligible price, then held.
- Missing data is reported. If history starts after your start date, the report says where it starts. If there is none, there is no result. Nothing is interpolated or invented.
- Liquidity is not modelled. Every accepted order fills in full at the feed price. Real venues can fill worse, or not at all.
Feed rounds are not candles. A round is written when the price moves by the feed’s deviation threshold (0.5% for most) or its heartbeat elapses, so moves smaller than the threshold between rounds are not observed. Every report prints its parameters, range, source, fee treatment, benchmark and these assumptions. The Lab does not search for the best-performing parameters: you choose them, then run.
Paper execution
A worker evaluates each active agent once per evaluation interval. An interval is identified by its start time (its slot).
- Prices are read first. If they cannot be read, nothing is written and the same interval is tried again at the next pass.
- One database transaction then locks the agent, claims the interval, runs the strategy, applies the limits, writes orders and simulated fills, updates holdings and cash, and writes the equity snapshot and the decision record.
- The claim is a unique row per agent and interval. A retry, a second worker or an overlapping scheduler call cannot create a second evaluation or a second fill.
- A fill uses the feed price of that evaluation, converted to USDG, moved against the order by your slippage; your fee is charged on its value. Each fill stores its price source, feed round and the time that round was written, and is labelled simulated.
- When the drawdown threshold is reached, the agent pauses itself and says why.
Accounting
Average cost. A buy adds its value and its fee to the position’s cost basis. A sell realizes proceeds after fee minus quantity times average cost. Fees are also totalled separately. Amounts are decimals, never floats: USDG amounts carry 6 decimals and quantities 18.
Three different prices
- USD market valuation: the asset’s feed price in US dollars.
- USDG quote price: that price divided by the USDG / USD feed. USDG is not assumed to equal one dollar.
- Execution price: the quote price after simulated slippage. In live trading it would be the price a venue actually gave.
Data freshness
Every price shown in the app carries its source, the time its feed round was written, its age and its currency. Prices come from Chainlink Data Feeds on Robinhood Chain, read through each feed proxy with a multicall (0xcA11bde05977b3631167028862bE2a173976CA11).
- A price is stale when it is older than its feed heartbeat plus 1 h. Most feeds have a 24 hour heartbeat.
- An evaluation that needs a stale price is recorded as skipped and never trades. This is normal for Stock Tokens on weekends: their feeds update 24/5.
- A Stock Token feed returns the price of one token, which is the share price times the token’s multiplier. It can differ from the headline share price.
- The issuer can pause a token’s oracle during a corporate action. Reazy relies on the staleness rule for that case.
- No sequencer-uptime feed is published for this network, so Reazy cannot check sequencer status separately.
36 assets are supported: WETH and 35 Stock Tokens (AAPL, AMD, AMZN, ASML, BABA, CLSK, COIN, CRCL and others). An asset is listed only when its contract is in the official registry, its feed is in the Chainlink directory, and both answer on chain. The list was last verified on 2026-11-17 (UTC) by pnpm verify:network.
Contract-enforced vs server-enforced
Not every rule is enforced in the same place, and the difference matters. Today every control is enforced by Reazy’s server, in paper mode. No control is enforced by a smart contract, because no Reazy contract exists.
| Control | Server-enforced today | Contract requirement for live |
|---|---|---|
| Allowed assets | Only verified assets can be saved in a strategy. | Token allowlist in the vault. |
| Allowed venues | Paper simulation only. | Venue allowlist; no arbitrary calls. |
| Maximum trade size | Orders are reduced to the limit. | Per-trade cap in the vault. |
| Slippage limit | Orders are rejected above the limit. | Minimum output in the swap transaction. |
| Daily turnover | Rolling 24 hour count; reduce or reject. | A period spending cap, alongside the server count. |
| Cash reserve, allocation cap | Applied before every buy. | Server-side only. |
| Drawdown pause | Checked at each evaluation. | Cannot be enforced on chain. |
| Pause, revoke | Pause stops evaluations at once. | Owner pause and operator revocation on the contract. |
Drawdown control is monitoring, not protection. It depends on the quality of the valuation and on the next evaluation happening. It pauses an agent after a loss is observed; it does not cap the loss, and it must not be read as a guaranteed maximum loss.
Live execution requirements
Live execution is not available. Enabling it requires all of the following, in this order:
- A vault contract that meets the list under Vault permissions, with tests covering authorization and every asset outflow.
- Deployment on Robinhood Chain, source verification on the explorer, and transactions that prove each permission behaves as claimed.
- Its address recorded in the network configuration (
src/config/network.ts,DEPLOYMENT). - Implementations of
VaultAdapterandExecutionAdapter(src/server/data/types.ts) against that contract and a verified venue, replacing the gated ones insrc/server/adapters/gated.ts. - A transaction review screen showing network, asset, amount, spender, permission and fees before signing, and hash, explorer link, pending, confirmed and failed states after.
Until then the site says “Built for Robinhood Chain”. It will say “Live on Robinhood Chain” only after a deployment and its transactions have been verified.
Vault permissions
The vault is the design for letting an agent trade real assets without being able to take them. A contract may be called a Reazy Vault only if it has:
- withdrawals by the owner only;
- an operator that acts only after explicit authorization by the owner, and that the owner can revoke at any time;
- a pause the owner controls, which never blocks the owner’s own withdrawals;
- allowlists of assets and venues;
- approvals bounded to the trade amount;
- trade size and minimum output enforced in the contract;
- an event for every authorization, trade, pause and withdrawal;
- no way for the operator to make an arbitrary call.
A generic wrapper around a swap router does not qualify. No such contract is included in this repository and none is deployed, so Reazy does not hold or protect any funds.
Liquidity limitations
Position monitor. Enter the ID of a Uniswap v3 position on Robinhood Chain and Reazy reads it from the chain: the two tokens, the fee tier, the range, the current price, whether it is in range, its liquidity and token amounts, and its uncollected fees. Fees come from a static call of collect() made as the owner, which changes nothing; when that call is not possible the fees are shown as not available. The contract addresses come from Uniswap’s official deployment registry. Only this venue is supported.
Range calculator. Works entirely from the numbers you type and follows the Uniswap v3 liquidity formulas. It reads no pool, ignores gas, and assumes the range is never adjusted. The fee estimate multiplies three assumptions of yours.
Automated rebalancing is not available. It would need your authorization through a vault, a maximum spend, a gas budget, a slippage limit, a cooldown, a supported execution adapter and a durable action history. Rebalancing does not remove impermanent loss, and no yield is guaranteed.
Payroll authorization
Payroll is planning: recipients, schedules, payment dates and the funding they require. Four states are kept strictly apart:
| State | Meaning | Today |
|---|---|---|
| Draft schedule | A plan. Nothing is authorized or sent. | Every schedule is here. |
| Authorized payment | The owner authorized it from a funded vault. | Refused: no authorization mechanism. |
| Submitted transaction | Broadcast; it can still fail. | Not reachable. |
| Confirmed payment | Confirmed on chain. | Not reachable. |
A saved schedule never means a payment happened. Automated payments need a verified authorization mechanism, a supported token (USDG), a funded vault and an execution worker. None of the first three exists, so schedules remain drafts and the vault balance is shown as unavailable.
Deduplication is built into the data model: each schedule occurrence has a stable index and one row; a submission is a conditional move from “authorized”, so a retry cannot submit twice; and a transaction hash can belong to one payment only. Recipient addresses are checked for format and checksum, and a recipient with open schedules cannot be pointed at a different wallet.
Schedules are defined in a time zone you choose; daylight saving moves the instant, not the local time, and month-end dates fall back to the last day of shorter months.
Fees
- Reazy charges no fee in paper mode.
- Simulated venue fee. A rate you set per agent, in basis points, charged on the value of every simulated fill.
- Simulated slippage. A rate you set, applied against you on every fill. It must not exceed your slippage limit.
- Both appear on every fill, in every export and on every backtest report.
- There is no live fee schedule, because there is no live trading. Network gas would be paid by the transaction’s sender.
Local setup
Requirements: Node.js 22.12 or newer and pnpm 9.
pnpm install
cp .env.example .env.local # then fill in the values below
pnpm db:dev # local PostgreSQL on 127.0.0.1:16040 (keep it running)
pnpm dev # http://localhost:29700
pnpm worker # in a third terminal: evaluates due agents| Variable | Needed for | Notes |
|---|---|---|
DATABASE_URL | Everything with an account | PostgreSQL URL. Migrations apply on first use. |
SESSION_SECRET | Sign-in (production) | 32 or more random characters. |
CRON_SECRET | Scheduled worker endpoint | Random string; sent as a Bearer token. |
ROBINHOOD_RPC_URL | Reliable chain reads | A provider endpoint. Defaults to the rate-limited public one. |
NEXT_PUBLIC_SITE_URL | Metadata | The public origin of the site. |
Checks: pnpm check runs the type checker, the linter and the tests. pnpm verify:network re-verifies the network facts against the official sources and the chain. pnpm e2e runs the whole paper workflow against a running server.
Deployment
Reazy has two parts with different hosting needs: a web application and a worker.
Web application
A standard Next.js application. It runs on any Node host and on serverless hosts such as Vercel. It needs a PostgreSQL database reachable from where it runs, and the environment variables above. Run pnpm db:migrate once, or leave automatic migration on.
Worker
A serverless web host does not run permanent background processes. Paper execution therefore needs one of two things: a small always-on host running pnpm worker against the same database, or a scheduler that calls /api/cron/tick with the worker credential. On Vercel, the included vercel.json schedules that call every 15 minutes with Vercel Cron, which needs a plan that allows that frequency; on a plan limited to daily schedules, use the standalone worker or an external scheduler instead. Fifteen minutes matches the shortest evaluation interval and keeps a free-tier database within its compute allowance.
Without a worker the site still works, and agents simply are not evaluated. The status page shows the worker as unavailable or stale when that is the case.
Worker operation
pnpm worker # long-running; evaluates due agents every 30 s (WORKER_INTERVAL_SEC)
pnpm worker:once # one pass, then exit
pnpm worker:http # calls /api/cron/tick on an interval (for hosts where the web app owns the database)- The worker keeps no state. Schedules, intervals and results live in the database, so it can be stopped, restarted or run in several copies.
- An agent is evaluated at most once per interval, whoever asks. Calling the endpoint more often than needed is harmless.
- If market data cannot be read, the interval stays open and the agent page shows what it is waiting for.
- If the worker stops for a while, missed intervals are not replayed. The next pass evaluates the current interval only.
- Each pass writes a heartbeat. The status page reports the worker as stale after 20 minutes without one.
- Logs are one JSON object per line and contain identifiers and counts, never secrets.
Risk disclosure
Automation does not guarantee returns. Strategies can lose money, and live results may differ from simulations.
Reazy is software. It is not investment advice, it does not promise profit, and it is not risk-free. It is not affiliated with or endorsed by Robinhood. Its contracts have not been audited, because it has none. Stock Tokens are tokenised debt securities issued by a third party; they give economic exposure, not shareholder rights, and they are not available everywhere.