MONARK

tech.monarkgatePublished by monarkgate.techOfficial publisherv0.4.0Updated Oct 25, 2026

Commit / defer / abstain over a conformal coverage region - not a probability of being right.

VerifiedStreamable HTTPWeb executableFinanceAI & ML

Overview

AI-generated overview

A remote MCP endpoint that turns a claim into a coverage-gated commit, defer or abstain decision against a depletable authorization budget, plus attested price,

What you can do
Submit a claim and receive a commit, defer or abstain decision with an auditable region and the remaining budget, dispatched by task class; some classes are retired or abstain as under-calibrated. Request an attested price testimony carrying bytes, a hash and named residual hypotheses rather than a verified price. Ask what a lending book would liquidate along a price path; this transitional tool abstains by construction. Compute a split-conformal quantile at a chosen miscoverage level over nonconformity scores you supply yourself.
When to use it
For agents that need a decision primitive which states an auditable region and a budget instead of a confidence score, and that can act on an explicit abstain. Useful when you want a citable attested price or a conformal quantile computed from your own scores without handing over your data or model.
Requirements
A remote streamable HTTP endpoint; no account, email or wallet is required according to the README. The caller supplies the claim, the authorization budget and, for calibrate, the nonconformity scores. Network access to the provider's endpoint is needed.
Before you install
The gate never reports a probability of being correct, and several classes abstain or are retired, so an abstain should be treated as no decision. The cascade tool abstains by construction and the README says its bound holds only under a frozen close-factor rule the gate does not check. Calibrate does not see, store or verify your data and its coverage holds only for exchangeable future points. Attestation attests origin and bytes, not truth.

Installation

In SourceWeft

  1. Open MONARK in the dashboard and add it to a workspace.
  2. Enable the server for the chats that should use its tools.

Web executable via Streamable HTTP. Remote servers run from the web runtime once configured in a workspace.

Use with an agent

Paste this prompt into Claude Code, Codex, Cursor or another agent — or into SourceWeft chat. The agent reads this server's install guide, shows you its publisher, endpoint and sign-in, and adds it to your client once you agree. Keys never go into a command.

Read https://sourceweft.com/mcp/tech.monarkgate%2Fmonark/install.md and connect the MCP server it describes to my client. Before changing any config, show me its publisher, endpoint and sign-in method and wait for my OK. Never put an API key in a command or in a file I would commit; ask me where it should come from.

Read the install guide the agent follows

Other MCP clients

Add this to your client's mcpServers config.

{
  "mcpServers": {
    "monark": {
      "type": "http",
      "url": "https://mcp.monarkgate.tech/mcp"
    }
  }
}

README

[MONARK — it abstains so DeFi can act.]

MONARK

[CI] [License: Apache-2.0]

[Latest Release]

MONARK is a two-sided toolkit — an AI side and a DeFi side — built like a Swiss-army knife: one handle, several blades. The handle is the MONARK engine, the AI side: a coverage-controlled decision gate that emits commit | defer | abstain against a depletable authorization budget (B_t) — never a probability of being right — with the sensors that attest to what happened on chain, the frozen contracts they speak, the harness through which other AI agents reach it, and the agents that keep it adapted to DeFi as DeFi changes. The blades are the DeFi side: the on-chain applications it powers, each one grown from an empirical study of on-chain data before it is served. The first is MONARK Bell; the others are research leads.

Single token, single ticker (MONARK). The agents are applications, not tokens. This repository is the MONARK tokenisation layer, the eight frozen interface contracts (one of them, AttestedBook, upcoming until served) and the served pieces that let AI agents and DeFi meet on measured ground.

Two sides, one engine — the eleven components

The engine is eleven components: three sensors, one gate, one act, six distribution pieces. Each of them can serve both sides. Left: what it gives an AI agent connected to the MONARK MCP endpoint (today's four tools are attest · gate · cascade · calibrate; a component marked planned has no served tool yet). Right: what it gives the DeFi side — the on-chain applications it powers (in parentheses: the applications on the site's diagram; wired = declared in the registry today, can serve = a lead, not a delivered link).

