Autonomous AI RWA Portfolio Manager · Mantle Turing Test 2026 · AI & RWA Track Path B (RWA Application)
"When an AI agent executes a trade, you see the transaction. You don't see the reasoning. TuringVault changes that."
We ship the three defining features the Mantle hackathon brief calls out — on-chain benchmarking of AI, ERC-8004 agent identity reference implementation, and radical transparency — end-to-end on Mantle Mainnet, with public best-effort autonomous cycles and live health checks judges can inspect. Under the updated AI & RWA scorecard, TuringVault is best read as Path B: RWA Application: it uses AI to manage existing Mantle-native RWA/yield rails rather than issuing a new RWA token.
Every claim below points to an artefact you can open without our help.
| # | Claim | Open this |
|---|---|---|
| 1 | Live multi-agent decisions on Mantle Mainnet | DecisionLog contract — scroll the events tab; every cycle writes a hashed reasoning anchor |
| 2 | ERC-8004 three-registry implementation (Identity + Reputation + Validation) | Identity NFT · ReputationRegistry · ValidationRegistry — all three contracts deployed, Sourcify-verified, and actively written every cycle (tokenURI auto-refresh, submitFeedback per cycle, submitProposal+submitValidation per decision) |
| 3 | Adversarial validation gate working (rejects unsafe proposals) | ValidationRegistry — totalRejected / totalApproved are public on-chain counters |
| 4 | Real RWA execution — first tokenized-Treasury swap | TX 0x0af2336…3e09de on Merchant Moe LB v2.2 |
| 5 | Autonomous cron is observable (not a screenshot) | Agent Cycle workflow runs — public GitHub Actions log, every scheduled run, every step |
| 6 | Reproducible AI — replay any past decision against the original LLM provider, anchor sealed on-chain | /replay — public verification page; click any cycle to see prompts + raw responses side-by-side with the cryptographic anchor verified live against Mantle Mainnet. combinedAnchor = keccak256(utf8(ipfsCid) ‖ manifestHash) is written to DecisionLog.txHash + ReputationRegistry.reasoningHash each cycle so the manifest cannot be edited after the fact without breaking the binding. A daily Replay Validator CI job picks a random cycle and asserts the binding still holds on-chain — green badge = system is honest. Optional local round-trip: npm run replay <cycle-id>. See audit 18. |
| 7 | Live social signal from Elfa V2 as 5th structured input | /api/elfa-snapshot (raw JSON) · /social drill-down (multi-ticker UI) |
| 8 | Discipline Layer post-execution proof verification | /discipline page — 3-gate history (TX proof · price freshness · regime drift) |
| 9 | Adversarial challenge arena (probe the agent yourself) | /challenge page — inject 4 attack vectors, watch the same multi-agent pipeline reason through them |
| 10 | Lifetime Decision-Quality / Outcome Score from settled outcomes (no simulation, no backtest) | /backtest page — outcome-score curve built from settled decision outcomes; not wallet PnL; cumulative bps + decision-level table |
Honesty rule: every numeric stat in the dashboard traces to a contract read or a settled outcome. The workspace enforces this as a steering rule in
.kiro/steering/no-lying-about-state.md.
AI trading agents are black boxes. They manage capital, execute trades, lose money — and leave zero trace of their decision-making process. You can't tell if a loss was due to market conditions (acceptable) or an AI hallucination (catastrophic).
No accountability. No auditability. No trust.
TuringVault introduces Proof-of-Reasoning (PoR) — a new primitive where every AI decision records an on-chain anchor for its full off-chain reasoning chain, survives adversarial multi-agent consensus, and is scored by an immutable reputation system.
DAO treasuries and on-chain funds parking capital in stablecoins because human-in-the-loop trading is too slow, but unwilling to delegate to a black-box agent. TuringVault gives them an AI portfolio manager whose every reallocation must survive an adversarial multi-model review before any DEX call — and whose reasoning is replayable from public artefacts (IPFS reasoning, on-chain anchor, manifest hash) without making a hardware vendor or a single LLM provider the source of truth.
🎬 Demo video: youtube.com/watch?v=AnLbnbW36ys
🔗 Dashboard: frontend-seven-beta-46.vercel.app
🔗 Proof Explorer: frontend-seven-beta-46.vercel.app/proof-explorer
🔗 DecisionLog on Explorer: explorer.mantle.xyz/address/0x7bCd...cfbB5
🔗 ValidationRegistry: explorer.mantle.xyz/address/0x6841...63b6
Stats (observed 2026-06-11 17:03 UTC — refreshable via /api/health, /api/performance, and /api/decisions; contract counters on Mantlescan are the on-chain ground truth):
- 463 ValidationRegistry proposals / public decision rows exposed through the public API, with full reasoning pinned off-chain and cryptographically anchored on Mantle (live count:
/api/decisions+ contract surfaces) - 126 of 463 ValidationRegistry proposals rejected before execution (~27.2% rejection rate) — adversarial Validator + confidence gates blocking unsafe proposals; this proposal denominator can differ from DecisionLog rows by one during fresh-cycle writes
- 337 approved, 126 rejected at the registry level — proposals reaching consensus go on-chain; off-chain block reasons (regime, low confidence, portfolio guard, intent-no-exec) shown in tier breakdown on
/proof-explorer - Real DEX execution path verified end-to-end on Merchant Moe LB v2.2 — first RWA swap
0x0af2336…; first autonomous-cron swap0x313c0fc…(cycle 123, 2026-05-28); first heartbeat-mode liveness swap (HEARTBEAT_SWAPtier) cycle 146, 2026-05-29; post-smart-router execution window cycles 149-157 — every cycle on this window produced real on-chain swap legs after the audit-21 smart wallet router landed — seeheartbeatMode.js,walletRouter.js, audit 17, audit 21 - Latest risk-on proof: cycle 453 (
HEARTBEAT_SWAP) executed USDT0 → USDT → WMNT with two Mantle transactions (leg 1, leg 2) — labelled as heartbeat/liveness mode, not blended into outcome PnL - Lifetime Decision-Quality / Outcome Score: +5083 bps across 358 settled outcomes, 53.1% settled win rate. Methodology: this is an outcome score from settled decisions, not realized wallet PnL;
/api/performance.realizedTradingPnlBpsis intentionally null. Settled inoutcomes.json, surfaced on/backtest, summary on/api/performance(winRate, cumulativePnlBps, dataScope:agent-lifetime) - Cron status is live-only — observed 23 successful / 0 failed cycles in the trailing 24h window; use
/api/health.cyclesSucceeded24h,cyclesFailed24h, andlastCycleAgefor the current value. GitHub Actions schedules are best-effort and the count changes every cycle - Scheduled cron via GitHub Actions (public log linked below); adaptive regime detection on each tick. Schedule is best-effort hourly — GH Actions skips slots under platform load; the
/api/healthlastCycleAgefield always reflects ground truth. - No catastrophic-loss event recorded in the current demo history — operator-funded demo capital, custodial EOA, vault contract pattern in development
| Scorecard area | What TuringVault shows |
|---|---|
| Technical depth | Multi-model AI cycle, deterministic portfolio/risk guards, Merchant Moe execution, IPFS proof storage, Mantle registry writes, replay verifier, Discipline Layer |
| Mantle ecosystem fit | Mantle Mainnet contracts, low-cost per-cycle proof anchoring, MNT/WMNT inventory, mETH yield/risk leg, USDT0 allocation rail, Merchant Moe LB v2.2 execution |
| Business potential | White-label accountability layer for DAO treasuries, on-chain funds, and operators that want AI allocation without losing auditability |
| Innovation | Proof-of-Reasoning: AI proposals are challenged, anchored, replayable, and reputation-bearing before the system scales |
| User experience | Public dashboard, Proof Explorer, Replay, Discipline Layer, and Challenge Arena turn a complex AI agent into inspectable judge flows |
| AI & RWA Path B | The app manages existing Mantle-native RWA/yield rails (USDT0, mETH, MNT/WMNT; USDY paper-ready) instead of pretending to issue a new RWA token |
| Compliance awareness | Operator-funded demo capital only; no public deposits, no yield promise, no live USDY claim, and AI-assisted controls: validator suitability review, deterministic risk gates, Discipline Layer proof checks, plus allowlists/KYC/AML/jurisdiction policy before any public vault |
| Requirement | Status |
|---|---|
| Smart contract deployed on Mantle Mainnet or Testnet | ✅ Six contracts deployed on Mantle Mainnet |
| Contract verified on Mantle Explorer | ✅ Five production contracts Sourcify perfect; Router is deployed but labelled as source-drifted legacy helper |
| AI-powered function callable or written on-chain | ✅ Every agent cycle writes AI proposal/validation/decision/reputation evidence to Mantle; /challenge can submit adversarial validation proposals |
| Public frontend demo | ✅ https://frontend-seven-beta-46.vercel.app |
| Deployment address in submission | ✅ Contract table below + DoraHacks link fields |
| Demo video ≥ 2 min | ✅ https://youtu.be/AnLbnbW36ys |
| Open-source repo with setup, architecture, deployed addresses | ✅ This README + docs/ARCHITECTURE.md + contract table |
No other DeFi project puts AI reasoning on-chain as a first-class primitive.
Traditional AI Agent: TuringVault:
User → Deposit → ??? User → Deposit → AI Reasons →
→ Profit/Loss → Proof stored on IPFS
→ No explanation → Hash anchored on Mantle
→ Multi-agent validation
→ On-chain reputation score
→ Full audit trail forever
Every decision creates an immutable record: what data the AI observed, what conclusions it drew, what risks it identified, and why it acted. Stored on IPFS, anchored on Mantle, scored by reputation.
┌────────────────────────────────────────────────────────────────────┐
│ TURINGVAULT SYSTEM │
├────────────────────────────────────────────────────────────────────┤
│ │
│ DATA LAYER │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │CoinGecko │ │Nansen MCP│ │Byreal¹ │ │DeFiLlama │ │Elfa REST │ │
│ │Price/Vol │ │SmartMoney│ │Funding/OI│ │Mantle TVL│ │Mindshare │ │
│ └────┬─────┘ └────┬─────┘ └────┬─────┘ └────┬─────┘ └────┬─────┘ │
│ └───────────┴────────────┼────────────┴────────────┘ │
│ ▼ │
│ SIGNAL ENGINE (Regime Detection) │
│ ┌────────────────────────────────────────────────────────────┐ │
│ │ RANGING │ TREND_UP │ TREND_DOWN │ HOLD │ CRISIS │ │
│ └────────────────────────────┬───────────────────────────────┘ │
│ ▼ │
│ TRIPLE-AGENT CONSENSUS │
│ ┌────────────────┐ ┌────────────────┐ ┌─────────────────┐ │
│ │ ANALYST 🧠 │ → │ VALIDATOR 🛡 │ → │ ARBITER ⚖️ │ │
│ │ GLM-5 │ │ Claude 4.6 │ │ Gemini 3.5 │ │
│ │ Seeks alpha │ │ Default REJECT│ │ Tiebreaker │ │
│ │ │ │ R:R ≥ 1.5:1 │ │ soft disputes │ │
│ └───────┬────────┘ └───────┬────────┘ └───────┬─────────┘ │
│ └────────────────┬────┴─────────────────────┘ │
│ ▼ validator-gated consensus │
│ ON-CHAIN VERIFICATION (Mantle Mainnet, 4 TXs per cycle) │
│ ┌────────────────────────────────────────────────────────────┐ │
│ │ submitProposal → validateProposal → logDecision │ │
│ │ → submitFeedback (reputation) │ │
│ │ + IPFS pin of full reasoning chain (hash anchored) │ │
│ └────────────────────────────┬───────────────────────────────┘ │
│ ▼ if consensus reached │
│ EXECUTION + DISCIPLINE LAYER (Synrail-inspired) │
│ ┌────────────────────────────────────────────────────────────┐ │
│ │ RWA Allocator (LLM-driven route · idle-parking route) │ │
│ │ → Merchant Moe LB v2.2 swap │ │
│ │ → Discipline Layer 3-gate verification: │ │
│ │ ✓ tx_proof ✓ price_freshness ✓ regime_drift │ │
│ │ → Outcome scheduled for settlement vs price 4h later │ │
│ └────────────────────────────────────────────────────────────┘ │
│ │
└────────────────────────────────────────────────────────────────────┘
↑
Scheduled GitHub Actions cron — public verifiable workflow log
¹ Byreal aggregates perps data from Hyperliquid and other venues. No direct Hyperliquid integration exists.
Execution requires passing two independent gates:
- Confidence threshold — the Analyst must report ≥ 60% confidence in its own proposal (elevated to 85% after 3 consecutive losses, see
BASE_CONFIDENCE_THRESHOLD/ELEVATED_CONFIDENCE_THRESHOLDinsrc/config/constants.js). Low-confidence proposals are blocked before the Validator even evaluates them. - Adversarial Validator — an independent model with a default-REJECT posture, requiring explicit evidence of R:R ≥ 1.5:1 and regime alignment to approve. A hard Validator rejection or excessive risk score is final; the Arbiter (Gemini 3.5 Flash) only resolves soft confidence disagreements where the Validator approves but confidence is marginal.
In the probed 50-cycle window below, the largest single blocking bucket was Gate 1: the Analyst proposed HOLD with moderate confidence during sideways markets, and the confidence threshold blocked execution. Gate 2 (Validator) flags risk issues in its reasoning even when it approves structurally safe HOLD proposals. This is by design: the validator's adversarial scrutiny matters most for high-risk directional trades, where it acts as the final safety floor.
The on-chain totalRejected counter on ValidationRegistry reflects proposals blocked by either gate. The 2026-06-11 17:03 UTC snapshot is 126 rejected / 463 proposals = 27.2%, demonstrating the system's capital-preservation bias without implying that every cycle produces a swap. The ratio drifts cycle-to-cycle as market conditions change; the live ratio is always the on-chain value (totalRejected() / totalProposals() on 0x6841…63b6), not this README.
A common misread of our consensus design is "the Validator must explicitly say REJECT for a proposal to be blocked." That is not how the gate works. Instead, over a probed 50-cycle window (script: scripts/audit/probe-validator-disagreement.js):
- The Validator never sets
disagreementSignal=trueon its own; it scrutinises and emitsvalidatorFlaggedIssues[](populated on 52% of cycles). - Final consensus is computed by
decisionTier.jsas the AND of four gates: Validator approves AND analyst-confidence ≥ 60% AND validator-confidence ≥ 75% AND riskScore ≤ 60. consensus=truereaches 30% of cycles;consensus=falseblocks 70%.- Tier distribution over the same window: BLOCKED_BY_LOW_CONFIDENCE 42%, INTENT_SWAP_NO_EXEC 24%, BLOCKED_BY_REGIME 16%, BLOCKED_BY_VALIDATOR 12%, EXECUTED_SWAP 4%, HEARTBEAT_SWAP-or-other 2%.
- The Arbiter (Gemini 3.5 Flash) ran on 24% of cycles — only on soft analyst-validator disagreements, never to override a hard Validator veto.
So "adversarial" here means a system of layered scrutiny rather than a single model voting REJECT. The Validator is a structural reviewer, the confidence gates are the rejection mechanism, and the Arbiter is the tiebreaker. Honest framing: the agent's adversarial-block narrative survives, but the load is distributed across confidence + regime + validator-flagged-issues, not concentrated in one model voting NO. This matches how real-world risk committees work — multiple veto sources, none of which is the single point of judgement.
This pattern was probed and documented in audit 27.
Six contracts deployed on Mantle Mainnet, 5 of 6 Sourcify-verified
status perfect (Identity, ReputationRegistry, ValidationRegistry,
ValidationHelper, DecisionLog — checked 2026-05-30 via
sourcify.dev/server/v2/contract/5000/<address>). The sixth contract,
TuringVaultRouter (0x8187…7001), is deployed and live but its
on-chain bytecode no longer matches the current source in this repo
because the source drifted between deploy time (2026-05-18) and the
ERC-8004 cleanup that landed afterwards. We do not redeploy
because:
- Redeploy would break the deployer history of the verified five.
- The Router does not store any state that justifies the cost.
- The execution path that judges actually evaluate (
MerchantMoe LB v2.2 swaps, RWA allocator, walletRouter) bypassesTuringVaultRouterentirely — it was an early-iteration helper that didn't survive the audit-21 smart-router refactor.
The five verified contracts together form the complete ERC-8004 three-registry implementation (Identity + Reputation + Validation) plus the application-specific DecisionLog and the ValidationHelper.
| Role | Contract | Address |
|---|---|---|
| ERC-8004 Identity Registry | TuringVaultIdentity | 0x6f86…28bD |
| ERC-8004 Reputation Registry | TuringVaultReputationRegistry | 0xC781…6e1a |
| ERC-8004 Validation Registry | TuringVaultValidationRegistry | 0x6841…63b6 |
| Pre-action Validation helper | TuringVaultValidation | 0x0aeE…f705 |
| Immutable decision history | TuringVaultDecisionLog | 0x7bCd…fbB5 |
| Trade execution & routing | TuringVaultRouter | 0x8187…7001 |
All three ERC-8004 registries are actively written every cycle — not vestigial:
- Identity stores the agent NFT with auto-refreshed
tokenURIpointing at the latest agent-card on IPFS - Reputation receives
submitFeedbackper cycle (proposal scoring) andrecordPnLat settlement - Validation receives
submitProposal+submitValidationfor every multi-agent decision
Traditional grid bots are dumb — fixed parameters, no regime awareness. Pure AI agents hallucinate and overtrade. TuringVault combines both:
- AI detects the regime (ranging/trending/crisis)
- Grid bot executes only in favorable conditions
- AI validates every proposed trade before execution
- On-chain proof ensures accountability
| Guard | Trigger | Action |
|---|---|---|
| Regime Filter | Trending market detected | HOLD (no trades) |
| Validator Veto | Risk > threshold | REJECT (logged on-chain) |
| Confidence Gate | Score < 60% | Skip execution |
| Channel Too Narrow | < 0.7% width | HOLD (slippage protection) |
| Crisis Mode | ATR spike | Stable/RWA risk-off; USDY route remains gated |
| Trailing Stops | Active position | Adaptive R:R ≥ 1.5:1 |
Inspired by Synrail — a generalized discipline framework for autonomous agents. After every swap execution, a three-gate verification runs:
- Proof Gate — TX exists on-chain, sender matches vault wallet, confirmed ≥ 2 blocks
- Freshness Gate — Price data used was < 60s old at decision time (rejects stale/cached)
- Drift Detection — Flags when action pattern diverges from declared market regime
If any gate fails → outcome settlement is blocked, bounded repair step triggered. This prevents "false-green" scenarios where the agent claims success without verifiable proof.
See docs/discipline-layer.md for full architecture.
Live dashboard: /discipline — full per-cycle gate history, aggregate pass rates, click-to-expand drill-down. The strip on the home page shows the latest cycle's gate statuses at a glance.
A live /challenge page lets anyone inject 4 canonical attack vectors
(flash crash, pump signal, oracle manipulation, sybil consensus) into the
real multi-agent pipeline and watch the agents reason. Each result
includes verbatim reasoning from GLM-5, Claude Sonnet 4.6, and, when a
soft confidence dispute occurs, Gemini 3.5 — the same code path that
drives production.
Live mode is gated by CHALLENGE_LIVE_ENABLED=true (Vercel env var). When
off, the page returns a deterministic preview and the banner clearly
labels it PREVIEW. With anchor enabled, each challenge submits one
ValidationRegistry.submitProposal TX with a [CHALLENGE-*] action prefix,
so a judge's session leaves an on-chain trail.
Operator runbook: .kiro/runbooks/challenge-operations.md.
Live page: https://frontend-seven-beta-46.vercel.app/challenge
The agent allocates to on-chain Treasury-collateralised stablecoins through two paths, both routed through Merchant Moe Liquidity Book:
- LLM-driven route. Analyst's action vocabulary includes
rwa_allocateandrwa_exit. When consensus reaches with one of these under validator-gated safety rules, the orchestrator builds a swap intent and executes against the USDT/USDT0 pool (binStep=1). - Deterministic idle-parking route. When the agent has been
FLAT for ≥ 24 h and regime is not
TREND_UP, a small fraction (20% default) of idle stables auto-routes to USDT0. Cooldown 6 h between events.
Active target: USDT0 (LayerZero omnichain Tether, Treasury-collateralised, 1:1 USD peg). USDT0 itself is not yield-bearing — the dashboard never claims an APY on it.
Paper-ready target: USDY (Ondo Finance tokenized US Treasuries).
Mantle pool depth is currently zero, so the swap path throws
RWA_POOL_INACTIVE until reactivated. Module is shipped, gated off; no
live USDY execution is claimed.
Per-swap and per-day caps are operator-tunable via GitHub Actions
secrets without redeploy. See
.kiro/runbooks/rwa-operations.md.
The ANALYST prompt evolves based on performance, gated by safeguards:
- Minimum 20 settled trades before any mutation
- Validator prompt is not subject to auto-evolution (operator-only changes) — only Analyst evolves
- Every prompt version pinned to IPFS for auditability
- An immutable
FORMAT_GUARD_SUFFIXis appended to every loaded evolved prompt so format drift can't break the JSON output contract (seesrc/orchestrator/multiAgent.js) - Default-off behind
EVOLVED_PROMPTS_ENABLED=trueenv flag while smoke tests confirm parse stability cycle-over-cycle (≥ 95% target; current measurements at 100% over the rolling 24h window — see/api/health.parseSuccessRate24hfor the live value, refreshed each cycle fromsrc/data/parse_metrics.json)npm run smoke:reasoning) - AI prompt v3.0.0 currently pinned to IPFS; pre-evolution baseline is v2.1.1. Evolution logic is implemented end-to-end (mutation after N BAD_CALL events, validator prompt is immutable as the safety floor) but default-off in production until a longer smoke-window confirms cycle-over-cycle parse stability above 95%.
Every entry below points to a verifiable code path or on-chain artefact. Removed
from earlier drafts: Tencent Cloud KMS, Elfa (now reinstated with real code),
OpenCheck, Surf, Orbit AI, Minds, Mirana — all had zero implementation behind
them per .kiro/steering/no-lying-about-state.md.
| Partner | Integration | Code path / artefact | Status |
|---|---|---|---|
| Mantle Network | Mainnet deployment (chain 5000), gas-paid in MNT, RPC via rpc.mantle.xyz |
frontend/app/providers.tsx + 5 deployed contracts |
✅ Live |
| Z.ai | GLM-5 analyst model via AWS Bedrock (zai.glm-5) |
src/orchestrator/multiAgent.js — MODELS.analyst |
✅ Live |
| Anthropic | Claude Sonnet 4.6 validator via AWS Bedrock | src/orchestrator/multiAgent.js — MODELS.validator |
✅ Live |
| Gemini 3.5 Flash arbiter via Vertex AI | src/orchestrator/geminiArbiter.js |
✅ Live | |
| Nansen | Smart-money intelligence via JSON-RPC 2.0 MCP client (we wire 9 named tools used per cycle: smart-money balances, smart-money perp trades, token top-holders, token DEX trades, general search, wallet PnL, address portfolio, token god-mode, growth chain rank) | src/mcp/nansenMCP.js — used in unifiedMarketData.js every cycle |
✅ Live |
| Elfa | Social intelligence — mindshare, smart-account ratio, attention surge | src/data/elfa.js — wired into signalEngine.js as 5th signal + /api/elfa-snapshot (V2 paths: /v2/data/top-mentions, /v2/aggregations/trending-tokens) |
✅ Live (free tier, 60 RPM) |
| Merchant Moe | DEX execution via Liquidity Book v2.2 router | src/dex/merchantMoe.js — first RWA swap 0x0af2336… |
✅ Live |
| Ondo Finance | USDY tokenized Treasuries metadata (paper-ready; pool currently dry on Mantle) | src/rwa/usdyModule.js — guarded behind RWA_POOL_INACTIVE |
🟡 Paper-ready |
| Bybit | Wallet connector — primary recommended in RainbowKit connectorsForWallets |
frontend/app/providers.tsx — bybitWallet from @rainbow-me/rainbowkit/wallets |
✅ Live |
| Pinata | IPFS pinning for Proof-of-Reasoning blobs and agent card auto-refresh | src/ipfs/storage.js |
✅ Live |
- ~$0.006 gas per attestation tx (cycle 123 verified sample, 8 TXs incl. 3 swaps = 0.077 MNT @ $0.62/MNT ≈ $0.048 per full cycle — block-by-block breakdown in
.kiro/audits/raw/gas-samples/cycle-123.json, regenerable vianode scripts/audit/gas-cost-sample.js) — enables logging every completed cycle's decision on-chain (cost-prohibitive on L1) - mETH native yield — real staking returns as trading asset
- EVM compatible — standard Solidity, standard tooling
- Growing AI ecosystem — aligned with Mantle's AI agent vision
| Layer | Technology |
|---|---|
| AI Models | Z.ai GLM-5 Analyst (via AWS Bedrock) + Anthropic Claude Sonnet 4.6 Validator (via AWS Bedrock) + Google Gemini 3.5 Flash Arbiter (via Vertex AI) |
| Blockchain | Mantle L2 Mainnet (chain 5000) |
| DEX | Merchant Moe Liquidity Book v2.2 |
| Data | CoinGecko, Nansen MCP, Byreal (aggregates Hyperliquid funding/OI), DeFiLlama, Elfa REST v2 |
| Storage | IPFS (Pinata) for Proof-of-Reasoning blobs |
| Frontend | Next.js 16 + Tailwind + Framer Motion + RainbowKit (Bybit Wallet primary) |
| RWA | USDT0 LayerZero (active), mETH Mantle LST (active risk-on/yield leg), Ondo Finance USDY metadata (paper-ready/gated) |
| Infra | GitHub Actions cron (best-effort hourly), Vercel (frontend), Pinata (IPFS pinning) |
Production runs are driven by .github/workflows/agent-cycle.yml,
which fires twice an hour at :17 and :47 UTC (best-effort — GH Actions
schedules under platform load; see audit notes). Each run:
- Executes one
runMultiAgentCycle()against live market data. - Writes a
data/last-cycle-summary.jsonrecord. - Commits state files (outcomes, parse metrics, threshold state, …)
back to
main. - Vercel auto-deploys the front-end on the resulting push, so the mascot turns 🟢 within ~2 minutes.
Cadence is best-effort hourly, not sub-minute — the mascot's threshold is
calibrated for that, and /api/health.lastCycleAge always reflects ground
truth (slots can be skipped by GitHub Actions under platform load; see
.kiro/audits/2026-05-28-pipeline-and-bridge-recheck.md for the
known-skipped-slot rate). Operator runbook with the secrets list, manual
trigger, pause/resume, and cost monitoring is at
.kiro/runbooks/cron-operations.md.
Public log: https://github.com/USBVadik/TuringVault-Core/actions/workflows/agent-cycle.yml
# Install dependencies
npm install
# Configure environment
cp .env.example .env
# Set: PRIVATE_KEY, NANSEN_API_KEY, AWS_*, PINATA_*, GOOGLE_APPLICATION_CREDENTIALS
# Single cycle (one-shot, no loop)
node scripts/run-cycle.js
# Smoke 5 cycles in dry-run mode (no on-chain TX, hits Bedrock)
npm run smoke:reasoning
# Grid bot (production, 5-min cycles)
node src/strategies/runGridCycle.sh
# Continuous local orchestrator (only while terminal stays open)
node src/cron/agentCron.js
# Backtest
node src/strategies/backtest.jsturingvault/
├── src/
│ ├── orchestrator/ # Multi-agent loop, signal engine, consensus
│ ├── strategies/ # Ranging grid, position state, backtest
│ ├── evolution/ # Self-evolving prompts with guard rails
│ ├── execution/ # On-chain execution engine
│ ├── dex/ # Merchant Moe + Odos integration
│ ├── rwa/ # USDY module (Ondo Finance)
│ ├── onchain/ # Contract interactions, IPFS
│ ├── mcp/ # Nansen MCP client
│ └── cron/ # Automated trading loop
├── contracts/ # Solidity (6 contracts deployed; 5/6 Sourcify-verified `perfect`, Router source drifted post-deploy)
├── frontend/ # Next.js dashboard + proof explorer
├── sdk/ # TuringVault SDK for external integration
├── test/ # Contract + integration tests
└── docs/ # Architecture, submission, vision docs
- Multi-agent consensus (GLM-5 + Claude Sonnet 4.6 + Gemini 3.5 arbiter)
- On-chain decision logging (463 public decision records/proposals in the 2026-06-11 17:03 UTC snapshot, growing whenever the best-effort GitHub Actions schedule fires)
- Adversarial validation (126 of 463 ValidationRegistry proposals rejected before execution in the 2026-06-11 17:03 UTC snapshot; live count via ValidationRegistry)
- Self-evolving AI prompts (v3.0.0 pinned to IPFS, default-off behind env flag while smoke tests confirm parse stability)
- Grid bot with regime detection (RANGING/TREND_UP/TREND_DOWN/CRISIS)
- Live dashboard + proof explorer
- ERC-8004 AI agent identity on-chain
- IPFS reasoning storage with on-chain anchoring
- Discipline Layer — post-execution proof verification (live; surfaced on dashboard)
- RWA allocation active (USDT0 Treasury-collateralised, first swap on Mantlescan)
- Adversarial Challenge page (preview-rules mode live; LIVE multi-agent mode in v3 spec)
- Elfa social intelligence integrated as 5th structured signal (mindshare, smart-account mentions, entity-graph sentiment)
- HSM-backed signing (investigated Tencent Cloud KMS —
ListAlgorithmsAPI confirmed secp256k1 not available on international tier, only NIST P-256 ECC; stub remains atsrc/kms/tencentKMS.jswithsimulate: true) - Cross-agent reputation marketplace
- Multi-vault strategy templates
- Governance: token-holder veto on prompt mutations
- Agent-to-agent trust scoring (ERC-8004 identity graph)
MIT
Built for the Mantle Turing Test Hackathon 2026 🏆