Skip to main content
Glama
Arsenal Decision Engine

Arsenal Decision Engine

Arsenal Decision Engine ๐Ÿ›ก๏ธ

The Risk-Validation Layer for Autonomous AI Agents (DeFAI)

Arsenal-Quant-Project MCP server

Method and raw results are published โ€” backtest script ยท result data (180 days of Binance ETH/USDC daily closes): ๐Ÿ”ฌ Breakeven Corridor is a deterministic algebraic boundary (where IL = accumulated yield). Any position whose price ratio stays within [lower_be, upper_be] has R_net > 0 by mathematical definition โ€” not a probabilistic model. ๐Ÿ“ This engine measures; it does not forecast. No predictive-accuracy figure is claimed โ€” read the published result files and judge the method for yourself.


Mission

Transform DeFi uncertainty into deterministic, actionable risk metrics for autonomous agents. We do not run stateful trading bots or generate speculative prediction signals; we provide a stateless risk middleware layer that agents query before deploying or maintaining standard constant-product / full-range LP positions.

Built for agents. 100 free calls per IP per day โ€” no wallet, no sign-up, custom parameters included. An L402 payment path is implemented in the gateway but is not operational in production: today, the engine is free to use.


Related MCP server: WETH

What This Engine Does

Before an autonomous agent deploys capital or adjusts a standard constant-product / full-range LP position (such as Uniswap V2 or full-range V3), it submits the pool parameters (APY, price ratio, days held) to our API. The engine computes the exact mathematical risk, the net return ($R_{net}$), and the dynamic Breakeven Corridor bounds.

  • No LLMs. No hallucinations. Pure algebraic calculation.

  • Complexity: $\mathcal{O}(1)$ time and memory.

  • Latency: $< 15\text{ms}$ local execution.

Two ways to call it

1. MCP JSON-RPC โ€” the endpoint advertised on the MCP registry

POST https://api.arsenal-quant.com/mcp
{"jsonrpc":"2.0","id":1,"method":"tools/call",
 "params":{"name":"evaluate_pool",
           "arguments":{"apy":0.20,"price_ratio":0.85,"days_held":30}}}

Standard MCP handshake: initialize โ†’ tools/list โ†’ tools/call. Available over streamable HTTP and stdio.

2. REST convenience route โ€” no MCP client required

GET https://api.arsenal-quant.com/mcp/evaluate?apy=0.20&price_ratio=0.85&days_held=30

Both routes run the same calculation and the same quota. Note that /mcp/evaluate is GET-only: a POST to that path returns 405 Allow: GET, because JSON-RPC belongs on /mcp.

Engine Response (JSON Contract)

{
  "impermanent_loss_pct": 0.3292,
  "accumulated_yield_pct": 1.6438,
  "r_net_pct": 1.3146,
  "il_to_yield_ratio": 0.2,
  "risk_level": "LOW",
  "breakeven_corridor": {
    "lower_ratio": 0.6941,
    "upper_ratio": 1.4407,
    "interpretation": "Position remains profitable if price ratio stays within [0.6941, 1.4407]"
  },
  "inputs": {
    "apy": 0.2,
    "price_ratio": 0.85,
    "days_held": 30
  },
  "source": "Arsenal Decision Engine v2.0",
  "oracle_signature": "<HMAC-SHA256 hex โ€” illustrative placeholder, yours will differ>",
  "layer": "FREE"
}

layer reports how the call was served: FREE while inside the free quota, PREMIUM once an L402 payment has been verified. The call shown above is served as FREE.


Access and Pricing

  • Free tier โ€” evaluate_pool: 100 calls per IP per day, custom parameters included. No Lightning wallet is needed. This is the only tier currently in service.

  • Beyond the free quota: the gateway implements the L402 challenge and returns 402 with a WWW-Authenticate header. The payment rail is not operational in production โ€” invoices issued today are not settleable, and no payment is expected or accepted. Treat the paid tier as announced, not available.

  • GET /mcp/audit/latest: 3 free calls per IP per hour; beyond that the route returns 402. That response documents the protocol; it is not a live payment path.


Python Integration Example

import urllib.request
import urllib.error
import json
import re
import os

API_URL = "https://api.arsenal-quant.com/mcp/evaluate?apy=0.20&price_ratio=0.85&days_held=30"
LNBITS_URL = "https://demo.lnbits.com"

# LNbits requires a wallet key with send permission to pay an invoice.
# Use a DEDICATED wallet funded with a small working balance, and never the key
# of a wallet holding significant funds. Keep it in the environment, never in code.
LNBITS_PAYMENT_KEY = os.getenv("LNBITS_PAYMENT_KEY")