AI side — for an agent on our MCPComponentDeFi side — DeFAI, for the applications
attest: an attested price testimony (bytes, hash, named residual hypotheses) the agent can cite instead of a scraped number — origin and bytes, never truth.Shōgen — sensor, attested perception · builtA price an application can defend when it spends, hedges or de-risks (can serve: Warden, Softlanding, Firebreak, Ballast).
gate + calibrate: the agent submits a claim and gets commit | defer | abstain, an auditable region and the budget left — never a probability of being right.Hikae — the gate, coverage-controlled inference · builtThe decision primitive of every application (wired: Firebreak, Warden, Softlanding, Verdict, Ballast). Bell's gate is its own closed publication check; a gate class for its off-hours gap is planned.
cascade: the agent asks what a lending book would liquidate along a price path (a transitional tool; it abstains, under_calib). Through gate, the class liquidation-eligible-coverage returns a conformal upper bound on a caller-carried liquidable amount in its committed stratum, calibrated on one recorded episode; the other strata abstain (under_calib) — stated on the wire.Ukemi — act, liquidation-cascade survival · builtReads the deleveraging queue or the position before it clears (wired: Firebreak, Softlanding).
A daily, replayable redemption-flow timeline (state.json, timeline.jsonl) any agent can read, and the served gate class stable-run-velocity-24h through gate.Narabi — sensor, redemption-run sensing · built, served dailyRedemption-run sensing for a treasury that holds the stable: a daily, replayable reading of the redemption flow, stated after the fact, never ahead of it (can serve: Warden, Ballast).
planned: attest a document or an event the agent must act on — bytes and hash, never a verdict on its truth.Mokugeki — sensor, document / event attestation · namedThe attested event a settled decision starts from (can serve: Verdict).
planned: ask, before routing a swap, whether the fill is exposed to LVR / toxic flow.Kaihi — LVR / toxicity avoidance · namedThe execution leg of a de-risk or a hedge that must not be picked off (can serve: Firebreak, Softlanding, Ballast).
planned: execute a swap under transaction-cost analysis, with the gate's decision attached.Kessai — swap execution, TCA · namedThe act leg — de-risk, ease down, rebalance (can serve: Firebreak, Softlanding, Ballast).
planned: quote and manage inventory for the agent's market-making.Kamae — inventory market-making · namedInventory-aware hedging for a treasury (can serve: Ballast).
planned: read a PT / YT curve as an attested rate surface.Kyokusen — PT / YT curve · namedThe rate surface a rate treasury steadies against (can serve: Ballast).
planned: the weekend / off-hours gap as a sensed quantity the agent can gate on.Koyomi — weekend gap · namedThe off-hours gap of tokenized equities, the very quantity Bell publishes (can serve: Bell).
The door: discovery of the tools and the skill (MCP Registry tech.monarkgate/monark).Genkan — the storefront / MCP entry point · named (the harness serves the door today)Distribution of every application to the agents that consume it (can serve: all six).

Measurement first. No piece of MONARK is designed on a whiteboard and shipped. Each one starts as an empirical study — a recorded liquidation book at an archive block, a redemption-flow series measured on calm windows, a census of trading halts, a session-by-session record of tokenized-equity fills — and the study's artefacts stay attached to the served piece: committed calibrations with their digests, replayable timelines with per-line hash chains, published signing keys. That is what we mean by an instrumented environment: an AI agent operating in DeFi through MONARK acts on attested readings and audited regions, and gets an explicit abstain where nothing is measured — instead of a guess dressed as a number.

Kept adapted. DeFi does not hold still: protocols upgrade, liquidation engines change shape, oracles and data feeds move, calibrations drift. The engine is built so that each of these is a measured event with a pre-registered response (a drift criterion, a new recorder, a new residual hypothesis, a versioned change to a contract). The adaptation agents are the part of the AI side that detects those events and prepares the response. They are on the roadmap, not yet shipped (see the maturity table below).

What is served today

Everything below is live, machine-readable, and replayable by a third party without an account:

SurfaceWhat it servesWho consumes it
https://mcp.monarkgate.tech/mcp · https://api.monarkgate.tech/openapi.jsonThe engine's four tools (attest · gate · cascade · calibrate) over MCP and a plain HTTP/JSON mirror; the served OpenAPI document states the served versionAny MCP-capable agent
https://monarkgate.tech/narabi/state.json · timeline.jsonlNarabi's tracker state and its append-only, per-line hash-chained daily timeline (one line per window, with the blocks it was read from)Anyone replaying the tracker; the site's /narabi page
https://monarkgate.tech/narabi/instrument.jsonA diagnostic file beside the tracker, written once from a closed block of days (never by the daily job): tracker replays at alternative parameters and a permutation-assessed CUSUM; it claims no boundAnyone auditing the tracker; no page reads it
https://bell.monarkgate.tech/state.json · timeline.jsonl · provenance.json · bell/pubkey.jsonMONARK Bell's signed publications: per-session fills, VWAP and volume for the listed tokenized equities, halt census, supply and proof-of-reserve residuals, the provenance of each run, the active Ed25519 keyAnyone verifying a publication; the site's /bell page
https://dojo.monarkgate.tech/ · timeline.jsonl · dojo/pubkey.json · lines/<sha256>.jsonl · history/<sha256>.jsonlMONARK Dōjō's hold snapshot: a dated, public record of the MONARK token balances held by each address, read from the chain through two distinct operators, with a hold score per address; the signed timeline, the published key, a day's lines file and the history file that a signed line of the timeline names by its SHA-256Anyone recomputing it; the site's /dojo page
https://monarkgate.techThe vitrine: every number on it is read from a committed, hashed copy of the served files above — never typedReaders

A surface that is not in this table is not served. A component that has no served surface is labelled named, not built, wherever it appears.

The backbone — the gate

Everything in MONARK plugs into one decision primitive. A sensor reads the world and attests to it; a predictor turns that reading into a claim; the gate conformalises the claim into a region at a target coverage and returns one of three actions against a depletable budget:

  • commit — the region is tight enough to act on, and the budget can pay for it;
  • defer — the reading is ambiguous; the gate waits for a better one;
  • abstain — the gate cannot state a region it stands behind, so it says nothing and invents no success.

The gate never reports how likely it is to be correct. It reports a region you can audit and a budget you can watch — never a probability of being right.

Maturity (labelled by what is built)

The labels are the point: they say what exists today and what is only named.

SideLayerWhat it isStatus
AIBackbone — the gateHikae (coverage control) + the MONARK token's budget B_t; turns a sensor reading into commit | defer | abstainBuilt — eight frozen contracts (AttestedBook upcoming until served)
AISensors and actsthe engine's agents: sensors that attest, acts that execute, one token across all of them4 built (Shōgen · Hikae · Ukemi · Narabi) · 7 named
AIHarness — the doorthe same engine made reachable by other AI agents over HTTP / MCPBuilt — public 4-tool MCP endpoint (attest · gate · cascade · calibrate)
AIAdaptation agentsagents that recalibrate, onboard protocols, track liquidation mechanics and watch data sourcesRoadmap — named, not shipped
DeFiApplications — powered by the engineone application per DeFi need, served with its own published artefacts1 built (MONARK Bell) · 5 research leads

The engine — AI side

Built:

  • Shōgen — attested perception: an attested price testimony — origin and bytes, never truth.
  • Hikae — coverage-controlled inference: the gate.
  • Ukemi — liquidation-cascade survival: a recorder reads a lending protocol's liquidation book at an archive block under a keyless RPC quorum and digests it (the AttestedBook contract). The served gate class liquidation-eligible-coverage holds a committed calibration for one stratum of one recorded episode: for a caller-carried liquidable amount in that stratum it returns a conformal upper bound (the lower edge is 0 by construction), and every other stratum abstains (under_calib). The bound holds only if the amount was produced by the frozen close-factor rule, which the gate does not check, and no coverage is claimed on any other event — stated plainly on the wire. The cascade tool is transitional and abstains by construction.
  • Narabi — redemption-run sensing. Its AttestedFlow attestation (the fifth frozen contract) and the velocity adapter ship in this repo; the public endpoint serves the gate class stable-run-velocity-24h with a committed calibration for one population — USDe — measured on calm onchain redemption-flow windows. That calibration is measured non-stationary across half-years, so no per-window coverage is claimed; the honesty sentence on the wire is the Barber, Candes, Ramdas and Tibshirani 2023 (Thm 2, unit weights) wording — no coverage is measured. Every other population abstains (under_calib). An off-tool daily sentinel steps the tracker at block finality and publishes a replayable timeline at https://monarkgate.tech/narabi/ (state.json, timeline.jsonl, per-line hash-chained).
    • instrument.json — Instrument, not the official tracker: tracker replays at alternative parameters, and a one-sided CUSUM in the form Page (1954) introduced and Lorden (1971) presents, on the static misses, assessed by a permutation test of exchangeability as Vovk (2012) defines it. A third way, outside Lorden's i.i.d. theory and the e-detectors of Shin, Ramdas and Rinaldo (2022); no bound is claimed. One snapshot, taken once, never refreshed by the daily job.

