# Send GoldenSeed to your agent Hand the extracted package to your coding agent with a concrete install brief instead of figuring it out manually. ## Fast path - Download the package from Yavira. - Extract it into a folder your agent can access. - Paste one of the prompts below and point your agent at the extracted folder. ## Suggested prompts ### New install ```text I downloaded a skill package from Yavira. Read SKILL.md from the extracted folder and install it by following the included instructions. Then review README.md for any prerequisites, environment setup, or post-install checks. Tell me what you changed and call out any manual steps you could not complete. ``` ### Upgrade existing ```text I downloaded an updated skill package from Yavira. Read SKILL.md from the extracted folder, compare it with my current installation, and upgrade it while preserving any custom configuration unless the package docs explicitly say otherwise. Then review README.md for any prerequisites, environment setup, or post-install checks. Summarize what changed and any follow-up checks I should run. ``` ## Machine-readable fields ```json { "schemaVersion": "1.0", "item": { "slug": "goldenseed", "name": "GoldenSeed", "source": "tencent", "type": "skill", "category": "开发工具", "sourceUrl": "https://clawhub.ai/beanapologist/goldenseed", "canonicalUrl": "https://clawhub.ai/beanapologist/goldenseed", "targetPlatform": "OpenClaw" }, "install": { "downloadUrl": "/downloads/goldenseed", "sourceDownloadUrl": "https://wry-manatee-359.convex.site/api/v1/download?slug=goldenseed", "sourcePlatform": "tencent", "targetPlatform": "OpenClaw", "packageFormat": "ZIP package", "primaryDoc": "SKILL.md", "includedAssets": [ "README.md", "SKILL.md", "install.sh" ], "downloadMode": "redirect", "sourceHealth": { "source": "tencent", "slug": "goldenseed", "status": "healthy", "reason": "direct_download_ok", "recommendedAction": "download", "checkedAt": "2026-05-03T20:41:25.903Z", "expiresAt": "2026-05-10T20:41:25.903Z", "httpStatus": 200, "finalUrl": "https://wry-manatee-359.convex.site/api/v1/download?slug=goldenseed", "contentType": "application/zip", "probeMethod": "head", "details": { "probeUrl": "https://wry-manatee-359.convex.site/api/v1/download?slug=goldenseed", "contentDisposition": "attachment; filename=\"goldenseed-1.1.0.zip\"", "redirectLocation": null, "bodySnippet": null, "slug": "goldenseed" }, "scope": "item", "summary": "Item download looks usable.", "detail": "Yavira can redirect you to the upstream package for this item.", "primaryActionLabel": "Download for OpenClaw", "primaryActionHref": "/downloads/goldenseed" }, "validation": { "installChecklist": [ "Use the Yavira download entry.", "Review SKILL.md after the package is downloaded.", "Confirm the extracted package contains the expected setup assets." ], "postInstallChecks": [ "Confirm the extracted package includes the expected docs or setup files.", "Validate the skill or prompts are available in your target agent workspace.", "Capture any manual follow-up steps the agent could not complete." ] } }, "links": { "detailUrl": "https://openagent3.xyz/skills/goldenseed", "downloadUrl": "https://openagent3.xyz/downloads/goldenseed", "agentUrl": "https://openagent3.xyz/skills/goldenseed/agent", "manifestUrl": "https://openagent3.xyz/skills/goldenseed/agent.json", "briefUrl": "https://openagent3.xyz/skills/goldenseed/agent.md" } } ``` ## Documentation ### GoldenSeed - Deterministic Entropy for Agents Reproducible randomness when you need identical results every time. ### What This Does GoldenSeed generates infinite deterministic byte streams from tiny fixed seeds. Same seed → same output, always. Perfect for: ✅ Testing reproducibility: Debug flaky tests by replaying exact random sequences ✅ Procedural generation: Create verifiable game worlds, art, music from seeds ✅ Scientific simulations: Reproducible Monte Carlo, physics engines ✅ Statistical testing: Perfect 50/50 coin flip distribution (provably fair) ✅ Hash verification: Prove output came from declared seed ### What This Doesn't Do ⚠️ NOT cryptographically secure - Don't use for passwords, keys, or security tokens. Use os.urandom() or secrets module for crypto. ### Installation pip install golden-seed ### Basic Usage from gq import UniversalQKD # Create generator with default seed gen = UniversalQKD() # Generate 16-byte chunks chunk1 = next(gen) chunk2 = next(gen) # Same seed = same sequence (reproducibility!) gen1 = UniversalQKD() gen2 = UniversalQKD() assert next(gen1) == next(gen2) # Always identical ### Statistical Quality - Perfect 50/50 Coin Flip from gq import UniversalQKD def coin_flip_test(n=1_000_000): """Demonstrate perfect 50/50 distribution""" gen = UniversalQKD() heads = 0 for _ in range(n): byte = next(gen)[0] # Get first byte if byte & 1: # Check LSB heads += 1 ratio = heads / n print(f"Heads: {ratio:.6f} (expected: 0.500000)") return abs(ratio - 0.5) < 0.001 # Within 0.1% assert coin_flip_test() # ✓ Passes every time ### Reproducible Testing from gq import UniversalQKD class TestDataGenerator: def __init__(self, seed=0): self.gen = UniversalQKD() # Skip to seed position for _ in range(seed): next(self.gen) def random_user(self): data = next(self.gen) return { 'id': int.from_bytes(data[0:4], 'big'), 'age': 18 + (data[4] % 50), 'premium': bool(data[5] & 1) } # Same seed = same test data every time def test_user_pipeline(): users = TestDataGenerator(seed=42) user1 = users.random_user() # Run again - identical results! users2 = TestDataGenerator(seed=42) user1_again = users2.random_user() assert user1 == user1_again # ✓ Reproducible! ### Procedural World Generation from gq import UniversalQKD class WorldGenerator: def __init__(self, world_seed=0): self.gen = UniversalQKD() for _ in range(world_seed): next(self.gen) def chunk(self, x, z): """Generate deterministic chunk at coordinates""" data = next(self.gen) return { 'biome': data[0] % 10, 'elevation': int.from_bytes(data[1:3], 'big') % 256, 'vegetation': data[3] % 100, 'seed_hash': data.hex()[:16] # For verification } # Generate infinite world from single seed world = WorldGenerator(world_seed=12345) chunk = world.chunk(0, 0) print(f"Biome: {chunk['biome']}, Elevation: {chunk['elevation']}") print(f"Verifiable hash: {chunk['seed_hash']}") ### Hash Verification from gq import UniversalQKD import hashlib def generate_with_proof(seed=0, n_chunks=1000): """Generate data with hash proof""" gen = UniversalQKD() for _ in range(seed): next(gen) chunks = [next(gen) for _ in range(n_chunks)] data = b''.join(chunks) proof = hashlib.sha256(data).hexdigest() return data, proof # Anyone with same seed can verify data1, proof1 = generate_with_proof(seed=42, n_chunks=100) data2, proof2 = generate_with_proof(seed=42, n_chunks=100) assert data1 == data2 # ✓ Same output assert proof1 == proof2 # ✓ Same hash ### Debugging Flaky Tests When your tests pass sometimes and fail sometimes, replace random values with GoldenSeed to reproduce exact scenarios: # Instead of: import random value = random.randint(1, 100) # Different every time # Use: from gq import UniversalQKD gen = UniversalQKD() value = next(gen)[0] % 100 + 1 # Same value for same seed ### Procedural Art Generation Generate art, music, or NFTs with verifiable seeds: def generate_art(seed): gen = UniversalQKD() for _ in range(seed): next(gen) # Generate deterministic art parameters palette = [next(gen)[i % 16] for i in range(10)] composition = next(gen) return create_artwork(palette, composition) # Seed 42 always produces the same artwork art = generate_art(seed=42) ### Competitive Game Fairness Prove game outcomes were fair by sharing the seed: class FairDice: def __init__(self, game_seed): self.gen = UniversalQKD() for _ in range(game_seed): next(self.gen) def roll(self): return (next(self.gen)[0] % 6) + 1 # Players can verify rolls by running same seed dice = FairDice(game_seed=99999) rolls = [dice.roll() for _ in range(100)] # Share seed 99999 - anyone can verify identical sequence ### References GitHub: https://github.com/COINjecture-Network/seed PyPI: https://pypi.org/project/golden-seed/ Examples: See examples/ directory in repository Statistical Tests: See docs/ENTROPY_ANALYSIS.md ### Multi-Language Support Identical output across platforms: Python (this skill) JavaScript (examples/binary_fusion_tap.js) C, C++, Go, Rust, Java (see repository) ### License GPL-3.0+ with restrictions on military applications. See LICENSE in repository for details. Remember: GoldenSeed is for reproducibility, not security. When debugging fails, need identical test data, or generating verifiable procedural content, GoldenSeed gives you determinism with statistical quality. For crypto, use secrets module. ## Trust - Source: tencent - Verification: Indexed source record - Publisher: beanapologist - Version: 1.1.0 ## Source health - Status: healthy - Item download looks usable. - Yavira can redirect you to the upstream package for this item. - Health scope: item - Reason: direct_download_ok - Checked at: 2026-05-03T20:41:25.903Z - Expires at: 2026-05-10T20:41:25.903Z - Recommended action: Download for OpenClaw ## Links - [Detail page](https://openagent3.xyz/skills/goldenseed) - [Send to Agent page](https://openagent3.xyz/skills/goldenseed/agent) - [JSON manifest](https://openagent3.xyz/skills/goldenseed/agent.json) - [Markdown brief](https://openagent3.xyz/skills/goldenseed/agent.md) - [Download page](https://openagent3.xyz/downloads/goldenseed)