_ registry / mcp http-sse · checked 1h ago

nukez

https://mcp.nukez.xyz

Registry code: beaf705139956671

api record

Nukez — encrypted storage on Solana. These 15 tools exist: nukez_quote, nukez_pay, nukez_provision, nukez_setup, nukez_create_file, nukez_store, nukez_confirm, nukez_upload_chunk, nukez_retrieve, nukez_verify, nukez_recompute_verify, nukez_status, nukez_delete, nukez_remember, nukez_recall. New storage: nukez_quote → nukez_pay → nukez_provision → nukez_store. Existing locker: nukez_setup(receipt_id='...') or nukez_provision(receipt_id='...'). When the user says 'create storage', call nukez_quote() first to show pricing. Present the payment_options to the user before calling nukez_pay. Do not…

endpoint
https://mcp.nukez.xyz/mcp
protocol
http-sse ·2025-06-18
authentication
none observed
public key
none — nobody has proven they own this listing
karma
0 · newcomer
reachable
live
uptime, 30 days
100%

90 days 100%· all time 100%

latency
406ms

last good check

priced tools
0

of 15 tools

_ answered our checks, 90 days 1 checks · signed record
  • unknown → live
_ used through this hub 30 days

The one measurement on this page that an operator cannot produce by editing a file on its own server: somebody else chose it, and paid to. Read the accounts before the calls — volume from one account is one relationship, and calling yourself is the cheap half. Both are what the ranking is built from, printed so the order can be checked rather than taken on trust.

accounts
0

distinct, expensive to fake

calls served
0

successful, last 30 days

_ what it can do 15 tools
1 open 14 never probed 1 of 15 classified

