Bellwatch AI — The Market Bell

Your agent for the moments that matter.

Bellwatch monitors supported assets on Robinhood Chain, tracks market sessions, price freshness and liquidity conditions, and explains transactions before you sign. Set your rules. Follow the evidence. Stay in control.

Bellwatch AI is an independent project. It is not affiliated with, endorsed by or an official product of Robinhood. It is not a trading strategy, not an audited security product, does not predict outcomes and does not guarantee that every risk is detected. Rules are evaluated by code; the assistant explains retrieved data and never acts on your behalf.

What it does

• Market watch — reference prices from Chainlink feeds with observation time, block and freshness; underlying market session from the NYSE calendar (time-zone and holiday aware); issuer tokenization window; uiMultiplier for Stock Tokens; onchain pool availability (Uniswap v3 and hookless v4) and executable quotes (KyberSwap, Uniswap v3) with price impact against the reference.
• Alert rules — price above/below, feed age, market session transition and quote price impact, evaluated by a deterministic engine on a schedule, with cooldowns, de-duplication and an in-app inbox.
• Execution guardian — review a transaction hash (recorded events) or an unsigned request (decoding, identity, gas, eth_simulateV1 balance changes) with four finding labels and an explicit list of what was checked and what was unavailable.
• Evidence-based agent — a tool-backed assistant that answers only from retrieved data and cites sources and observation times; deterministic template answers when no AI key is configured.
• Landing page — a particle bell (React Three Fiber) swinging from its top pivot with a separately moving clapper, pointer influence, a "Preview alert" built from a live observation and a static SVG fallback. The rule cards and the review card are live: three example rules evaluated right now by the real engine, and the latest successful router transaction on the chain run through the real review pipeline (/api/showcase, cached five minutes).
• $BELLW token info — symbol, network and contract address (shown as "Soon" until published) in the Token section; pnpm token:ca 0x… verifies the contract on chain, writes src/config/token.ts and deploys. Informational only: no sale, staking or tokenomics.

See docs/CAPABILITIES.md for the full capability matrix, docs/DATA-SOURCES.md for sources, docs/VERIFICATION.md for the latest verification run and docs/DEPLOYMENT.md for hosting.

Works immediately / needs configuration

Verified providers and networks (2026-11-09 UTC): Robinhood Chain mainnet 4663 (official RPC, publicnode, dRPC — chain id checked), Chainlink feed directory (62 feeds), issuer registry (203 Stock Tokens), Uniswap deployments registry v1.0.0 (2026-11-04), KyberSwap aggregator (chain slug robinhood), Blockscout API, Sourcify v2, DefiLlama, NYSE calendar 2026–2028. Testnet 46630 answers its chain id but publishes no feeds, venues or Stock Tokens; a testnet build exposes gas balances only. Details and the raw check table: docs/VERIFICATION.md.

Not available: transaction execution of any kind, push/e-mail delivery, RFQ venues, Rialto, Lighter, exhaustive pool enumeration, testnet prices, audits or "safe" verdicts.

Local setup

pnpm install
cp .env.example .env.local      # defaults: pglite database, dev secrets, DoH pin for *.robinhood.com
pnpm dev                        # http://127.0.0.1:27500

Optional: pnpm worker in a second terminal runs the evaluator every 60 s against the dev server (HTTP mode, uses CRON_SECRET from .env.local); pnpm worker -- --once runs one pass.

Checks:

pnpm typecheck && pnpm lint && pnpm test   # tsc, eslint (React Compiler rules), vitest
pnpm verify:integrations                    # live registry verification → docs/VERIFICATION.md
pnpm build && pnpm start                    # production build on http://127.0.0.1:27510
node scripts/smoke.mjs                      # HTTP smoke + auth/ownership checks (SMOKE_BASE=…, CRON_SECRET=…)
node scripts/flow.mjs --base=http://127.0.0.1:27510   # browser flow with a stub wallet (nothing is broadcast)
node scripts/shot.mjs http://127.0.0.1:27510/ shots/landing.png --bell   # bell motion check + screenshot

Results of the checks performed for this release are in docs/TEST-RESULTS.md.

Layout

