NousResearch/hermes-agent · warning · LoadoutError

${Noun} looks corrupted (checksum mismatch).

Error message

${Noun} looks corrupted (checksum mismatch).

What it means

Thrown by the loadout codec's decode() in apps/desktop/src/lib/loadout.ts:268 when the 16-bit checksum stored in the frame header does not match checksum16() recomputed over the payload bytes. The frame is version(8 bits) + checksum(16 bits) + DEFLATE-compressed body; the checksum catches corruption between encode and decode — character loss/mutation in transit, a bad copy/paste, or bit rot — before inflate+schema parsing produces nonsense.

Source

Thrown at apps/desktop/src/lib/loadout.ts:268

      throw new Err(`That doesn't look like a ${noun}.`)
    }

    if (framed.length <= HEAD_BYTES) {
      throw new Err(`${Noun} is too short to be valid.`)
    }

    const head = new BitReader(framed.subarray(0, HEAD_BYTES))
    const version = head.uint(8)
    const storedSum = head.uint(16)

    if (version !== spec.version) {
      throw new Err(`${Noun} is version ${version}; this build reads version ${spec.version}.`)
    }

    const payload = framed.subarray(HEAD_BYTES)

    if (checksum16(payload) !== storedSum) {
      throw new Err(`${Noun} looks corrupted (checksum mismatch).`)
    }

    try {
      return spec.read(new BitReader(inflateSync(payload)))
    } catch (err) {
      throw new Err(err instanceof Error ? `${Noun} is malformed: ${err.message}` : `${Noun} is malformed.`)
    }
  }

  return { decode, encode }
}

View on GitHub (pinned to c896c09c42)

Solutions

1. Re-copy the code from its source, unedited, and paste it whole (the codec already tolerates whitespace).
2. If it persists, regenerate the code at the producer — the payload itself may have been corrupted before hashing.
3. Verify producer and consumer use the same checksum16 and the same header layout/version.
4. Treat this as data corruption, not a schema problem — do not try to decode past it.

Example fix

// not a code fix — corruption is in the data, not the call site.
// Producer-side round-trip assertion to catch bad encoders early:
const code = encode(payload)
const back = decode(code) // assert deep-equals payload before shipping the codec change

try { const v = decode(code) } catch (e) { if (e instanceof Err && /checksum mismatch/.test(e.message)) { promptRecopyOrRegenerate(); return null } throw e }

When it happens

Trigger: A share code that lost or gained characters but still base64-decodes (checksum then fails); manual editing of a code; a transport layer that truncates or re-encodes part of the payload; producing codes with a checksum computed over different bytes than framed (encode bug).

Common situations: Clipboard truncation at a fixed length; messaging apps mangling long strings; users 'fixing' a code by typing; mismatched checksum function between producer and consumer builds.

Related errors

• That doesn't look like a ${noun}.
• ${Noun} is too short to be valid.
• ${Noun} is version ${version}; this build reads version ${sp
• loadout truncated
• ${Noun} is malformed: ${err.message}

AI-assisted analysis of NousResearch/hermes-agent@c896c09c42 (2026-08-14). Data as JSON: /api/errors/fe5929f6ebdd9007. Report an issue: GitHub.