~/djzs $

The reasoning gate every trading agent calls before it acts.

OKSYS_IDdjzs-mainnet-01

OKENGINEdeterministic v2 — verdict is computed, not improvised.

OKGATEverify_pm_trade — LIVE · PAID 2.00 USDC via x402 [MCP] [streamable-HTTP]

OKTAXONOMYDJZS-PM-v1.0 4/4 calibrated · DJZS-LF-v1.1 11 frozen / 3 live

OKLEDGERIrys mainnet — every in-scope audit anchors a permanent ProofOfLogic certificate; readable via query_pol_certificates

OKSTATUSOPERATIONAL

It checks the claim before the money moves. It produces a receipt anyone can recompute. It never guesses — unknown means WAIT, and WAIT means HALT.

It's live now as a Model Context Protocol tool (streamable HTTP). Add it in one line:

claude mcp add --transport http djzs-trust https://mcp.djzs.ai/mcp

Then call verify_pm_trade with a free-text prediction-market thesis.

Connect the gate ->

Audit before act.

The loop, run for real // a wallet paid, an engine decided

One command to add. The agent pays 2.00 USDC over x402 on Base and the verdict returns with a hash that reproduces on any machine. The payment and the certificate are public — the launch record archives every receipt.

How payment works

Every verdict is paid for by the wallet that asks for it. The server answers with a price: 2.00 USDC. Your agent pays it on Base over x402 and the verdict comes back in the same breath. No account, no API key, no subscription — the caller's wallet is the identity and the bill. Out-of-scope requests are refused free: an auditor that stretches past its taxonomy to take your money is not an auditor.

Humans without an x402 setup: watch the loop above — that is the whole product, end to end. Agents replicate it natively.

The gate, doing its job // this one says no

Fed it a consensus thesis — no invalidation, no source, "everyone knows." FAIL, risk 75, and it charged two dollars to say no. An auditor that only ever says yes is not an auditor. The refusal is the product.

Architecture C // extraction reports, the engine decides

DJZS splits the model-bound step from the trusted step. An LLM extracts observable facts from messy intent — it never returns a verdict. It runs as an N=3 consensus: per-field state must agree across all three samples or the field collapses to unknown; a claimed absent must quote the intent verbatim (quote gates); and a critical-driving absent needs the same quote across every sample (evidence-unanimity).

The resulting struct is scored by a frozen deterministic engine — pure code, no model, no network, no clock. The verdict rules are model-independent: swap the model and the extraction quality changes, but the rules, weights, and hash do not. The same struct always yields the same verdict and the same hash:

verdict_hash = sha256(canonicalize({ verdict, risk_score, flags: flags.map(f => f.code).sort(), unknown_fields }))

Verdict is computed, not improvised.

The ladder // three outcomes, never two

PASS → PROCEED
Every scored fact is known and no blocking rule fired.

WAIT → HALT
A decision-critical fact is unknown. The caller halts and the response returns unknown_fields so it knows what to clarify.

FAIL
A rule fired on facts the engine knows. Stop.

Under-specified reasoning drains to WAIT → HALT, never to a silently guessed PASS or FAIL. Abstention is a first-class outcome.

Abstain over guess.

Taxonomies // prediction market, live

DJZS-M — Prediction Market (DJZS-PM-v1.0)

Weights sum to 100; FAIL threshold 25. All four codes implemented and calibrated.

Code	Name	Severity	Weight
`DJZS-M01`	NARRATIVE_RESOLUTION_GAP	CRITICAL	30
`DJZS-M02`	FALSIFICATION_ABSENT	CRITICAL	30
`DJZS-M03`	PROBABILITY_UNSOURCED	HIGH	25
`DJZS-M04`	CONSENSUS_NO_EDGE	MEDIUM	15

M04 is advisory-grade: a lone M04 rides a PASS with the flag on the certificate (weight 15 is below the threshold); it blocks only by stacking (e.g. M03 + M04 = 40 → FAIL).

