decker
Server Details
Deterministic market-state engine for trading agents — state, gate, coordinates, with receipts.
- Status
- Healthy
- Uptime
- 100.0% over the last 24 hours
- Last Tested
- Transport
- Streamable HTTP · MCP 2024-11-05
- URL
- Repository
- gigshow/decker-ai
- GitHub Stars
- 3
- Server Listing
- Decker
- ChatGPT
- –
- Claude
- –
TDQS
Scored across 15 tools
The execution axis is clean (place_order / close_position / update_protective_stops), but the read axis has five heavily overlapping tools — get_assembly, get_market_state, get_reading, get_view, and get_signals all surface the same underlying judgment state in different shapes. The descriptions mitigate this with explicit cross-references ('distinct from get_signals...', '⚠ state.direction is only this timeframe's direction'), but the volume of disambiguation text itself signals that an agent will frequently hesitate between them.
Every tool follows a clean snake_case verb_noun pattern under a uniform decker. prefix: get_*, set_*, place_order, close_position, update_protective_stops, validate_intent. No camelCase, no vague verbs, and the prefixes map onto readable axis groupings.
15 tools sits at the top of the ideal band and the surface is mostly earned: judgment reads, signal history, exposure, execution, and skill configuration are all legitimate concerns. The count is slightly inflated by redundant read variants (get_reading vs get_view vs get_market_state) that could be collapsed into format parameters.
Both the read lifecycle (verdict, per-timeframe state, signals, trigger history, episodes, positions, skills) and the write lifecycle (place, close/partial-reduce, modify protective stops, pre-trade validation, skill toggles) are covered, and the absence of cancel_order is explicitly justified by market-only execution. Minor gaps remain: no order/execution log beyond the last 10 round-trips per mode, and no way to inspect account settings or universe/eligibility themselves.
Available Tools
15 toolsdecker.close_positionAInspect
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.
Inputs: symbol (required), close_fraction.
decker.get_assemblyBInspect
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.
Inputs: detail, symbol.
decker.get_episodesAInspect
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.
Inputs: symbol (required), timeframe (required), limit.
decker.get_market_stateAInspect
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, evaluated after the 15:30 KST close). Before placing any order, check the intent with decker.validate_intent.
Inputs: symbol (required), detail, timeframe, timeframes, +1 more. Returns: as_of, price, events, ladder, +5 more
decker.get_positionsAInspect
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.
Inputs: no named parameters.
decker.get_readingAInspect
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.
Inputs: symbol (required), tf, include_tfs.
decker.get_signalsAInspect
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.
Inputs: limit, symbols, timeframe, action_gate, +1 more.
decker.get_trigger_historyAInspect
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.
Inputs: symbol (required), limit, since, timeframe.
decker.get_user_skillsAInspect
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).
Inputs: no named parameters.
decker.get_viewAInspect
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.
Inputs: symbol (required), tf.
decker.place_orderAInspect
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.
Inputs: side (required), symbol (required), notional_usd (required).
decker.set_skill_overlayAInspect
Change active trading skill overlay for this user. Immediately affects all subsequent get_signals calls and downstream channels.
Inputs: skill_id (required).
decker.set_symbol_skillAInspect
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.
Inputs: symbol (required), enabled (required), horizon, quantity, +3 more.
decker.update_protective_stopsAInspect
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.
Inputs: symbol (required), mode, sl_price, tp_price.
decker.validate_intentAInspect
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.
Inputs: side (required), symbol (required), timeframe, order_type.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Related MCP Connectors
Deterministic, receipted digital microservices. Gate A is simulation-only.
Coherence-gated signal engine. Paid verdict settled end-to-end 2026-11-01 (SELF-PROOF, XRPL).
Agent routing, safety preflight, execution receipts, best execution and verified outcomes.
Your agent carries its own resume — outcome receipts minted at settlement, held by the agent.
Related MCP Servers
- AlicenseNot gradedqualityBmaintenanceEd25519-signed market-state receipts for 28 exchanges: is the venue open right now, as a receipt any agent can verify without trusting the operator, fail-closed (unknown is reported as closed). MCP tools: get_market_status, get_market_schedule, list_exchanges, get_payment_options. Free tier 500 calls a day with an instant key; x402 pay-per-call at 0.001 USDC on Base; Builder 99 USDC a monthMIT
- AlicenseNot gradedqualityBmaintenanceEnables multi-agent systems to share and coordinate a common state space over MCP, detecting concurrent mutation race conditions, synchronizing state through vector clocks, and resolving conflicting decisions via consensus arbitration. Also supports deterministic policy validation and cryptographic state hashing with zero external dependencies.7MIT

bitraofficial
AlicenseAqualityAmaintenanceAutonomous trading agents with deterministic execution. The agents propose, the system decides.10366 PyPI47MIT
Cruxible Coreofficial
AlicenseNot gradedqualityCmaintenanceDeterministic decision engine with DAG-based receipts. Build entity graphs, query with MCP, get auditable proof.17Apache 2.0
Glama MCP Gateway
Add one secure layer between your agents and this server.