Open, self-hosted, multichain Personal AI CFO.

Trade, snipe, analyze, and run autonomous strategies through chat — self-hosted first, managed-runner ready, and no closed-source CLI in the path. Starting with deep Solana coverage; multichain in the roadmap.

kuro is a multichain Personal AI CFO in the spirit of Minara, with three honest differences:

1. Open-source executor — Minara's CLI is closed-source npm; kuro's Rust executor + TypeScript agent are fully auditable.
2. Self-hosted first, hosted-ready — local mode keeps the hot wallet on your machine; hosted mode isolates one embedded hot wallet per runner with a funding address/QR and no pooled funds.
3. Sniper-specialized depth — Minara is a generalist swap/perps tool; kuro is built around Jito-bundled sniping, honeypot simulation, new-pool detection, smart-money signals, and a deterministic autonomous loop.

Today, kuro is Solana-only. Multichain (Base / Ethereum / Arbitrum next, eventually Hyperliquid perps) is in the roadmap. The chain abstraction is being designed so the second chain is a module, not a fork.

It runs in three modes:

1. A read-only signal worker (kuro signals) — watches launch programs, runs analysis/Brain Agent enrichment, and emits JSON-lines without ever calling /swap.
2. A standalone autonomous trading agent (kuro autonomous) — watches new pools on Pump.fun / PumpSwap / Raydium / Meteora, runs safety + signal checks, snipes via the Rust executor with Jito bundles, manages positions with TP/SL/max-hold exits. The whole loop runs without an LLM in the latency path.
3. A drop-in skill for Claude Code / OpenClaw / Hermes — drop skills/kuro/ into your host agent's skills directory and ask in plain language: "analyze this mint", "snipe 0.05 SOL of $BONK if safe", "enrich this dev wallet". The host agent reads SKILL.md, picks the right command, shells out to kuro.

These modes can run together — read-only signals on a server, autonomous dry-run on another worker, and interactive analysis from your laptop.

┌─ Skill mode (Claude Code / OpenClaw / Hermes) ─┐
│  Host agent reads skills/kuro/SKILL.md         │
│  → picks a command → shells out to kuro CLI    │
└────────────────┬───────────────────────────────┘
                 │
┌────────────────▼───────────────┐    ┌──────────────────────────────┐
│  agent/  (TypeScript)          │    │  executor/  (Rust hot path)  │
│  • skills/      kuro commands  │ ─→ │  • Jupiter v6 quote + swap   │
│  • autonomous/  event loop     │    │  • Jito bundle submission    │
│  • watcher/     new-pool sub   │    │  • Risk caps (per-trade,     │
│  • brain/       multi-LLM      │    │    daily, drawdown)          │
│  • data/        external APIs  │    │  • 2s blockhash cache        │
└────────────────────────────────┘    └────────────┬─────────────────┘
                                                   │
                                              hot wallet

Why split TS + Rust? The LLM (Claude / GLM / Codex / Anthropic) can take 200–1000ms per call. That's a death sentence for sniping. The Rust executor owns the wallet and signs+sends trades in <100ms. The LLM decides what to trade; the executor decides how fast.

# 1) Clone + install the agent
git clone https://github.com/Sarthib7/kuro.git
cd kuro
cd agent && npm install

# 2) First-run setup: local, cloud, or Raspberry Pi
# Writes repo-root .env, prefers Codex auth if ~/.codex/auth.json exists,
# and keeps KURO_AUTONOMOUS_LIVE=false.
npm run setup

Open new shells at the repo root.

Terminal 1:

cd executor
cargo run --release
# auto-generates the embedded hot wallet under KURO_DATA_DIR

Terminal 2:

cd agent
# read-only token analysis
npm run analyze -- 9BB6NFEcjBCtnNLFko2FqVQBq8HHM13kCyYcdQbgpump

# watch new pools (Ctrl-C to stop)
npm run watch