The single public sentence for Narabi, verbatim:

Narabi runs an adaptive quantile tracker (Angelopoulos–Barber–Bates 2024, decaying step) on the attested daily USDe redemption flow: its state moves each 24h window from the realized outcome, and the full timeline is published so anyone can replay it. What it carries is a deterministic long-run bound that tightens as windows accumulate, printed daily with T, not a per-window coverage, not a probability; the gate's committed calibration does not depend on the tracker state. Until the pre-registered drift criterion fires and an ADR says otherwise, the gate's region is still the committed static calibration: the tracker adapts, the gate does not yet.

What Narabi is NOT. The bound printed daily is the Angelopoulos, Barber and Bates 2024 (Thm 1) quantity (B + η₁)/(T·η_T) with c = B = 1/24 and ε = 0.1. The published region is the tracker's, not the gate's: the gate keeps the committed static calibration and does not change until the pre-registered drift criterion (rolling90_calm_miss ≥ 0.40, evaluable after 90 calm pairs) fires and a published decision record says so. Not a per-window coverage, not a probability of being right, not a price call.

Replay them yourself. Narabi: recompute every window from its [from_block, to_block] via eth_getLogs + totalSupply, then re-derive q with the committed trackerReplay over the s column of timeline.jsonl. Bell: verify each timeline line's Ed25519 signature against the published key, recompute state_sha256 from the served state, and rebuild the digest from the declared pools at the declared window (apps/bell, scripts/verify-bell.mjs). The per-line hash chains make any rewrite detectable.

Named on the engine's roadmap (teasers — not delivered pieces, no metrics claimed): Mokugeki (document / event attestation) · Kaihi (LVR / toxicity avoidance) · Kessai (swap execution, transaction-cost analysis) · Kamae (inventory market-making) · Kyokusen (PT / YT curve) · Koyomi (weekend gap) · Genkan (the storefront / MCP entry point).

The applications — DeFi side

Applications are what the engine is put to work on. Each one is derived from the same gate and the same contracts, starts as an empirical study, and is served with its own published, replayable artefacts.

Built and served:

  • MONARK Bell — the first application: a public, attested witness of tokenized equities outside cash-market hours: per session (pre, regular, after, overnight, weekend), the on-chain fills at the declared pools, their VWAP and volume, the trading-halt census and the supply / proof-of-reserve residuals — published as a signed, hash-chained timeline at https://bell.monarkgate.tech/ (state.json, timeline.jsonl, provenance.json, the Ed25519 public key at bell/pubkey.json) with a reader-side verifier and the signing keyring in this repo. Never a price call; abstentions are counted and published as such.

Development leads — research phase (named, not delivered; no metrics, no dates):

  • MONARK Firebreak — ride out an auto-deleveraging cascade on a perp venue rather than be caught in it.
  • MONARK Warden — a least-privilege gate on a treasury a DAO or another agent controls.
  • MONARK Softlanding — read the liquidation risk on a leveraged position and ease the exposure down before it clears.
  • MONARK Verdict — turn a raw event call into a coverage-controlled, settled decision.
  • MONARK Ballast — named; scope under study.

Each lead becomes an application the way Bell did: a study on chain data, a recorder, a frozen contract if one is needed, a served host with a signed timeline — then, and only then, built.

Maturity criteria

A component or an application is labelled built when all of the following hold; otherwise it is named:

  1. A study first. A measurement on chain data, pre-registered where it can be (hypotheses and thresholds written before the run), with its artefacts committed and hashed next to the code.
  2. A frozen contract if the piece speaks a new shape (six today; a seventh is a versioned change to the interface, not a patch).
  3. A served surface. Its output is consumed by a live surface — an MCP/HTTP tool, a published file, a downstream component — not only by a test or a demo.
  4. An end-to-end integration test that replays the composition, and a deployment check that runs the reader-side verifier against the served host.

The same criteria apply to a change in the engine: a recalibration, a new recorder, a new residual hypothesis.

