io.github.gigshow/decker
REMOTE · API.DECKER-AI.COM
Deterministic market-state engine for trading agents — state, gate, coordinates, with receipts.
Available components
Last scanned (21 hours ago)
Scores higher than 67% of remote servers
Reachable. Last reached 21 Nov 2026.
Category Finance and Payments
How this component scores in each security and reliability category. Every signal is checked automatically against the live server, and we only credit what we can confirm. How we score → Why this is hard to score →
Endpoint Security63
- The endpoint's TLS certificate is valid, in date, and uses a strong key. View diagnostics → Pass
- Authorisation not fully verified: no authorisation is required to call this server, and 15 tool(s) never declared a destructiveHint. The MCP spec treats an absent hint as destructive by default, so we cannot call this surface safe. See how to fix → View diagnostics → Unverified
- HTTPS is enforced; there's no plaintext access path. View diagnostics → Pass
- The HSTS (Strict-Transport-Security) header is present. View diagnostics → Pass
- DNSSEC check failed: this domain isn't protected by DNSSEC. See how to fix → View diagnostics → Fail
Transport & Reachability100
- Verified streamable-http transport via a live MCP handshake. View diagnostics → Pass
Schema Quality & AI Usability73
- 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).Pass
- AI-judged instruction clarity (good).Pass
- Context-footprint check failed: tool/resource definitions use about 5205 tokens (~306/item across 17 items; 15 tools + 2 resources), over budget; trim descriptions and params. See how to fix → Fail
- Usage-examples check failed: none of the tools include examples. See how to fix → Fail
Stability & Change Management100
- No destabilizing schema changes in the last 30 days.Pass
Tool Coverage97
- 100% of tools have a non-trivial description (not blank, and not just the tool's name).Pass
- 89% of tool parameters carry a description.Partial
- Structured output schemas are declared (7% of tools); any adoption earns full credit.Pass
Tool Safety100
- No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.Pass
- We read all 15 captured tool definition(s), and no name or description among them implies an irreversible operation.Pass
- An AI judge read all 16 captured unit(s) of tool text and found none that tries to manipulate the model reading it.Pass
Capabilities20
- Spec-recency check failed: implements MCP spec 2024-11-05; the latest is 2026-07-28. See how to fix → Fail
Checks we ran (12)
- TLS certificate
- HTTPS
- HSTS header
- DNSSEC
- Transport
- Schema quality
- Stability
- Tool coverage
- Injection markers
- Destructive annotations
- Judged manipulation
- MCP protocol
Checks we could not complete (1)
These are gaps on our side, not findings about this hosted endpoint. We only credit what we can confirm, so a category made up entirely of them scores 0.
- Authorization in Endpoint SecurityAuthorisation not fully verified: no authorisation is required to call this server, and 15 tool(s) never declared a destructiveHint. The MCP spec treats an absent hint as destructive by default, so we cannot call this surface safe.
Does not apply to this hosted endpoint (2)
- Supply Chain SecurityScored on package channels only. This is a hosted endpoint, so there is nothing to install or inspect.
- Provenance & TransparencyScored on package channels only. This is a hosted endpoint, so there is nothing to install or inspect.
The score does not measure everything. What the score does not measure →
Every change we have recorded for this component, newest first. Security-relevant changes are always shown. ▲ marks a change for the better, ▼ a change for the worse; unmarked changes are neutral.
- 20 Nov 26 +3
- Stability: fail → pass ▲ security
- 17 Nov 26 0
- Tool “decker.get_market_state” rewrote its description, which is the text the model reads security
- 14 Nov 26 0
- Tool “decker.get_episodes” rewrote its description, which is the text the model reads security
- Tool “decker.get_market_state” rewrote its description, which is the text the model reads security
- “decker.get_market_state” reworded the description of “detail” cosmetic
- 8 Nov 26 0
- Tool “decker.get_assembly” rewrote its description, which is the text the model reads security
- Tool “decker.get_market_state” rewrote its description, which is the text the model reads security
- 7 Nov 26 0
- Endpoint reachability: unreachable → reachable ▲ functional
- 6 Nov 26 0
- We updated how we score, so this day's move reflects our rubric, not a change to the server See what changed → functional
- 5 Nov 26 0
- Endpoint reachability: reachable → unreachable ▼ security
- Stability: fail → unverified ▼ security
- Tool safety: pass → unverified ▼ security
- TLS certificate: pass → unverified ▼ security
- HSTS header: pass → unverified ▼ security
- Transport: pass → fail ▼ security
- Authorization: Authorisation not yet verified: we couldn't confirm whether this endpoint requires it. security
- Schema quality: 100 → unverified ▼ functional
- Capabilities: fail → unverified ▼ functional
- Tool coverage: 100 → unverified ▼ functional
- 4 Nov 26 −1
- Tool “decker.get_assembly” rewrote its description, which is the text the model reads security
- Tool “decker.get_market_state” rewrote its description, which is the text the model reads security
- “decker.get_market_state” added an optional parameter “detail” cosmetic
Diagnostic detail from the automated scan of this channel: what the scanner observed at each step, so you can see exactly where a check passed or failed. It is informational only and never changes the trust score.
Captured 21 Nov 2026 · Probed https://api.decker-ai.com/api/v1/mcp
TLS valid
Negotiated TLS 1.3 with TLS_AES_128_GCM_SHA256 .
| Subject | Issuer | Valid from | Valid until | Key | Signature | Serial |
|---|---|---|---|---|---|---|
| CN=api.decker-ai.com | CN=YR1,O=Let's Encrypt,C=US | 9 Nov 2026 | 7 Feb 2027 | RSA 2048 | SHA256-RSA | 5f3a46a917bc7b9298f62472e8d49e0da38 |
| SANs: api.decker-ai.com | ||||||
| CN=YR1,O=Let's Encrypt,C=US (CA) | CN=Root YR,O=ISRG,C=US | 3 Sept 2025 | 2 Sept 2028 | RSA 2048 | SHA256-RSA | a20253f15f2691c05dc1ce13b9bcca4e |
| CN=Root YR,O=ISRG,C=US (CA) | CN=ISRG Root X1,O=Internet Security Research Group,C=US | 13 May 2026 | 2 Sept 2032 | RSA 4096 | SHA256-RSA | f24b6d17f9d9ad7cb1c9fea78782699f |
Background: What to check on a remote MCP endpoint →
DNSSEC insecure
Validation of api.decker-ai.com. — Not signed
| Zone | DS | Keys | Algorithms | Outcome |
|---|---|---|---|---|
| . | Trust anchor | 20326, 38696 | 8, 8 | Verified |
| com. | DS published | 19718 | 13 | Verified |
| decker-ai.com. | No DS | Unsigned (proven) parent-signed NSEC/NSEC3 proves an unsigned delegation |
Authentication No authorisation required
The endpoint answered without asking for a token. Anyone who knows the URL can reach it.
| Result | No authorisation required |
|---|---|
| HTTP status | 200 |
| Header | Value |
|---|---|
| strict-transport-security | max-age=31536000; includeSubDomains |
| content-security-policy | default-src 'self'; script-src 'self' 'unsafe-inline' 'unsafe-eval' https://cdn.jsdelivr.net; style-src 'self' 'unsafe-inline' https://cdn.jsdelivr.net; img-src 'self' data: https://fastapi.tiangolo.com https://cdn.jsdelivr.net; font-src 'self' data:; connect-src 'self' http://localhost:* ws://localhost:* https://* wss://* |
| x-content-type-options | nosniff |
| x-frame-options | SAMEORIGIN |
| referrer-policy | strict-origin-when-cross-origin |
| permissions-policy | geolocation=(), microphone=(), camera=() |
Background: How OAuth 2.1 works in the 2026 MCP spec →
Transports 2 probes
| Transport | URL | Outcome | Status | Location |
|---|---|---|---|---|
| streamable-http | https://api.decker-ai.com/api/v1/mcp | Verified | 200 | |
| http (plaintext) | http://api.decker-ai.com/api/v1/mcp | HTTPS enforced | 301 | https://api.decker-ai.com/api/v1/mcp |
The tools this component advertises to a client, with an estimated token cost for each. Expand a tool to see its parameters and schema. The per-tool counts are indicative and are not scored directly; the schema's total context footprint is one signal in Schema Quality & AI Usability. A tool's description is untrusted text the model reads on every call, which is what makes this list a security surface and not just an inventory: how tool poisoning works →
decker.close_position ~258
Axis③ (Order/Execution) — closes (or partially reduces) an existing position through DECKER'S OWN execution engine (see decker.place_order for what that means — same account-linkage requirement applies here for real positions). Unlike place_order, there is no crypto-6 restriction — this reduces risk, not adds it, so any symbol you actually hold (including HL-synthetic/KRX paper positions) can be closed. Mode is NOT chosen by the caller — this looks up whatever position(s) actually exist for the symbol (real via live exchange query, virtual via the paper ledger) and closes whichever are open; if both a real and a virtual position exist for the same symbol, both are closed and the response reports execution_mode as 'mixed'. No open position for the symbol = a clean not-found response, not an error — safe to call speculatively.
| Name | Type | Req | Description |
|---|---|---|---|
| close_fraction | number | – | Fraction of the current position to close, 0 < x <= 1. Default 1.0 = full close. E.g. 0.5 closes half. |
| symbol | string | yes | e.g. BTCUSDT, XYZ_GOLDUSD — whatever symbol you hold. Aliases resolve like other tools. |
No output schema declared.
No examples provided.
decker.get_assembly ~519
THE answer for 'what is the situation and what do I do on this symbol now' — one verdict per symbol from the per-timeframe judgment state (CR1); no scores or weights. TWO LAYERS — TOP = the machine's judgment, BOTTOM = its sources. READ THE TOP FIRST: `top_ko` (also the first lines of summary_ko) = 4 judged lines: ① 지금 시장 — the theme (the latest still-current close transition — a target touch or an outcome — of the 1w/1d judgment loops, else 4h/1h/30m; several target→judgment loops run at once in each timeframe), lower-timeframe outcomes in that period (진행 progress | 테마 반대 against it), tests against the theme (막히는 중 blocked | 넘는 중 crossing) → the conclusion ② 행동 action + one reason ③ 목표 next cells in the theme direction · 무효화 the confirm price of the highest test against the theme ④ 다음 결정 the next closes in time order with what each outcome means, and which side the current price is on now. BOTTOM (sources): verdict = state + action (진입 enter now, a new signal | 유지 hold, NOT a new entry | 청산 exit | 대기 wait), `reason` and `condition` (the nearest closes that would change it); entry / stop / target / rr (entry.mode says new entry or hold; target may be null with target.reason); as_of = the bar it is based on. With `symbol` also `readings`/`events` (get_market_state lines). detail=true adds path, watch, story, ladders, matrix_summary (every timeframe incl. gate), tf_states, knots. `grade` = the theme's phase (test | confirm | null). head_horizons_ko = per-horizon lines (a GO timeframe below the theme is a piece for that horizon, not the symbol answer; 1w is a horizon only). Omit `symbol` for all 14 symbols. Narrate or filter the result — do not re-decide coordinates.
| Name | Type | Req | Description |
|---|---|---|---|
| detail | boolean | – | Include path / watch / story / ladders / matrix_summary (about 20KB per symbol). Default false: the answer only. |
| symbol | string | – | Optional symbol or alias (BTC, 비트코인, GOLD, 테슬라...). Omit for all 14 symbols. |
No output schema declared.
No examples provided.
decker.get_episodes ~289
Price-axis EPISODE history — answers 'where did I buy/sell last time, what was the target value and the event chain then, and where did price move WITHOUT a signal (and which target values it passed = missing points)'. Read-only from the persisted event ledger (no recompute). `episodes` (newest first) = one target selection until the next: target {price, from_price, reason}, chain (primary-unit judgment events), signals {ts, side, entry, targets, resolved{status, close, bar_low, bar_high}}, left (unit ends in that episode: result CONFIRMED | FAILED | MISSING = a target price passed before its judgment bar | EXPIRED = judgment sequence lapsed), missing, signal_gap (no signal in that episode), move {start_close, end_close, pct}. `signal_gaps` (ascending) = the interval between consecutive signals with its price move and the missing points inside (last one is open). Unit ends carry `side` (up/down = the target's run direction), `cand` and `reason` — classify on the read side; do not re-decide coordinates. History starts at the first persisted event of this generation.
| Name | Type | Req | Description |
|---|---|---|---|
| limit | integer | – | number of episodes |
| symbol | string | yes | e.g. BTCUSDT |
| timeframe | string | yes | – |
No output schema declared.
No examples provided.
decker.get_market_state ~683
PER-TIMEFRAME judgment state of a symbol — the evidence behind decker.get_assembly's single verdict (call get_assembly first for 'what do I do'). DEFAULT (detail=false): per timeframe (top→short) `reading` = one Korean line: target (touch kind, touch bar time) · phase (대상선정 / 테스트 국면 / 확인 국면 with hold count / outcome) · bar role now and what the next bar makes it · latest signal and its outcome (signal bar time, close) · action · price vs target · next close and what confirms or fails it; `chain` = the last 3 targets: selected → judge bar·signal bar results → outcome; `events[].line` = one line per state change, newest first, each timeframe's latest included; `assembly_summary_ko` = the symbol's answer (same lines as get_assembly); `head_reading` = theme line: the theme timeframe (latest current close transition across its concurrent loops, 1w/1d first, else 4h/1h/30m) with that timeframe's one signal (entry·target·invalidation); each timeframe's `reading` names the next live loop when the primary one has ended; `head_horizons` = one line per horizon timeframe: its target · next cell up/down · action · pieces (just-born signals at or below it, goal = that horizon's next cell). Read these as-is. detail=true: the full structured state (consumer contract CR1) — stage (target_selected | pending | confirmed | failed | none), side, signal_bar {time, low, high}, entry (= close at the signal), stop, target (take-profit, else null + target_reason), unit_target (the price being judged — NOT the take-profit), units, reverse_pending, standing, board (the board: target·judging·candidates·goal·next_judgment·reading — reading.next_judge_bar = next-bar label by move), levels, ladder, events (structured). as_of = the latest closed bar among the returned timeframes. Read as persisted (no recompute); no scores, weights or probabilities. A state reading, NOT a trade instruction. Crypto, Hyperliquid synthetics and KRX stocks (005930.KRX or the Korean name — daily/weekly timeframes only,…
| Name | Type | Req | Description |
|---|---|---|---|
| detail | boolean | – | false (default) = per timeframe only `reading` (one Korean line: target, phase, bar role and what the next bar makes it, latest signal, action, next close and what confirms/fails) + `chain` (recent t… |
| events_limit | integer | – | – |
| symbol | string | yes | e.g. BTCUSDT, XYZ_GOLDUSD |
| timeframe | string | – | Alias for a single-element `timeframes` (backward compatible). |
| timeframes | array | – | Subset to return. Omit for all timeframes. |
| Name | Type | Req | Description |
|---|---|---|---|
| as_of | string|null | yes | 가장 최근 평가 봉의 마감 시각 |
| events | array | yes | 최근 사건(새것 먼저). 대상선정·신호·신호 결말·실패(대상 방어)(reverse_failed: 1순위 대상의 반전이 실패한 판정 결과, side = 유지되는 추세 쪽 — 신호 아님)·반전 테스트(reverse_tested: 1순위 대상의 반전 첫 키 결과, status beyond|short — 신호 아님)·이전 판정 가격 도달(conn_arrival:… |
| ladder | object | – | 현재가 위·아래 가까운 순서로 각 8개. 같은 가격은 한 점이고 at 에 그 가격이 어느 시간대에서 어떤 역할인지(kind) 모두 나열된다 — 하위 시간대가 닿는 가격이 상위 시간대의 대상·후보·신호봉 경계이면 그 한 사건이 두 시간대의 사건이다(상위는 하위의 조각이 모여 만들어진다). signal_edge.edge: confirm=그 방향 확인 경계 ·… |
| missing_timeframes | array | yes | 아직 평가값이 없는 시간대 |
| price | number|null | yes | 가장 최근 평가 봉의 종가 |
| state_text | string|null | – | 사용자에게 그대로 보여 줄 수 있는 현재 상태 문면 — 상위·중간·단기로 묶어 시간대마다 방향+단계, 마지막에 주목 가격. 해석·전망 문장은 없다(그건 호출자 몫). 시간대 행이 없으면 null |
| symbol | string | yes | – |
| timeframe_summary | object | – | 시간대 행을 단계(confirmed 확인·pending 판정보류·failed 실패)와 방향(buy·sell)별로 나열만 한다. 우세·점수·투표 없음 — 실패는 반대 방향을 뜻하지 않는다. target_selected = 대상선정 중인 시간대 목록 |
| timeframes | array | yes | 상위→단기 순. 각 시간대가 낸 상태를 나란히 — 시간대 간 종합 판정은 없다(종합은 호출자 몫). |
No examples provided.
decker.get_positions ~182
Axis③ (Order/Execution) — this user's actual exposure (each open row carries vs_verdict: does the held side match the current symbol verdict, plus `knots` = the decision prices nearest to the price above and below, with which timeframes sit on each — the ORDER in which transactions would be reached, not a probability; `exit_levels` only when the held side matches): real open futures positions (execution_mode=real, with live sl_price/tp_price), virtual (paper) open positions, and the last 10 closed round-trips per mode. This is what your money actually did, distinct from decker.get_signals (axis②, what the engine recommends) — use this before deciding whether to place another order (avoid duplicate/over-exposure) and to check current protective stop/target on a real position.
Input schema present but exposes no named parameters.
No output schema declared.
No examples provided.
decker.get_reading ~223
How ONE timeframe looks right now, in plain language: state (phase, this timeframe's key direction, posture GO/WATCH/HOLD — a stance, not an order), mtf.by_tf (the same for other timeframes), narrative, plus `assembly` = the symbol's single verdict (the same one decker.get_assembly returns: direction, action 진입/유지/청산/대기, entry/stop/target). ⚠ `state.direction` is only this timeframe's direction and can differ from `assembly.direction` — for the decision use `assembly` (direction_basis says which is which). For the full detail call decker.get_assembly with detail=true; for the structured per-timeframe judgment use decker.get_market_state. Engine-native raw fields are not exposed here.
| Name | Type | Req | Description |
|---|---|---|---|
| include_tfs | string | – | Comma-separated additional TFs (e.g. '1h,4h,1d'). |
| symbol | string | yes | e.g. BTCUSDT |
| tf | string | – | – |
No output schema declared.
No examples provided.
decker.get_signals ~460
Active trading signals for the current user (with Skill Overlay applied), in customer-facing shape: coordinates (entry/target/stop), decision (ENTER/WAIT/SKIP — is_actual_trigger=true only for ENTER; WAIT/SKIP are standing candidates, not executed triggers), action_gate posture (GO/WATCH/HOLD — a stance, not an order command), progress, MTF verdict, and a plain-language summary_ko line. risk_reward_ratio is computed on the DISPLAYED coordinates (after overlay). Signals are retained rather than cut when they age (turn-retention policy) — read freshness_state (open|aged) / age_bars / freshness_sec before treating an old PENDING row as current. Filtered by symbols / min_progress / action_gate — action_gate here filters the CURRENT-MOMENT representative state, it does not search history (almost always 0 rows unless a gate is GO right now); for past GO events with their entry/target/stop and realized performance use decker.get_trigger_history instead. Before placing any order through any execution tool, check the intent with decker.validate_intent.
| Name | Type | Req | Description |
|---|---|---|---|
| action_gate | string | – | Engine action gate filter (3-layer grammar: gate = transition posture, not an order command). Rows where the engine emitted no gate for this bar (effective_action_gate null, e.g. KRX daily) are exclu… |
| limit | integer | – | – |
| min_progress | number | – | Minimum progress_pct (0-100). |
| symbols | array | – | Symbol filter (e.g. ['BTCUSDT','ETHUSDT']). Omit for all. |
| timeframe | string | – | Signal horizon filter (30m=scalp, 1h=swing, 4h/8h/1d=position). The same symbol can hold OPPOSITE directions on different horizons — omit to get the latest active signal regardless of horizon (its ti… |
No output schema declared.
No examples provided.
decker.get_trigger_history ~227
ACTION axis — actual historical GO triggers (not standing WATCH/HOLD candidates) for a symbol, with entry/target/stop coordinates and realized performance (mfe_pct/mae_pct/exit_reason/exit_price from trigger_performance, null = still open). Distinct from decker.get_signals (which reflects only the current-moment state, not a searchable history — its action_gate filter answers 'what does symbol×tf look like right now', not 'when did this last fire'). Use this to answer 'what did the engine actually trigger recently and at what price' — decker.get_signals/get_market_state cannot answer that. direction is judgment_signals-native vocabulary ("long"/"short"), distinct from the "+"/"-" convention used by other tools — read as-is, no translation.
| Name | Type | Req | Description |
|---|---|---|---|
| limit | integer | – | – |
| since | string | – | ISO8601 lower bound on trigger time (exclusive). Optional. |
| symbol | string | yes | e.g. BTCUSDT |
| timeframe | string | – | Optional — omit for all timeframes. |
No output schema declared.
No examples provided.
decker.get_user_skills ~112
Trading skill catalog + currently active overlay for this user. Returns 8 published skills (conservative_v0/standard_v0/aggressive_v0/default_v0/scalp_v0/tight_v0/wide_v0/swing_v0) and the user's selected one. Also returns symbol_skills: the symbols where this user's paper account turns the symbol verdict's entry event into an order (turn on/off with decker.set_symbol_skill or REST /auto-order-rules/symbol-skills).
Input schema present but exposes no named parameters.
No output schema declared.
No examples provided.
decker.get_view ~430
Ready-to-show Korean status card for a symbol — the same card the daily briefing sends, built from the same consumer contract (CR1) as decker.get_market_state, so direction and prices always agree with it. Shows the timeframes grouped 상위/중간/단기 with one line each (direction + stage + the price that decided it), the nearby prices to watch, and a short explanation of the chosen timeframe (tf, default 4h): what closed beyond what, whether the signal flips the previous one, entry/target/stop. Also returns direction (+/- only while that timeframe's signal is pending or confirmed; a failed or absent signal gives no direction — failure does not assert the opposite side), wait_target, invalidation, ref_price and recent self-scoring verdicts. Use this when you want text to show as-is; use decker.get_market_state when you want structured values to reason over. layer=STATE_VIEW: a market-state reading, NOT a trade instruction. The response carries TWO readings: the timeframe card (`lines`, top-level `direction`/`phase` — that one timeframe's own state, its action words are about that timeframe) and `verdict` (the symbol's single judgment across timeframes — the one to act on). They can differ (e.g. card direction null / '매도 유지' while verdict is '진입'); `direction_basis` says which is which and `direction_basis.differs` flags it. Before placing any order through any execution tool, check the intent with decker.validate_intent.
| Name | Type | Req | Description |
|---|---|---|---|
| symbol | string | yes | e.g. BTCUSDT, XYZ_GOLDUSD (crypto + HL TradFi synthetics; KRX daily lineage not yet covered by view v1) |
| tf | string | – | Optional view timeframe — the grounded narrative is composed on this TF's bar (e.g. '1h' when the user asks about the 1-hour picture). Omit for the engine's default action TF (usually 4h, same as the… |
No output schema declared.
No examples provided.
decker.place_order ~423
Axis③ (Order/Execution) — unlike every other tool here, this one moves money. It places a market order through DECKER'S OWN execution engine (same path as the decker-ai.com chat trading UI, source='mcp') — it does NOT hand off to your own broker connection or exchange account; Decker executes using whatever exchange credentials this user has separately linked to their Decker account on the website. execution_mode (virtual|real) is NOT chosen by the caller — it is resolved server-side from this user's account settings (user_settings.execution_mode) AND the platform's real-trading kill switch; a real-money order requires both an explicit user opt-in AND role/tier eligibility (PRO/ENTERPRISE or admin) AND passing the tier's hard notional/leverage/daily-count caps (checked here before dispatch — violation blocks the order, does not downgrade it to virtual). The response always states which mode actually executed — treat 'virtual' in the response as authoritative even if you expected real. Restricted to the crypto-6 universe (BTCUSDT/ETHUSDT/SOLUSDT/BNBUSDT/XRPUSDT/DOGEUSDT) for this MCP path — HL-synthetic and KRX symbols are read-only via other tools. Call decker.validate_intent first to read the engine's current stance; this tool does not check it for you. Positions are tracked as ONE net row per user+symbol+mode, not per order — if you already hold a position on this symbol, this order nets into it and the response's pre_existing_position field says so. A later close_position call closes the combined total, not just what this call added.
| Name | Type | Req | Description |
|---|---|---|---|
| notional_usd | number | yes | Order size in USD (quantity = notional_usd / current price). This is the value checked against the account's tier notional cap. |
| side | string | yes | Order direction (buy/long or sell/short). |
| symbol | string | yes | Crypto-6 only for this MCP write path. |
No output schema declared.
No examples provided.
decker.set_skill_overlay ~53
Change active trading skill overlay for this user. Immediately affects all subsequent get_signals calls and downstream channels.
| Name | Type | Req | Description |
|---|---|---|---|
| skill_id | string | yes | trading_skills.id (e.g. 'aggressive_v0'). |
No output schema declared.
No examples provided.
decker.set_symbol_skill ~386
Turn the per-symbol integrated skill on or off for this user's paper (virtual, default) or live (execution_mode=real, quantity required) account. When on, the symbol verdict's entry event (decker.get_assembly) opens an order and the same verdict's exit / opposite-entry events close it — same algorithm in both modes; per-timeframe rules never close a position this skill opened. Defaults: paper notional quantity, engine stop/target. replace_timeframe_rules=true pauses this user's paper per-timeframe rules for the symbol and hands their open positions to the skill (adopted_position_ids); paused_rule_ids restore the rules via enabled=false + restore_rule_ids. Current state: decker.get_user_skills → symbol_skills.
| Name | Type | Req | Description |
|---|---|---|---|
| enabled | boolean | yes | true = on (idempotent), false = off (rule kept, paused). |
| execution_mode | string | – | virtual (default) = paper account; real = live exchange (Binance USDT-M futures / Hyperliquid), same verdict→order→exit algorithm. With enabled=false: turn off only that mode's skill. |
| horizon | string | – | Horizon timeframe to hold: orders every just-born signal at or below it toward that timeframe's next cell (≥2%), exits on that timeframe's action. own (default) = each signal's own timeframe. Omitted… |
| quantity | number | – | Optional order size. Omitted = paper default notional. Required when execution_mode=real. |
| replace_timeframe_rules | boolean | – | Pause this user's paper per-timeframe rules for the symbol (default false). |
| restore_rule_ids | array | – | With enabled=false: re-activate these paused per-timeframe rules. |
| symbol | string | yes | e.g. BTCUSDT, XYZ_GOLDUSD (a symbol with an engine verdict). |
No output schema declared.
No examples provided.
decker.update_protective_stops ~281
Axis③ (Order/Execution) — modifies the stop-loss and/or take-profit on an EXISTING open position. There is no cancel_order tool because Decker only places market orders (there is no resting order to cancel) — the actual gap this fills is modifying protective stops on a position you already hold. real: cancels the old exchange stop/take-profit order(s) and places new ones at the given price(s) (new order placed first, old one canceled only after — no unprotected window). virtual: updates the paper position's stop_loss/take_profit columns directly (polled by the paper monitor). Provide at least one of sl_price/tp_price — the other side, if omitted, is left at its current value. If both a real and a virtual position are open for this symbol, pass mode explicitly or the call is rejected asking which one.
| Name | Type | Req | Description |
|---|---|---|---|
| mode | string | – | Only required when both a real and a virtual position are open for this symbol — says which one to modify. |
| sl_price | number | – | New stop-loss price. Omit to leave the current stop unchanged. |
| symbol | string | yes | e.g. BTCUSDT — must be a symbol you currently hold. |
| tp_price | number | – | New take-profit price. Omit to leave the current target unchanged. |
No output schema declared.
No examples provided.
decker.validate_intent ~578
Pre-trade gate check for a proposed order intent. Call this BEFORE placing any order through any execution tool (e.g. a broker MCP's review→place flow). Checks the intent (symbol + side) against Decker's deterministic market state: engine action_gate (GO/WATCH/HOLD — a transition posture, not an order command), current structural state, and the active signal's direction / invalidation (stop) coordinates. Returns a stance reading, NOT an approval or rejection: the vocabulary is the engine gate as-is plus a mechanical tf_signal_alignment (aligned/opposed vs the active signal's direction). covered=false means the engine does not emit state for this symbol — treat as unknown, not as HOLD. top-level action_gate can be null even when covered=true — this is not a missing field, it means the current bar has no fresh trigger reading; check gate_null_reason ('no_gate_available' = neither the current bar nor the carried-forward signal had a gate at all, vs 'signal_stale' = a value existed but the underlying signal exceeded the staleness threshold and was deliberately suppressed rather than served as a confident-but-old answer). The order decision and responsibility remain with the calling agent/user. Every check is persisted to an auditable decision ledger (check_id). READ verdict_check FIRST: it compares the intent with the symbol's single verdict (the same one decker.get_assembly returns — direction, action 진입/유지/청산/대기, entry/stop/target, what would change it) and says in summary_ko whether a NEW entry exists now (entry_now) or the stance is only being held. The timeframe-level gate/signal fields below describe one timeframe (default: your open position's) and can be stale. When the symbol verdict is not an entry right now, `signal.is_actual_trigger` is false even if that one timeframe's own signal is ENTER: the timeframe's call is kept in `signal.tf_decision` and `signal.superseded_by` names the verdict action that overrides it.
| Name | Type | Req | Description |
|---|---|---|---|
| order_type | string | – | Optional, informational (market/limit/…) — recorded in the ledger, does not change the state verdict. |
| side | string | yes | Proposed order direction (buy/long = +, sell/short = -). |
| symbol | string | yes | e.g. BTCUSDT, SILVER, 테슬라 — aliases resolve to the engine symbol (XYZ_SILVERUSD, XYZ_TSLAUSD, …). |
| timeframe | string | – | Gate horizon. Omit = your open position's entry TF if you hold one on this symbol, else decker.get_assembly's entry TF (the single judgment authority's current best-path TF), else the engine's defaul… |
No output schema declared.
No examples provided.
How do I install the io.github.gigshow/decker MCP server?
io.github.gigshow/decker is a hosted endpoint at https://api.decker-ai.com/api/v1/mcp, so there is nothing to install locally. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.
remote · api.decker-ai.com
claude mcp add --transport http gigshow-decker 'https://api.decker-ai.com/api/v1/mcp'
What is the io.github.gigshow/decker MCP server?
io.github.gigshow/decker is an MCP server listed in the public MCP registry as io.github.gigshow/decker. Deterministic market-state engine for trading agents, state, gate, coordinates, with receipts. This page covers its hosted endpoint (https://api.decker-ai.com/api/v1/mcp).
Is the io.github.gigshow/decker MCP server safe to use?
io.github.gigshow/decker scores 77 out of 100 on VerifyMCP. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.
What tools does the io.github.gigshow/decker MCP server expose?
io.github.gigshow/decker exposes 15 tools: decker.get_assembly, decker.get_market_state, decker.get_view, decker.get_reading, decker.get_signals, and 10 more. Their descriptions and schemas cost roughly 5,104 tokens of context every time the server is loaded.
Does the io.github.gigshow/decker MCP server require authentication?
No. We connected to io.github.gigshow/decker without credentials and it answered, so anything it exposes is reachable by anyone who knows the address.
Is the io.github.gigshow/decker MCP server still maintained?
io.github.gigshow/decker is still listed as active in the MCP registry. We last reached this channel on 21 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.
What did VerifyMCP test on the io.github.gigshow/decker MCP server?
VerifyMCP ran 12 checks on io.github.gigshow/decker, covering TLS certificate, HTTPS, HSTS header, DNSSEC and 8 more. One item could not be completed, a gap on our side rather than a finding about io.github.gigshow/decker: Authorization. Supply Chain Security and Provenance & Transparency do not apply to a hosted endpoint, so they were not tested. The score does not measure everything, and the scoring documentation lists what it leaves out.