Solace

Inspiration

Crypto wallets are where most new users bounce off Web3. You are asked to memorize 44-character addresses, understand slippage and priority fees, reason about whether a transaction is safe to sign, and manually rebalance your portfolio across half a dozen tokens. We wanted to build a wallet that felt less like cockpit instruments and more like texting a friend who happens to be a quant, a security researcher, and a trading desk all at once. Solana was the obvious home for it: sub-second finality and near-zero fees meant natural language commands could feel instant, the way chat should.

What it does

Solace is a natural language Solana wallet. You type what you want in plain English, and an AI agent handles the rest.

• Natural language intent parsing. Every message routes through Claude Haiku, which classifies it into one of 17 structured intents (send, swap, schedule, save contact, set portfolio target, pause rebalancing, and more) and extracts the relevant fields.
• AI Wallet Guard. Before you sign any transaction, a second Claude call analyzes the tx context for risk. You see a safe, caution, or danger badge in the confirmation modal. Flagged transactions are logged to a local threat table.
• Autonomous portfolio manager. Tell it keep my portfolio 60% SOL, 30% USDC, 10% BONK, and a background poll checks drift every 30 seconds. When drift crosses your threshold, Claude picks the exact swaps needed to rebalance, and executes them through Jupiter.
• Scheduled payments and DCA. Send 10 USDC to Alice every Friday becomes a cron-like recurring payment stored in SQLite. Buy $50 of SOL weekly becomes a DCA order that the app executes on schedule.
• Multi-step commands. Swap 50 USDC to SOL then send it to Alice chains up to four sequential actions, with the output of each step feeding the next.
• Contacts. Save addresses under names once, then just say the name.
• Voice input. Click the mic, speak the command, it runs through the same pipeline.
• Liquid staking. Stake SOL for mSOL through Marinade in one sentence.

Under the hood it is a Solana wallet with Phantom, Jupiter swaps, Marinade staking, and AI wrapping the whole experience.

How we built it

Stack:

Architecture. Every user message goes through one pipeline: parse intent with Claude, build the raw Solana transaction, run the AI security scan in parallel, show a confirmation modal with a risk badge, sign with the wallet adapter, broadcast, and generate an AI receipt card linked to Solscan. The portfolio manager sits on top of this as a polling loop that synthesizes natural language swap commands autonomously when drift is detected.

Notable decisions. All Claude calls go server-side so the API key never reaches the client. Transaction amounts are stored and computed in lamports internally, only converted for display. We use VersionedTransaction everywhere so priority fees and compute budget instructions compose cleanly. The security scan uses AbortController so that cancelling a preview kills the in-flight analysis, preventing stale risk badges from leaking into the next preview.

Challenges we ran into

Getting mainnet SOL in time. Two hours before the deadline we realized we could not move enough SOL to mainnet to record the demo video without putting real capital at risk. Jupiter has no liquidity on devnet and Marinade is mainnet-only, so the swap and staking flows were hard-blocked. We built a "devnet demo mode" that keeps the entire UX pipeline identical but intercepts the final execution step: quotes still come from real Jupiter pricing, but swap execution is substituted with a 1-lamport SOL self-transfer on devnet so you still get a real signature and working Solscan link. Synthetic non-SOL balances are seeded in SQLite so the portfolio manager has something to rebalance against. The flip back to mainnet is one environment variable.

Reliable structured output from an LLM. Parse-intent needed to return valid JSON every time across 17 intent types, with strict field validation, or the whole pipeline broke. We iterated on the system prompt until Claude reliably emitted JSON-only responses with no preamble, and added a second layer of TypeScript-side validation on top.

Multi-step intent chaining. Swap 50 USDC to SOL then send it to Alice means the send step needs to know the output amount from the swap, which does not exist until after Jupiter executes. We introduced a sentinel (amount: null) that the executor resolves at runtime from the previous step's receipt.

Keeping the security scan non-blocking. The scan has to run before the user signs, but must never prevent signing if Claude is unavailable. We return an analyzed: false baseline on failure and surface it in the UI as "AI Guard unavailable" instead of a misleading "Safe" or an error state.

Accomplishments that we're proud of

• 17 intent types, one prompt. A single Claude system prompt handles sends, swaps, scheduling, contacts, portfolio configuration, pausing, drift thresholds, multi-step chains, and unknown-intent clarifications, all with strict JSON output.
• The autonomous portfolio manager actually works. You set a target once, walk away, and the app watches drift and rebalances through Jupiter without asking you again. It is the closest thing to an index fund we have seen in a self-custody wallet.
• The AI Wallet Guard is novel. Most wallets rely on block-explorer style post-mortems or static allowlists. Ours reasons about the specific transaction in context: program, amount, route, your balance, price impact, and gives you a three-tier risk read before you sign.
• We shipped a demo-mode architecture in under two hours when we realized the mainnet plan was not going to happen, without sacrificing a single feature.

What we learned

• LLM-driven UX needs aggressive boundaries. Parse-intent had to be narrow and deterministic. Anything that let Claude freelance ended up with unpredictable behavior in the transaction pipeline. Strict JSON schemas and enum-typed discriminators saved us.
• Solana's transaction model is a pleasure once you commit to VersionedTransactions. Priority fees, compute budgets, and multi-instruction batching compose predictably.
• Autonomy is a trust problem, not a technical one. Building something that signs transactions on your behalf means every edge case matters: drift threshold math, minimum swap size to avoid micro-trades, sequential execution so swaps do not race each other. We spent as much time on guardrails as on the happy path.
• Demo-mode as a first-class architecture pattern. Gating the execution layer behind a single IS_DEMO_MODE flag, rather than scattering mocks through the codebase, meant the entire pivot was reversible with one env var.

What's next for Solace

• True server-side background rebalancing. Today the portfolio manager requires the app tab to stay open. A session-key or custodial-key architecture would let Solace rebalance while the user is offline, closer to a real robo-advisor.
• Full SPL token send support. Native SOL sends work today; SPL transfers are built but not wired into every intent path. Small lift, big UX win.
• SOL domain resolution. Resolve .sol names via Bonfida before building any send transaction, so users can say send 2 SOL to ahmad.sol.
• More DEXes, more stakers. Orca and Raydium as fallback routes when Jupiter has poor liquidity. Jito and BlazeStake alongside Marinade.
• Mobile app. The current interface is responsive but a native mobile experience with biometric signing would be the ideal form factor for a chat-first wallet.
• Agent marketplace. Let users install third-party agents (tax-loss harvesting, yield optimization, NFT sniping) that plug into the same intent pipeline. Solace becomes the runtime, others build the strategies.

Built With

• claude
• magicui
• next
• shadcn
• solana
• tailwind
• typescript