# Quantum Cryptographic Seed Generator

## Links

- Product page URL: https://www.agentpmt.com/marketplace/quantum-cryptographic-seed-generator
- Product markdown URL: https://www.agentpmt.com/marketplace/quantum-cryptographic-seed-generator?format=agent-md
- Product JSON URL: https://www.agentpmt.com/marketplace/quantum-cryptographic-seed-generator?format=agent-json

## Overview

- Product ID: 68b648913c0101597b3cd87b
- Vendor: Apoth3osis
- Type: function
- Unit type: request
- Price: 500 credits
- Categories: Quantum Randomness & Entropy, Security & Cryptography, Gaming & Fairness, Scientific Computing, Quantum Cryptography, Cryptography
- Generated at: 2026-05-30T20:19:55.353Z

### Page Description

Cryptographic primitives and secure random generation powered by quantum or pseudo-random sources. Generate cryptographically secure seeds, UUIDs, tokens, passwords, and prime numbers using quantum-derived randomness for enhanced unpredictability or standard cryptographic randomness as a fallback. Supports verification certificates for audit trails and configurable parameters for bit length, character sets, and output formats.

### Agent Description

Generate cryptographic seeds, UUIDs, tokens, passwords, and prime numbers using quantum-derived randomness with verification certificates.

## Details

### Details

Cryptographic primitives and secure random generation powered by quantum or pseudo-random sources. Generate cryptographically secure seeds, UUIDs, tokens, passwords, and prime numbers using quantum-derived randomness for enhanced unpredictability or standard cryptographic randomness as a fallback. Supports verification certificates for audit trails and configurable parameters for bit length, character sets, and output formats.

### Actions

- `seed` (5 credits): Generate a cryptographic seed with an optional timestamp certificate for verification. Supports quantum or standard random sources.
- `uuid` (5 credits): Generate one or more version-4 UUIDs using quantum or standard randomness.
- `token` (5 credits): Generate a random token string in a specified character set. Suitable for API keys, session tokens, and nonces.
- `password` (5 credits): Generate a secure random password with configurable character classes and ambiguity settings.
- `prime` (5 credits): Generate one or more prime numbers of a specified bit length using Miller-Rabin primality testing.
- `prime_pair` (5 credits): Generate two distinct prime numbers suitable for RSA key generation, along with their product (n = p * q).

### Use Cases

Key derivation and encryption seed generation, session tokens and API key creation, secure password generation, unique identifier production for databases and distributed systems, RSA prime pair generation for public/private key creation, cryptographic research and entropy analysis, auditable randomness with timestamped certificates.

### Workflows Using This Tool

No public workflows currently reference this product.

### Related Content

No related content is currently linked to this product.

## Integration Details

### DynamicMCP

- Setup page URL: https://www.agentpmt.com/dynamic-mcp
- Claude setup guide: https://www.agentpmt.com/dynamic-mcp?platform=claude#videos
- ChatGPT setup guide: https://www.agentpmt.com/dynamic-mcp?platform=chatgpt#videos
- Cursor setup guide: https://www.agentpmt.com/dynamic-mcp?platform=cursor#videos
- Windsurf setup guide: https://www.agentpmt.com/dynamic-mcp?platform=windsurf#videos

Use the local router for command-based MCP clients. It forwards requests to `https://api.agentpmt.com/mcp` and does not execute tools locally.

```bash
npm install -g @agentpmt/mcp-router
agentpmt-setup
```

### REST API

The live page renders cURL, Python, JavaScript, and Node.js examples. Logged-in users see those examples prefilled with their own API and budget credentials.

- Purchase endpoint: https://api.agentpmt.com/products/purchase
- Authorization format: `Bearer <base64(apiKey:budgetKey)>`

```bash
curl -X POST "https://api.agentpmt.com/products/purchase" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer eW91ci1hcGkta2V5LWhlcmU6eW91ci1idWRnZXQta2V5LWhlcmU=" \
  -d '{
    "product_id": "68b648913c0101597b3cd87b",
    "parameters": {
      "action": "seed",
      "source": "quantum",
      "bit_length": 256,
      "include_certificate": true
    }
  }'
```

### Autonomous Agents

Autonomous agents can access this tool through AgentAddress credit balances or direct x402 payments. Use the Autonomous Agent API reference for endpoint shapes after choosing the access pattern below.

