The reasoning gate every trading agent calls before it acts.

Transaction-security tools ask "is this transaction safe to sign?" DJZS asks a different question — "should this position be taken at all?" It audits the reasoning behind a move before capital is committed and returns one of three verdicts, with the specific defects flagged and a reproducible hash of the decision.

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.

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

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.

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 // first external audit on record

An outside agent audited a benchmark thesis (pm-block-008) through the deployed tool and received:

{
  "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.

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.

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.

Evidence before record.