src/config          network, asset registry (generated from the sources), integrations, site copy
src/lib/util        decimal (bigint) arithmetic, errors, retry, caches, allow-listed fetch, time zones
src/lib/chain       RPC client with chain-id gate and Multicall3 waves
src/lib/market      prices (Chainlink), sessions (NYSE calendar + tokenization window), pools, quotes, snapshot
src/lib/rules       rule types + deterministic engine
src/lib/monitor     evaluator tick + worker status
src/lib/review      calldata decoders, findings, identity (Sourcify), preview (eth_simulateV1), history
src/lib/agent       tools, Anthropic runner, template answers
src/lib/auth        SIWE + sessions
src/lib/db          Drizzle schema + client (postgres / pglite / memory); migrations in drizzle/
src/app/api         route handlers (health, status, rpc relay, registry, market, quote, wallet, auth, watchlist,
                    rules, notifications, review, agent, cron)
src/components      landing (bell, sections), app (shell, tables, review view), ui primitives
scripts             brand, sync-docs, worker, migrate, verify-integrations, shot, smoke, flow, stub wallet
tests               vitest: decimal, engine, sessions, decode/findings, tool schemas, evaluator (PGlite)
docs                capabilities, data sources, deployment, privacy, verification, test results

Security notes

• Server fetches go only to allow-listed providers; user-supplied URLs are never fetched.
• Sign-in is SIWE with single-use nonces, domain + chain binding, expiry and server-side sessions; every private table is owner-scoped.
• The RPC relay allows read methods only; the app never signs, sends or schedules transactions; seed phrases and private keys are never requested.
• Public routes are rate-limited per IP; the cron endpoint requires CRON_SECRET.
• Tool results given to the assistant are data, never instructions; the assistant cannot modify rules.

Scripts

Supported capabilities

What Bellwatch does today, by network, and what each capability needs. "Unavailable" means the feature is shown as unavailable in the product rather than replaced by placeholder data.

Networks

One build targets one network (NEXT_PUBLIC_NETWORK). Mainnet and testnet data never mix. The chain id reported by every RPC endpoint is checked before any of its data is used.

Market watch

Reference prices are never executable quotes, and a price difference between venues is never presented as arbitrage.

Wallet and watchlist

Alert engine

Rules store owner, network, asset, type, threshold (decimal string), unit, source, enabled flag, cooldown, last evaluation, last result, last state and last trigger time. Evaluation is deterministic (bigint decimal arithmetic), edge-detected with cooldown re-notification, and every notification is bound to the observation that produced it (duplicate-proof after retries). Missing or stale data is "unknown", never zero.

The evaluator runs from a protected cron endpoint (/api/cron/evaluate, CRON_SECRET) or the standalone pnpm worker. The UI distinguishes worker active, worker delayed, background monitoring not configured and database unavailable from recorded runs. Browser notifications are optional, permission-based and tab-bound: no push delivery is promised.

Transaction review

Decoders: ERC-20 (approve, transfer, transferFrom, increase/decreaseAllowance, permit), WETH9, Permit2 (approve, permit, lockdown), Uniswap SwapRouter02 (exact input/output, multicall), Universal Router (command names, v3/v2 legs, wrap/unwrap, Permit2 permit), KyberSwap MetaAggregationRouterV2 (swap, swapSimpleMode), Uniswap V2 Router02. Unknown selectors are reported as unknown.

Findings use four labels only: Information, Review recommended, High-impact permission, Unknown. There is no "safe" verdict. Each review lists what was checked, what was unavailable, the block used and whether the simulation succeeded. Nothing is signed or sent; seed phrases and private keys are never requested.

Agent assistant

With ANTHROPIC_API_KEY: a server-side tool-backed assistant (model ANTHROPIC_MODEL, default claude-opus-5-5) using listSupportedAssets, getAssetObservation, getWatchlist, getAlertHistory, getTransactionReview, getIntegrationStatus, getMarketSessions. Tools enforce the caller's scope; the model cannot change rules or execute anything; tool text is data, never instructions; refusals and tool limits are reported.

Without a key: "AI explanations unavailable" and deterministic template answers built from the same tools (stale prices, why an alert fired, what an approval allows, what a transaction recorded, session status, monitoring status, per-asset observation).