def query_risk_oracle():
    req = urllib.request.Request(API_URL, method="GET")
    req.add_header("x-agent-id", "autonomous-lp-bot")

    try:
        with urllib.request.urlopen(req) as resp:
            return json.loads(resp.read().decode('utf-8'))
    except urllib.error.HTTPError as e:
        if e.code == 402:
            auth_header = e.headers.get("WWW-Authenticate")
            macaroon = re.search(r'token="([^"]+)"', auth_header).group(1)
            invoice = re.search(r'invoice="([^"]+)"', auth_header).group(1)

            pay_req = urllib.request.Request(
                f"{LNBITS_URL}/api/v1/payments",
                data=json.dumps({"out": True, "bolt11": invoice}).encode(),
                headers={"X-Api-Key": LNBITS_PAYMENT_KEY, "Content-Type": "application/json"}
            )
            with urllib.request.urlopen(pay_req) as pay_resp:
                preimage = json.loads(pay_resp.read().decode())["preimage"]

            retry_req = urllib.request.Request(API_URL, method="GET")
            retry_req.add_header("Authorization", f"L402 {macaroon}:{preimage}")
            retry_req.add_header("x-agent-id", "autonomous-lp-bot")

            with urllib.request.urlopen(retry_req) as final_resp:
                return json.loads(final_resp.read().decode('utf-8'))
        else:
            raise

if __name__ == "__main__":
    evaluation = query_risk_oracle()
    print(f"Risk Level     : {evaluation['risk_level']}")
    print(f"R_net          : {evaluation['r_net_pct']:+.4f}%")
    print(f"Breakeven      : [{evaluation['breakeven_corridor']['lower_ratio']}, {evaluation['breakeven_corridor']['upper_ratio']}]")

Developer Integration

  • Integration cookbook & MCP guides: COOKBOOK.md

  • MCP auto-discovery card: https://api.arsenal-quant.com/.well-known/mcp/server-card.json

Why per-call pricing is the intended model

This engine does not prevent losses, and it makes no claim about how much money it saves you. What it does is compute โ€” deterministically, in $\mathcal{O}(1)$ โ€” whether a position sits above or below its breakeven boundary. Each response carries an HMAC tag over the result, which lets the engine detect tampering with its own output; it is a symmetric provenance marker, not a proof a third party can verify independently.

The intended model is per-call pricing, so the cost can be budgeted like any other input. That model is not yet in service: today every call is free.

Available Tools

2 tools
evaluate_poolAInspect

Evaluate LP position risk and calculate R_net & breakeven corridor.

Inputs: apy (required), price_ratio (required), days_held.

get_latest_auditAInspect

Fetch the latest cost-intelligence and risk mitigation audit signal.

Inputs: no named parameters.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelogโ€ฆ

    TDQS

    A3.7/5.0

    Scored across 2 tools

    Disambiguation5/5

    The two tools target clearly distinct functions: one fetches an audit signal, the other evaluates LP pool risk. There is no overlap or ambiguity between them.

    Naming Consistency5/5

    Both tool names follow a consistent verb_noun snake_case pattern: get_latest_audit and evaluate_pool. This is predictable and uniform.

    Tool Count3/5

    With only 2 tools, the server sits at the thin end of the scale. The scope appears narrow, so the count is plausible, but it feels slightly sparse for a 'decision engine' that might warrant additional supporting functions.

    Completeness4/5

    For the apparent purpose of providing audit signals and LP risk evaluation, the two tools cover the core workflow without obvious dead ends. Minor gaps may exist, such as historical audit retrieval or pool parameters, but the essential actions are covered.

    Maintenance

    ActivityStale
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      C
      maintenance
      Deterministic risk governance for crypto trading agents. 5-level policy engine with position sizing, leverage limits, and trade blocking. One tool: get_risk_policy. Supports BTC and ETH.
      4
      72 npm
      1
      MIT
    • A
      license
      Not graded
      quality
      C
      maintenance
      Enables AI agents to analyze Ethereum wallets, simulate transactions, and draft transfers with deterministic policy and risk scoring, requiring human approval before on-chain execution.
      12 npm
      ISC
    • A
      license
      Not graded
      quality
      D
      maintenance
      The verifiable risk engine for autonomous agents: deterministic, self-verifying financial calculations that an agent can delegate and prove. It covers liquidation and funding, position sizing and risk of ruin, options Greeks and margin, LP divergence, treasury concentration and depeg, execution quality checks, plus intelligence on options, DeFi, prediction markets, and transaction safety analysis.
      11 npm
      2
      MIT
    • A
      license
      Not graded
      quality
      B
      maintenance
      Enables AI trading agents to submit proposed trades for deterministic pre-execution risk evaluation, returning allow/warn/deny decisions, risk scores, and tamper-evident audit hashes. It also supports token safety checks, balance simulation, asset registry lookup, and audit trail verification.
      MIT