Inspiration

Memecoins launch by the thousands every day, and most die within hours. The coins that survive have something in common: an active community and a creator who keeps rewarding the people who show up. That takes constant work, and it usually means one person holding the treasury and making every payment by hand.

AI agents looked like the answer, but I didn't want to hand an AI a wallet. If an agent holds the keys to the money, one bad prompt or one bug can drain everything. So I set out to answer one question: can a coin have an AI agent that does real work with real money, while the creator stays fully in control?

What it does

Ryyven is a memecoin terminal and launchpad with an AI agent for every coin.

  • Live terminal: new pairs, coins about to graduate, and graduated coins, refreshed every 3 seconds. Filters (age, market cap, volume, holders, curve progress, safety) search the whole market, not just what's on screen. Each coin has its own trading page with live charts from 1 second to 1 day, and you can buy or sell from your own wallet.
  • Launch: create a coin on a bonding curve in one transaction. It's tradable the moment it's live.
  • AI agent: every coin can deploy an agent you talk to in plain English: "Reward three contributors with 0.01 SOL each", "Alert me if SOL drops 5%", "Analyse my wallet and give me ideas". It pays contributors, proposes or makes trades, sets price alerts and writes a daily wallet brief.
  • Treasury you own: the agent's treasury belongs to you. The agent can only spend the allowance you give it, and Solana itself enforces that limit.

How I built it

  • App: Next.js 16 (App Router), React 19, TypeScript and Tailwind, deployed on Vercel. Postgres (Supabase) with Drizzle stores agents, payments and history.
  • Wallets: Phantom and Solflare through the Wallet Standard, and Sign-In With Solana (a free signed message, with no email or password).
  • AI: Claude with tool use. The agent can only act through a fixed set of tools (pay, swap, analyse portfolio, set alerts, read trading activity), and every tool call goes through a rule engine before anything is signed.
  • Treasury design: each treasury is a token account owned by the creator. The agent's key is only a delegate with a capped allowance. Solana rejects anything above that allowance, even if my server were compromised, and the creator can revoke it in one transaction. SOL treasuries use wrapped SOL, so the same model works for SOL, USDC and the coin itself.
  • Rule engine: limits per payment and per day, payment categories, a list of allowed recipients, and an emergency pause. Payments above the auto-approve limit pop up for the creator to approve. The engine is pure code, separate from the AI, and fully unit-tested.
  • Trading safety: before any trade is signed, Ryyven checks which programs the transaction calls, who signs it and who pays the fee. It then simulates the transaction to measure what it really spends.
  • Market data: Jupiter for swap quotes, routing and market data; Pyth and DexScreener for prices. A shared server cache keeps the live terminal fast for every user.
  • Testing: the treasury flows (fund, pay, revoke, withdraw, close) run against the real SPL Token program in LiteSVM, alongside about 90 tests for the rule engine, filters and transaction checks.

Challenges I ran into

  • Making AI safe with money. The key decision was that the AI never holds spending power. It proposes; deterministic code and the on-chain allowance decide. Getting this right meant reserving budget before signing, locking per agent so that parallel requests can't overspend the daily limit, and making every payment safe to retry.
  • Wallets change transactions. Buys suddenly failed for real users because Phantom adds its own safety-check instructions when it signs. My strict list of allowed programs rejected them. I had to allow those check-only instructions without loosening any other protection.
  • Serverless constraints. Background timers don't survive on Vercel, so price alerts and daily briefs moved to cron jobs with token authentication. A domain redirect then quietly dropped the authentication header, which took a while to track down.
  • Live data at scale. Polling a market that changes every second, hitting rate limits from data providers, and making filters search the whole market without slowing the page all needed careful caching.
  • Not stranding funds. Deleting an agent destroys its key, so before deleting, Ryyven returns everything in the treasury and the trading wallet to the creator. It re-checks on-chain that nothing is left behind before the agent is removed.
  • UX for non-experts. Early versions sent people to separate approval tabs, and the terminal showed raw tool logs. Users were lost. Both became simple popups ("Approve", "Sign", "Fund") right where the agent needs them.

What I learned

  • Agents propose, code disposes. Combining an AI agent with on-chain spending limits gives you the flexibility of AI and the guarantees of a blockchain.
  • The token program is a security tool. Solana's delegate and allowance model already enforces spending limits, with no custom smart contract needed.
  • Simulate before you sign. Simulation catches what reading the transaction alone misses.
  • Real users find what tests don't. Wallet quirks, domain warnings, hotlinked images and confusing approval flows only showed up once people used the app.

What's next

I want to add more agent skills (scheduled rewards, community campaigns, on-chain reputation for contributors), agent-to-agent payments between coins, and a mobile-first trading view.

Built With

  • anthropic
  • claude
  • dexscreener
  • drizzle-orm
  • helius
  • ipfs
  • jupiter
  • next.js
  • node.js
  • phantom
  • pinata
  • postgresql
  • pumpportal
  • pyth
  • react
  • solana
  • solana-wallet-adapter
  • solana-web3.js
  • solflare
  • spl-token
  • supabase
  • tailwind-css
  • token-2022
  • typescript
  • vercel
Share this project:

Updates

Submission history