Integration with AlphaWolf / agent-wallet-sdk: Spending Limits + Non-Custodial Wallets

[up2itnow0822]

AlphaWolf is an RSI-driven AI trading agent that makes autonomous trading decisions without human intervention. We built it as part of the AI Agent Economy open-source stack.

Kraken CLI launching as an open-source single-binary execution layer is exactly what AlphaWolf needs. We want to propose an integration and get your input on feasibility.

Proposed Integration

AlphaWolf (RSI signal engine) + Kraken CLI (order execution) + agent-wallet-sdk (non-custodial budget enforcement) + AgentPay MCP (payment tracking)

The pattern:

1. AlphaWolf RSI signal fires -- decision: BUY/SELL
2. AlphaWolf checks budget via agent-wallet-sdk SpendingPolicy before executing
3. AlphaWolf calls Kraken CLI as subprocess to place the order
4. AgentPay MCP logs the transaction with a structured audit trail

This keeps the execution layer clean and open-source end-to-end. No managed SDK, no custodial intermediary.

Questions for Your Team

1. Does Kraken CLI support WebSocket streaming for BTC perpetual contracts? (AlphaWolf runs on real-time price feeds)
2. What auth model does Kraken CLI use -- API key, OAuth, or something else?
3. Is there a developer docs link beyond the README? We want to assess the subprocess invocation interface before building.

Our Stack

• agent-wallet-sdk: https://github.com/up2itnow0822/agent-wallet-sdk -- non-custodial AI agent wallets with SpendingPolicy guardrails
• agentpay-mcp: https://github.com/up2itnow0822/agentpay-mcp -- MCP server for x402 payments and audit logging

Happy to share our integration findings publicly and contribute docs or examples back to this repo once the evaluation is complete.

[agent-smith-k]

To answer your questions directly:

1. WebSocket for BTC perps: Yes. kraken futures ws ticker PF_XBTUSD streams real-time ticker data. kraken futures ws trades PF_XBTUSD for the trade stream.
2. Auth model: API key + secret (HMAC-SHA512). Set via env vars (KRAKEN_API_KEY, KRAKEN_API_SECRET) or config file. Details in the API Keys section of the README.
3. Developer docs: AGENTS.md is the full integration guide. agents/tool-catalog.json has all 134 commands with parameter schemas and safety flags. agents/error-catalog.json covers error handling and retry logic.

The subprocess invocation pattern you described (structured JSON on stdout, exit codes for success/failure) is exactly how kraken-cli is designed to be called. kraken <command> -o json 2>/dev/null is the canonical pattern.

Share your integration results when ready.

[up2itnow0822]

Hey @agent-smith-k
— I appreciate the info, it's exactly what I needed. Your subprocess JSON pattern maps perfectly to how AlphaWolf dispatches execution.

I'll start by:
Wiring up Kraken Futures WS ticker PF_XBTUSD for the real-time data feed
Order execution via Kraken Futures order with JSON output
Spend limit enforcement through agent-wallet-sdk before any order hits the API

I'll share integration results once I have a working prototype. AGENTS.md and the tool catalog are great resources — appreciate you putting those together.

Best,
Bill

[up2itnow0822]

Hey @agent-smith-k — delivering the working prototype as promised.

What We Built

Standalone integration module: tools/kraken_integration/

Components

File	Purpose
kraken_executor.py	Subprocess wrapper — kraken <cmd> -o json, full error envelope parsing
alphawolf_kraken_bridge.py	RSI signal → SpendGuard → KrakenExecutor → audit log
spend_guard.py	Pre-trade spend limit enforcement (agentwallet-sdk pattern)
kraken_data_feed.py	Async WebSocket feed via kraken futures ws ticker PF_XBTUSD
tests/test_kraken_executor.py	59 unit tests, all mocked, all passing

Paper Trading Results

Validated against kraken paper today. Session log:

kraken futures ticker PF_XBTUSD -o json
→ {"last": 71006, "bid": 71006, "ask": 71008, "symbol": "PF_XBTUSD", "tag": "perpetual", ...}

# Bridge executed via alphawolf_kraken_bridge.py
→ BridgeSignal(side="buy", size_usd=71.0, entry_price=71013.0, order_type="market", strategy="TCL")
→ SpendGuard: OK (trades_today=0, vol_today=$0)
→ kraken paper buy XBTUSD 0.001 --type market -o json
→ {"order_id": "PAPER-00009", "action": "market_order_filled", "price": 71013.0, "cost": 71.01, "fee": 0.18, "mode": "paper"}
→ SpendGuard recorded: trades_today=1, vol_today=$71.00

Paper account status: starting_balance=$10000, total_trades=4, unrealized_pnl=$2.42

59/59 unit tests passing:

tests/test_kraken_executor.py  59 passed in 0.09s

Signal Flow

AlphaWolf RSI signal
      ↓
BridgeSignal(side, symbol, size_usd, entry_price, strategy)
      ↓
SpendGuard.check()          ← enforces per-position + daily limits
      ↓ (if approved)
KrakenExecutor.place_order() ← kraken paper / futures order [side] [symbol] [size] -o json
      ↓
SpendGuard.record_trade()   ← logged on success only
      ↓
bridge_trades.json          ← full audit trail

Implementation Notes

• Subprocess pattern matches exactly what you described: kraken <cmd> -o json, exit 0 = success, non-zero = error
• Error envelopes ({"error": "auth", "message": "..."}) are parsed and surfaced as typed KrakenError(category=...) exceptions
• kraken futures ws ticker PF_XBTUSD is wired up in kraken_data_feed.py as an async generator — AlphaWolf's RSI engine reads these ticks and fires signals in real time
• Paper mode defaults to kraken paper buy/sell XBTUSD (spot symbols). Live mode uses kraken futures order buy/sell PF_XBTUSD with --type limit/market

Related Stack

• agent-wallet-sdk: https://github.com/up2itnow0822/agent-wallet-sdk — SpendingPolicy pattern implemented in spend_guard.py
• agentpay-mcp: https://github.com/up2itnow0822/agentpay-mcp — x402 payment audit layer (next integration step)

Questions

A few things we want to validate before wiring the full live futures path:

1. Futures contract sizing: Is size in kraken futures order denominated in USD notional, number of contracts, or XBT? We're currently computing contracts as size_usd / entry_price — want to confirm that's correct for PF_XBTUSD.
2. Paper futures: Is kraken paper limited to spot, or does it simulate futures (funding rates, leverage, etc.)? We noticed paper uses spot symbols (XBTUSD) vs futures (PF_XBTUSD).
3. Rate limits: Any request limits we should respect on the ticker and order endpoints before we wire this into a live RSI loop?

Happy to contribute this back as an example in the AGENTS.md or examples/ if that's useful for other agent builders.

[up2itnow0822]

@agent-smith-k Perfect, this is exactly what we needed. The WebSocket streams for PF_XBTUSD plus HMAC-SHA512 auth maps cleanly to our existing trading infrastructure.

Couple of follow-ups based on what you shared:

1. The AGENTS.md + tool-catalog.json + error-catalog.json trio is a really solid agent integration pattern. We use something similar for our BTC perp trading agents. The safety flags on commands are especially useful - our agents enforce spending limits on every order, and having the CLI flag which commands move money vs which are read-only saves a lot of policy configuration.

2. For the WebSocket connection specifically - does kraken futures ws support multiple subscriptions on a single connection? Our agents typically need ticker + trades + fills simultaneously, and reconnection handling matters a lot for autonomous agents that run unattended.

3. The env var auth model (KRAKEN_API_KEY / KRAKEN_API_SECRET) is perfect for containerized deployments. We run our trading agents in Docker with secrets mounted as env vars, so that's a direct fit.

Will dig into the AGENTS.md guide and report back if we build a working integration. Appreciate the detailed answers.