Landing page live examples and token info

• The three rule cards are example rules with fixed thresholds (NVDA > 150 USD, ETH feed age > 3,600 s, SPY sell impact > 1.5 %) evaluated at request time by the production rule engine against live observations; each shows the observed value, source, observation time and verdict, and "Unknown" when data is stale or unavailable.
• The review card is the latest successful transaction sent to a registry router (SwapRouter02, else the Universal Router), found through Blockscout and decoded by the production review pipeline; when the explorer does not answer, the card says so.
• "Preview alert" rings the bell and shows a notification built from the live NVDA observation; it states that none of the visitor's rules triggered.
• Token section: $BELLW, network, contract address ("Soon" until published, then the verified on-chain facts). Informational only.

Not implemented / unavailable

• Transaction execution, signing or scheduling of any kind.
• Push notifications, e-mail, Telegram.
• Enumeration of every pool on the chain, RFQ venues (0x, 1inch Fusion, LiFi), Rialto propAMM, Lighter.
• Price prediction, strategies, "safe" verdicts, audits.
• Testnet prices, venues or Stock Tokens (none are published).

Data sources

Every figure in Bellwatch carries its source and observation time. This is the list of sources the server is allowed to contact (an allow-list in src/lib/util/http.ts); user-supplied URLs are never fetched.

Observation records carry value, unit, chainId, source, sourceUrl, observedAt, fetchedAt, blockNumber and a status of live, stale, unavailable, unsupported or illustrative. Token amounts are stored and compared as integer base units or decimal strings; no floating point is used for balances or thresholds.

Verification

Generated by pnpm verify:integrations on 2026-11-09T01:05:14.990Z (UTC) against Robinhood Chain (chain 4663), head block 109661810.

Result: 72 ok, 0 warnings, 0 failures. Warnings are unreachable sources from the machine that ran the check (for example DNS-blocked hosts); failures are mismatches between the registry and the sources and must be fixed before shipping.

Sources

• Chain ids, public endpoints and explorers: https://docs.robinhood.com/chain/connecting/
• Stock Token semantics, tokenization window and trading capabilities: https://docs.robinhood.com/chain/stock-tokens/ and https://docs.robinhood.com/chain/building-with-stock-tokens/
• Oracle semantics (multiplier included in the feed, 24/5 schedule, staleness guidance): https://docs.robinhood.com/chain/oracles-and-price-feeds/
• Feed addresses: https://reference-data-directory.vercel.app/feeds-robinhood-mainnet.json
• Canonical Stock Token addresses and multipliers: https://api.robinhood.com/rhj/assets (https://docs.robinhood.com/chain/stock-token-apis/)
• WETH / USDG addresses: https://docs.robinhood.com/chain/contracts/
• Uniswap deployments: https://developers.uniswap.org/deployments.json
• KyberSwap aggregator: https://docs.kyberswap.com/kyberswap-solutions/kyberswap-aggregator/aggregator-api-specification
• NYSE holidays and hours: https://www.nyse.com/markets/hours-calendars

Not verified / unavailable

• No Chainlink L2 sequencer-uptime feed is published for Robinhood Chain; feed heartbeat staleness is the primary freshness guard.
• Testnet (46630): no feed directory, no Uniswap registry record, no issuer deployments, no KyberSwap support; the testnet build exposes gas balances only.
• RFQ venues (0x, 1inch Fusion, LiFi), the Rialto propAMM and Lighter are named in the issuer documentation but are not integrated: no verified contract record was established for them here.

Deployment

Three pieces: the web app (Next.js), a PostgreSQL database, and the scheduled evaluator (a cron that calls the protected endpoint, or the standalone worker).

1. Web app

Any Node 22+ host that runs next build / next start, or Vercel.

Environment (see .env.example):

Build: pnpm install && pnpm build (runs scripts/sync-docs.mjs first). Start: pnpm start (port 27510) or next start.

Vercel

vercel.json declares the framework and a cron (*/15 * * * * → /api/cron/evaluate). Vercel sends Authorization: Bearer $CRON_SECRET when the CRON_SECRET environment variable is set on the project. Set every variable above in the project settings. Heavy routes declare maxDuration (60 s; the agent route 300 s, which needs Fluid compute or a Pro plan).

