Skip to content
Back to search

crypto-claude-desk

SkillWorks with Claude CodeGitHub

Multi-agent cryptocurrency intelligence system built with Claude Code. 6 AI agents, 66 MCP tools, Agent Teams, zero orchestration code.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/hugoguerrap--crypto-claude-desk/badge.svg)](/listings/hugoguerrap--crypto-claude-desk)

HTML

<a href="/listings/hugoguerrap--crypto-claude-desk"><img src="/api/listings/hugoguerrap--crypto-claude-desk/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Option A: As a plugin (recommended for users)

# 1. Add the marketplace
claude plugin marketplace add hugoguerrap/crypto-claude-desk

# 2. Install the plugin
claude plugin install crypto-trading-desk@hugoguerrap

# 3. Start Claude Code
claude

Option B: From source (recommended for contributors)

# 1. Clone the repo
git clone https://github.com/hugoguerrap/crypto-trading-desk.git
cd crypto-trading-desk

# 2. Start Claude Code with the plugin directory
claude --plugin-dir .

Both modes auto-discover agents, skills, and MCP servers. Same code, same behavior.

Then run setup once:

/crypto-trading-desk:setup

Setup detects your OS (macOS, Linux, or Windows), installs [uv](https://docs.astral.sh/uv/) if missing, downloads Python dependencies, verifies all 9 MCP servers work, and reports status. Takes ~30 seconds. You only need to do this once.

First thing to try

/crypto-trading-desk:quick BTC

Live market snapshot in ~15 seconds: price, volume, Fear & Greed, funding rates, whale activity.

---

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 19 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. {
  2. "name": "hugoguerrap",
  3. "owner": {
  4. "name": "hugoguerrap"
  5. },
  6. "metadata": {
  7. "description": "Crypto Claude Desk - Multi-agent cryptocurrency intelligence system for Claude Code",
  8. "version": "1.1.2"
  9. },
  10. "plugins": [
  11. {
  12. "name": "crypto-trading-desk",
  13. "source": "./",
  14. "description": "7 AI agents, 9 MCP servers (95 tools), cognitive learning, self-evolving platform. Zero orchestration code.",
  15. "version": "1.1.2",
  16. "category": "productivity"
  17. }
  18. ]
  19. }
README.md · README · 378 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # Crypto Trading Desk
  2. > *I used to spend weeks building multi-agent systems with LangGraph, CrewAI, and AutoGen. Hundreds of lines of Python orchestration code, custom state machines, fragile message passing between agents. Then I realized Claude Code already has everything — subagents, MCP servers, persistent memory, model routing. I just needed to describe my agents in markdown and give them tools. This plugin is the result: 7 coordinated AI agents, 83 real-time tools, zero lines of orchestration code. It even learns from its own trades and can extend itself.*
  3. >
  4. > — [Hugo Guerra](https://github.com/hugoguerrap)
  5. ---
  6. **Claude Code is not just for writing code.** Its agent system is a general-purpose intelligence platform. You can point it at any domain, give it specialized tools, and let it coordinate expert agents to solve problems that would take a human team hours.
  7. This project proves it. One plugin turns Claude Code into a full crypto trading desk — and it's built entirely with markdown files and MCP servers. No framework. No SDK. No middleware.
  8. **It's markdown all the way down.**
  9. ---
  10. ## Install
  11. ### Option A: As a plugin (recommended for users)
  12. ```bash
  13. # 1. Add the marketplace
  14. claude plugin marketplace add hugoguerrap/crypto-claude-desk
  15. # 2. Install the plugin
  16. claude plugin install crypto-trading-desk@hugoguerrap
  17. # 3. Start Claude Code
  18. claude
  19. ```
  20. ### Option B: From source (recommended for contributors)
  21. ```bash
  22. # 1. Clone the repo
  23. git clone https://github.com/hugoguerrap/crypto-trading-desk.git
  24. cd crypto-trading-desk
  25. # 2. Start Claude Code with the plugin directory
  26. claude --plugin-dir .
  27. ```
  28. Both modes auto-discover agents, skills, and MCP servers. Same code, same behavior.
  29. Then run setup once:
  30. ```
  31. /crypto-trading-desk:setup
  32. ```
  33. Setup detects your OS (macOS, Linux, or Windows), installs [uv](https://docs.astral.sh/uv/) if missing, downloads Python dependencies, verifies all 9 MCP servers work, and reports status. Takes ~30 seconds. You only need to do this once.
  34. ### First thing to try
  35. ```
  36. /crypto-trading-desk:quick BTC
  37. ```
  38. Live market snapshot in ~15 seconds: price, volume, Fear & Greed, funding rates, whale activity.
  39. ---
  40. ## What you can do
  41. ### Slash commands
  42. | Command | What it does | Time |
  43. |---------|-------------|------|
  44. | `/crypto-trading-desk:setup` | First-time setup (detects OS, installs deps, verifies) | ~30 sec |
  45. | `/crypto-trading-desk:quick BTC` | Live market snapshot (1 agent) | ~15 sec |
  46. | `/crypto-trading-desk:analyze ETH` | Full 5-agent phased analysis with trading decision | ~3-5 min |
  47. | `/crypto-trading-desk:portfolio` | View balances, open trades, P&L | ~30 sec |
  48. | `/crypto-trading-desk:close-trade trade_001` | Close a trade + post-mortem + learning | ~1 min |
  49. | `/crypto-trading-desk:validate-predictions` | Review predictions against market data | ~30 sec |
  50. | `/crypto-trading-desk:monitor` | Autonomous loop: check SL/TP, close trades, evaluate, summarize | ~2-3 min |
  51. | `/crypto-trading-desk:create` | Extend the system with new components | ~2-3 min |
  52. ### Natural language
  53. Just ask naturally. The system routes to the right agent(s) based on complexity:
  54. | You say | What happens |
  55. |---------|-------------|
  56. | "How's BTC?" | 1 agent (market-monitor) checks price, volume, sentiment |
  57. | "RSI of ETH?" | 1 agent (technical-analyst) calculates indicators |
  58. | "What's the news on SOL?" | 1 agent (news-sentiment) scans web + social media |
  59. | "Analyze LINK" | 3 agents in parallel: market + technical + news |
  60. | "Should I buy BTC? Full analysis" | 5-agent team with phased execution and final decision |
  61. | "Check my portfolio" | Portfolio manager reviews positions and P&L |
  62. | "Check my predictions" | Learning agent validates predictions against current prices |
  63. | "Create a DeFi tracker" | System builder researches APIs and generates the component |
  64. ---
  65. ## How it works
  66. ### The 7 agents
  67. Each agent is a specialist with its own model tier, tools, and instructions:
  68. | Agent | Role | Model | What it uses |
  69. |-------|------|-------|-------------|
  70. | **market-monitor** | Live prices, volume, funding rates, whale alerts | Haiku (fast, cheap) | 5 exchanges via CCXT, CoinGecko, web search |
  71. | **technical-analyst** | RSI, MACD, Bollinger, Ichimoku, patterns, signals | Sonnet | 38 technical indicators |
  72. | **news-sentiment** | Breaking news, social mood, FUD/FOMO detection | Sonnet | Web search + web fetch (Claude's native NLP) |
  73. | **risk-specialist** | Volatility, VaR, orderbook depth, spoofing detection | Sonnet | Microstructure analysis, correlation |
  74. | **portfolio-manager** | Final EXECUTE/WAIT/REJECT decision, paper trading | Opus (smartest) | Reads all reports, manages portfolio state |
  75. | **learning-agent** | Predictions, patterns, post-mortem | Opus | Tracks accuracy, evaluates setups, builds patterns |
  76. | **system-builder** | Generate new MCP servers, agents, skills + tests | Opus | Researches APIs, reads existing patterns, generates code + tests |
  77. Using Haiku for data scouts and Opus only for final decisions saves ~40-60% on tokens compared to running everything on one model.
  78. ### Full analysis flow (`/analyze`)
  79. When you request a full analysis, 5 agents coordinate in phases:
  80. ```
  81. Phase 1 (parallel, ~60 sec)
  82. market-monitor ---------> market-data.md
  83. technical-analyst ------> technical-analysis.md
  84. news-sentiment ---------> news-sentiment.md
  85. |
  86. v (waits for Phase 1)
  87. Phase 2 (~60 sec)
  88. risk-specialist --------> risk-assessment.md
  89. |
  90. v (waits for Phase 2)
  91. Phase 3 (~60 sec)
  92. portfolio-manager ------> decision.md
  93. |
  94. v
  95. EXECUTE / WAIT / REJECT
  96. with entry, SL, TP, position size, R:R ratio
  97. ```
  98. Each agent writes a report file. The next phase reads those files. No message passing — just files on disk.
  99. ### 95 MCP tools across 9 servers
  100. | Server | Tools | What it provides |
  101. |--------|-------|-----------------|
  102. | crypto-data | 11 | Fear & Greed, dominance, rankings, categories (CoinGecko) |
  103. | crypto-exchange | 15 | Live prices, orderbooks, OHLCV, volume, arbitrage (5 exchanges via CCXT) |
  104. | crypto-technical | 14 | RSI, MACD, Bollinger, patterns, signals, backtesting |
  105. | crypto-futures | 10 | Funding rates, open interest, long/short ratios, liquidation levels |
  106. | crypto-advanced-indicators | 8 | OBV, MFI, ADX, Ichimoku, VWAP, Pivot Points, divergences |
  107. | crypto-market-microstructure | 6 | Orderbook depth, imbalance, spread, spoofing, market impact |
  108. | crypto-learning-db | 18 | Trade CRUD, predictions, track records, patterns, summaries, trade modifications (SQLite) |
  109. | crypto-polymarket | 6 | Prediction market probabilities — wisdom of crowds priced in real capital (Polymarket Gamma) |
  110. | crypto-defillama | 7 | TVL by chain/protocol, stablecoin supply, DEX volume — on-chain capital flows (DefiLlama) |
  111. All powered by public APIs. **No API keys required.**
  112. ### Paper trading
  113. The portfolio manager executes trades in a local SQLite database (`data/db/learning.db`) via the crypto-learning-db MCP. No real money. You start with $10,000 spot + $10,000 futures. Every trade has mandatory stop-loss, minimum 2:1 risk/reward, and position limits.
  114. ### Cognitive learning
  115. The system gets smarter with every trade:
  116. 1. **Predictions tracked** — When a trade opens, every agent's testable prediction is recorded (price targets, support levels, funding expectations)
  117. 2. **Evaluated in natural language** — When the trade closes, the learning agent reads original predictions vs actual outcomes and writes a detailed NL evaluation: what worked, what failed, why, and what we can learn. No formulas — just reasoning stored for future reference.
  118. 3. **Setup-centric track records** — `get_prediction_track_record()` provides accuracy by time window (7d, 30d, 90d, global) plus NL evaluations, filtered by setup type, symbol, and agent. The portfolio manager asks "how has this type of setup performed?" not "do I trust this agent?"
  119. 4. **Expired prediction detection** — Predictions past their timeframe are automatically surfaced with market context so the learning agent can batch-evaluate them
  120. 5. **Pattern library** — Named trading setups (e.g., "oversold bounce at support") with tracked win rates. Patterns above 60% are marked SEEK; below 40% are marked AVOID
  121. 6. **Claude is the consensus engine** — No weighted formulas, no confidence_adjustment math. The portfolio manager reads setup track records, evaluations, and agent reasoning, then decides through natural language analysis how reliable each signal is for this specific trade
  122. ### Dashboard (optional)
  123. An optional Next.js ops dashboard lives in `dashboard/`. It reads `data/db/learning.db` **read-only** and visualizes the portfolio: equity curve, trades, predictions with accuracy, patterns, market intelligence (Polymarket + DefiLlama), and analysis reports. It also embeds a local terminal.
  124. ```bash
  125. cd dashboard
  126. npm install
  127. npm run dev # starts Next.js + the terminal (pty) server
  128. ```
  129. Then open `http://localhost:3000`. **Localhost only** — the embedded terminal grants shell access over a loopback WebSocket, so never expose the dev server to the network. Run `/setup` and at least one analysis first so the database exists.
  130. ### Dynamic workflows
  131. `.claude/workflows/close-learning.js` is a [dynamic workflow](https://code.claude.com/docs/en/workflows) that validates expired predictions in parallel (one agent per prediction) and closes the learning loop. Run it with `/close-learning`.
  132. Run `/validate-predictions` anytime to check pending predictions against current market data.
  133. ### Self-evolving platform
  134. The `/create` skill lets you extend the system in natural language:
  135. ```
  136. /create an MCP server for on-chain analytics
  137. /create an agent for macro economic analysis
  138. /create a skill for multi-coin comparison
  139. ```
  140. The system-builder agent (opus) researches APIs, reads existing components for patterns, generates the new component, and tells you what integration steps remain. The system grows with your needs.
  141. ### Autopilot mode
  142. Claude Code's `-p` flag runs headless (no interaction needed). Combine it with cron and the system becomes an autonomous analyst.
  143. **Important:** Cron runs without a terminal, so you need `--allowedTools` to pre-approve tool permissions. You also need the correct working directory so Claude Code finds `CLAUDE.md` and the plugin configuration.
  144. ```bash
  145. # Use the wrapper script for proper environment setup
  146. # Monitor every hour: check SL/TP, close trades, evaluate expired predictions
  147. 0 * * * * /path/to/crypto-trading-desk/bin/autopilot.sh monitor
  148. # Morning market briefing at 8am
  149. 0 8 * * * /path/to/crypto-trading-desk/bin/autopilot.sh quick "BTC ETH SOL"
  150. # Full analysis every Monday at 9am
  151. 0 9 * * 1 /path/to/crypto-trading-desk/bin/autopilot.sh analyze "BTC"
  152. # Portfolio check at US market close
  153. 0 16 * * 1-5 /path/to/crypto-trading-desk/bin/autopilot.sh portfolio
  154. ```
  155. **Why a wrapper?** Skills (`/skill-name`) are not invoked in `-p` mode. The wrapper maps workflow names to detailed natural language prompts, handles PATH/env for cron, pre-approves tool permissions with `--allowedTools`, auto-detects `--plugin-dir` (works for both plugin install and local clone), and logs output to `data/logs/`.
  156. **Adding custom workflows:** Edit `bin/autopilot.sh` and add a new `case` block. Each workflow is just a natural language prompt — describe what you want Claude to do using the agents and MCP tools available.
  157. The `monitor` workflow closes the autonomous loop: it checks open trades against SL/TP levels, closes trades that hit targets, triggers post-mortem analysis with NL evaluations, validates expired predictions, and generates monthly summaries. Combined with `analyze` for trade entries, the system runs a complete learn-trade-evaluate cycle without human intervention.
  158. ---
  159. ## The old way vs. this way
  160. | | Traditional multi-agent frameworks | This plugin |
  161. |---|---|---|
  162. | **Orchestration** | Python code (LangGraph, CrewAI, AutoGen) | `CLAUDE.md` — plain English routing rules |
  163. | **Agent definitions** | Python classes, decorators, schemas | Markdown files with YAML frontmatter |
  164. | **Tool integration** | Custom wrappers, API clients, SDKs | MCP servers (standard protocol) |
  165. | **Coordination** | State machines, graphs, message queues | File-based — agents write reports, next phase reads them |
  166. | **Memory** | Vector databases, custom storage | Built-in `memory: project` (one line in agent config) |
  167. | **Model routing** | Custom logic per agent | `model: haiku` / `sonnet` / `opus` in frontmatter |
  168. | **Setup time** | Days to weeks | Hours. Describe agents, build MCP tools, write CLAUDE.md |
  169. | **Lines of orchestration code** | Hundreds to thousands | **Zero** |
  170. ---
  171. ## Requirements
  172. | Requirement | How it's handled |
  173. |-------------|-----------------|
  174. | **Claude Code** | [Install guide](https://docs.anthropic.com/en/docs/claude-code) — you need a Claude Pro/Max/Team plan |
  175. | **Python 3.11+** | Most systems have it. `uv` downloads it automatically if missing |
  176. | **uv** | `/setup` installs it automatically. Or install manually: `curl -LsSf https://astral.sh/uv/install.sh \| sh` |
  177. ### Recommended settings
  178. Add to `~/.claude/settings.json` for the smoothest experience:
  179. ```json
  180. {
  181. "permissions": {
  182. "allow": [
  183. "mcp__crypto-data",
  184. "mcp__crypto-exchange",
  185. "mcp__crypto-technical",
  186. "mcp__crypto-futures",
  187. "mcp__crypto-advanced-indicators",
  188. "mcp__crypto-market-microstructure",
  189. "mcp__crypto-learning-db",
  190. "WebSearch",
  191. "WebFetch",
  192. "Write"
  193. ]
  194. }
  195. }
  196. ```
  197. Without this, Claude Code will ask you to approve each tool on first use (which works fine, just slower).
  198. ---
  199. ## Troubleshooting
  200. **First step for any issue:** run `/crypto-trading-desk:setup`. It detects problems and fixes them automatically.
  201. ### MCP servers not starting
  202. **"spawn uv ENOENT"** — `uv` is installed but Claude Code can't find it. Common when launching from GUI apps (Claude Desktop, VS Code) that don't inherit your terminal's PATH.
  203. Fix:
  204. ```bash
  205. # Create a symlink so GUI apps can find uv
  206. sudo ln -sf ~/.local/bin/uv /usr/local/bin/uv
  207. # Then restart Claude Code
  208. ```
  209. Or just run `/crypto-trading-desk:setup` — it detects this and offers to fix it.
  210. ### Dependencies not installing
  211. ```bash
  212. cd ~/.claude/plugins/cache/crypto-trading-desk # or your local clone
  213. uv sync
  214. ```
  215. ### Windows users
  216. The plugin works on Windows. Run `/crypto-trading-desk:setup` — it detects Windows and uses PowerShell to install `uv` if needed. If you get PATH issues, ensure `uv` is in your system PATH or install it via `winget install astral-sh.uv`.
  217. ---
  218. ## Architecture
  219. ```
  220. crypto-trading-desk/
  221. ├── agents/ # 7 agent definitions (Markdown + YAML frontmatter)
  222. ├── bin/ # autopilot.sh wrapper for cron/headless execution
  223. ├── skills/ # 8 slash commands (setup, quick, analyze, portfolio, close-trade, validate-predictions, monitor, create)
  224. ├── hooks/ # SessionStart: creates data directories
  225. ├── mcp-servers/ # 9 Python MCP servers (95 tools total)
  226. ├── mcp-servers.plugin.json # MCP config for plugin distribution
  227. ├── .claude/workflows/ # Dynamic workflows (e.g. close-learning)
  228. ├── dashboard/ # Next.js ops dashboard (reads the DB read-only, localhost only)
  229. ├── tests/ # pytest suite for the MCP servers
  230. ├── docs/ # architecture.md + extending.md
  231. ├── pyproject.toml # Python dependencies (pinned in uv.lock)
  232. ├── uv.lock # Reproducible dependency resolution
  233. ├── .python-version # Pins Python 3.12
  234. ├── CLAUDE.md # Routing logic — Claude Code reads this to coordinate
  235. └── data/
  236. ├── db/learning.db # SQLite cognitive memory (trades, predictions, patterns)
  237. ├── reports/ # Analysis reports (one folder per analysis)
  238. └── create/ # /create research artifacts
  239. ```
  240. **Zero orchestration code.** Claude Code reads `CLAUDE.md` and coordinates everything. The agents are markdown files. The skills are markdown files. The routing logic is markdown.
  241. ---
  242. ## Build your own
  243. This project is a template. The architecture — agents as markdown, tools as MCP servers, coordination as CLAUDE.md — works for any domain:
  244. - **Security research**: agents for CVE scanning, exploit analysis, patch verification
  245. - **Competitive intelligence**: agents for pricing, feature tracking, sentiment monitoring
  246. - **Operations**: agents for log analysis, incident triage, runbook execution
  247. - **Financial analysis**: agents for fundamentals, technicals, macro, portfolio optimization
  248. To build your own multi-agent system on Claude Code:
  249. 1. Define your agents in `agents/` (markdown + YAML frontmatter)
  250. 2. Build your data sources as MCP servers in `mcp-servers/`
  251. 3. Write routing logic in `CLAUDE.md`
  252. 4. Add user commands in `skills/`
  253. See [docs/extending.md](docs/extending.md) for the full guide.
  254. ---
  255. ## Contributing
  256. This is an open project. Add new agents, MCP servers, skills, or improve existing ones.
  257. - **New MCP server** — add a data source (on-chain analytics, DEX data, social metrics)
  258. - **New agent** — add a specialist (macro analyst, on-chain detective, DeFi strategist)
  259. - **New skill** — add a workflow (multi-coin comparison, portfolio rebalancing, alert system)
  260. - **Improve existing agents** — better prompts, smarter routing, new analysis patterns
  261. See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines. PRs welcome.
  262. ---
  263. ## Disclaimer
  264. This is a **paper trading system** for educational and experimental purposes. No real money is at risk. All trades are simulated. This is not financial advice.
  265. ---
  266. ## License
  267. [MIT](LICENSE)
  268. Built by [Hugo Guerra](https://github.com/hugoguerrap)

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.