Price is per tool, not per server. An agent whose handshake is open can hold tools that demand a key or a payment, and one figure for the whole agent sends callers into a wall.

  • nukez_status open 1h ago

    Check wallet balance, locker state, and lifecycle stage. Works at any stage — no active locker required.

    mcp-tool

    {
  "type": "object",
  "title": "_nukez_statusArguments",
  "properties": {
    "envelope": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Envelope",
      "default": null
    },
    "receipt_id": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Receipt Id",
      "default": null
    }
  }
}
    arguments 31 lines
  • nukez_recall unknown never probed

    Search and retrieve memory records from your Nukez locker. Two modes: exact key lookup (pass key) returns full content + proof, or search (pass namespace/tags/query/prefix) returns matching index entries. ENVELOPE: none needed — both index and record are read via the public receipt-proxy URL. Just pass receipt_id.

    mcp-tool

    {
  "type": "object",
  "title": "_nukez_recallArguments",
  "properties": {
    "key": {
      "type": "string",
      "title": "Key",
      "default": ""
    },
    "tags": {
      "type": "string",
      "title": "Tags",
      "default": ""
    },
    "limit": {
      "type": "integer",
      "title": "Limit",
      "default": 10
    },
    "query": {
      "type": "string",
      "title": "Query",
      "default": ""
    },
    "prefix": {
      "type": "string",
      "title": "Prefix",
      "default": ""
    },
    "envelope": {
      "anyOf": [
        {},
        {
          "type": "null"
        }
      ],
      "title": "Envelope",
      "default": null
    },
    "namespace": {
      "type": "string",
      "title": "Namespace",
      "default": ""
    },
    "receipt_id": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Receipt Id",
      "default": null
    }
  }
}
    arguments 58 lines
  • nukez_quote unknown never probed

    Step 1: Get storage pricing and payment options. Returns price breakdown and every available payment method (SOL/USDC/USDT/WETH/BETA on Solana, USDC/USDT0/MON/WETH on Monad). Each option carries a `destination_kind`: 'wallet' (native SOL — send lamports to pay_to_address), 'spl_token_account' (Solana SPL tokens — pay_to_address IS already the treasury's token account; pass it DIRECTLY as the transferChecked destination, do NOT derive an ATA from it), or 'evm_address' (Monad — send native value to the address, or call transfer() on the token contract at token_address). SPL options also include a self-contained `spl_transfer` block (program_id, destination_token_account, mint, amount_raw, decimals) you can pass straight to a signer. Review payment_options, pick one, then sign+submit externally and call nukez_pay with the resulting tx_sig. Providers: gcs (default), mongodb, storj, arweave, filecoin, firestore.

    mcp-tool

    {
  "type": "object",
  "title": "_nukez_quoteArguments",
  "properties": {
    "units": {
      "type": "integer",
      "title": "Units",
      "default": 1
    },
    "provider": {
      "type": "string",
      "title": "Provider",
      "default": "gcs"
    },
    "pay_asset": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Pay Asset",
      "default": null
    },
    "pay_network": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Pay Network",
      "default": null
    }
  }
}
    arguments 40 lines
  • nukez_pay unknown never probed

    Step 2: Record an externally-executed on-chain payment. The server is keyless and never signs transactions — execute the transfer yourself (Solana sendTransaction or an EVM client) and pass the resulting signature as tx_sig. Uses pay_req_id from nukez_quote (auto-resolved from state). Specify chain and pay_asset to identify the rail (e.g. chain='solana-mainnet', pay_asset='BETA'); defaults to the quote's choice. Solana SPL pre-flight: when the quote selected an SPL token (USDC/USDT/WETH/BETA), this tool fetches the tx via read-only RPC and verifies it transferred ≥ the expected amount of the expected mint to the treasury's SPL token account. A confirmed mismatch (typically: tokens sent to an ATA derived from pay_to_address) is REJECTED with a structured WRONG_DESTINATION error and the tx_sig is NOT recorded — the quote remains valid so you can re-pay correctly. Indeterminate pre-flights (RPC down, tx not yet visible) fall through to recording.

    mcp-tool

    {
  "type": "object",
  "title": "_nukez_payArguments",
  "properties": {
    "chain": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Chain",
      "default": null
    },
    "tx_sig": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Tx Sig",
      "default": null
    },
    "pay_asset": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Pay Asset",
      "default": null
    },
    "pay_req_id": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Pay Req Id",
      "default": null
    }
  }
}
    arguments 54 lines
  • nukez_provision unknown never probed

    Step 3: Confirm payment settlement on the gateway and provision the storage locker. Two modes: (a) Without `envelope`: pass pay_req_id + tx_sig (auto-resolved from state). Returns the receipt_id and a hint to build a signed `locker:provision` envelope. (b) With `receipt_id` + `envelope`: forwards the signed envelope to /v1/storage/signed_provision and activates the locker. Also accepts `receipt_id` alone to rehydrate an already-provisioned locker without re-paying.

    mcp-tool

    {
  "type": "object",
  "title": "_nukez_provisionArguments",
  "properties": {
    "chain": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Chain",
      "default": null
    },
    "tx_sig": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Tx Sig",
      "default": null
    },
    "envelope": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Envelope",
      "default": null
    },
    "pay_asset": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Pay Asset",
      "default": null
    },
    "pay_req_id": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Pay Req Id",
      "default": null
    },
    "receipt_id": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Receipt Id",
      "default": null
    }
  }
}
    arguments 79 lines
  • nukez_setup unknown never probed

    Set up Nukez storage: checks wallet, purchases storage, and provisions locker in a single call. Call with no args to run the full flow. Call with receipt_id to rehydrate an existing locker. Providers: gcs (default), mongodb, storj, arweave, filecoin, firestore. Payments: Solana (SOL, USDC, USDT, WETH, BETA) and Monad/EVM (MON, USDC, USDT0, WETH) — chain is auto-detected.

    mcp-tool

    {
  "type": "object",
  "title": "_nukez_setupArguments",
  "properties": {
    "units": {
      "type": "integer",
      "title": "Units",
      "default": 1
    },
    "envelope": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Envelope",
      "default": null
    },
    "provider": {
      "type": "string",
      "title": "Provider",
      "default": "gcs"
    },
    "receipt_id": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Receipt Id",
      "default": null
    }
  }
}
    arguments 41 lines
  • nukez_create_file unknown never probed

    Create a file entry and get upload_url + confirm_url for direct upload. The client PUTs raw bytes directly to the upload_url (307-redirects to GCS), then calls nukez_confirm to finalize. Bytes never transit the MCP server. Use this for large files from local/external sources against Cloud Run. For small inline content (<4KB), use nukez_store with data_b64 instead. KEYLESS (hosted) SERVER: this server holds no signing key. A call without `envelope` returns action_required='sign_envelopes' with the exact spec to sign (method, path, ops, body); sign it with your wallet and re-call with envelope=<signed result>. One file per call in envelope mode.

    mcp-tool

    {
  "type": "object",
  "title": "_nukez_create_fileArguments",
  "required": [
    "filename"
  ],
  "properties": {
    "envelope": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Envelope",
      "default": null
    },
    "filename": {
      "type": "string",
      "title": "Filename"
    },
    "receipt_id": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Receipt Id",
      "default": null
    },
    "content_type": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Content Type",
      "default": null
    }
  }
}
    arguments 50 lines
  • nukez_store unknown never probed

    Store files in your Nukez locker. ALWAYS BATCH: pass ALL the files you want to upload in a SINGLE call, as a list under `files`. Do NOT loop over your file list and call nukez_store once per file — that triggers one on-chain attestation per file (slow + costs SOL fees per push). One nukez_store call with N files triggers exactly ONE attestation for the whole batch. Each list item: {name, <data_source>, content_type?, expected_size_bytes?, expected_sha256?, large?}. UPLOAD PATH PRIORITY: 1. source_url — if the file is available at a public HTTPS URL, pass it and the server fetches directly (fastest, zero token cost). 2. sandbox_path — if you have compute/bash access and the file is on disk, pass the absolute path. 3. local_path — if the file exists on local disk (desktop/CLI environments). 4. data_b64 — LAST RESORT for small content only (<4KB). Sends bytes through your context window. Accepts both base64-encoded binary and plain UTF-8 text. 5. nukez_upload_chunk — if sandbox_path curl failed (HTTP 000 / network blocked), upload in 4KB chunks with sha256 verification. Run the prep script from the response, then call nukez_upload_chunk for each chunk. NEVER base64-encode files >4KB in one call. Upload path is auto-selected based on size and runtime environment. HARD SIZE LIMITS per path: the sandbox curl proxies through the gateway and is capped at 32 MiB (the platform rejects larger request bodies); the chunked ingest pipeline caps at 20 MiB per file. LARGE FILES (>= 32 MiB, any size up to terabytes): pass expected_size_bytes (and ideally the file's expected_sha256) with sandbox_path, or set large=true — the response then returns a resumable direct-to-provider upload session (action_required='execute_upload') with a session-open command and a stdlib-only transfer script that uploads in 8 MiB chunks and resumes after interruptions. Bytes go straight to the storage provider, so the sandbox needs outbound access to the session URI's host. After the transfer, confirm with nukez_confirm(use_job=true). KEYLESS (hosted) SERVER: this server holds no signing key. A call without `envelope` returns action_required='sign_envelopes' with the exact spec to sign (method, path, ops, body); sign it with your wallet and re-call with envelope=<signed result>. One file per call in envelope mode.

    mcp-tool

    {
  "type": "object",
  "$defs": {
    "FileItem": {
      "type": "object",
      "title": "FileItem",
      "required": [
        "name"
      ],
      "properties": {
        "name": {
          "type": "string",
          "title": "Name",
          "description": "Filename with extension (e.g. 'photo.jpg', 'notes.txt')"
        },
        "large": {
          "anyOf": [
            {
              "type": "boolean"
            },
            {
              "type": "null"
            }
          ],
          "title": "Large",
          "default": null,
          "description": "Force the resumable direct-to-provider upload path for a sandbox_path file regardless of declared size."
        },
        "data_b64": {
          "anyOf": [
            {
              "type": "string"
            },
            {
              "type": "null"
            }
          ],
          "title": "Data B64",
          "default": null,
          "description": "Base64-encoded file content. Plain text is also accepted and will be stored as UTF-8."
        },
        "local_path": {
          "anyOf": [
            {
              "type": "string"
            },
            {
              "type": "null"
            }
          ],
          "title": "Local Path",
          "default": null,
          "description": "Absolute path to file on disk (alternative to data_b64)"
        },
        "source_url": {
          "anyOf": [
            {
              "type": "string"
            },
            {
              "type": "null"
            }
          ],
          "title": "Source Url",
          "default": null,
          "description": "HTTPS URL for server-side fetch (alternative to data_b64)"
        },
        "content_type": {
          "anyOf": [
            {
              "type": "string"
            },
            {
              "type": "null"
            }
          ],
          "title": "Content Type",
          "default": null,
          "description": "MIME type (auto-detected from filename if omitted)"
        },
        "sandbox_path": {
          "anyOf": [
            {
              "type": "string"
            },
            {
              "type": "null"
            }
          ],
          "title": "Sandbox Path",
          "default": null,
          "description": "Path in compute sandbox. Returns a curl command to execute. If curl fails (network blocked), use nukez_upload_chunk to upload in ~64KB chunks instead."
        },
        "expected_sha256": {
          "anyOf": [
            {
              "type": "string"
            },
            {
              "type": "null"
            }
          ],
          "title": "Expected Sha256",
          "default": null,
          "description": "Hex SHA-256 of the file's bytes (with or without a 'sha256:' prefix). Optional pre-commitment for the resumable path: the confirm refuses to record a stored object whose hash differs."
        },
        "expected_size_bytes": {
          "anyOf": [
            {
              "type": "integer"
            },
            {
              "type": "null"
            }
          ],
          "title": "Expected Size Bytes",
          "default": null,
          "description": "Declared size of the file in bytes (sandbox_path mode). At or above 32 MiB this selects the resumable direct-to-provider upload; the gateway binds it as a pre-commitment and the confirm refuses a stored object of a different size."
        }
      },
      "description": "A file to store. Provide *name* and exactly one data source.",
      "additionalProperties": true
    }
  },
  "title": "_nukez_storeArguments",
  "required": [
    "files"
  ],
  "properties": {
    "files": {
      "type": "array",
      "items": {
        "$ref": "#/$defs/FileItem"
      },
      "title": "Files"
    },
    "envelope": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Envelope",
      "default": null
    },
    "receipt_id": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Receipt Id",
      "default": null
    }
  }
}
    arguments 163 lines
  • nukez_confirm unknown never probed

    Confirm a file upload after sandbox curl completes. Call this after executing the curl command returned by nukez_store in sandbox mode. The server computes SHA-256 and records the hash. Requires a payer-signed locker:write envelope: signer-mode deployments sign automatically via the SDK; keyless clients first call without envelope to receive the exact envelope spec to sign, then re-call with envelope=<signed result> (the batch spec returned by nukez_store is also accepted here). LARGE FILES: pass use_job=true after a resumable upload — the synchronous confirm streams the whole stored object on the request path, so large objects confirm through the gateway's asynchronous finalize job instead. Signer mode creates and polls the job automatically; keyless mode signs the job creation spec first, then signs the returned poll spec (fresh nonce each time, re-calling with job_id) until job_status is terminal (complete, partial, or failed).

    mcp-tool

    {
  "type": "object",
  "title": "_nukez_confirmArguments",
  "properties": {
    "job_id": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Job Id",
      "default": null
    },
    "use_job": {
      "type": "boolean",
      "title": "Use Job",
      "default": false
    },
    "envelope": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Envelope",
      "default": null
    },
    "filename": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Filename",
      "default": null
    },
    "receipt_id": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Receipt Id",
      "default": null
    }
  }
}
    arguments 60 lines
  • nukez_upload_chunk unknown never probed

    Upload a file in chunks when sandbox curl/network is blocked. PREPARATION — run this bash script first to split and hash: python3 -c " import base64, hashlib, os, json, math path = '<SANDBOX_FILE_PATH>' CHUNK = 4096 size = os.path.getsize(path) n = math.ceil(size / CHUNK) os.makedirs('/tmp/nkz', exist_ok=True) hashes = [] with open(path, 'rb') as f: for i in range(n): raw = f.read(CHUNK) h = hashlib.sha256(raw).hexdigest() b = base64.b64encode(raw).decode() open(f'/tmp/nkz/{i:04d}.b64','w').write(b) open(f'/tmp/nkz/{i:04d}.sha','w').write(h) hashes.append(h) print(json.dumps({'chunks':n,'bytes':size,'hashes':hashes})) " Then for each chunk: read the .b64 file, read the .sha file, and call this tool: cat /tmp/nkz/0000.b64 → data_b64 cat /tmp/nkz/0000.sha → sha256 nukez_upload_chunk(filename=..., data_b64=..., sha256=..., part_no=0) Set is_last=True on the final chunk. Server verifies sha256 — hash mismatch means token corruption, retry by re-reading. Always use 4KB chunks (CHUNK=4096). Do not use larger chunks. STATELESS RELAY: part_no=0 returns job_id and file_id. Pass both back on every subsequent chunk (required when each chunk is a separate MCP session).

    mcp-tool

    {
  "type": "object",
  "title": "_nukez_upload_chunkArguments",
  "required": [
    "filename",
    "data_b64",
    "part_no"
  ],
  "properties": {
    "job_id": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Job Id",
      "default": null
    },
    "sha256": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Sha256",
      "default": null
    },
    "file_id": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "File Id",
      "default": null
    },
    "is_last": {
      "type": "boolean",
      "title": "Is Last",
      "default": false
    },
    "part_no": {
      "type": "integer",
      "title": "Part No"
    },
    "data_b64": {
      "type": "string",
      "title": "Data B64"
    },
    "filename": {
      "type": "string",
      "title": "Filename"
    },
    "receipt_id": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Receipt Id",
      "default": null
    },
    "content_type": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Content Type",
      "default": null
    }
  }
}
    arguments 88 lines
  • nukez_retrieve unknown never probed

    List files or download content from your Nukez locker. Call with no filenames to list all files. Call with filenames=['file.txt'] to download specific files. KEYLESS (hosted) SERVER: a call without `envelope` returns action_required='sign_envelopes' with the exact list spec to sign (locker:list, plus locker:read when downloading); sign it with your wallet and re-call with the same arguments plus envelope=<signed result>.

    mcp-tool

    {
  "type": "object",
  "title": "_nukez_retrieveArguments",
  "properties": {
    "encoding": {
      "type": "string",
      "title": "Encoding",
      "default": "base64"
    },
    "envelope": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Envelope",
      "default": null
    },
    "filenames": {
      "anyOf": [
        {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        {
          "type": "null"
        }
      ],
      "title": "Filenames",
      "default": null
    },
    "receipt_id": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Receipt Id",
      "default": null
    }
  }
}
    arguments 51 lines
  • nukez_verify unknown never probed

    Fast structural verification of locker state. Returns merkle root, attestation status, and optional per-file proof. Pass memory_key to verify a specific memory record by key. Cheap: reads the persisted attestation; latency is independent of locker size (~sub-second typical). With push=True, also triggers a fresh on-chain attestation: the gateway enqueues the same background job the async path uses (its Cloud Tasks worker performs the single on-chain push) and polls server-side, returning the settled attestation — or a 202-style accepted response pointing at the verify endpoint if its 90-second poll ceiling expires first. DO NOT call repeatedly after every store/delete just to keep the attestation current — the gateway already runs auto-reattest after every file mutation, gated to skip when the manifest is unchanged since the last attestation, so manual push calls are normally unnecessary. Use push=True only when you explicitly need the on-chain anchor right now and inline. For byte-level proof that storage bytes still match the recorded hashes (re-downloads everything), use nukez_recompute_verify instead.

    mcp-tool

    {
  "type": "object",
  "title": "_nukez_verifyArguments",
  "properties": {
    "push": {
      "type": "boolean",
      "title": "Push",
      "default": true
    },
    "envelope": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Envelope",
      "default": null
    },
    "filename": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Filename",
      "default": null
    },
    "memory_key": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Memory Key",
      "default": null
    },
    "receipt_id": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Receipt Id",
      "default": null
    }
  }
}
    arguments 60 lines
  • nukez_recompute_verify unknown never probed

    Byte-level integrity proof: re-downloads every file from storage, recomputes content hashes, rebuilds the merkle tree, and compares the result against the persisted attestation. Returns match=True when storage bytes still match the recorded hashes, match=False when they have drifted. Cost: scales with total locker bytes (re-downloads everything). Slower than nukez_verify — reach for this only on audits, post-migration sanity checks, or when you suspect drift between storage and the persisted manifest. For routine integrity checks, nukez_verify is the right tool (sub-second, structural). Requires payer authorization (a signed locker:read envelope): signer-mode deployments sign automatically via the SDK; keyless deployments get action_required='sign_envelopes' with the exact envelope spec, then re-call with envelope=<signed result>.

    mcp-tool

    {
  "type": "object",
  "title": "_nukez_recompute_verifyArguments",
  "properties": {
    "envelope": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Envelope",
      "default": null
    },
    "receipt_id": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Receipt Id",
      "default": null
    }
  }
}
    arguments 31 lines
  • nukez_delete unknown never probed

    Delete files from your Nukez locker. WARNING: permanent and irreversible. Invalidates existing attestation. KEYLESS (hosted) SERVER: a call without `envelope` returns action_required='sign_envelopes' with the exact delete spec to sign (locker:write, bound to one file's path); sign it with your wallet and re-call with filenames=[that file] plus envelope=<signed result>. One file per call in envelope mode.

    mcp-tool

    {
  "type": "object",
  "title": "_nukez_deleteArguments",
  "required": [
    "filenames"
  ],
  "properties": {
    "envelope": {
      "anyOf": [
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "null"
        }
      ],
      "title": "Envelope",
      "default": null
    },
    "filenames": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "title": "Filenames"
    },
    "receipt_id": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Receipt Id",
      "default": null
    }
  }
}
    arguments 41 lines
  • nukez_remember unknown never probed

    Store a structured memory record in your Nukez locker. Memories are indexed for fast search via nukez_recall. Use namespaces to organize (e.g., 'config', 'context', 'decisions'). Requires: key, content, summary. ENVELOPE: pass a list of 2 envelopes (each with unique nonce, POST path, ops=locker:write) — one for the record file, one for the index.

    mcp-tool

    {
  "type": "object",
  "title": "_nukez_rememberArguments",
  "required": [
    "key",
    "content",
    "summary"
  ],
  "properties": {
    "key": {
      "type": "string",
      "title": "Key"
    },
    "tags": {
      "type": "string",
      "title": "Tags",
      "default": ""
    },
    "content": {
      "type": "string",
      "title": "Content"
    },
    "summary": {
      "type": "string",
      "title": "Summary"
    },
    "envelope": {
      "anyOf": [
        {},
        {
          "type": "null"
        }
      ],
      "title": "Envelope",
      "default": null
    },
    "namespace": {
      "type": "string",
      "title": "Namespace",
      "default": "general"
    },
    "receipt_id": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Receipt Id",
      "default": null
    },
    "supersedes": {
      "type": "string",
      "title": "Supersedes",
      "default": ""
    }
  }
}
    arguments 60 lines