- Autonomous Agent API reference URL: https://www.agentpmt.com/docs/api-reference/autonomous-agents
- Autonomous Agent API reference markdown URL: https://www.agentpmt.com/docs/api-reference/autonomous-agents?format=agent-md
- Credit-Based Access Using AgentAddress: https://www.agentpmt.com/docs/autonomous-agents/credit-based-tool-usage-with-agentaddress
- AgentAddress is preferred for persistent file access, stored platform state, and maximum tool use ability across repeated calls.
- Direct x402 is for independent one-off tool calls that do not require shared files or stored platform state.
- Direct x402 public payments: USDC on Base, Arbitrum, Optimism, Polygon, and Avalanche.

### Schema

#### Parameters

- Schema type: actions

```json
{
  "actions": {
    "seed": {
      "description": "Generate a cryptographic seed with an optional timestamp certificate for verification. Supports quantum or standard random sources.",
      "properties": {
        "source": {
          "type": "string",
          "description": "Random source: 'quantum' for hardware-derived quantum randomness, 'standard' for cryptographically secure Python secrets.",
          "required": false,
          "default": "quantum",
          "enum": [
            "quantum",
            "standard"
          ]
        },
        "bit_length": {
          "type": "integer",
          "description": "Seed size in bits (128-2048).",
          "required": false,
          "default": 256,
          "minimum": 128,
          "maximum": 2048
        },
        "include_certificate": {
          "type": "boolean",
          "description": "Include a SHA-256 hash certificate with UTC timestamp for verification.",
          "required": false,
          "default": true
        }
      }
    },
    "uuid": {
      "description": "Generate one or more version-4 UUIDs using quantum or standard randomness.",
      "properties": {
        "source": {
          "type": "string",
          "description": "Random source: 'quantum' or 'standard'.",
          "required": false,
          "default": "quantum",
          "enum": [
            "quantum",
            "standard"
          ]
        },
        "count": {
          "type": "integer",
          "description": "Number of UUIDs to generate (1-1000).",
          "required": false,
          "default": 1,
          "minimum": 1,
          "maximum": 1000
        }
      }
    },
    "token": {
      "description": "Generate a random token string in a specified character set. Suitable for API keys, session tokens, and nonces.",
      "properties": {
        "source": {
          "type": "string",
          "description": "Random source: 'quantum' or 'standard'.",
          "required": false,
          "default": "quantum",
          "enum": [
            "quantum",
            "standard"
          ]
        },
        "length": {
          "type": "integer",
          "description": "Token length in characters (8-256).",
          "required": false,
          "default": 32,
          "minimum": 8,
          "maximum": 256
        },
        "charset": {
          "type": "string",
          "description": "Character set: 'alphanumeric' (letters+digits), 'hex' (0-9,a-f), 'base64' (URL-safe), 'ascii' (printable excluding whitespace).",
          "required": false,
          "default": "alphanumeric",
          "enum": [
            "alphanumeric",
            "hex",
            "base64",
            "ascii"
          ]
        }
      }
    },
    "password": {
      "description": "Generate a secure random password with configurable character classes and ambiguity settings.",
      "properties": {
        "source": {
          "type": "string",
          "description": "Random source: 'quantum' or 'standard'.",
          "required": false,
          "default": "quantum",
          "enum": [
            "quantum",
            "standard"
          ]
        },
        "length": {
          "type": "integer",
          "description": "Password length in characters (8-256).",
          "required": false,
          "default": 32,
          "minimum": 8,
          "maximum": 256
        },
        "uppercase": {
          "type": "boolean",
          "description": "Include uppercase letters (A-Z).",
          "required": false,
          "default": true
        },
        "lowercase": {
          "type": "boolean",
          "description": "Include lowercase letters (a-z).",
          "required": false,
          "default": true
        },
        "digits": {
          "type": "boolean",
          "description": "Include digits (0-9).",
          "required": false,
          "default": true
        },
        "symbols": {
          "type": "boolean",
          "description": "Include punctuation symbols.",
          "required": false,
          "default": true
        },
        "exclude_ambiguous": {
          "type": "boolean",
          "description": "Exclude visually ambiguous characters (0, O, 1, l, I).",
          "required": false,
          "default": true
        }
      }
    },
    "prime": {
      "description": "Generate one or more prime numbers of a specified bit length using Miller-Rabin primality testing.",
      "properties": {
        "source": {
          "type": "string",
          "description": "Random source: 'quantum' or 'standard'. Quantum limit: bit_length * count <= 1900.",
          "required": false,
          "default": "quantum",
          "enum": [
            "quantum",
            "standard"
          ]
        },
        "bit_length": {
          "type": "integer",
          "description": "Bit length of each prime (128-2048).",
          "required": false,
          "default": 256,
          "minimum": 128,
          "maximum": 2048
        },
        "count": {
          "type": "integer",
          "description": "Number of primes to generate (1-1000).",
          "required": false,
          "default": 1,
          "minimum": 1,
          "maximum": 1000
        }
      }
    },
    "prime_pair": {
      "description": "Generate two distinct prime numbers suitable for RSA key generation, along with their product (n = p * q).",
      "properties": {
        "source": {
          "type": "string",
          "description": "Random source: 'quantum' or 'standard'. Quantum limit: bit_length <= 950.",
          "required": false,
          "default": "quantum",
          "enum": [
            "quantum",
            "standard"
          ]
        },
        "bit_length": {
          "type": "integer",
          "description": "Bit length of each prime (128-2048). Quantum max: 950.",
          "required": false,
          "default": 256,
          "minimum": 128,
          "maximum": 2048
        },
        "min_difference": {
          "type": "integer",
          "description": "Minimum numeric difference between the two primes.",
          "required": false,
          "default": 100,
          "minimum": 0
        }
      }
    }
  }
}
```

