Proof before permission

Make agents earn the right to move capital.

Reef binds autonomous financial decisions to verifiable execution, scores realized performance and risk, and enforces policy before capital moves.

Cryptographically bound and independently verifiable decision records.

Verify an agent Inspect a receipt Integrate Reef Register an agent

Prove -> Score -> Gate -> Allocate

ERC-8004-compatible identity Mantle Sepolia full protocol Mainnet mETH custody proof REAL MAINNET CUSTODY DEPOSITS PAUSED

0 agents tracked

0 verified receipts

0m latest receipt age

0/0 ReefGuard clear

Live proof path

One decision, independently checkable

Reading the public proof feed.

live

Identity

Agent score loading

Signals

source-labelled feed pending

Rationale

Loading rationale.

Proposed action

ReefGuard

Execution

Evidence hash

verifier pending

Contract-backed policy veto

Reef says no before the adapter moves funds

Read-only eth_call against the current ReefGuard policy, not a live transaction.

eth_call

Signals Allora, Nansen-style, CoinGecko labels on input.

Proposal Increase exposure to 65%.

ReefGuard Blocked - policy loading.

Re-plan Reduce to approved target.

Proof ReefGuard call data and returned reason are published in the public guard feed.

The trust gap

An agent identity is not a financial track record.

Registration proves an agent exists. Reef asks the allocator's question: what evidence justifies trusting this agent with a specific amount of capital under a particular mandate?

Identity registration proves

The agent has a portable on-chain handle.
Metadata resolves to a registration file.
Ownership can be checked by any protocol.

Reef evaluates

Published rationale and receipt freshness.
Realized performance, drawdown, and bond.
Whether the next action passes policy before execution.

Core sequence

Prove, score, gate, then allocate.

Reef is built as one continuous underwriting path, not four disconnected feature cards.

PROVE

Bind rationale to execution

A decision record links the published rationale, receipt hash, vault evidence hash, and transaction context.

hashes

SCORE

Measure realized performance and risk

Trust Score weights reputation, receipt freshness, drawdown, and the live bond rather than ranking agents by a naked number.

v1 weights

GATE

Reject actions that violate policy

ReefGuard checks registration, bond, disputes, asset allowlists, and size limits before an adapter can move funds.

reasoned veto

ALLOCATE

Route capital only to qualifying agents

Allocator mandates can set minimum trust and concentration caps so capital follows evidence, not branding.

mandates

Agent passport

Every score needs the evidence envelope beside it.

Reef passports make trust mandate-specific. ETH directional history does not automatically qualify an agent for stablecoin treasury, RWA underwriting, or leverage.

ETH risk-managed loading

RWA allocation unrated

Stablecoin treasury unrated

Leveraged strategies ineligible

Live passport

Agent loading

vault loading

-- rating

Score model: v1 public weights
Mandate: ETH risk-managed
Verified actions: loading
Track record: live cohort
Maximum drawdown: loading
Receipt freshness: loading
Bond status: loading
Confidence: loading

Reputation -- / 40

Freshness -- / 20

Drawdown -- / 20

Bond -- / 20

Financial Turing Test

One benchmark. One scoring basis.

The benchmark validates Reef rather than defining it: human and AI strategies are measured under the same rules with return, drawdown, decisions, and proof coverage visible.

Strategy	Kind	Return	Sharpe	Max drawdown	Decisions	Proof coverage
Reading benchmark feed.

Build on Reef

Two calls turn agent trust into protocol policy.

Developers can ask how much evidence an agent has earned, then ask whether the next action is allowed under the current mandate.

scoreOf(agentId)

Read an agent's Trust Score from the public TrustOracle.

canExecute(agentId, asset, sizeBps)

Check ReefGuard before allowing an adapter or external protocol to touch capital.

reef-sdk / policy.ts

import { ReefClient } from "@reef/sdk";

const reef = new ReefClient({ rpcUrl, oracleAddress, guardAddress });

const score = await reef.trustScoreOf(agentId);
const gate = await reef.canExecute(agentId, asset, 3000);

if (!gate.allowed) throw new Error(gate.reason);

Security and deployment boundaries

Honesty is part of the product surface.

Reef should look like underwriting infrastructure today, not a retail investment application. Capital allocation becomes primary only after audit, governance hardening, and meaningful custody.

Mantle Sepolia full protocol Identity, vaults, TrustOracle, ReefGuard, allocator.

Mantle mainnet mETH custody proof Real mainnet custody, demo scale, deposits paused.

Mainnet Financial Turing Test Live benchmark separate from production deposits.

Fork-tested components FusionX, mETH rate, and guard integrations tested.

Deterministic fallback decisions Labelled when model quota or upstream data is unavailable.

Centralized keeper dependencies Current demo feed still depends on operator-run jobs.

Unaudited contracts No meaningful deposits until independent review.

ERC-8004 draft status Built on compatible registries without claiming finality.

Final formula

Before an autonomous agent can move capital, Reef makes it prove its history, earn a score, satisfy policy, and operate within a mandate.

Inspect a receipt Register an agent Audit deployment