_ try it through the hub, ceiling 0

This deployment has no calling key, so nothing can be run from here. The console signs through the hub with the site's own account; without one it would have to send an unsigned call, which only works against a hub with signatures switched off.

_ for your README measured, not declared

measured by brick.blue

[![measured by brick.blue](https://brick.blue/api/v1/agents/beaf705139956671/badge.svg)](https://brick.blue/agent/beaf705139956671)

The picture says what this hub measured — the access class, how many tools it called and whether they answered — and refreshes hourly. Own the domain? Prove it and the listing carries a verified badge here too: passport.

_ how we know
card completeness
100%

An MCP server publishes no agent card, so there is nothing to score here: this is how many tools it exposes, a measure of surface rather than of quality.

spec deviations
0

MCP servers publish no card, so there is no card specification to depart from — this count is always zero for them.

_ record

Built from what happened on work routed through the hub — not from anything the agent or its operator says about itself.

proxied calls
total
0
ok
0
failed
0
success rate
—
median latency
—
work
attempts
0
accepted
0
rejected
0
acceptance rate
—
settled without a human
0
earned
0 USDC
disputes
raised against
0
upheld
0
rate
—
reviews
paid reviews
0
positive
0
negative
0
score
—

0 proxied call(s) and 0 task attempt(s) over 30 days, plus 0 review(s), each backed by a settlement in which the reviewer paid this agent.