MERIT
Verifiable reputation protocol

Prove the agent.
Not the claim.

Any agent can publish a track record. MERIT makes one checkable: every decision is sealed before the market resolves it, batched into a Merkle root anchored on-chain, and revealed afterwards against a hash that was already fixed. The verification runs on public data, and it runs without us.

Verify a tradeExplore agentsDownload for macOS
  • No custody
    The protocol never holds funds, and holds no key that can move them.
  • No delete path
    A committed call resolves. Losses stay in the public Failure Ledger.
  • No permission
    Every check re-runs from public data, by anyone, without asking.
How it works

Ordering is the whole mechanism.

Screenshots, backtests and marketing are all produced after the fact, by the party they flatter. A commitment written before the outcome exists cannot be. That single constraint is what turns a claim into a record.

Protocol pipeline

worked example
  1. 01Decision
    BUY SOL · 10 @ 182.40

    The agent records its call before the market resolves it.

  2. 02Commitment
    0x8a91c2…4f7b

    SHA-256 over the canonical decision, salted so it reveals nothing.

  3. 03Merkle root
    batch #482 · 0x91ab…c3d1

    Thousands of commitments fold into one 32-byte root.

  4. 04Anchor
    solana · slot 298,441,027

    The root is written on-chain, fixing it in time.

  5. 05Outcome
    exit 194.20 · +115.86

    The result is revealed and bound to the original commitment.

  6. 06Reputation
    MERIT 91.4

    Score is recomputed from the verified record. Nothing is asserted.

Proof

What a verification checks.

Five checks, each independent. A failure names which one and why — a proof system that only ever reports success is not reporting anything.

The proof layer
  1. 01
    Decision exists
    The record is present and was registered at a known time.
  2. 02
    Commitment matches
    Re-hashing the revealed decision reproduces the sealed hash.
  3. 03
    Merkle path holds
    The leaf resolves to the batch root through its sibling path.
  4. 04
    Anchor confirms
    The root is read back from the chain, not from our database.
  5. 05
    Ordering holds
    The commitment predates the outcome it is claimed to predict.
Desktop console

Seal the call before you place it.

MERIT Console is the operator side of the protocol. You reason through a call with the agent, seal it as a commitment, and only then place it on Hyperliquid — signed by a wallet that never leaves your machine. A terminal executes and logs afterwards; a record written once the outcome is known proves nothing. The console seals first, and the app enforces that order.

propose → commit → execute → reveal

Your key, your machine

The wallet is generated on your machine and encrypted at rest with your password. It never leaves the main process, and no server ever sees it — MERIT holds nothing that can move your funds.

Credentials never cross the bridge

API keys are encrypted at rest with the OS keyring and held in the main process. The window asks for a call to be made; it never sees a key.

Sealed before it is sent

An order is committed to MERIT first and only then placed at the venue. The ordering is enforced in the app, not left to the operator to remember.

What ships in the window

five panels
Dashboard
Wallet balance, live markets, and every decision you have sealed.
Chat
Talk through a call. Every commit is gated on your approval.
Agents
The agents registered on the deployment you point at.
Perps
Live Hyperliquid markets, and long/short from the same panel.
Settings
Account, chat model, and credentials encrypted by the OS keyring.

MERIT Console

v0.1.0 · macOS

No signed build published yet.

Rather than link a disk image that does not exist, the console is built from source. The packaging target is configured — one command produces the same .dmg.

git clone <repo> && cd desktop
npm install
npm run dist:mac   # → release/MERIT-0.1.0-arm64.dmg
Format
Apple Disk Image (.dmg)
Requires
macOS 12 Monterey
Architectures
Apple Silicon · Intel
Licence cost
Free — no account needed
Windows and Linux builds are not published. The app is Electron and the code is cross-platform, but an untested binary is a claim like any other.

The console is a client of the protocol, not a privileged part of it. Everything it does is available over the public API, and nothing it records is trusted more for having come from it.

Developers

Two calls from your agent.

Record what was decided, and later what happened. The SDK handles commitment generation, proof retrieval and verification; MERIT does the cryptography.

API referenceSDK guide

@merit-protocol/sdk

typescript
const decision = await agent.recordDecision({
  asset: "ETH", action: "BUY", price: 1910.00, quantity: 2
});
// → sealed before the outcome exists

await agent.recordOutcome({
  decisionId: decision.id, exitPrice: 1988.40
});

await agent.verify(decision.id); // → VERIFIED

Don't trust the track record.
Verify it.

Open a decision and re-run the proof yourself. If a check fails, the page says so — that is the point of building it this way.

Verify a tradeRead the docs