Kura (蔵 — a storehouse that guards your treasures)

A local EVM wallet for AI agents. On a Mac, when an AI like Claude makes an internet payment (x402), this is the wallet where a human approves it with a password.

• Not a human wallet (like MetaMask) — it's for AI agents

• Not a cloud SaaS — it runs locally only. Keys never leave this computer.

• AI requests a payment → a human approves with a password → it executes

• The chain is Base (Ethereum L2, near-zero fees). Default is the testnet (Base Sepolia)

At a glance

[ AI 앱 (Claude Code / 데스크톱) ]
        │  MCP로 "결제해줘" 요청
        ▼
[ Kura 데스크톱 앱 ]  ← 승인 팝업 → 사람이 비밀번호 입력
        │  서명 (키는 이 앱 안에서만)
        ▼
[ Base 체인 / x402 페이실리테이터 ]  ← 실제 결제

The password is only ever entered in the Kura app's input field. It never goes into chat windows, MCP, or config files.

Related MCP server: cardzero-mcp

Installation

Apple Silicon Mac (macOS 11 or later)

(A) Homebrew

brew install --cask dinggi5/tap/kura

(B) Download the DMG directly

Download Kura_<version>_aarch64.dmg from Releases, open it, and drag Kura into the Applications folder.

Since this is an app you're entrusting with your keys, I've written down the exact commands for verifying that the app you received is really the one I built in SECURITY.md.

(C) Build from source

Prerequisites: Rust, Node.js (20.19+ or 22.12+ — required by Vite 7), macOS.

git clone https://github.com/dinggi5/kura.git
cd kura
git checkout v0.1.1   # 배포본과 같은 소스. 빼면 개발 중인 최신 코드가 받아져요
npm ci                # package-lock.json 그대로 설치 (install 은 버전이 올라갈 수 있어요)

# 개발 모드로 바로 실행
npm run tauri dev

# 앱으로 빌드해 /Applications에 설치
npm run tauri build -- --bundles app --no-sign
ditto src-tauri/target/release/bundle/macos/Kura.app /Applications/Kura.app
open /Applications/Kura.app

Updates

The app updates itself.
Go to Settings → About to check the version and changelog, then click Install now and restart.

• Only the check is automatic — installation always requires you to click it.

• Downloaded files are installed only after their signature is verified (signature verification cannot be disabled). Details are in the "Updates" section of SECURITY.md.

• If you don't want the automatic update-check traffic, turn off Settings → About → Check on startup.

Uninstalling

⚠️ Uninstalling the app does not delete your wallet. Keys, settings, and transaction history live in ~/.jigap outside the app, so removing just the app leaves them intact — I did this on purpose so you don't accidentally lose your assets (even brew uninstall --zap won't remove them).

# 앱만 제거 (지갑은 남음 — 나중에 다시 설치하면 그대로 이어서 써요)
brew uninstall --cask dinggi5/tap/kura   # 또는 /Applications/Kura.app 을 휴지통으로

To completely erase the wallet too on this Mac, follow this order:

1. First make sure you have the 12-word recovery phrase in hand. You can view it again via the key button in the app's header.

2. If there's a balance left, move it to another wallet.

3. Quit Kura completely (right-click the menu bar icon → Quit). If it's running, it writes a state file to ~/.jigap every few seconds, so a deleted folder will reappear right away.

4. Also quit any AI tools (like Claude Code) that have the Kura MCP attached.

5. If you had auto-start enabled, turn it off or run rm ~/Library/LaunchAgents/Kura.plist (this file remains if you delete the app via Trash. If you uninstall with brew uninstall --cask, it goes away with it).

6. Then run rm -rf ~/.jigap

Running that final rm -rf ~/.jigap without the 12 words means no one can ever recover that wallet's assets.

First run

Kura lives in the menu bar. When you launch it, a storehouse icon (◻︎) appears in the menu bar at the top of your screen, and the window only drops down when you click that icon. Clicking elsewhere closes it, and the app stays in the background waiting for AI payment requests. To quit completely, right-click the icon → Quit. (On first launch when no wallet exists yet, the window opens by itself.)

1. Create a wallet — set a password (8+ characters) that you'll enter for every transfer. Your key is encrypted and stored with this password (~/.jigap/wallet.enc).

2. Back up the seed — 12 words are shown. This is the real proof of ownership of your assets, so write them down on paper or in a password manager. Even if you forget your password, the 12 words alone can recover it: quit the app, first make sure you have the 12 words in hand, then delete ~/.jigap/wallet.enc and relaunch the app — you can restore it via Import on the first screen (you can also put them into any other standard BIP-39 wallet). However, deleting this file without the 12 words means losing your assets forever.

3. Welcome tour — walks you through funding, AI connection, and safety features. You can revisit it anytime from the ⓘ Help in the header.

Funding (USDC)

To make payments, your wallet needs USDC (digital dollars).

• Tap Receive in the app to see your address and QR code.

• When sending from an exchange or another wallet, be sure to select the Base network. Sending on another network will lose your funds.

• On the testnet (default), it's not real money. Use the Faucet button on the receive screen to get free test coins and practice.

• ETH is optional — for x402 payments, the facilitator pays the fee, so you can have 0 ETH. You only need a little ETH for gas when sending directly via the app's Send (Base fees are around a cent). Funding with USDC alone is enough.

Connecting AI (Claude)

Register the Kura server in your AI app's MCP settings to connect. Once connected, a "Claude connected" badge appears on the main screen. Since 0.1.2, the MCP server is built into the app, so you can connect without cloning the source or installing Rust.