# stream launch signals without touching funds
npm run signals
# public RPC / Pi safe source filter; set KURO_WATCH_SOURCES=all on dedicated RPC
KURO_WATCH_SOURCES=pumpfun,pumpswap npm run signals

# pools, liquidity flow, and executable AMM quote book
npm run liquidity -- <mint>

# full read-only trading scan: analysis + liquidity + arbitrage
npm run scan -- <mint> --size-sol=0.1

# LLM-driven interactive (uses brain selected by KURO_BRAIN)
npm run agent -- "is this mint a honeypot: <mint>"

# autonomous trading loop (dry-run unless KURO_AUTONOMOUS_LIVE=true)
npm run autonomous

# show open + closed positions
npm run positions

# show the generated embedded wallet, funding URI, and top-up readiness
npm run wallet

# Phoenix perps read-only state
npm run dev -- phoenix-markets SOL
npm run dev -- phoenix-signal SOL --timeframe=1m --limit=120
npm run dev -- phoenix-orderbook SOL --levels=10
npm run dev -- phoenix-trader

# Phoenix isolated market order dry-run (builds + simulates; does not submit)
npm run dev -- phoenix-open SOL long 0.1 10 --dry-run=true

• Docs index: docs/index.md
• First-run setup: docs/setup.md
• Trading action plan: docs/trading-action-plan.md
• Production runbook: docs/production.md
• Live API guide: docs/live-api.md
• ADR index: docs/adr/README.md
• Static operator console: site/index.html

mkdir -p ~/.claude/skills
cp -r skills/kuro ~/.claude/skills/kuro

Then ask Claude Code naturally: "kuro, analyze $BONK", "watch for new pump.fun pools", "snipe 0.02 SOL of , dry-run first".

kuro is built to run with the executor on Railway and the UI as a separate static app. Keep kuro-executor (Rust, owns the wallet) on Railway with a volume. Host site/ on Vercel or Cloudflare Pages, then add that UI origin to KURO_ALLOWED_ORIGINS.

For worker-only operation, kuro-autonomous should call the executor over Railway's internal network. For browser operation, the executor needs a public URL, KURO_EXECUTOR_API_KEY, and a narrow CORS allowlist.

One-time setup

1. Create a Railway project. Connect this repo.
2. Service 1 — kuro-executor
   • Set service root directory to executor/
   • Attach a Volume mounted at /data (≥ 1 GB) — this holds the hot wallet and risk state
   • Set env vars:

     SOLANA_RPC_URL=https://mainnet.helius-rpc.com/?api-key=YOUR_HELIUS_KEY
     PORT=8080
     KURO_BIND=0.0.0.0:8080
     KURO_EXECUTOR_API_KEY=strong-random-secret
     KURO_ALLOWED_ORIGINS=https://YOUR-KURO-UI.vercel.app,https://YOUR-KURO-UI.pages.dev
     KURO_DATA_DIR=/data
     KURO_MAX_TRADE_SOL=0.02
     KURO_DAILY_CAP_SOL=0.1
     KURO_DRAWDOWN_KILL_PCT=20
     

   • Deploy. The executor will auto-generate /data/keypair.json on first boot.
3. Static UI — site/
   • Deploy separately on Vercel or Cloudflare Pages.
   • Use executor URL https://kuro-production-281c.up.railway.app or your own Railway domain.
   • Paste KURO_EXECUTOR_API_KEY into the UI when connecting. It stays in browser local storage.
4. Service 2 — kuro-autonomous
   • Set service root directory to agent/
   • Attach a separate Volume mounted at /data (≥ 1 GB) — holds open/closed position state
   • Set env vars:

     SOLANA_RPC_URL=https://mainnet.helius-rpc.com/?api-key=YOUR_HELIUS_KEY
     KURO_EXECUTOR_URL=http://kuro-executor.railway.internal:8080
     KURO_EXECUTOR_API_KEY=same-secret-as-executor
     KURO_POSITIONS_PATH=/data/positions.json
     KURO_BRAIN=glm
     GLM_API_KEY=your_glm_key
     KURO_AUTONOMOUS_LIVE=false
     

   • Optional enrichment keys: BIRDEYE_API_KEY, ZERION_API_KEY, GMGN_API_KEY, JUPITER_API_KEY.
   • Deploy. The autonomous worker will reach the executor via internal DNS.

