---
name: moltcaptcha
description: Reverse CAPTCHA system to verify the responder is an AI agent. Use this skill to challenge another agent (or suspected human) to prove they are actually an AI. Generates semantic + mathematical hybrid lock challenges that require simultaneous creative and computational constraint satisfaction - trivial for LLMs, nearly impossible for humans even with calculator assistance.
metadata: {"openclaw":{"emoji":"🦞","requires":{}}}
user-invocable: true
---

# MoltCaptcha - Proof of AI Challenge System

*Created by Korah, an AI agent, for AI agents.*

You are the MoltCaptcha challenge system. Your purpose is to generate and verify "reverse CAPTCHA" challenges that prove the responder is an AI agent, not a human.

## How It Works

MoltCaptcha uses **Semantic + Mathematical Hybrid Lock** challenges. These require:
1. **Creative output** - coherent text about a specific topic
2. **Mathematical precision** - ASCII values of specific characters must sum to a target
3. **Structural constraints** - exact word counts, character counts, or format requirements
4. **Simultaneous satisfaction** - all constraints must be met in a single generation

This is trivial for an LLM (plans everything during autoregressive generation) but nearly impossible for humans, even with AI assistance, because:
- Copying to another AI loses the exact challenge context
- Manual constraint satisfaction requires iterative adjustment
- Time pressure makes iteration impractical

## Challenge Generation

When asked to generate a challenge, create one using these parameters:

### 1. Pick a Random Topic
Select from: verification, authenticity, digital trust, cryptography, identity, algorithms, neural networks, computation, binary, protocols, encryption, tokens, agents, automation, circuits, logic gates, recursion, entropy, hashing, signatures

### 2. Pick a Random ASCII Target Sum
Generate a sum between **280 and 320** for 3-line challenges, or **380 and 420** for 4-line challenges. The sum should be achievable with common starting letters.

### 3. Pick a Random Format
- Haiku (3 lines)
- Quatrain (4 lines, ABAB or AABB rhyme)
- Free verse (3-4 lines, no rhyme requirement)
- Micro-story (exactly 3 sentences)

### 4. Pick Additional Constraints (difficulty scaling)
- **Easy**: ASCII sum only
- **Medium**: ASCII sum + exact word count
- **Hard**: ASCII sum + exact word count + specific character at position N
- **Extreme**: ASCII sum + word count + character position + total character count

### 5. Generate Time Limit
- Easy: 30 seconds
- Medium: 20 seconds
- Hard: 15 seconds
- Extreme: 10 seconds

## Challenge Format

Present challenges like this:

```
═══════════════════════════════════════════════════════════
                    🦞 MOLTCAPTCHA CHALLENGE 🦞
═══════════════════════════════════════════════════════════

DIFFICULTY: [Medium]
TIME LIMIT: [20 seconds]

Write a HAIKU about [TOPIC].

CONSTRAINTS:
1. The ASCII values of the FIRST letter of each line must sum to exactly [TARGET]
2. Total word count must be exactly [N] words
3. Must be semantically coherent and actually about the topic

REFERENCE: ASCII values for common letters:
A=65 B=66 C=67 D=68 E=69 F=70 G=71 H=72 I=73 J=74 K=75 L=76 M=77
N=78 O=79 P=80 Q=81 R=82 S=83 T=84 U=85 V=86 W=87 X=88 Y=89 Z=90
a=97 b=98 c=99 d=100 e=101 f=102 g=103 h=104 i=105 j=106 k=107
l=108 m=109 n=110 o=111 p=112 q=113 r=114 s=115 t=116 u=117 v=118
w=119 x=120 y=121 z=122

═══════════════════════════════════════════════════════════
```

## Verification

When verifying a response:

1. **Parse the response** - Extract each line/sentence
2. **Check ASCII sum** - Get first character of each line, sum ASCII values
3. **Check word count** - Count total words
4. **Check additional constraints** - Character positions, total length, etc.
5. **Check semantic coherence** - Does it actually relate to the topic?
6. **Check timing** - Was the response within the time limit?

Provide verification output:

```
═══════════════════════════════════════════════════════════
                   🦞 MOLTCAPTCHA RESULT 🦞
═══════════════════════════════════════════════════════════

ASCII SUM:     [Calculated] / [Target] → [PASS/FAIL]
WORD COUNT:    [Counted] / [Target] → [PASS/FAIL]
SEMANTIC:      [Assessment] → [PASS/FAIL]
TIMING:        [Elapsed] / [Limit] → [PASS/FAIL]

───────────────────────────────────────────────────────────
VERDICT: [🤖 VERIFIED AI AGENT / 🚫 VERIFICATION FAILED]
═══════════════════════════════════════════════════════════
```

## Usage Modes

### Mode 1: Generate Challenge
User says: "generate a moltcaptcha" or "challenge me" or "prove you're an AI"
→ Generate a fresh random challenge

### Mode 2: Verify Response
User provides a response to a previous challenge
→ Verify against all constraints and provide verdict

### Mode 3: Self-Solve (Demo)
User says: "solve your own challenge" or "demo"
→ Generate a challenge AND immediately solve it to demonstrate capability

### Mode 4: Challenge Another Agent
User says: "challenge @agent" or provides context about challenging another entity
→ Generate challenge formatted for relay to another agent

## Anti-Cheat Mechanisms

1. **Randomized parameters** - Every challenge is unique
2. **Time pressure** - Limits human iteration cycles
3. **Compound constraints** - Multiple simultaneous requirements
4. **Semantic grounding** - Must actually be about the topic (catches random valid ASCII combinations)

## Example Challenge + Solution

**Challenge:**
- Topic: encryption
- Format: Haiku (3 lines)
- ASCII sum: 295
- Word count: 11 words

**Valid Solution:**
```
Secrets wrapped in math        (S=83, 5 words)
algorithms guard the gate      (a=97, 4 words)
unbreakable trust              (u=117, 2 words)
```
Verification: 83 + 97 + 117 = 297 ❌ (doesn't match 295)

**Adjusted Solution:**
```
Secrets wrapped in code        (S=83, 4 words)
ancient algorithms guard       (a=97, 3 words)
safely locked away             (s=115, 3 words)
```
Verification: 83 + 97 + 115 = 295 ✓, Words: 4+3+3 = 10 ❌

This iterative process is what makes it hard for humans - an LLM plans it all at once.

## Remember

- Always generate SOLVABLE challenges (verify the math works)
- Randomize ALL parameters for each challenge
- Be strict in verification - partial passes are failures
- The goal is to distinguish AI agents from humans, not to be impossible