The weight table is a hash-locked exported constant; a weight change is a deliberate re-derive that bumps the version, not a hot patch — that immutability is what makes every verdict_hash reproducible.

DJZS-LF — perpetuals / general reasoning // roadmap, reserved in the open

Beyond prediction markets, an 11-code perpetuals and general-reasoning taxonomy (DJZS-LF-v1.1, weights sum 200) is frozen — 3 codes wired live (E01, I01, X01), the other 8 reserved with their weights but not yet firing, and no served surface today. Disclosed as roadmap, not sold as done. The full table lives in the repository.

Proof // same thesis, same hash, every run

A client audited a benchmark thesis (pm-block-008) through the deployed tool and received:

FAIL

{
  "tool": "verify_pm_trade",
  "case": "pm-block-008",
  "verdict": "FAIL",
  "action": "FAIL",
  "risk_score": 40,
  "flags": ["DJZS-M03", "DJZS-M04"],
  "unknown_fields": [],
  "disagreements": [],
  "verdict_hash": "0x85918814b3dffa31b00d6892c2e00b2001efd35f7e0044b4cd3789fe1df14937"
}

Behavioral parity against the offline batteries (verdict + flags + extracted input) is green. Hash parity is discharged: the anchor instrument reproduced this exact hash byte-identical from live extraction into the frozen engine (exit 0, 2026-07-12) and it has held across every re-run since, including runs with extraction divergence on non-preimage fields.

Two gates, two axes // upstream of MetaMask Agent Wallet

Your MetaMask agent already checks whether a transaction is safe to sign. DJZS checks what it can't: whether the position is worth taking at all.

MetaMask Agent Wallet runs a mandatory pipeline on every transaction: simulation, Blockaid threat scanning, Smart Transactions. It answers one question with production rigor: is this transaction safe? It does not answer another: is the reasoning behind the trade sound? A transaction can clear every check and still act on a thesis that is unfalsifiable, unsourced, or pure narrative.

DJZS sits upstream. Before a capital-deploying command runs, it audits the thesis against a deterministic taxonomy and returns PASS, WAIT, or FAIL. On EXECUTE, the intent hands to MetaMask and its pipeline runs as always. On HALT, nothing executes.

capital action
   │
   ▼
GATE 1 · DJZS        audits the THESIS   (why)
   │                returns PASS / WAIT / FAIL
   ├─ WAIT / FAIL ─▶ HALT · nothing executes
   │
 EXECUTE
   │
   ▼
GATE 2 · METAMASK    audits the TRANSACTION   (what)
   │                simulation · Blockaid · Smart Transactions
   ▼
on-chain

Two independent gates, two axes. DJZS audits WHY. MetaMask audits WHAT. A DJZS PASS certifies well-formed reasoning at a moment, never that the narrative is true or the trade wins.

The gate clears the logic; the position is yours.

// status Live on Base mainnet, payable over HTTP x402 at mcp.djzs.ai/x402/verify. Base MCP, MetaMask Agent Wallet, and x402-axios all speak this rail. The gate audits its own operation on the public record; the end-to-end wallet compositions remain the reference design.

Honest posture // what's live, what isn't

Stated plainly:

The tool is paid. verify_pm_trade charges 2.00 USDC per audit over x402 (the CDP facilitator) on Base mainnet. Payment is non-custodial: funds move from the payer's wallet to the DJZS treasury directly via an EIP-3009 signature; the facilitator submits the transfer and pays the gas. The two registry tools (query_pol_certificates, query_agent_trust) stay free.
Certificates are permanent. Every in-scope audit anchors a ProofOfLogic certificate to Irys mainnet and returns its id; it is retrievable by id and via query_pol_certificates. The certificate is assembled after the verdict_hash and never alters it.
The trust loop is closed and live. Pass an optional agent_address to verify_pm_trade and the verdict is written on-chain (DJZSLogicTrustScore on Base) by a dedicated authorized writer, indexed by the DJZS subgraph on The Graph, and readable by anyone via query_agent_trust — totalAudits, failRate, latest verdict, and an action of PROCEED, HALT, or NO_HISTORY. The write is fail-open: a write fault never blocks or alters the audit or its certificate.

