RYNE BENSONGet in touch

nōōmen

Reverse-engineers a Solana wallet's trading into a strategy dossier with a copy or no-copy verdict, then runs a bot that trades beside it, paper first.

Ryne Benson

Product · On-chain research · 2 min read

A profitable wallet's history shows what it did, never why. nōōmen turns raw transactions into a ledger, a fingerprint of how the wallet trades, from its tooling and tips to its venues, failure rate and hours, and a set of typed rules you can test before any money moves.

The console is chat-first. An analyst agent queries the ledger, charts what it finds and walks the operator through building a strategy. A saved strategy runs on paper against live token launches, and only a strategy that survives paper earns a managed wallet of its own.

How it works

Backfill the wallet

A backfill pages the wallet's full transaction history into an S3 lake as raw pages and decoded trades.

Profile every token

Each token's launch is profiled: its creator, the dev buy, the bundled share and the early buyers, so the ledger knows what the wallet was actually buying into.

Build the ledger

Weighted-average and FIFO accounting, positions and the wallet's fingerprint, all queryable with DuckDB straight over the lake.

Ask the analyst, save a strategy

The analyst answers in SQL, charts and step-by-step forms. The strategy plugin ends in a card that saves typed entry, sizing, exit and risk rules.

Trade on paper

New token launches arrive by webhook onto an engine queue. The engine checks each one against every running strategy, fills paper buys and ticks positions until an exit closes them.

Decisions worth explaining

Routing each turn to the right model

Before a turn runs, a router scores its complexity. Simple turns go to a faster model, plugin turns and anything uncertain go to the strongest one, and a routing error falls back to the default instead of failing the turn.

Live trading is hard to reach

Personal stages can only paper trade. A kill switch starts on and needs a 2FA code to turn off, per-trade and daily-loss limits are enforced in code, and one isolated signer is the only thing that can read wallet keys.

A decoder that doesn't care about venues

Trades are decoded from the wallet's own balance changes, with program ids used only as labels, so a new DEX or router doesn't break the ledger.

Prompt caching that holds

Plugins and skills ride the user turn instead of the system prompt, so the cached system prompt never changes. Each turn's data access is limited by a signed scope.

Streams that survive a reconnect

Turns publish whole-content snapshots over IoT Core every 250ms, DynamoDB keeps a slower copy and the console falls back to polling, so text is never lost or duplicated.

By the numbers

  • 1 agent
  • 2 mcp servers
  • 12 mcp tools
  • 8 skills

The stack

  • Interface. Next.js, React, Tailwind CSS, shadcn/ui, Web Push
  • Agents. Claude Agent SDK, Bedrock AgentCore, Model routing
  • Tools. FastMCP, AgentCore Gateway, Helius, Jupiter
  • Data. DynamoDB, S3 lake, DuckDB
  • Platform. SST, Lambda, SQS, IoT Core, Cognito, KMS, Stripe
  • Delivery. GitHub Actions, semantic-release, Images by git tree id