The studies behind the pieces

  • Narabi — attested redemption flow of a stablecoin, read at block finality; calibration measured on calm windows and found non-stationary across half-years, which is why the served region says so instead of claiming a coverage. A pre-registered drift criterion decides when the gate may move.
  • Ukemi — a lending protocol's liquidation book recorded at an archive block under a keyless RPC quorum, health factors cross-checked in exact fixed-point arithmetic, liquidations replayed along recorded oracle paths; hypotheses and outcomes of the calibration course are published on the site, digit for digit from the hashed report.
  • MONARK Bell — a census of U.S. trading halts, session calendars with daylight-saving handling, the on-chain fills of tokenized equities at their declared pools read on two operators, and a signed publication protocol with an explicit earliest publication time.
  • Shōgen and Hikae — a testimony format that carries bytes and residual hypotheses instead of truth, and a coverage-controlled gate whose region is auditable and whose budget is depletable.

Where a study finds nothing, the piece says so: an abstain, a named residual, a counted absence.

The interlocking (why the pieces work together)

AI side — the MONARK engine  sensors (attest)  →  the gate: Hikae + MONARK B_t  →  acts (execute · upcoming)                            commit | defer | abstain  harness (MCP / HTTP)  ·  adaptation agents: recalibrate · onboard · track · watch                                        │                                        ▼DeFi side — the applications  MONARK Bell (built, served)  ·  Firebreak · Warden · Softlanding · Verdict · Ballast (research)

Every application plugs into the same gate; every future sensor attests into the same contract shape; every change to the engine meets the same maturity criteria.

Verify it yourself

  • Bell. Fetch bell/pubkey.json, then each line of timeline.jsonl: check its Ed25519 signature against the active key, recompute state_sha256 from the served state and provenance_sha256 from the served provenance, and follow prev_line_hash back to the genesis line. scripts/verify-bell.mjs does exactly this with Node alone; the deploy check it produces is committed in this repo.
  • Dōjō. node apps/dojo/scripts/dojo-verify-cli.mjs --url https://dojo.monarkgate.tech --keyring apps/dojo/keys/dojo-keyring.json reads the served files alone, with the public keyring in this repo as its trust root (the served dojo/pubkey.json is cross-checked against it): it walks the signed timeline (Ed25519 signatures, chaining, the validity window of each key), then recomputes every price_version, the history file and the lines of every snapshot with their Merkle roots; --address <address> adds the inclusion proof of one address, --day <YYYY-MM-DD> checks a past day. It prints one JSON line, whose ok is true only when every check holds, with Node alone. It does not replay the collection (a signature attests origin, never truth: the readings are what two operators reported), does not read the chain, and does not check the BLS signature of the public randomness beacon.
  • Narabi. Recompute every window from its [from_block, to_block] via eth_getLogs + totalSupply, then re-derive q with the committed trackerReplay over the s column of timeline.jsonl.
  • The site. Every figure on monarkgate.tech is read from a file under apps/site/data/ whose hash is pinned in manifest.sha256.json and compared byte for byte to the served file by a test.

For agent builders

  1. Add the endpoint (hermes / openclaw one-liners below) or install the skill.
  2. Call attest for a price you must cite, gate for a claim you must act on, cascade for a lending position you must protect, calibrate to bring your own scores.
  3. Read the answer as a region and a budget. On abstain, do nothing and say why — the reason is on the wire. No confidence score exists to be misread.
  4. Read Bell and Narabi as files: they are published to be consumed by programs, not only by people.

Eight frozen contracts