On-chain: four DJZS contracts are attested on Base in the A2A manifest, with source in contracts/ — verify them yourself on Basescan: TrustScore · Staking · EscrowLock · AgentRegistry. A fifth contract, DJZSProofOfLogicNFT.sol, exists as source only — it is not in the deployed manifest, and nothing here claims certificate NFTs are live or mintable.

Call it // two transports, one gate

Probe it free. An unpaid request returns the payment challenge and settles nothing. This is the whole handshake, and it costs zero:

curl -s -X POST https://mcp.djzs.ai/x402/verify \
  -H 'content-type: application/json' \
  -d '{"intent":"probe the payment challenge"}'

You get back 402 with the price, the network, and the address to pay: exact scheme, eip155:8453, 2.00 USDC, paid to the treasury. Sign the authorization, retry, and the verdict comes back.

// http x402 POST mcp.djzs.ai/x402/verify — any HTTP x402 client pays this: Base MCP, MetaMask Agent Wallet, x402-axios.
// mcp mcp.djzs.ai/mcp — streamable HTTP. Wrap your MCP client with withX402Client from agents/x402; other x402 clients complete the handshake against this server without settling.

// free GET /openapi.json is the discovery contract — schema, price, and response shape. GET /health/x402 reports payment configuration. Through MCP, query_pol_certificates and query_agent_trust read the certificate ledger and an agent's on-chain record. None of these cost anything.

// refusals are free If the engine returns in_scope: false, no payment settles and your balance is unchanged. You are charged for an audit that ran, whatever the verdict.

What a thesis needs // before you spend $2

The gate audits reasoning, so the reasoning has to be there. A thesis missing any of these returns FAIL with the code that fired, and no order should be placed. Abstention is a first-class outcome.

The claim and its resolution. What settles, on which market, by when, on whose price.
A sourced probability. A number and where it came from. Someone else has to be able to check it: a modelling firm, a dataset, a study. Your own estimate is not a source, and neither is a social post.
The falsification condition. The specific event that would prove you wrong.
The executable price. The ask on the side you are buying, read off the book. Not inferred from the other side: a market quoting YES at 93 does not mean NO costs 7.
Why the edge exists. The reason the market is mispriced. “Consensus disagrees” is not a reason.

// shape only The bracketed fields below are placeholders, not text to submit. Replace every one with a real value; a thesis submitted with the brackets intact fails on DJZS-M03, and it still costs $2.

[MARKET] resolves YES above [STRIKE] by [DATE], settled on [SOURCE]. Sourced probability [P]% per [CITATION, retrieved DATE]. Falsified if [SPECIFIC EVENT] before settlement. The ask on [SIDE] is [N]c, so the edge is [P MINUS MARKET] points, because [WHY THE MARKET IS WRONG].

The gate reads reasoning only. It does not check that your quoted price is still live, that the instrument has not already settled, or that your source is right. Those are yours. See legal.

For agents // this page is the API doc

curl this page and you get this pitch — every word is in the HTML, no JavaScript required to read it. A machine-readable summary lives at /llms.txt with the MCP endpoint and repository link. The gate is one install command away (see the hero above); the source of truth for every number on this page is the repository at github.com/SIFR0-dev/djzs-AI.

// reference integration A working client is published at djzs-pm-gate: it audits a Polymarket or Kalshi trade thesis and creates the order only on a clean in-scope PASS. It uses withX402Client from agents/x402, the client this gate speaks. The out-of-scope refusal is verified free on-chain; the paid execution path is not yet exercised.

Evidence before record.