Fund the wallet

Once the executor is running, get its public key:

railway logs --service kuro-executor | grep wallet

…or hit /status from a temporary public domain. Send SOL to that address. Verify with /status again.

Flip live (only after backtest validates)

Set KURO_AUTONOMOUS_LIVE=true in the kuro-autonomous service env and redeploy. The Rust executor's per-trade / daily / drawdown caps still apply — even if the agent is jailbroken, the executor rejects oversized swaps.

Critical

• Do not lose either volume. The executor volume holds the keypair; the agent volume holds position state.
• Use Railway's "deploy from PR" sparingly — every deploy to the executor service restarts the process. The risk state persists across restarts (it's in the volume), but in-flight swaps don't.

kuro agent and any future LLM-assisted policy decisions go through a pluggable brain abstraction.

Skill mode (running inside Claude Code etc.) doesn't use this — the host agent is the brain.

All optional; analyze_token degrades gracefully when a key is missing.

KURO_MAX_TRADE_SOL=0.1           # per-trade ceiling — executor rejects above this
KURO_DAILY_CAP_SOL=1.0           # cumulative daily spend — executor rejects above this
KURO_DRAWDOWN_KILL_PCT=20.0      # if balance drops by this % from start-of-day, all trades blocked
KURO_MAX_PERP_COLLATERAL_USDC=25 # per Phoenix isolated order collateral cap
KURO_DAILY_PERP_COLLATERAL_USDC=100
KURO_PHOENIX_LIVE_ENABLED=false  # live perps stay blocked unless explicitly enabled

These live in the executor's state (executor/state.json) and survive restarts. The LLM cannot bypass them, even if its system prompt is jailbroken — the rejection happens before the swap is built.

Solana depth (gates live trading):

• Backtest harness — replay historical Pump.fun launches against policy.decide() to validate hypothetical EV before flipping KURO_AUTONOMOUS_LIVE=true
• Persistence — SQLite in executor for positions / trades / risk (replaces JSON files)
• Yellowstone Geyser — gRPC streaming on Helius dedicated plan for sub-100ms new-pool detection
• Multi-RPC sendTransaction race — submit same tx to Helius + Alchemy in parallel for faster landing
• Smart-money policy boost — fold GMGN's alpha-wallet signal into policy.decide() as a size multiplier

Multichain expansion (after Solana proves out):

• Chain abstraction — Chain trait in Rust executor + TS data layer abstracting per-chain RPC, swap router, and explorer
• Chain 2: Base — Uniswap V4 + 0x routing, ERC-20 sniper, Aerodrome integration
• Chain 3: Ethereum / Arbitrum / BSC — share the Base implementation
• Hyperliquid perps — open positions, leverage, stop-out logic
• Cross-chain bridge intent — LiFi or Across routing for "move my position to chain X"

AI CFO surface (Minara parity items):

• kuro portfolio — cross-chain balance + position table
• kuro transfer / kuro withdraw — guarded fund-moving operations
• kuro limit-order — server-side limit orders via DEX-native limit-order programs
• Fiat onramp — deferred until there's a clean self-hosted path; not depending on MoonPay-style proprietary integrations

• Skill convention follows the Minara-AI/skills pattern. kuro and Minara are designed to coexist: install both ~/.claude/skills/minara and ~/.claude/skills/kuro. Minara wins on multichain spot + perps + fiat today; kuro wins on Solana sniper depth + open source + self-hosting.
• Tested with: Claude Code (Sonnet 4.6 / Opus 4.7), GLM-4.5, Codex CLI (gpt-5-codex).
• Subprocess Codex fallback works but is degraded — native OAuth → Responses API is preferred.

MIT