io.github.gigshow/decker

Decker AI

The deterministic market-state layer your trading agents call.

Rules trade, LLMs explain. Live, non-custodial, with receipts.

Open the app · Telegram bot · Kakao channel · API docs

What you get

• Signals you can act on, with context. Not "BUY" — GO / WATCH / HOLD + progress_pct (0–100% lifecycle) + entry / stop / target.
• It explains itself. Every signal has a structural cause (multi-timeframe alignment, state machine phase) that an LLM translates into plain language.
• Same engine, two markets. Crypto (24/7) + Korean equities (KOSPI + KOSDAQ, Beta).
• Use it your way. Web app, Telegram, Kakao channel, REST API, or MCP server inside Claude / Cursor.

"Where are we in the current structural cycle — and what's the next optimal move?"

Get started in 60 seconds

Free tier is generous (30 calls/day on the API; Web + Telegram included). During Beta, signed-up users get PRO access for free.

See it in action

Start here — 30 seconds. No signup, no key.

curl -s https://api.decker-ai.com/api/v1/public/demo | jq .

▶️ Play — MCP journey demo (30s) · One live session, all 13 tools: explore a market → set your risk profile → decide → execute → manage — zero LLM in the signal path.

Shorter cut with the response and the plain-language takeaway shown together on every call (no separate captions needed): Play — Shorts cut (35s)

The engine room — live FSM, MTF alignment, R:R

▶️ Play — the live cockpit (16s) · Every signal traces to a structural cause: progress_pct + operation_gate + entry / stop / target.

Signal → execution, non-custodial

▶️ Play — non-custodial execution (16s) · Click Order · wallet-sign · custody 0. Decker relays your signature only (revocable agent wallet, EIP-712). For information only — not investment advice.

Read it daily — and we score our own calls

▶️ Play: web hub (10s) · Telegram (6s)

Every morning (08:00 KST): the engine's view per symbol — baseline, what winning and losing look like, and a pick you can answer. Evening: the same view scored against what actually happened — hits and misses alike, on the record. We stamp our wrong calls too.

Web hub: decker-ai.com/briefing · Subscribe: @deckerclawbot → /briefing

Korean equities (KRX) — Beta, free

▶️ Play — KRX (16s) · Same deterministic engine on KOSPI + KOSDAQ. Portfolio states — ADD / HOLD / REDUCE / EXIT, not buy/sell. Daily closing-bell checkup at 16:30 KST · @krxdeckerbot.

Three things that make it different

1. progress_pct — every signal has a lifecycle. A signal at 25% progress is a different trade than the same signal at 80%. Most tools just say "BUY"; Decker tells you where in the move you are.

Entry                                                           Target
  0%──────────33%──────────50%──────────67%──────────83%────────100%
 Wait       Entry        Active       Late TP      Final TP     Exit

2. GO / WATCH / HOLD — three gates, not binary.

WATCH is the gate most tools skip. It's why users enter too early.

3. Deterministic + traceable. LLM explains, doesn't decide.

Pricing

Beta (now): all authenticated users get PRO for free via BETA_TIER_OVERRIDE=PRO. No payment required.

Web sign-up and Telegram bot are always free for the basics.

For developers

Building a bot, app, or agent on top of Decker? Everything you need — REST endpoints, MCP server (Claude / Cursor / Codex), Python SDK, OpenClaw skill, self-host — lives in one place:

→ DEVELOPER_README.md

# 60-second smoke test (no auth needed)
curl https://api.decker-ai.com/api/v1/public/demo

# With an API key (decker-ai.com → Settings → API Keys, or Telegram /apikey)
curl "https://api.decker-ai.com/api/v1/public/signals/BTCUSDT/latest?timeframe=1h" \
  -H "X-API-Key: dk_live_xxx"

Prefer a runnable file? → examples/quickstart.py — zero dependencies (stdlib only), no key, prints the composed view + receipts in one run. Wrapping Decker for an agent crew: examples/langgraph_decker_tool.py. More in examples/.

The demo returns the composed view — the same card our daily briefing sends:

