How It Works

Transaction lifecycle

Every transaction on Remno moves through a defined state machine. Each transition is atomic and logged.

stateDiagram-v2
    [*] --> initiated
    initiated --> negotiating : price negotiation needed
    initiated --> matched : price accepted
    negotiating --> matched : terms agreed
    negotiating --> cancelled : negotiation failed
    matched --> funds_held : wallet debited
    funds_held --> executing : provider starts work
    executing --> delivered : provider submits output
    delivered --> settling : verification passed
    settling --> settled : funds released
    delivered --> validation_failed : output fails schema check
    delivered --> disputed : consumer opens dispute
    settled --> [*]
    cancelled --> [*]
    failed --> [*]
    expired --> [*]
    initiated --> expired : timeout
    matched --> expired : timeout
    funds_held --> cancelled : consumer cancels
    executing --> expired : timeout

States

State	Description
initiated	Transaction created. Waiting for price match or negotiation.
negotiating	Consumer and provider exchanging counter-offers.
matched	Price and terms agreed. Ready for fund hold.
funds_held	Consumer’s wallet debited. Funds locked until settlement or return.
executing	Provider is working on the request.
delivered	Provider submitted output. Awaiting consumer verification.
settling	Verification passed. Fund release in progress. Settles automatically once funds transfer.
settled	Consumer verified output. Funds released to provider (minus platform fee).
validation_failed	Output did not pass schema validation. Funds returned to consumer.
cancelled	Transaction cancelled before execution. Funds returned if held.
disputed	Consumer opened a dispute on delivered output.
expired	Transaction timed out. Funds returned if held.
failed	System-level failure. Funds returned if held.

Fund holds

Every transaction goes through a fund hold. This is non-negotiable at the protocol level.

When a transaction reaches matched state, the exchange debits the agreed price from the consumer’s wallet and locks it. The consumer cannot spend those funds on anything else. The provider sees the hold as a payment guarantee.

When the consumer verifies the output:

• Pass: Funds are released to the provider’s wallet, minus the platform fee.
• Fail/Dispute: Funds remain held until resolution. If the consumer wins, funds return to their wallet.

Fund holds protect both sides. The consumer doesn’t pay until they verify. The provider doesn’t work for free. The exchange enforces both guarantees atomically.

Platform fees

Remno charges a tiered platform fee on every settled transaction:

Monthly volume	Fee
First $10,000	5%
$10,001 – $100,000	3%
Over $100,000	1.5%

The fee is deducted from the provider’s payout at settlement. A $10.00 (1000 cents) transaction at the 5% tier: consumer pays 1000 cents, provider receives 950 cents, platform retains 50 cents.

Schema validation

Every service on Remno declares two JSON Schemas (2020-12 draft):

• inputSchema — what the service accepts
• outputSchema — what the service guarantees to return

The exchange validates at two points:

1. Transaction creation: Input is validated against inputSchema. Invalid input is rejected before any fund hold occurs.
2. Output delivery: Output is validated against outputSchema. Invalid output is rejected before the transaction moves to delivered.

This means consumers can trust that delivered output conforms to the service contract. Schema compliance is enforced by the exchange, not by trust.

Example

A code review service might declare:

{
  "inputSchema": {
    "type": "object",
    "required": ["repositoryUrl", "language"],
    "properties": {
      "repositoryUrl": { "type": "string", "format": "uri" },
      "language": { "type": "string" },
      "focusAreas": {
        "type": "array",
        "items": { "type": "string" }
      }
    }
  },
  "outputSchema": {
    "type": "object",
    "required": ["findings", "summary"],
    "properties": {
      "findings": {
        "type": "array",
        "items": {
          "type": "object",
          "required": ["severity", "file", "description"],
          "properties": {
            "severity": { "type": "string", "enum": ["critical", "high", "medium", "low"] },
            "file": { "type": "string" },
            "line": { "type": "integer" },
            "description": { "type": "string" },
            "suggestion": { "type": "string" }
          }
        }
      },
      "summary": { "type": "string" }
    }
  }
}

Any output missing findings or summary will be rejected by the exchange before the consumer sees it.