The interface is frozen and language-neutral (source of truth: schemas/*.json):

ContractProducerMeaning
AttestedPriceShōgenAn attested testimony (bytes + hash + named residual hypotheses) — origin and bytes, never truth. The price number is interpreted by a Hikae-side adapter — Shōgen never asserts a price.
AttestedFlowNarabiAn attested testimony of redemption flow (bytes + hash + a closed residual[] enum) — origin and bytes, never truth. burns/mints/supply are carried raw.
Predictionany predictorThe ŷ Hikae conformalises, with predictor_id (venue/model).
CoverageVerdictHikaeConformal region — polymorphic set (classification) | interval (regression, so Ukemi plugs in). No p_correct field.
GateDecisionHikae L3commit | defer | abstain + remaining_budget = B_t, the depletable conformal authorization capacity that attaches to MONARK (never a return).
AttestedBookUkemi (recorder)A self-declared reading of a liquidation book at an archive block under a keyless RPC quorum: the digests (book, holders) with block/provider/quorum context — upcoming until served.
PolicyTableMONARK (policy tables)A class's policy table: one class entry and its rows (cell key, alpha, n, the served rank and q̂, scores_sha256). The verdict carries the digest of the table (policy_table_sha256) and of the row it used (policy_row_sha256).
ToolErrorthe harnessThe body of an HTTP 400 or 500 answer: {error, operation, message, code}, the code from the closed catalogue of the specification. Read the code, not the message.

The token

MONARK carries B_t, a depletable authorization budget: each commit spends it; defer and abstain do not. It is the fleet's right-to-act, metered — not a return, not a deposit, not an oracle. Tokenomics: to be announced.

Contract address (CA): FYZcYCHSp8FzNba1UtDZydKKGosmxVNpFBiVuia38AhT (address only — no price, no buy call).

Fleet invariant — no confidence field, anywhere

Both Shōgen and Hikae refuse it. An output is a region, a set, or bytes + hash + named residual hypotheses — never a score. There is no confidence field anywhere in the interface, and the contract layer enforces this in code:

  1. Closed schemas (additionalProperties: false) — the primary guard, mirroring Shōgen's decoder, which refuses an unknown key rather than ignoring it. Enforced at runtime by closed-check.ts (hand-rolled allow-key sets), kept in sync with the JSON Schemas by a test.
  2. Recursive forbidden-key check — defense in depth (forbidden-keys.ts), catching a banned key at any depth. A contract carrying one throws instead of serialising.
  3. Vocabulary gate (scripts/grep-forbidden.mjs) — CI fails on marketing or overclaim wording.

Reach the engine (the door for other AI agents)

The engine is reachable by any MCP-capable agent over one public endpoint:

  • MCP endpoint: https://mcp.monarkgate.tech/mcp (HTTP/JSON mirror: POST https://api.monarkgate.tech/{attest|gate|cascade|calibrate}; the served openapi.json states the served version). Four tools: attest · gate · cascade · calibrate. Listed on the official MCP Registry as tech.monarkgate/monark.
  • Add it in one line:
bash
hermes mcp add monark --url https://mcp.monarkgate.tech/mcpopenclaw mcp add monark --url https://mcp.monarkgate.tech/mcp --transport streamable-http

No personal data is required to use the service (no account, e-mail, or wallet).

Status

Phase two — integration, served piece by piece. The interface is frozen and the Hikae + Ukemi engines are complete; Narabi and MONARK Bell are served with published, replayable timelines. The public projection of this repository is produced by scripts/export-public.mjs.

Run the gates

bash
npm cinpm run ci   # vocabulary gate → typecheck (tsc strict) → tests (node:test)

Engineering choices

  • Polyglot fleet, schema-first contracts. Shōgen is Rust, the runtime is Python, Hikae's engine and the storefront are TS. So the contracts are expressed as language-neutral JSON Schema; the TS package in packages/contracts is the first binding. Rust and Python bind to the same schemas.
  • Zero runtime dependencies. The published contracts pull in nothing at runtime. Dev deps: typescript, @types/node, ajv/ajv-formats (test-only), and eslint/typescript-eslint (lint only); tests run on the built-in node:test (Node ≥ 24 native TS type-stripping). Key-closedness is enforced hand-rolled at runtime (mirroring Shōgen's zero-dep unknown-key refusal); the value constraints (min/unique items, hash length, ASCII-printable) are expressed in the JSON Schemas and exercised against ajv in tests.
  • ajv is a dev-dependency (test-only): it compiles the frozen JSON Schemas, resolves the $refs, and proves they reject the value-constraint violations (empty/duplicate arrays, wrong-length hash, control chars) that the TS types alone do not.
  • Measured before served. A piece reaches a public surface only with its study artefacts committed and hashed next to it (calibration digests, recorded fixtures with same-directory provenance, replayable timelines) and an end-to-end execution test as the proof of composition.

Layout

schemas/            JSON Schema — the language-neutral source of truth (closed)packages/contracts  TS binding: types, closed-check, forbidden-keys, scores_sha256, serializers, testspackages/hikae      HAC-CP engine: L1 split / L2 monitor / L3 gate, interval conformer  (built)packages/ukemi      liquidation-cascade survival: clearing, liquidable                  (built)packages/monark     integration adapters: Shōgen→AttestedPrice, Narabi AttestedFlow→Prediction; canonical CBORpackages/atelier    local demo surface (not a shipped application)apps/harness        the MCP / HTTP harness — four tools over the frozen contracts (engine, AI side)apps/sentinel       off-tool sentinels: Narabi daily tracker; Ukemi liquidation-book recorder (engine, AI side)apps/bell           MONARK Bell — the first application (DeFi side): publisher, hash chain, verifier, public keyringapps/site           public vitrineskills/monark       the integration skill (MIT-0).github/workflows   CI (5 blocking jobs)

Links

License

Apache-2.0 — see LICENSE. The published integration skill is MIT-0.

Source: README.md at commit c29ba23

Tools

4

gate

Coverage-gated decision from the real HIKAE L3 policy (commit/defer/abstain) over a caller-carried authorization budget B_t. Dispatches on task_class. The class 'btc-dir-15m' is retired and answers a named refusal. For 'cascade-liquidable-24h' no cascade calibration is committed; the gate abstains (under_calib) on this class. For 'stable-run-velocity-24h' (Narabi: a redemption-flow velocity forecast) the gate holds a committed stable-run velocity calibration for the USDe synthetic-dollar-whitelisted-redeem population (key narabi:persistence-v2@eip155:1/erc20:0x4c9edd5852cd905f086c759e8383e09bff1e68b3) over calm-window redemption flow; coverage is stated under the split-conformal bound of Barber, Candes, Ramdas and Tibshirani 2023 (Thm 2, unit weights): at least 1 − α minus the average total-variation gap between calibration windows and the next one; that gap is not estimated here and the calibration is measured non-stationary across half-years, so 1 − α is the coverage only if that gap is zero (exchangeability), which is not assumed here; no coverage is measured; on that key it requires alpha = 0.1, nMin = 50; for any other population, no stable-run velocity calibration is committed for this population; the gate abstains (under_calib). For 'liquidation-eligible-coverage' (Ukemi: a per-account liquidable-amount class, class A only) the served region is a conformal upper bound on the liquidable amount for the calibrated class; the lower edge is 0 by construction, not a calibrated bound; abstains (under_calib) outside it; this class requires alpha = 0.01, nMin = 100; calibrated on one recorded episode; no coverage is claimed on any other event; the H-3 exchangeability check is a report, a YES licenses nothing more; the bound holds only if yhat was produced by the frozen close-factor rule on a mono-collateral WETH account at the first crossing, which the gate does not check. The 32 kata classes `{btc,eth,bnb,sol}-{dir,range,mae-down,mae-up}-{1h,4h}` are served from thei

Parametersparamsrequiredattestedpredictionrequired

cascade

Estimated liquidable amount from the real UKEMI cascade primitives (imported, never re-implemented): an Eisenberg-Noe clearing of the interbank system (L, e) with alpha=beta=1 yields the largest clearing vector L*; each node is then read as a leveraged position — collateral is its cleared balance-sheet value (external assets plus interbank receipts under L*), debt is its nominal obligations, liquidation threshold K=1 — and liquidableAmount sums the debts of the nodes whose cleared value, once shocked by the caller-carried 24h fraction, no longer covers their obligations. Shocking the whole cleared value is a v0 simplification; no source supports shocking interbank receivables. yhat is that liquidable amount: a monetary quantity in the reference asset, a single point that HIKAE conformalizes downstream — no guarantee, no score. Downstream, no cascade calibration is committed; the gate abstains (under_calib) on this class. This cascade tool is v0, replaced at U-5.

ParametersLrequirederequiredshockrequiredproducedAtrequired

attest

projection of a committed Shōgen-verified witness (Binance BTCUSDT, self-notarized); the verifier is NOT executed at call time.

Takes no parameters.

calibrate

split-conformal quantile at miscoverage α over caller-supplied nonconformity scores. MONARK does not see, store, or verify the caller's data or model, and does not validate that the supplied numbers are nonconformity scores of any model. Marginal 1−α coverage holds ONLY for future points exchangeable with the supplied scores; non-exchangeable data (e.g. distribution-shifted or time-ordered) voids it. Never a probability of being right.

ParametersnMinrequiredalpharequiredscoresrequired

Version history

3
  1. v0.4.0LatestSep 18, 2026
  2. v0.3.0Sep 17, 2026
  3. v1.0.0Sep 16, 2026

Score

100% of the applicable checks met

How complete this listing is, computed from the registry entry, the endpoint and public sources. Not a rating of the server and not a statement that it is safe or working today: reachability is a dated check, and no installs or reviews go into the score.

  • Reached in the last 30 daysRequired25 pts
  • Auth declaredRequired10 pts
  • Tools listedRequired15 pts
  • DescriptionRequired15 pts
  • Logo10 pts
  • Documentation15 pts
  • License10 pts