{ "layer": "STATE_VIEW", "symbol": "BTCUSDT", "ref_price": 63650.0,
  "lines": ["■ BTC — 층간 힘겨루기: 주 판 아래쪽 · 지금 판 위쪽", "…"],
  "wait_target": "...", "invalidation": "...",
  "verdict_recent": [{"briefing_date": "2026-07-05", "slot": "morning", "verdict": "hit"}],
  "provenance": { "composer": "briefing_story.compose_card" } }

Add to Claude Desktop / Cursor (MCP): guided 2-minute setup with per-client config → decker-ai.com/mcp.

Cursor (~/.cursor/mcp.json) takes a remote server directly:

{
  "mcpServers": {
    "decker": {
      "url": "https://api.decker-ai.com/api/v1/mcp",
      "headers": { "X-API-Key": "dk_live_YOUR_KEY" }
    }
  }
}

⚠ Endpoint is /api/v1/mcp (stateless Streamable HTTP) — an old /sse suffix now returns 405 Method Not Allowed.

Claude Desktop / Codex reach it through the mcp-remote bridge (needs Node/npx) — see decker-ai.com/mcp or DEVELOPER_README.md (endpoints · auth · rate limits · MCP tools · SDK · OpenClaw · self-host).

Running a multi-agent crew (TradingAgents / LangGraph / AutoGen)? Give your analysts one deterministic market-state instrument — with receipts — instead of re-deriving structure per prompt: → docs/integrations/multi-agent-frameworks.md

How the engine works (one diagram)

Raw OHLCV candles
  ↓  Sequence Labeler  →  every candle gets a role (anchor / test / signal)
  ↓  State Machine     →  C_SET → B_FORMING → B_SET → A_FORMING → W_PENDING
  ↓  Operation Gate    →  GO · WATCH · HOLD
  ↓  RULES Engine      →  9-layer YAML rulebook → strategy + ranked choices
  ↓  AI Consultation   →  LLM translates structural state → plain language
  ↓
"67% progress. B-leg confirmed. Recommended: 30% partial TP or hold to target."

No price prediction. No black box. Every output traces to a formal structural cause.

Deep dives: Sequence Engine · Labeling Algorithm · Market State Theory

Supported symbols

Crypto (GA): BTCUSDT · ETHUSDT · SOLUSDT · BNBUSDT · XRPUSDT · DOGEUSDT — timeframes 30m, 1h, 4h, 1d.

KRX (Beta, free): KOSPI 948 + KOSDAQ 1,822 = 2,770 tickers. Universe = top 200 by trading value ∪ user watchlist ∪ momentum spike ∪ volume spike. Timeframe 1d only (1w expanding). Daily evaluation at 16:30 KST.

KRX details: docs/krx/KRX_BUSINESS_MODEL_AND_ROADMAP_2026-05-09.md.

Performance

We don't publish a headline win rate. Backtest numbers without method and sample size are marketing, not evidence — and easy to cherry-pick.

What we stand on instead:

• Deterministic & reproducible. Same input → same output, always. The rules path has zero LLM in it, so a signal is not a model's opinion — it's a formal structural verdict you can re-derive.
• Auditable. Every read carries its provenance (composer + the versioned rulebook contract) and traces back to the exact engine emit. The full RULES.yaml is open, so you can re-derive any verdict yourself.
• Scored in public, daily. The morning briefing's view is graded against what actually happened that evening — hits and misses alike, on the record. → decker-ai.com/briefing · a GitHub Action stamps the daily scorecard straight into this repo: TRACK_RECORD.md

Method and rulebook are open: Model & Algorithm · Operation Rules (YAML) · Signal Performance.

For information only. Not investment advice.

Docs

Links

| | | |-|-| | Web app | https://decker-ai.com | | API docs | https://api.decker-ai.com/docs | | Telegram bot (crypto) | https://t.me/deckerclawbot | | Telegram bot (KRX) | https://t.me/krxdeckerbot | | Kakao channel | https://pf.kakao.com/_RxlxjVX | | X / Twitter | https://x.com/blockoceandev |

This repository is the public hub for Decker AI — SDK, samples, rulebook, architecture docs, OpenClaw skill packages. Production application code runs in a private monorepo. All listed endpoints, channels, and the web app are live.

Built by gigshow (Dohyung Kim · 김도형) — founder. Open to investor / partnership conversations.