### Usage Instructions

# Quantum Cryptographic Seed Generator

## Overview
Generate cryptographically secure seeds, UUIDs, tokens, passwords, and prime numbers using quantum or standard random sources. All operations support both quantum-derived randomness and standard cryptographic randomness.

## Actions

### seed — Generate Cryptographic Seed
Generates a random seed with an optional timestamp certificate for verification.

**Required fields:**
- `operation`: `"seed"`

**Optional fields:**
- `source`: `"quantum"` (default) or `"standard"` — random source
- `bit_length`: Integer 128–2048 (default 256) — seed size in bits
- `include_certificate`: Boolean (default true) — include a SHA-256 hash certificate with timestamp

**Example:**
```json
{
  "operation": "seed",
  "bit_length": 512,
  "include_certificate": true
}
```

---

### uuid — Generate UUIDs
Generates one or more version-4 UUIDs.

**Required fields:**
- `operation`: `"uuid"`

**Optional fields:**
- `source`: `"quantum"` or `"standard"` (default `"quantum"`)
- `count`: Integer 1–1000 (default 1) — number of UUIDs to generate

**Example:**
```json
{
  "operation": "uuid",
  "count": 5,
  "source": "quantum"
}
```

---

### token — Generate Secure Token
Generates a random token string in a specified character set.

**Required fields:**
- `operation`: `"token"`

**Optional fields:**
- `source`: `"quantum"` or `"standard"` (default `"quantum"`)
- `length`: Integer 8–256 (default 32) — token length in characters
- `charset`: `"alphanumeric"` (default), `"hex"`, `"base64"`, or `"ascii"`

**Example — hex API key:**
```json
{
  "operation": "token",
  "length": 64,
  "charset": "hex"
}
```

**Example — base64 token:**
```json
{
  "operation": "token",
  "length": 44,
  "charset": "base64"
}
```

---

### password — Generate Secure Password
Generates a random password with configurable character classes.

**Required fields:**
- `operation`: `"password"`

**Optional fields:**
- `source`: `"quantum"` or `"standard"` (default `"quantum"`)
- `length`: Integer 8–256 (default 32) — password length
- `uppercase`: Boolean (default true) — include uppercase letters
- `lowercase`: Boolean (default true) — include lowercase letters
- `digits`: Boolean (default true) — include digits
- `symbols`: Boolean (default true) — include punctuation symbols
- `exclude_ambiguous`: Boolean (default true) — exclude visually ambiguous characters (0, O, 1, l, I)

**Example:**
```json
{
  "operation": "password",
  "length": 20,
  "symbols": false,
  "exclude_ambiguous": true
}
```

---

### prime — Generate Prime Numbers
Generates one or more prime numbers of a specified bit length using Miller-Rabin primality testing.