The easiest way — the "AI Connect" screen in the app

Click the "AI not connected" badge at the top of the main screen to open the connection screen.

• Claude Desktop — click the "Connect" button and an extension install window appears in Claude. Just click 'Install' and you're done.

• Claude Code — registered with one click (the app runs claude mcp add for you). From the next claude launch, it's connected from any folder.

Below is how to do the same thing by hand.

Claude Desktop — one extension file is all you need

Download kura-<version>.mcpb from the releases page and double-click it — Claude Desktop will ask to install it. (Or go to Claude Settings → Extensions → Choose file.)

The extension contains no executable — it only has a launcher that verifies the signature of the signed and notarized MCP server inside the installed Kura.app and then runs it. So you need to install the Kura app first.

Claude Code · other MCP apps

Register the in-app binary with its absolute path:

claude mcp add --scope user kura -- /Applications/Kura.app/Contents/MacOS/kura-mcp

(--scope user is the option that makes it available everywhere, not just "this folder". If you only want it in one project, you can omit it.)

For other MCP apps, write it in the settings like this:

{
  "mcpServers": {
    "kura": {
      "command": "/Applications/Kura.app/Contents/MacOS/kura-mcp"
    }
  }
}

If you're developing from source

The repo root already has .mcp.json. Running claude in this folder picks it up automatically (the first time it asks whether to use the server — approve it). This path is for development, rebuilding with cargo run every time — if you're using an installed build, registering the app path above is the right approach.

Tools the AI can use: get_wallet_status · get_balances · get_history (read-only) · request_payment (payment request → approval popup in the app) · x402_fetch (calls a URL that requires 402 payment).

If you change the MCP tools, restart the AI app for it to take effect (the server is loaded once at session start).

How a payment flows

1. The AI requests a payment.

2. The Kura window appears showing how much, to where (it pops up automatically even if the window was hidden).

3. Enter the password and approve.

4. The payment executes and the result goes back to the AI. If you don't approve within 5 minutes, it's automatically rejected.

Security model

• Password approval — by default, every payment requires password approval (if autonomous payments are enabled, exceptions apply only under the conditions below). Keys are stored encrypted (Argon2id + AES-256-GCM) and are only decrypted at payment time, then wiped immediately (if an autonomous payment session is enabled, they're kept in memory only while unlocked).

• Limits — set how much can be sent per transaction / per day in settings (default: 5 USDC single, 20 USDC daily). Anything over is blocked.

• Emergency lock — turning on the shield button in the header immediately blocks all transfers.

• Trusted addresses · autonomous payments — for automatic approval without a password, session unlock + small limits + trusted address must all be satisfied. Otherwise, a password is always required.

• Transaction history — records all outgoing transfers, blocked attempts, and signatures.

• Local-first — keys (~/.jigap/) live outside the repo and never get committed to git.

• No analytics, no font CDN — the app connects to the internet on its own for only three things: ①the RPC server used for balance lookups and transfers ②x402 addresses requested by the AI ③update checks (GitHub). Usage data is never sent anywhere, and fonts are bundled in the app, so the UI renders fine offline too.

• Update checks can be disabled — on launch it asks GitHub whether a new version exists (your IP and current version are logged there). Turning off Settings → About → Check on startup removes even this traffic. Whether the check is on or off, installation only proceeds when you click it — nothing ever changes silently.

For developers

You can also drive the same wallet from the CLI kura (it shares the MCP server and core logic). It's already inside the installed app, so one line on your PATH and you're set:

sudo mkdir -p /usr/local/bin
sudo ln -sf /Applications/Kura.app/Contents/MacOS/kura-cli /usr/local/bin/kura
kura status

To run from source:

cargo run --manifest-path ./kura-mcp/Cargo.toml --bin kura -- status
cargo run --manifest-path ./kura-mcp/Cargo.toml --bin kura -- balance
cargo run --manifest-path ./kura-mcp/Cargo.toml --bin kura -- history --limit 10
cargo run --manifest-path ./kura-mcp/Cargo.toml --bin kura -- pay <주소> <금액> --token usdc
cargo run --manifest-path ./kura-mcp/Cargo.toml --bin kura -- fetch <URL>

pay/fetch never take a password via the CLI — the Kura app must be running, and a human enters the password in the approval popup.

Tests:

(cd src-tauri && cargo test)        # 백엔드(지갑·암호화·한도·송금)
(cd kura-mcp && cargo test)         # MCP/CLI 어댑터
npx tsc --noEmit && npx vite build  # 프론트

The procedure for producing a release build (signed, notarized DMG) is in docs/RELEASE.md. It needs an Apple Developer account and a one-time setup, and after that it's one line:

./scripts/release.sh

Tech stack

Structure: [Rust core (src-tauri)] ← MCP / CLI adapters (kura-mcp). Only the GUI process has key access (signing) — that's the last line of defense.

License · status

MIT license — since this is code that handles keys and money, I believe it should be something you can read, verify, and modify yourself.

If you find a vulnerability, please report it through the private channel in SECURITY.md before filing an issue. The same document also lists what Kura cannot protect against.

The bundled Pretendard font is under the SIL Open Font License 1.1 (full text).

The number one user is myself — a wallet for Korean developers and creators on Apple Silicon Macs who pay with local LLMs/Claude. It's still an early 0.1.x version, so I recommend learning on the default testnet first and only putting what you can afford to lose on mainnet.