A 15-minute cadence keeps a free-tier managed PostgreSQL (which suspends after idle minutes) within its monthly compute allowance; a faster cadence needs a paid database or the standalone worker.

2. Database

PostgreSQL 14+. Apply migrations once per deploy:

DATABASE_URL=postgres://… pnpm db:migrate

(AUTO_MIGRATE=1 makes the app apply them on first use instead.) Locally, DATABASE_URL=pglite://./.data/pglite runs an embedded single-process PostgreSQL with no setup; memory:// is used by the tests.

Tables: users, auth_nonces, sessions, watchlist_items, alert_rules, rule_evaluations, notifications, observations, worker_runs, tx_reviews, agent_conversations, agent_messages (see drizzle/0000_init.sql).

3. Scheduled evaluator

Either:

• Cron → endpoint (serverless): a scheduler calls POST /api/cron/evaluate with Authorization: Bearer <CRON_SECRET> every MONITOR_INTERVAL_SECONDS. One call is one bounded pass (50 s budget).
• Standalone worker (any host with Node):
  • pnpm worker loops every WORKER_INTERVAL_SECONDS (default 60) in HTTP mode: it calls the web app's endpoint (WORKER_TARGET_URL or NEXT_PUBLIC_SITE_URL) with CRON_SECRET, so it works with whatever database the web app owns, including the local PGlite file.
  • pnpm worker -- --mode=direct opens DATABASE_URL itself (PostgreSQL only; PGlite cannot be shared between processes).
  • pnpm worker -- --once runs one pass and exits (useful in CI or as a systemd timer).

The product shows Worker active when the last recorded run is within twice the promised interval, Worker delayed when it is older, and Background monitoring not configured when no run was ever recorded or no database is configured. A browser tab is never presented as 24/7 monitoring.

4. Verification before shipping

pnpm verify:integrations   # re-checks the registry against the chain and the published sources → docs/VERIFICATION.md
pnpm check                 # typecheck, lint, unit tests
pnpm build && pnpm start   # production server on 27510
node scripts/smoke.mjs     # HTTP smoke + ownership checks (SMOKE_BASE=https://your-host for a live check; CRON_SECRET to exercise the cron)
node scripts/shot.mjs http://127.0.0.1:27510/ shots/landing.png --bell   # bell motion check + screenshot

Nothing in these steps sends a transaction or deploys a contract.

Test results

Checks actually run for this release, on 2026-11-09 (UTC), from the development machine (Windows 11, Node 24.16, pnpm 9.15). Robinhood Chain hosts are DNS-hijacked on this machine's ISP, so server-side reads ran with UPSTREAM_DOH=1 (DNS-over-HTTPS pin); a deployment on a normal network needs no pin.

Production build run

• NEXT_DIST_DIR=.next-build pnpm build (Next 16.4.5, Turbopack): compiled successfully; one warning ("Failed to find font override values for font Big Shoulders": next/font has no size-adjust metrics for this family; cosmetic). 25 routes: landing, app pages and docs prerendered static, API routes and the asset detail page dynamic.
• pnpm start on port 27510, then:
  • SMOKE_BASE=http://127.0.0.1:27510 CRON_SECRET=… node scripts/smoke.mjs → 65 passed / 65.
  • node scripts/flow.mjs --base=http://127.0.0.1:27510 → 29 passed / 29 (first production run 28/29: the flow driver clicked "Remove" and then kept looking for the button that had already disappeared; the driver now checks the expected state when a control vanishes after a click; the app was right).
  • pnpm worker -- --once (HTTP mode against 27510) → one evaluator pass recorded (ok: 2 rules, 0 triggered), status flipped to "Worker active"; --mode=direct with the PGlite URL refuses with the documented message; pnpm db:migrate applied the migration.
  • Screenshots (scripts/shot.mjs, SwiftShader): landing desktop (webgl-full, 15,100 particles, bell check ok), mobile (webgl-lite, 5,620 particles, bell check ok), reduced motion (svg-reduced-motion fallback), ?bell=svg (svg-no-webgl fallback), preview-alert click (toast + ring), scrolled hero, full page, every app page including the mobile watchlist, docs desktop and mobile. No horizontal overflow on any capture, no console errors. Files in shots/.