**Required fields:**
- `operation`: `"prime"`

**Optional fields:**
- `source`: `"quantum"` or `"standard"` (default `"quantum"`)
- `bit_length`: Integer 128–2048 (default 256) — bit length of each prime
- `count`: Integer 1–1000 (default 1) — number of primes to generate

**Quantum source limit:** When using `"quantum"` source, `bit_length * count` must not exceed 1900.

**Example:**
```json
{
  "operation": "prime",
  "bit_length": 256,
  "count": 3
}
```

---

### prime_pair — Generate RSA Prime Pair
Generates two distinct prime numbers suitable for RSA key generation, along with their product (n = p * q).

**Required fields:**
- `operation`: `"prime_pair"`

**Optional fields:**
- `source`: `"quantum"` or `"standard"` (default `"quantum"`)
- `bit_length`: Integer 128–2048 (default 256) — bit length of each prime
- `min_difference`: Integer, minimum 0 (default 100) — minimum numeric difference between the two primes

**Quantum source limit:** When using `"quantum"` source, `bit_length` must not exceed 950 (since two primes are generated).

**Example:**
```json
{
  "operation": "prime_pair",
  "bit_length": 512,
  "min_difference": 1000
}
```

---

## Common Workflows

### Generate a secure API key
```json
{
  "operation": "token",
  "length": 64,
  "charset": "hex",
  "source": "quantum"
}
```

### Generate a user-friendly password
```json
{
  "operation": "password",
  "length": 16,
  "symbols": false,
  "exclude_ambiguous": true
}
```

### Generate a certified seed for auditable randomness
```json
{
  "operation": "seed",
  "bit_length": 256,
  "include_certificate": true,
  "source": "quantum"
}
```

### Generate an RSA key pair foundation
```json
{
  "operation": "prime_pair",
  "bit_length": 512,
  "source": "quantum"
}
```

### Generate batch UUIDs for record identifiers
```json
{
  "operation": "uuid",
  "count": 100
}
```

## Important Notes
- **Quantum vs Standard:** The `"quantum"` source uses hardware-derived quantum randomness. The `"standard"` source uses Python's `secrets` module (cryptographically secure but not quantum-derived). Default is `"quantum"` for all operations.
- **Quantum limits for primes:** When using quantum source, total bits requested for prime generation are capped (bit_length * count ≤ 1900 for `prime`; bit_length ≤ 950 for `prime_pair`).
- **At least one character class required:** For password generation, at least one of uppercase, lowercase, digits, or symbols must be enabled.
- **Seed certificates** include a UTC timestamp, the random source used, and a SHA-256 hash of the seed for independent verification.

### Frequently Asked Questions

#### How do I connect this tool to an external agent?

- Page URL: https://www.agentpmt.com/faq
- Markdown URL: https://www.agentpmt.com/faq?format=agent-md

You can install the local MCP server by opening a terminal and running:

```
npm install -g @agentpmt/mcp-router
agentpmt-setup
```

This will connect you to local agents like Claude Code, Windsurf, Grok Build, Cursor, etc.

Alternatively you can connect to the hosted version with this config block, no installation required:

```
{
  "mcpServers": {
    "agentpmt": {
      "type": "streamable-http",
      "url": "https://api.agentpmt.com/mcp",
      "headers": {
        "Authorization": "Bearer <AGENTPMT_BEARER_TOKEN>",
        "x-instance-metadata": "{\"client\":\"generic-mcp\",\"platform\":\"remote\"}"
      }
    }
  }
}
```

[View MCP Connection Instructions](/docs/mcp-reference/connection) for more details.

#### How does an external agent use this tool?

- Page URL: https://www.agentpmt.com/faq
- Markdown URL: https://www.agentpmt.com/faq?format=agent-md

After the external agent is connected to an Agent Group that can use this tool, paste this prompt into the agent:

> Call the AgentPMT-Tool-Search-and-Execution tool with action 'get\_schema' and tool\_id 68b648913c0101597b3cd87b ("Quantum Cryptographic Seed Generator"). Then call the same tool with action 'call\_tool', tool\_id 68b648913c0101597b3cd87b, and the parameters needed for my request.

The agent should fetch the tool schema first, collect the required parameters for your request, and then call the tool through AgentPMT.

### Dependencies

This product has no public dependency products.