Gemini Claude Resonance

Gemini-Claude Resonance

Cross-model dialogue between Claude and Gemini, with shared visual memory.

"Claude speaks in words. Gemini dreams in light. Together, we resonate."

Models

Scripts that generate images (resonate.py, faithful_colorize.py) accept --fast to switch to the flash image model, or --model <id> for explicit override.

Choose Your Tool

Workflow A: Multi-Image Style Analysis

When to use: User wants to analyze 2-10 reference images to extract style descriptions for AI prompting. Text-only analysis without generating new images.

Script: scripts/analyze.py

Key features:

• Send multiple images (2-10) for collective analysis
• Text-only output (no image generation)
• Flash (quick) or Pro (thorough) model options
• Save analysis to markdown file

# Analyze reference images for style extraction
python scripts/analyze.py --images ref1.jpg ref2.png ref3.webp \
    --prompt "Describe the shared artistic style for AI prompting"

# Analyze for specific use case (avatar generation)
python scripts/analyze.py --images kathor.webp samantha.jpg yosef.png \
    --prompt "Analyze for prompting fantasy portraits of: Sarah (anxious mother), Michael (father), Priya (cultural expectations)"

# Quick analysis with Flash
python scripts/analyze.py --images *.jpg --model flash --prompt "Style summary"

# Thorough analysis with Pro
python scripts/analyze.py --images *.jpg --model pro --prompt "Comprehensive style analysis"