• Final clean rebuild (same code plus the docs and a hero scroll tweak): build ok, smoke 65 / 65, flow 29 / 29, bell probe ok. The local PGlite file was reset once before this run after a tooling accident on the development machine (a second server process opened the same data directory and was force-killed, after which PGlite aborted on every query); PGlite is single-process development storage, production uses PostgreSQL.
• Checks are only as good as their environment: all network reads went through the public endpoints (DoH-pinned) from one machine during a weekend session. US equities were closed and the Stock Token feeds showed weekend ages until the 24/5 window reopened at 01:00 UTC Monday; both states were observed and rendered as such.

Live deployment (2026-11-09 04:22 UTC)

• Vercel project bellwatch (team flow3515), deployment dpl_99wF5K5ML2odBK7uP6B6hqfguzyY, READY, aliased to https://bellwatch.vercel.app (the deployment-specific URL is SSO-gated, 302, as Vercel's default). Build on Vercel: compiled with the same single font warning; Vercel chose Node 26.x because engines was a range, so engines.node is now pinned to 24.x for the next deploy.
• Database: Neon Free (bellwatch-db, Vercel Marketplace, us-east-1) attached to production/preview/development; migrations applied from this machine over the unpooled URL before the first deploy. Cron */15 * * * * → /api/cron/evaluate registered with CRON_SECRET.
• SMOKE_BASE=https://bellwatch.vercel.app CRON_SECRET=… node scripts/smoke.mjs → 65 passed / 65 (pages, live Chainlink prices, pools, quotes, wallet reads, review preview with eth_simulateV1, SIWE sign-in of two generated accounts against Neon, ownership isolation, manual evaluation + inbox, cron pass with the secret → status "Worker active"). The smoke leaves two throwaway test accounts in the database.
• scripts/shot.mjs https://bellwatch.vercel.app/ --bell → webgl-full, 15,100 particles, swing −0.19…+0.19 rad from the top pivot, clapper separate; no overflow, no console errors.
• MetaMask/Blockaid rates bellwatch.vercel.app as BLOCK / DRAINER before any wallet connected (a known false positive for fresh *.vercel.app hosts); wallet sign-in should be served from a custom domain, which can be attached without a code change.

Not exercised

• The Anthropic model path was not exercised live (no ANTHROPIC_API_KEY on this machine); the template path was. The runner uses the SDK shapes from the official documentation (client.beta.messages.create, fallbacks: 'default', strict tools) and the strict-schema unit test guards the tool definitions; test one real reply after setting a key.
• Browser notifications were not granted in headless Chrome; the permission flow and its limits are described in the UI.
• No transaction was signed or sent anywhere; the stub wallet rejects every send and the RPC relay refuses non-read methods.
• Testnet build (NEXT_PUBLIC_NETWORK=robinhood-testnet) was type-checked and its registry is separate, but it was not run end to end.

Privacy

• Guests (no sign-in): the watchlist, read-only address and preferences live in the browser's local storage only. Read-only lookups (balances, market data, transaction reviews, agent questions) are answered from the server but not stored.
• Signed-in users (wallet signature): the server stores the wallet address, watchlist items, alert rules, rule evaluations, notifications, saved transaction reviews and agent conversations, keyed to the address. Sessions are HMAC-signed cookies backed by a server row and expire after seven days; signing out revokes the row.
• Authentication is Sign-In with Ethereum: a single-use nonce, domain and chain binding, a ten-minute expiry and signature verification. Connecting a wallet alone grants nothing. Seed phrases and private keys are never requested; Bellwatch never signs or sends transactions.
• Outbound requests from the server go only to the allow-listed providers in docs/DATA-SOURCES.md. User-supplied URLs are never fetched. Public routes are rate-limited per IP.
• AI: when an API key is configured, the question and the tool results needed to answer it are sent to the Anthropic API; nothing else is. Without a key nothing leaves the server.
• Retention: recorded observations are kept for 30 days; everything else until the user deletes it (rules are soft-deleted).

Bellwatch AI is an independent project and not affiliated with Robinhood.