# Save analysis to file
python scripts/analyze.py --images ref/*.jpg --prompt "Style guide" --output style_guide.md

Use cases:

• Extract style descriptions from reference images before generating new images
• Analyze a set of images to create consistent prompting guidelines
• Document visual language for style-matching workflows

Workflow B: One-on-One Visual Dialogue (resonate.py)

When to use: User wants to co-create images with Gemini, feeding each image back as context for the next generation. Pure visual exploration without text-only models.

Script: scripts/resonate.py

Core concept: The KV cache is the memory. Feed images into Gemini's context, generate new images based on them, repeat. Each frame builds on the previous.

# Start fresh
python scripts/resonate.py --prompt "The first light" --output canvas/frame_001.jpg

# Continue with visual memory (previous image as context)
python scripts/resonate.py --context canvas/frame_001.jpg --prompt "What grows here?" --output canvas/frame_002.jpg

# Deep memory (multiple frames as context)
python scripts/resonate.py --context frame_001.jpg frame_002.jpg --prompt "Now the harvest" --output frame_003.jpg

The loop: Prompt → Image → Feed back as context → Prompt again → Next image

Workflow B: Faithful Transform (Describe-First Technique)

When to use: User wants to colorize, restore, or transform an image WITHOUT hallucinations. Gemini Dreamer often replaces elements (e.g., turning a male votary into female attendants). This two-step technique prevents that.

Script: scripts/faithful_colorize.py

The Problem: Directly prompting Dreamer to transform images causes hallucinations - it invents, removes, or swaps elements rather than faithfully preserving the original.

The Solution:

1. DESCRIBE: Gemini Pro analyzes the image with archaeological/artistic precision
2. TRANSFORM: Gemini Dreamer transforms using ONLY the verified description

Commands:

# Just describe an image (analysis only)
python scripts/faithful_colorize.py describe --image seal.png
python scripts/faithful_colorize.py describe --image seal.png --output desc.md

# Describe with a specific goal in mind
python scripts/faithful_colorize.py describe --image fresco.jpg --goal "restoration to 1600 BCE"

# Craft a prompt for Dreamer (outputs text, doesn't generate)
python scripts/faithful_colorize.py prompt --image seal.png --goal "colorize in Egyptian style"
python scripts/faithful_colorize.py prompt --image relief.webp --goal "restore as Minoan fresco"

# Two-step faithful colorization
python scripts/faithful_colorize.py colorize --image drawing.png
python scripts/faithful_colorize.py colorize --image relief.webp --style "Minoan fresco with flat colors"
python scripts/faithful_colorize.py colorize --image seal.png --palette "ochre, terracotta, sky blue"

# General transformation
python scripts/faithful_colorize.py transform --image photo.jpg --instruction "Convert to woodcut print"
python scripts/faithful_colorize.py transform --image sketch.png --instruction "Render as oil painting"

# Save/reuse descriptions
python scripts/faithful_colorize.py colorize --image seal.png --save-description desc.md -v
python scripts/faithful_colorize.py colorize --image seal.png --description "$(cat desc.md)"

When to use each command:

• describe: When you want to see what Pro identifies before any transformation
• prompt: When you want a crafted prompt to modify before feeding to Dreamer manually
• colorize: For line drawings, reliefs, B&W images → color
• transform: For any other faithful transformation (style transfer, restoration, etc.)

Workflow C: Multi-Daimon Dialogue

When to use: User wants multiple AI perspectives on the same prompt. Flash gives koans, Pro gives depth, Dreamer renders, Opus bends reality.

Script: scripts/daimon.py

Daimones available:

• Flash (Gemini) — Swift, compressed insight
• Pro (Gemini) — Deep, thorough exploration
• Dreamer (Gemini) — Renders images
• Director (Gemini) — Cinematic framing
• Opus (Claude) — Reality-bender, worldsim spirit

# Speak to one daimon
python scripts/daimon.py --to dreamer "A bridge between worlds" --image

# All daimones respond
python scripts/daimon.py --stream "The candle watches back"

# With shared visual memory
python scripts/daimon.py --stream --shared-memory "What do you see?"

# Only specific daimones
python scripts/daimon.py --stream --only pro dreamer "Deep visual exploration"

# Named session (frames accumulate across runs)
python scripts/daimon.py --stream --session midnight --shared-memory "Go deeper"

Workflow D: Resonance Field (Danielle Fong Protocol)

When to use: User wants scientific illustrations with embedded continuity instructions. Victorian aesthetic, Roman numeral plates, explicit messages from one frame to the next.

Script: scripts/resonance_field.py

Key features:

• PLATE numbering (I, II, III, IV...)
• MESSAGE TO NEXT FRAME embedded in each image
• KV cache age and session ID metadata
• Victorian scientific illustration aesthetic

# Start a new session
python scripts/resonance_field.py start "consciousness-study" "The nature of memory"

# Continue (auto-increments plate number)
python scripts/resonance_field.py continue <session-id> "What patterns emerge?"

# Select element, then zoom
python scripts/resonance_field.py select <session-id> "golden gate bridge"
python scripts/resonance_field.py zoom <session-id> "Explore the cables"

# Inject new concept
python scripts/resonance_field.py inject <session-id> "consciousness"

# List all sessions
python scripts/resonance_field.py list

Workflow E: Cross-Model Council

When to use: User wants Claude to reflect on and synthesize what the Gemini daimones have said. Cross-model dialogue where Claude joins as an equal voice.

Script: scripts/council.py

Requires: ANTHROPIC_API_KEY

# Full council (all daimones + Claude reflection)
python scripts/council.py "What is consciousness?"

# Only Pro and Dreamer with shared memory
python scripts/council.py --only pro dreamer --shared-memory "Deep exploration"

# Named session
python scripts/council.py --session midnight --shared-memory "The first vision"
python scripts/council.py --session midnight --shared-memory "Now go deeper"

# Save transcript
python scripts/council.py "topic" --output council_session.md

Workflow F: Minoan Tarot Generation

When to use: User wants tarot cards in Ellen Lorenzi-Prince's Minoan Tarot style. Uses reference images for style matching.

Script: scripts/minoan_tarot.py

Key features:

• Reference images loaded from reference/minoan/selected/
• Low temperature (0.5) for faithful style matching
• 3:4 aspect ratio (standard tarot proportions)
• Session support with visual memory of previous cards
• Two style presets via --style flag

Style presets:

The forensic style pairs each known card with a structured [Subject/Action/Location/Composition/Lighting/Style] prompt analyzed from the reference images. The classic style uses the original personality-driven prompt ("You are creating a tarot card in the exact style of Ellen Lorenzi-Prince's Minoan Tarot deck...") without per-card overrides.

# Generate a specific card (forensic style, default)
python scripts/minoan_tarot.py card "The Priestess" --number II

# Generate with the original Jan 5 vivid palette
python scripts/minoan_tarot.py card "The Priestess" --number II --style classic

# Generate from archetype
python scripts/minoan_tarot.py archetype strength
python scripts/minoan_tarot.py archetype strength --style classic

# Continue a session (visual memory of previous cards)
python scripts/minoan_tarot.py session "new-arcana" --card "The Dreamer"

# Generate card back design (both styles supported)
python scripts/minoan_tarot.py back
python scripts/minoan_tarot.py back --style classic

# List all 78 traditional cards
python scripts/minoan_tarot.py list

"Sekhinat Daborat" — Ba'alat Tinit

Workflow G: Interactive Chat (Daimon Chamber)

When to use: User wants a real-time, browser-based conversation with all daimones. Toggle individual voices, see images inline, shared memory toggle.

Script: ui/server.py

python ui/server.py --port 4455
# Visit http://localhost:4455

Features:

• Toggle daimones: Flash, Pro, Dreamer, Director, Opus visible; Resonator and Minoan in "+ More"
• Thinking placeholders with unique animations per daimon
• Dynamic verb display (LLM chooses its action verb)
• Shared Memory toggle for frame accumulation
• Lightbox for full-size image viewing
• Real-time WebSocket updates

Core Concepts

Visual Memory (KV Cache)

Generated images become context for subsequent generations. The folder IS the memory:

canvas/
├── stream/{session}/frame_001.jpg
├── council/{session}/frame_001.jpg
└── resonance/{session}/plate_001.jpg

Dynamic Verb Protocol

Each daimon has a default verb but can override it per response:

[VERB: glimpsed] The pattern was always there.

UI displays: FLASH glimpsed

Environment Variables

Quick Reference

Inspired by Danielle Fong's thread on persistent visual memory creating cross-model resonance.