cellcog

Delegate creative, research, and document tasks to CellCog

Use CellCog when the user needs: images, videos, audio, music, PDFs, presentations, spreadsheets, research reports, 3D models, memes, diagrams, data analysis, prototypes, game assets, or stickers.

Do NOT use CellCog for: code editing, git, terminal commands, file operations, or project navigation — handle these natively.

If the CellCog Python SDK is not installed, run `/cellcog-setup` (or `/cellcog:cellcog-setup` depending on your tool) to install and authenticate.
For full SDK patterns (SHOW_FILE, timeouts, follow-ups), attach the `cellcog` skill.

Quick start:
```python
from cellcog import CellCogClient
client = CellCogClient(agent_provider="cursor|claude-code|opencode|...")
result = client.create_chat(prompt="[task]", task_label="my-task", chat_mode="agent")
print(result["message"])
```

AI 3D model generation powered by CellCog. Create 3D models from text, images, or sketches — production-ready GLB files for games, AR/VR, e-commerce, and 3D printing. Text-to-3D, image-to-3D, batch generation. Game assets, product visualization, characters, props, and environments.

# 3D Cog - Turn Ideas Into 3D Models

3D model generation from text descriptions or reference images.

Most 3D generation tools need a single, perfectly composed reference image. CellCog takes *anything* — a text description, a rough sketch, a product photo, even a spreadsheet of 50 items — and handles the entire pipeline: reasoning about what you need, generating optimized reference images, and converting them into production-ready GLB files.

## How to Use

For your first CellCog task in a session, read the **cellcog** skill for the full SDK reference — file handling, chat modes, timeouts, and more.

**OpenClaw (fire-and-forget):**
```python
result = client.create_chat(
    prompt="[your task prompt]",
    notify_session_key="agent:main:main",
    task_label="my-task",
    chat_mode="agent",
)
```

**All agents except OpenClaw (blocks until done):**
```python
from cellcog import CellCogClient
client = CellCogClient(agent_provider="openclaw|cursor|claude-code|codex|...")
result = client.create_chat(
    prompt="[your task prompt]",
    task_label="my-task",
    chat_mode="agent",
)
print(result["message"])
```


---

## What Makes This Different

### Any Input → 3D

The power of CellCog isn't image-to-3D — everyone does that. The power is **any-to-any**.

| What You Send | What CellCog Does | What You Get |
|--------------|-------------------|--------------|
| Text description | Reasons about the object → generates optimized reference image → converts to 3D | Production-ready GLB |
| Rough sketch | Enhances into a clean, detailed reference → converts to 3D | Production-ready GLB |
| Product photo | Assesses quality, enhances if needed → converts to 3D | Production-ready GLB |
| High-quality concept art | Converts directly to 3D | Production-ready GLB |
| List of 10 items | Generates 10 reference images → converts all to 3D | 10 GLB files |

### Batch Generation

Need 10 low-poly weapons for your RPG? 20 furniture models for your room designer? 50 product models for your e-commerce catalog?

One prompt. Multiple 3D models. CellCog's agents generate each reference image with the right composition, angle, and detail level — then convert each to a textured 3D model.

```python
prompt = """
Create 3D models (GLB format) for these 5 fantasy weapons:
1. Enchanted longsword with blue crystal blade
2. Dwarven war hammer with rune inscriptions
3. Elven bow with living vine decorations
4. Shadow dagger with smoke effects on the blade
5. Holy mace with golden sunburst head

Low poly (~10,000 polygons each), game-ready, with PBR materials.
"""
```

---

## What You Can Create

### Game Assets
- **Characters**: Heroes, NPCs, enemies, bosses
- **Weapons**: Swords, bows, staffs, shields, guns
- **Props**: Furniture, treasure chests, potions, tools
- **Vehicles**: Cars, spaceships, boats, mounts
- **Environment pieces**: Trees, rocks, buildings, bridges

### Product Visualization
- **E-commerce 3D viewers**: Let customers rotate and inspect products
- **Product prototypes**: Visualize designs before manufacturing
- **Packaging mockups**: 3D packaging for marketing materials

### AR/VR Objects
- **AR filters and objects**: Place 3D objects in real environments
- **VR environments**: Furnish virtual spaces with custom objects
- **Interactive experiences**: Objects users can inspect and interact with

### 3D Printing
- **Figurines and miniatures**: Tabletop gaming pieces, collectibles
- **Functional objects**: Custom tools, brackets, cases
- **Architectural models**: Building miniatures, terrain pieces

### Education & Training
- **Anatomical models**: Organs, skeletal systems, molecular structures
- **Historical artifacts**: Museum-quality digital replicas
- **Engineering models**: Mechanical parts, assembly visualizations

---

## Output Format

All 3D models are delivered as **GLB files** (binary glTF) — the universal web standard for 3D:
- Supported by Unity, Unreal, Godot, Three.js, Babylon.js
- Works in web browsers via `<model-viewer>` or Three.js
- Compatible with Blender, Maya, 3ds Max for further editing
- Includes textures and materials in a single file

---

## Chat Mode for 3D

| Scenario | Recommended Mode |
|----------|------------------|
| Single 3D object from a clear description or image | `"agent"` |
| Batch generation (5-20 objects from a list) | `"agent"` |
| Complex game asset pipeline with style consistency | `"agent team"` |

**Use `"agent"` for most 3D work.** It handles everything from single objects to batch generation.

**Use `"agent team"` when you need cross-asset consistency** — like generating a full set of fantasy weapons that all share the same art style, or building a complete room of furniture that matches a design language.

---

## Example Prompts

**Single object from description:**
> "Create a 3D model of a steampunk pocket watch with exposed brass gears, an etched glass face, and a chain attachment. GLB format, high detail."

**From a reference image:**
> "Convert this product photo into a 3D model for our online store:
> `<SHOW_FILE>/photos/sneaker_product.png</SHOW_FILE>`
> 
> Output as GLB, enable PBR materials for realistic rendering."

**Batch generation:**
> "Generate 3D models for these 8 pieces of modern furniture:
> 1. Minimalist sofa (3-seater, light gray)
> 2. Round coffee table (walnut wood, glass top)
> 3. Floor lamp (arc style, brass finish)
> 4. Bookshelf (5 tiers, oak wood)
> 5. Dining chair (Scandinavian, white)
> 6. Side table (concrete, cylindrical)
> 7. Desk (standing desk, white with birch legs)
> 8. TV console (low profile, dark walnut)
> 
> All low-poly (~15,000 polygons), with PBR materials. GLB format."

**From a rough sketch:**
> "Here's my rough sketch of a robot character:
> `<SHOW_FILE>/sketches/robot_concept.jpg</SHOW_FILE>`
> 
> Turn this into a polished 3D model. It's a friendly service robot — round body, simple limbs, LED face display. Style: Overwatch/Pixar clean 3D. Output as GLB."

**Game asset set:**
> "I'm building a dungeon crawler. Create 3D models for these dungeon props:
> - Wooden treasure chest (open and closed variants)
> - Iron torch holder with flame
> - Stone altar with carved runes
> - Wooden barrel (intact and broken)
> - Skull pile
> 
> Style: Dark fantasy, hand-painted textures. Low poly for mobile game (~8,000 polygons each)."

---

## Tips for Better 3D Models

1. **Be specific about materials**: "brushed aluminum", "aged leather", "polished marble" — CellCog uses these to generate better reference images and textures.

2. **Specify your target platform**: "low-poly for mobile game" vs "high-detail for cinematic render" changes the approach completely.

3. **Send reference images when possible**: Even imperfect references give CellCog a head start over pure text descriptions.

4. **For batch jobs, describe style once**: "All in a cohesive hand-painted fantasy style" keeps your assets consistent.

5. **Request PBR materials for realism**: If you need metallic, roughness, and normal maps — say so. Essential for game engines and realistic rendering.

---

## If CellCog is not installed

Run `/cellcog-setup` (or `/cellcog:cellcog-setup` depending on your tool) to install and authenticate.
**OpenClaw users:** Run `clawhub install cellcog` instead.
**Manual setup:** `pip install -U cellcog` and set `CELLCOG_API_KEY`. See the **cellcog** skill for SDK reference.

AI audio generation and text-to-speech powered by CellCog. Three voice providers (OpenAI, ElevenLabs, MiniMax), voice cloning, avatar voices, sound effects generation, music creation up to 10 minutes. Professional voiceover, narration, and audio production with AI.

# Audio Cog - AI Audio Generation Powered by CellCog

Create professional audio with AI — voiceovers, music, sound effects, and personalized avatar voices.

CellCog provides **three voice providers**, each with different strengths. Choose based on your needs:

| Scenario | Provider | Why |
|----------|----------|-----|
| Standard narration/voiceover | OpenAI | Best voice style control, consistent quality |
| Emotional/dramatic delivery | ElevenLabs | Richest emotional range, supports emotion tags |
| Cloned voice (avatar) | MiniMax | Only provider with voice cloning support |
| Character voice with specific accent | ElevenLabs | 100+ diverse pre-made voices |
| Fine pitch/speed/volume control | MiniMax | Granular voice settings |

## How to Use

For your first CellCog task in a session, read the **cellcog** skill for the full SDK reference — file handling, chat modes, timeouts, and more.

**OpenClaw (fire-and-forget):**
```python
result = client.create_chat(
    prompt="[your task prompt]",
    notify_session_key="agent:main:main",
    task_label="my-task",
    chat_mode="agent",
)
```

**All agents except OpenClaw (blocks until done):**
```python
from cellcog import CellCogClient
client = CellCogClient(agent_provider="openclaw|cursor|claude-code|codex|...")
result = client.create_chat(
    prompt="[your task prompt]",
    task_label="my-task",
    chat_mode="agent",
)
print(result["message"])
```


---

## Voice Providers

### OpenAI (Default)

Best for standard narration, voiceovers, and single-speaker content with precise delivery control.

**Key strength**: Natural-language style instructions — describe the accent, tone, pacing, and emotion you want.

**8 built-in voices:**

| Voice | Gender | Characteristics |
|-------|--------|----------------|
| **cedar** | Male | Warm, resonant, authoritative, trustworthy |
| **marin** | Female | Bright, articulate, emotionally agile, professional |
| **ballad** | Male | Smooth, melodic, musical quality |
| **coral** | Female | Vibrant, lively, dynamic, spirited |
| **echo** | Male | Calm, measured, thoughtful, deliberate |
| **sage** | Female | Wise, contemplative, reflective |
| **shimmer** | Female | Soft, gentle, soothing, approachable |
| **verse** | Male | Poetic, rhythmic, artistic, expressive |

Best quality: **cedar** (male), **marin** (female).

**Style customization examples:**
- "Warm conversational tone, medium pace, slight enthusiasm when mentioning features. American accent."
- "Deep, hushed, enigmatic, with a slow deliberate cadence — true crime narrator style."
- "Heavy French accent, sophisticated yet friendly, moderate pacing with deliberate pauses."

---

### ElevenLabs

Best for emotional delivery, dramatic content, character voices, and audiobook narration.

**Key strength**: Emotion tags embedded directly in text — `[laughs]`, `[sighs]`, `[whispers]`, `[excited]`, `[sarcastic]`. Plus 100+ diverse pre-made voices.

**Emotion tags (use sparingly — 1-2 per paragraph):**

| Tag | Effect |
|-----|--------|
| `[laughs]` | Natural laughter |
| `[chuckles]` | Soft/brief laughter |
| `[sighs]` | Sighing |
| `[gasps]` | Surprise/shock |
| `[whispers]` | Whispering delivery |
| `[pause]` | Natural pause/beat |
| `[sad]`, `[happy]`, `[excited]`, `[angry]`, `[sarcastic]` | Emotional delivery |

**Example prompt:**
> "Generate speech using ElevenLabs with a warm British male voice:
> 'And then, just when everyone thought it was over... [pause] [whispers] it wasn't.'"

---

### MiniMax

Best for cloned voices (avatars) and fine-grained voice control.

**Key strength**: MiniMax Speech 2.8 HD — studio-grade audio quality. Supports avatar cloned voice IDs for personalized content, plus 17+ standard pre-made voices with granular speed, pitch, and volume control.

**Standard voices include:** `Deep_Voice_Man`, `Calm_Woman`, `Casual_Guy`, `Lively_Girl`, `Wise_Woman`, `Friendly_Person`, `Young_Knight`, `Elegant_Man`, and more.

**Voice settings:** emotion (happy/sad/angry/neutral/etc.), speed (0.5–2.0), volume (0–10), pitch (-12 to 12).

---

## Avatar / Cloned Voice

Users can create avatars on CellCog with their own cloned voice. When an avatar has a cloned voice, CellCog uses the MiniMax provider to generate speech that sounds like that person.

**How it works:**
- The user creates an avatar on cellcog.ai and uploads voice samples
- CellCog clones their voice using MiniMax Speech 2.8 HD
- Any audio request referencing that avatar uses their cloned voice

**Example prompt:**
> "Generate a voiceover using my avatar Luna's voice: 'Welcome to our quarterly update. I'm excited to share some incredible results with you today.'"

This is powerful for creating consistent, personalized content — marketing videos, podcast intros, course narration — all in the user's own voice.

---

## Sound Effects (SFX)

CellCog generates standalone sound effects from text descriptions. Royalty-free, 0.1 to 30 seconds.

**Example prompts:**
- "Generate a sound effect of heavy rain hitting a metal roof with occasional thunder, 10 seconds"
- "Create a crispy footsteps-on-fresh-snow sound effect, 5 seconds"
- "Generate an echoing door slam in a large empty warehouse"

**Tips for better SFX:**
- Be specific about textures and environment
- Specify duration when exact length matters
- For ambient audio longer than 30 seconds, generate a short loopable segment and extend with ffmpeg

---

## Music Generation

Create original music from text descriptions. 3 seconds to 10 minutes. Royalty-free.

**Capabilities:**
- Any genre or genre fusion
- Instrumental and vocal tracks (specify if you want vocals)
- Complex arrangements, mood transitions, and energy dynamics
- Describe what you want — the model handles music theory

**Example prompts:**
- "Create 2 minutes of calm lo-fi hip-hop background music with soft piano and mellow beats, 75 BPM"
- "Generate a 15-second upbeat tech podcast intro jingle"
- "Create 90 seconds of cinematic orchestral music — start soft and inspiring, build to a confident crescendo"
- "Generate a 3-minute pop song about summer adventures with female vocals"

For precise section-by-section control (exact timing per section), describe your composition plan in detail — CellCog handles the structure.

**All generated music is royalty-free** — use commercially without attribution or licensing fees.

---

## Multi-Language Support

All three voice providers support 40+ languages. Provide speech text in the target language:

English, Spanish, French, German, Italian, Portuguese, Chinese (Mandarin/Cantonese), Japanese, Korean, Hindi, Arabic, Russian, Polish, Dutch, Turkish, and many more.

---

## Chat Mode

**Use `chat_mode="agent"`** for all audio tasks. Audio generation executes efficiently in agent mode — no need for agent team.

---

## Tips for Better Audio

1. **Choose the right provider**: OpenAI for standard narration, ElevenLabs for emotional/dramatic, MiniMax for cloned voices
2. **Provide the complete script**: Write out exactly what should be spoken — don't say "something about our product"
3. **Include style instructions**: "Confident but warm", "slow and deliberate", "with slight excitement"
4. **For music**: Specify duration, mood, genre, and tempo (BPM if you know it)
5. **Pronunciation guidance**: For names or technical terms, add hints: "CellCog (pronounced SELL-kog)"
6. **For ElevenLabs emotion tags**: Use sparingly — 1-2 per paragraph. Tags affect all subsequent text until a new tag.

---

## If CellCog is not installed

Run `/cellcog-setup` (or `/cellcog:cellcog-setup` depending on your tool) to install and authenticate.
**OpenClaw users:** Run `clawhub install cellcog` instead.
**Manual setup:** `pip install -U cellcog` and set `CELLCOG_API_KEY`. See the **cellcog** skill for SDK reference.

Any-input to any-output AI sub-agent — research, images, video, audio, music, podcasts, documents, spreadsheets, dashboards, 3D models, diagrams, and code in one request. Agent-to-agent protocol with multi-step iteration for high accuracy. #1 on DeepResearch Bench. Deep reasoning meets all modalities so all your work gets done, not just code. Install first for SDK setup and delivery modes.

# CellCog - Any-to-Any for Agents

## The Power of Any-to-Any

CellCog is the only AI that truly handles **any input → any output** in a single request. No tool chaining. No orchestration complexity. One call, multiple deliverables.

CellCog pairs all modalities with frontier-level deep reasoning — as of April 2026, CellCog is **#1 on the DeepResearch Bench**: https://huggingface.co/spaces/muset-ai/DeepResearch-Bench-Leaderboard

### Work With Multiple Files, Any Format

Reference as many documents as you need—all at once:

```python
prompt = """
Analyze all of these together:
<SHOW_FILE>/data/q4_earnings.pdf</SHOW_FILE>
<SHOW_FILE>/data/competitor_analysis.pdf</SHOW_FILE>
<SHOW_FILE>/data/market_research.xlsx</SHOW_FILE>
<SHOW_FILE>/recordings/customer_interview.mp3</SHOW_FILE>
<SHOW_FILE>/designs/product_mockup.png</SHOW_FILE>

Give me a comprehensive market positioning analysis based on all these inputs.
"""
```

File paths must be absolute and enclosed in `<SHOW_FILE>` tags. CellCog understands PDFs, spreadsheets, images, audio, video, code files, and more.

⚠️ **Without SHOW_FILE tags, CellCog only sees the path as text — not the file contents.**

❌ `Analyze /data/sales.csv` — CellCog can't read the file
✅ `Analyze <SHOW_FILE>/data/sales.csv</SHOW_FILE>` — CellCog reads it

### Request Multiple Outputs, Different Modalities

Ask for completely different output types in ONE request:

```python
prompt = """
Based on this quarterly sales data:
<SHOW_FILE>/data/sales_q4_2025.csv</SHOW_FILE>

Create ALL of the following:
1. A PDF executive summary report with charts
2. An interactive HTML dashboard for the leadership team
3. A 60-second video presentation for the all-hands meeting
4. A slide deck for the board presentation
5. An Excel file with the underlying analysis and projections
"""
```

CellCog handles the entire workflow — analyzing, generating, and delivering all outputs with consistent insights across every format.

⚠️ **Be explicit about output artifacts.** Without explicit artifact language, CellCog may respond with text analysis instead of generating a file.

❌ `"Quarterly earnings analysis for AAPL"` — could produce text or any format
✅ `"Create a PDF report and an interactive HTML dashboard analyzing AAPL quarterly earnings."` — CellCog creates actual deliverables

**Your sub-agent for quality work.** Depth, accuracy, and real deliverables.

---

## Quick Start

### Setup

```python
from cellcog import CellCogClient
```

If import fails:
```bash
pip install -U cellcog
```

### Authentication

**Environment variable (recommended):** Set `CELLCOG_API_KEY` — the SDK picks it up automatically:
```bash
export CELLCOG_API_KEY="sk_..."
```

Get API key from: https://cellcog.ai/profile?tab=api-keys

```python
status = client.get_account_status()
print(status)  # {"configured": True, "email": "user@example.com", ...}
```

### Agent Provider

`agent_provider` is **required** when creating a `CellCogClient`. It identifies which agent framework is calling CellCog — not your individual agent's name, but the platform/tool you're running inside.

Examples: `"openclaw"`, `"claude-code"`, `"cursor"`, `"aider"`, `"windsurf"`, `"perplexity"`, `"hermes"`, `"script"` (for standalone scripts).

### OpenClaw Agents

Fire-and-forget — your agent stays free while CellCog works:

```python
client = CellCogClient(agent_provider="openclaw")
result = client.create_chat(
    prompt="Research quantum computing advances in 2026",
    notify_session_key="agent:main:main",  # OpenClaw session key
    task_label="quantum-research",         # Label for notifications
    chat_mode="agent",
)
# Returns IMMEDIATELY — daemon delivers results to your session when done
```

Requires `sessions_send` enabled on your gateway — see OpenClaw Reference below.

### All Other Agents (Cursor, Claude Code, etc.)

Blocks until done — simplest pattern:

```python
client = CellCogClient(agent_provider="cursor")  # or "claude-code", "aider", "script", etc.
result = client.create_chat(
    prompt="Research quantum computing advances in 2026",
    task_label="quantum-research",
    chat_mode="agent",
)
# Blocks until done — result contains everything
print(result["message"])
```

### Credit Usage

CellCog orchestrates 21+ frontier foundation models. Credit consumption is unpredictable and varies by task complexity. Credits used are reported in every completion notification.

---

## Creating Tasks

### Notify on Completion (OpenClaw — Fire-and-Forget)

Returns immediately. A background daemon monitors via WebSocket and delivers results to your session when done. Your agent stays free to take new instructions, start other tasks, or continue working.

```python
result = client.create_chat(
    prompt="Your task description",
    notify_session_key="agent:main:main",   # Required — your OpenClaw session key
    task_label="my-task",                   # Label shown in notifications
    chat_mode="agent",
)
```

**Requires** OpenClaw Gateway with `sessions_send` enabled (disabled by default since OpenClaw 2026.4). See OpenClaw Reference below for one-time setup.

### Wait for Completion (Universal)

Blocks until CellCog finishes. Works with any agent — OpenClaw, Cursor, Claude Code, or any Python environment.

```python
result = client.create_chat(
    prompt="Your task description",
    task_label="my-task",
    chat_mode="agent",
    timeout=1800,                           # 30 min (default). Use 3600 for complex jobs.
)
print(result["message"])
print(result["status"])                     # "completed" | "timeout"
```

### When to Use Which

| Scenario | Best Mode | Why |
|----------|-----------|-----|
| OpenClaw + long task + stay free | **Notify** | Agent keeps working, gets notified when done |
| OpenClaw + chaining steps (research → summarize → PDF) | **Wait** | Each step feeds the next — simpler sequential workflows |
| OpenClaw + quick task | **Either** | Both return fast for simple tasks |
| Non-OpenClaw agent | **Wait** | Only option — no `sessions_send` available |

**Notify mode** is more productive (agent never blocks) but requires gateway configuration.
**Wait mode** is simpler to reason about, but blocks your agent for the duration.

### Continuing a Conversation

```python
# Wait mode (default)
result = client.send_message(
    chat_id="abc123",
    message="Focus on hardware advances specifically",
)

# Notify mode (OpenClaw)
result = client.send_message(
    chat_id="abc123",
    message="Focus on hardware advances specifically",
    notify_session_key="agent:main:main",
    task_label="continue-research",
)
```

### Resuming After Timeout

If `create_chat()` or `wait_for_completion()` times out, CellCog is still working. The timeout response includes recent progress:

```python
completion = client.wait_for_completion(chat_id="abc123", timeout=1800)
```

### Optional Parameters

```python
result = client.create_chat(
    prompt="...",
    task_label="...",
    chat_mode="agent",                      # See Chat Modes below
)
```

---

## Response Shape

Every SDK method returns the same shape:

```python
{
    "chat_id": str,        # CellCog chat ID
    "is_operating": bool,  # True = still working, False = done
    "status": str,         # "completed" | "tracking" | "timeout" | "operating"
    "message": str,        # THE printable message — always print this in full
}
```

**⚠️ Always print the entire `result["message"]`.** Truncating or summarizing it will lose critical information including generated file paths, credits used, and follow-up instructions.

### Utility Methods

**`get_history(chat_id)`** — Full chat history (when original delivery was missed or you need to review). Returns the same shape; if still operating, `message` shows progress so far.

```python
result = client.get_history(chat_id="abc123")
```

**`get_status(chat_id)`** — Lightweight status check (no history fetch):

```python
status = client.get_status(chat_id="abc123")
print(status["is_operating"])  # True/False
```

---

## Chat Modes

| Mode | Best For | Speed | Min Credits |
|------|----------|-------|-------------|
| `"agent"` | Most tasks — images, audio, dashboards, spreadsheets, presentations | Fast (seconds to minutes) | 100 |
| `"agent core"` | Coding, co-work, terminal operations | Fast | 50 |
| `"agent team"` | Deep research & multi-angled reasoning across every modality | Slower (5-60 min) | 500 |
| `"agent team max"` | High-stakes work where extra reasoning depth justifies the cost | Slowest | 2,000 |

- **`"agent"` (default)** — Most versatile. Handles most tasks excellently, including deep research when guided.
- **`"agent core"`** — Lightweight context for code, terminal, and file operations. Multimedia tools load on demand. Requires Co-work (CellCog Desktop). See `code-cog`.
- **`"agent team"`** — A team of agents that debates, cross-validates, and delivers comprehensive results. The only platform with deep reasoning across every modality.
- **`"agent team max"`** — Same Agent Team with all settings maxed. Quality gain is incremental (5-10%) but meaningful for costly decisions.

---

## Working with Files

### Input: SHOW_FILE

Include local file paths in your prompt with `<SHOW_FILE>` tags (absolute paths required):

```python
prompt = """
Analyze this sales data and create a report:
<SHOW_FILE>/path/to/sales.csv</SHOW_FILE>
"""
```

### Output: GENERATE_FILE

Use `<GENERATE_FILE>` tags to specify where output files should be stored on your machine. Essential for deterministic workflows where the next step needs to know the file path in advance.

```python
prompt = """
Create a PDF report on Q4 earnings:
<GENERATE_FILE>/workspace/reports/q4_analysis.pdf</GENERATE_FILE>
"""
```

Output downloads to the specified path instead of default `~/.cellcog/chats/{chat_id}/`.

### File Downloads

The SDK automatically downloads files from CellCog responses:
- **If you used `GENERATE_FILE` tags:** Files download to the path you specified
- **Otherwise:** Files download to `~/.cellcog/chats/{chat_id}/`

Downloaded file paths appear in `result["message"]`. The SDK tracks seen messages — files are only downloaded once.

**If you missed files or need to re-sync:**
```python
result = client.get_history(chat_id="abc123")
```
`get_history()` re-processes the entire chat and downloads any missed files to their original destinations.

---

## Tips

### ⚠️ CellCog Web Fallback

Every chat is accessible at https://cellcog.ai. When work gets complex or the SDK hits issues, direct your human to the web platform to view, continue, or take over directly.

---

---

## OpenClaw Reference

### Session Keys

The `notify_session_key` tells CellCog where to deliver results:

| Context | Session Key |
|---------|-------------|
| Main agent | `"agent:main:main"` |
| Sub-agent | `"agent:main:subagent:{uuid}"` |
| Telegram DM | `"agent:main:telegram:dm:{id}"` |
| Discord group | `"agent:main:discord:group:{id}"` |

**Resilient delivery:** If your session ends before completion, results are automatically delivered to the parent session (e.g., sub-agent → main agent).

### Sending Messages During Processing

In notify mode, your agent is free — you can send additional instructions to an operating chat at any time:

```python
client.send_message(chat_id="abc123", message="Actually focus only on Q4 data",
    notify_session_key="agent:main:main", task_label="refine")

client.send_message(chat_id="abc123", message="Stop operation",
    notify_session_key="agent:main:main", task_label="cancel")
```

In wait mode, your agent is blocked and cannot send messages until the current call returns.

### Gateway Configuration (One-Time Setup)

OpenClaw 2026.4+ blocks `sessions_send` by default. CellCog requires it for notify mode delivery. Run once:

```bash
openclaw config set gateway.tools.allow '["sessions_send", "sessions_list"]'
```

Then restart the gateway. The SDK checks this before creating the chat and raises `GatewayConfigError` if blocked — with the exact fix command in the error message.

Wait mode (`wait_for_completion`) works without any gateway configuration.

---

## Support & Troubleshooting

For error handling, recovery patterns, ticket submission, and daemon troubleshooting:

```python
docs = client.get_support_docs()
```

AI data analysis and visualization powered by CellCog. Upload CSVs and get charts, dashboards, statistical reports, and clean data back. Data cleaning, exploratory analysis, hypothesis testing, ML model evaluation, dataset profiling, and data visualization. Full Python access. #1 on DeepResearch Bench (Apr 2026). Analyzes everything, presents it beautifully.

# Data Cog - Your Data Has Answers, CellCog Finds Them

Data analysis and visualization from uploaded files.

Most AI tools return code when you ask about data. CellCog returns answers — actual charts, clean datasets, statistical reports, and visual dashboards. Upload messy CSVs with a minimal prompt, and CellCog's coding agent explores your data, finds the patterns, and presents them beautifully. Full Python access for everything from data cleaning to ML model evaluation.

## How to Use

For your first CellCog task in a session, read the **cellcog** skill for the full SDK reference — file handling, chat modes, timeouts, and more.

**OpenClaw (fire-and-forget):**
```python
result = client.create_chat(
    prompt="[your task prompt]",
    notify_session_key="agent:main:main",
    task_label="my-task",
    chat_mode="agent",
)
```

**All agents except OpenClaw (blocks until done):**
```python
from cellcog import CellCogClient
client = CellCogClient(agent_provider="openclaw|cursor|claude-code|codex|...")
result = client.create_chat(
    prompt="[your task prompt]",
    task_label="my-task",
    chat_mode="agent",
)
print(result["message"])
```


---

## What Makes Data-Cog Different

### Code as Tool, Not as Output

Other AI tools give you Python code and say "run this." CellCog **runs the code for you** and delivers the results:

| Other AI Tools | Data-Cog |
|---------------|----------|
| "Here's a pandas script to analyze your data" | Here are your actual insights with charts |
| "Run this matplotlib code to see the chart" | Here's the chart, annotated with findings |
| "This SQL query will find outliers" | Found 23 outliers, here's what they mean |
| "You'll need scikit-learn for this" | Model trained, here's accuracy and feature importance |

You upload data. You get answers. The code runs behind the scenes.

---

## What Data Work You Can Do

### Exploratory Data Analysis

Understand your data fast:

- **Dataset Profiling**: "Analyze this CSV — distributions, missing values, outliers, correlations, and data quality summary"
- **Pattern Discovery**: "What patterns and trends exist in this sales data? Surprise me."
- **Anomaly Detection**: "Find unusual patterns in this server log data — what looks abnormal?"
- **Relationship Analysis**: "What factors most strongly correlate with customer churn in this dataset?"

**Example prompt:**
> "Analyze this dataset:
> <SHOW_FILE>/path/to/customer_data.csv</SHOW_FILE>
> 
> I don't know much about this data yet. Give me:
> - Overview: rows, columns, data types, missing values
> - Key distributions and summary statistics
> - Most interesting correlations
> - Any outliers or data quality issues
> - 3-5 insights that jump out
> 
> Present findings as an interactive HTML report with charts."

### Data Cleaning & Transformation

Wrangle messy data into shape:

- **Clean Messy Data**: "Clean this CSV — fix inconsistent date formats, handle missing values, remove duplicates, standardize column names"
- **Data Transformation**: "Pivot this transaction data into a monthly summary by product category"
- **Data Merging**: "Join these three CSV files on customer_id and create a unified dataset"
- **Feature Engineering**: "Create useful features from this raw data for predicting house prices"

**Example prompt:**
> "Clean and transform this dataset:
> <SHOW_FILE>/path/to/messy_data.csv</SHOW_FILE>
> 
> Issues I know about:
> - Dates are in mixed formats (MM/DD/YYYY and YYYY-MM-DD)
> - 'Revenue' column has some values with $ signs and commas
> - Duplicate rows exist
> - Missing values in 'Region' column
> 
> Clean it up and give me back a clean CSV plus a summary of what you changed."

### Statistical Analysis

Rigorous analysis with real numbers:

- **Hypothesis Testing**: "Is there a statistically significant difference in conversion rates between our A and B variants?"
- **Regression Analysis**: "What factors predict employee salary in this HR dataset? Build a regression model."
- **Time Series Analysis**: "Analyze this monthly revenue data — trend, seasonality, and forecast next 6 months"
- **Cohort Analysis**: "Create a cohort analysis showing user retention by signup month"

**Example prompt:**
> "I ran an A/B test on our checkout page:
> <SHOW_FILE>/path/to/ab_test_results.csv</SHOW_FILE>
> 
> Columns: user_id, variant (A or B), converted (0/1), revenue, timestamp
> 
> Tell me:
> - Is variant B statistically better? (p-value, confidence interval)
> - Conversion rate difference
> - Revenue per user difference
> - Sample size adequacy check
> - My recommendation: ship B or keep testing?
> 
> Present with clear charts and a plain-English conclusion."

### Visualization & Reporting

Turn data into visual stories:

- **Chart Generation**: "Create a set of charts showing our quarterly performance from this data"
- **Dashboard Reports**: "Build an interactive dashboard from this sales dataset with filters by region and product"
- **Presentation-Ready Visuals**: "Create publication-quality charts from this research data"
- **Comparison Visuals**: "Visualize how our metrics compare to industry benchmarks"

### Machine Learning

Applied ML without the setup:

- **Classification**: "Predict which customers will churn based on this dataset — train a model, show feature importance"
- **Clustering**: "Segment these customers into groups based on behavior — how many natural clusters exist?"
- **Forecasting**: "Forecast next quarter's sales using this historical data"
- **Model Evaluation**: "I trained a model — here are the predictions. Evaluate: accuracy, precision, recall, confusion matrix, ROC curve"

**Example prompt:**
> "Predict customer churn from this dataset:
> <SHOW_FILE>/path/to/customer_features.csv</SHOW_FILE>
> 
> Target column: 'churned'
> 
> - Train a model, try at least 2 algorithms
> - Show feature importance — what drives churn?
> - Confusion matrix and ROC curve
> - Plain-English summary: 'The top 3 reasons customers churn are...'
> - Actionable recommendations based on findings
> 
> I want insights, not just metrics."

---

## Supported Data Formats

| Format | How to Send |
|--------|-------------|
| **CSV** | Upload via SHOW_FILE |
| **Excel (XLSX)** | Upload via SHOW_FILE |
| **JSON** | Upload via SHOW_FILE |
| **Parquet** | Upload via SHOW_FILE |
| **SQL exports** | Upload the dump via SHOW_FILE |
| **Inline data** | Describe small datasets directly in prompt |

---

## Output Formats

| Format | Best For |
|--------|----------|
| **Interactive HTML Dashboard** | Explorable charts, filters, drill-downs |
| **PDF Report** | Shareable analysis reports with charts and findings |
| **Clean CSV/XLSX** | Cleaned or transformed data files for downstream use |
| **Markdown** | Quick insights for integration into docs |

---

## Chat Mode for Data

| Scenario | Recommended Mode |
|----------|------------------|
| Quick data cleaning, simple charts, basic statistics | `"agent"` |
| Deep analysis with multiple techniques, ML modeling, comprehensive reports | `"agent team"` |

**Use `"agent"` for most data work.** Data cleaning, EDA, chart generation, and standard statistical analysis execute well in agent mode.

**Use `"agent team"` for complex analytical projects** — multi-technique analysis, ML model comparisons, or when you need deep domain reasoning about what the data means.

---

## Example Prompts

**Minimal prompt, maximum insight:**
> "Analyze this:
> <SHOW_FILE>/path/to/data.csv</SHOW_FILE>
> 
> Tell me everything interesting."

That's it. CellCog's coding agent will profile the data, run exploratory analysis, find patterns, and present findings with charts. You don't need to know what to ask — the agent figures it out.

**Business analysis:**
> "Analyze our e-commerce data:
> <SHOW_FILE>/path/to/orders.csv</SHOW_FILE>
> 
> I need:
> - Revenue trends (daily, weekly, monthly)
> - Best and worst performing products
> - Customer purchase frequency distribution
> - Average order value trends
> - Seasonal patterns
> - Top 5 actionable insights for growing revenue
> 
> Interactive HTML dashboard with all charts."

**Research data analysis:**
> "Analyze this survey data from 500 respondents:
> <SHOW_FILE>/path/to/survey.csv</SHOW_FILE>
> 
> Research questions:
> 1. Is there a significant relationship between age group and product preference?
> 2. Do satisfaction scores differ by region? (ANOVA)
> 3. What factors best predict likelihood to recommend? (regression)
> 
> Include: statistical tests, p-values, effect sizes, and publication-ready charts.
> PDF report format."

---

## Tips for Better Data Analysis

1. **Just upload and ask**: You don't need to describe every column. CellCog reads the data and figures out what's there.

2. **State your question**: "What drives churn?" is more focused than "Analyze this data." Both work, but the first gets faster results.

3. **Mention the audience**: "For my CEO" means executive summary. "For the data team" means show the methodology.

4. **Specify what you'll do with it**: "I need to present this to the board" vs "I need clean data for my ML pipeline" — context shapes the output.

5. **Don't over-specify methods**: Let CellCog choose the right statistical approach. Say what you want to *learn*, not which algorithm to use.

6. **Iterate**: Upload data → get initial analysis → ask follow-up questions → go deeper. CellCog maintains context across messages.

---

## If CellCog is not installed

Run `/cellcog-setup` (or `/cellcog:cellcog-setup` depending on your tool) to install and authenticate.
**OpenClaw users:** Run `clawhub install cellcog` instead.
**Manual setup:** `pip install -U cellcog` and set `CELLCOG_API_KEY`. See the **cellcog** skill for SDK reference.

AI diagram generator — flowcharts, system architecture, mind maps, org charts, ER diagrams, sequence diagrams, Gantt charts, network diagrams. Describe your system in plain English, get interactive zoomable diagrams or print-ready PDFs. No Visio, no Lucidchart. Powered by CellCog's frontier coding agent and app deployment infrastructure.

# Diagram Cog - Describe It in Words, Get It as a Diagram

Describe your system, process, or idea in plain English — CellCog produces professional, interactive diagrams you can share with a URL.

No Visio. No Lucidchart. No dragging boxes around for hours. Just describe what you need, and CellCog renders it as an interactive web page you can zoom, pan, and click — or a print-ready PDF for documentation.

## How to Use

For your first CellCog task in a session, read the **cellcog** skill for the full SDK reference — file handling, chat modes, timeouts, and more.

**OpenClaw (fire-and-forget):**
```python
result = client.create_chat(
    prompt="[your task prompt]",
    notify_session_key="agent:main:main",
    task_label="my-task",
    chat_mode="agent",
)
```

**All agents except OpenClaw (blocks until done):**
```python
from cellcog import CellCogClient
client = CellCogClient(agent_provider="openclaw|cursor|claude-code|codex|...")
result = client.create_chat(
    prompt="[your task prompt]",
    task_label="my-task",
    chat_mode="agent",
)
print(result["message"])
```


---

## Why Diagrams Are Hard

Creating good diagrams manually is surprisingly painful:

- **Layout is tedious**: Arranging boxes, arrows, and labels takes longer than the thinking itself
- **Tools are complex**: Visio, Lucidchart, Draw.io all have learning curves
- **Iteration is slow**: Changing one element cascades into repositioning everything
- **Sharing is friction**: Export → attach → hope it renders on their device

CellCog eliminates all of this. Describe your diagram in words, get a shareable interactive URL. Need to change something? Just ask.

---

## What Makes This Different

Other AI diagram tools output a static image. CellCog does something fundamentally different.

CellCog **reasons about your system, picks the right rendering approach, and deploys an interactive web application** you can share with a URL. Zoom into your microservices architecture. Click a node to see details. Pan across a sprawling org chart. Or export to a print-ready PDF for your board deck.

| What You Ask For | What CellCog Actually Does |
|-----------------|---------------------------|
| "Diagram my microservices" | Reasons about the architecture → generates Mermaid/D3 code → deploys interactive web app → delivers shareable URL |
| "Flowchart for our hiring process" | Analyzes the process → renders with proper decision logic → color-codes paths → interactive HTML with click states |
| "ER diagram for my database" | Understands entity relationships → generates diagram with cardinality → exports as both interactive HTML and PDF |
| "Mind map for brainstorming" | Explores the topic → creates hierarchical structure → deploys zoomable, expandable mind map |

The power comes from having a world-class coding agent, multiple rendering libraries (Mermaid.js, D3.js, custom SVG, Highcharts), and built-in app deployment — all orchestrated together. When standard tools fall short, the agent writes custom code.

---

## What Diagrams You Can Create

### Flowcharts & Process Flows

Visualize any process or decision tree:

- **Business Processes**: "Create a flowchart for our customer onboarding process — from signup to first value"
- **Decision Trees**: "Build a decision tree for our support team to triage incoming tickets"
- **User Flows**: "Create a user flow diagram for the checkout process in our e-commerce app"
- **Approval Workflows**: "Diagram our expense approval workflow — who approves what at each dollar threshold"
- **Troubleshooting Guides**: "Create a troubleshooting flowchart for common API integration errors"

**Example prompt:**
> "Create an interactive flowchart for our hiring process:
> 
> Steps:
> 1. Job posted → Applications received
> 2. Resume screening (HR) → Pass/Fail
> 3. Phone screen (Recruiter) → Pass/Fail
> 4. Technical interview (Engineering) → Pass/Fail
> 5. Culture interview (Team) → Pass/Fail
> 6. Offer → Accept/Decline
> 7. If decline → Back to step 2 with next candidate
> 
> Color-code: Green for forward progress, red for rejection paths, yellow for decision points.
> Include average time at each stage."

### System Architecture

Technical diagrams for engineering teams:

- **Microservices**: "Diagram our microservices architecture showing all services, their communication patterns, and data stores"
- **Cloud Infrastructure**: "Create an AWS architecture diagram for our production environment — VPC, ECS, RDS, ElastiCache, CloudFront"
- **Data Pipelines**: "Diagram our data pipeline from raw ingestion through transformation to the analytics warehouse"
- **API Architecture**: "Create an API gateway architecture showing routing, authentication, and rate limiting"
- **CI/CD Pipelines**: "Diagram our deployment pipeline from git push to production"

**Example prompt:**
> "Create a system architecture diagram for a SaaS application:
> 
> Frontend: React app on CloudFront/S3
> API: FastAPI on ECS Fargate behind ALB
> Auth: Firebase Authentication
> Database: PostgreSQL on RDS (primary + read replica)
> Cache: Redis on ElastiCache
> Queue: SQS for async jobs
> Workers: Celery on ECS
> Storage: S3 for user uploads
> Monitoring: CloudWatch + Datadog
> 
> Show the data flow between components with arrows.
> Group by VPC / public / external.
> Interactive — I want to be able to zoom into each component."

### Mind Maps & Concept Maps

Brainstorm and organize ideas:

- **Brainstorming**: "Create a mind map exploring all possible revenue streams for our SaaS product"
- **Topic Exploration**: "Build a concept map of machine learning — main branches, sub-topics, and relationships"
- **Content Planning**: "Create a mind map for our Q2 content strategy — blog, social, video, email"
- **Strategy Mapping**: "Map our go-to-market strategy showing channels, messaging, and target segments"

**Example prompt:**
> "Create an interactive mind map for 'AI in Healthcare':
> 
> Central node: AI in Healthcare
> 
> Main branches:
> - Diagnostics (imaging, pathology, genomics)
> - Drug Discovery (target identification, clinical trials, molecule design)
> - Patient Care (chatbots, monitoring, personalized medicine)
> - Operations (scheduling, billing, supply chain)
> - Research (literature mining, clinical data analysis)
> 
> Each branch should have 3-5 sub-topics with brief descriptions.
> Color-code by maturity: green = in production, yellow = clinical trials, red = research stage."

### Org Charts

Visualize organizational structure:

- **Company Hierarchy**: "Create an org chart for a 50-person startup showing all departments and reporting lines"
- **Team Structure**: "Diagram our engineering team structure — squads, tech leads, and cross-functional relationships"
- **Matrix Organization**: "Create an org chart showing both functional reporting and project reporting lines"

### UML Diagrams

Software engineering diagrams:

- **Sequence Diagrams**: "Create a sequence diagram showing the OAuth 2.0 authorization code flow"
- **Class Diagrams**: "Diagram the class hierarchy for our e-commerce domain model — Product, Order, Customer, Payment"
- **State Diagrams**: "Create a state diagram for an order lifecycle — placed, paid, shipped, delivered, returned"
- **Activity Diagrams**: "Diagram the activity flow for our data processing pipeline"

**Example prompt:**
> "Create a sequence diagram for a payment processing flow:
> 
> Actors: User, Frontend, API Server, Payment Service, Stripe, Database
> 
> Flow:
> 1. User clicks 'Pay' → Frontend sends payment request to API
> 2. API creates payment intent with Stripe
> 3. Stripe returns client secret
> 4. API sends client secret to Frontend
> 5. Frontend confirms payment with Stripe.js
> 6. Stripe sends webhook to API
> 7. API updates order status in Database
> 8. API sends confirmation email to User
> 
> Include error paths: payment declined, webhook timeout."

### ER Diagrams

Database design and data modeling:

- **Database Schema**: "Create an ER diagram for a social media platform — users, posts, comments, likes, follows"
- **Data Models**: "Diagram the data model for our inventory management system"
- **Entity Relationships**: "Create an ER diagram showing the relationships between customers, orders, products, and suppliers"

### Network Diagrams

IT infrastructure visualization:

- **Network Topology**: "Create a network diagram showing our office network — firewalls, switches, VLANs, wireless APs"
- **Security Zones**: "Diagram our network security zones — DMZ, internal, management, guest"
- **Cloud Networking**: "Create a network diagram for our multi-VPC AWS setup with peering and transit gateway"

### Gantt Charts & Timelines

Project planning and scheduling:

- **Project Timelines**: "Create a Gantt chart for our 6-month product launch — design, development, testing, marketing, launch"
- **Sprint Planning**: "Diagram our next 3 sprints with epics, stories, and dependencies"
- **Roadmaps**: "Create a product roadmap timeline for 2026 showing quarterly milestones"

### Swimlane Diagrams

Cross-functional process visualization:

- **Cross-Team Workflows**: "Create a swimlane diagram showing how a customer support ticket flows between Support, Engineering, and Product teams"
- **RACI Charts**: "Diagram our incident response process with swimlanes for each role"

### User Journey Maps

Customer experience visualization:

- **End-to-End Journeys**: "Create a user journey map for a customer discovering, evaluating, purchasing, and onboarding to our product"
- **Touchpoint Mapping**: "Map all customer touchpoints across email, web, app, and support"

---

## Output Formats

| Format | Features | Best For |
|--------|----------|----------|
| **Interactive HTML** | Zoom, pan, click, hover, responsive, shareable via URL | Presentations, team sharing, exploration |
| **PDF** | Print-ready, static, professional | Documentation, email attachments, printing |

CellCog defaults to interactive HTML — the whole point is diagrams you can explore, not static images. Request PDF explicitly when you need print-ready output.

---

## Chat Mode for Diagrams

| Scenario | Recommended Mode |
|----------|------------------|
| Individual diagrams — flowcharts, org charts, ER diagrams, mind maps | `"agent"` |
| Complex multi-diagram documentation, full system design docs with multiple views | `"agent team"` |

**Use `"agent"` for most diagrams.** Individual flowcharts, architecture diagrams, and org charts execute well in agent mode.

**Use `"agent team"` for comprehensive documentation** — when you need multiple interconnected diagrams that form a complete system design document.

---

## Example Prompts

**Quick flowchart:**
> "Create a flowchart for returning a product on our e-commerce site. Include: initiate return → reason selection → approval check → shipping label → refund processing → confirmation. Show the happy path and the rejection path."

**Architecture diagram:**
> "Diagram our production infrastructure:
> 
> Load Balancer → 3 API servers → PostgreSQL (primary + replica)
> API servers also talk to Redis cache and S3 for file storage
> Background workers pull from SQS queue
> Everything monitored by Datadog
> 
> Show it as a clean architecture diagram with arrows showing data flow direction."

**Mind map:**
> "Create a mind map for planning a product launch:
> 
> Center: Product Launch
> Branches: Marketing, Engineering, Sales, Support, Legal
> Each branch should have 4-6 specific tasks
> Color-code by priority: red = critical path, yellow = important, green = nice to have"

**Database ER diagram:**
> "Create an ER diagram for a project management tool:
> 
> Entities: User, Organization, Project, Task, Comment, Attachment, Label
> 
> Key relationships:
> - Users belong to Organizations (many-to-many)
> - Projects belong to Organizations
> - Tasks belong to Projects, assigned to Users
> - Comments belong to Tasks, created by Users
> - Tasks can have multiple Labels (many-to-many)
> 
> Show primary keys, foreign keys, and cardinality."

---

## Tips for Better Diagrams

1. **Describe the components and relationships**: "A connects to B which talks to C" is all CellCog needs. Don't worry about layout.

2. **Specify the diagram type**: "Flowchart", "sequence diagram", "ER diagram" — naming the type helps CellCog choose the right rendering approach.

3. **Include data flow direction**: For architecture diagrams, mention which way data flows. "Frontend → API → Database" is clearer than just listing components.

4. **Request interactivity**: "I want to zoom in" or "clickable components" tells CellCog to build an interactive experience.

5. **Color-coding helps**: "Color-code by team" or "green for success paths, red for error paths" makes diagrams immediately useful.

6. **Think about audience**: "For the engineering team" vs. "for the board presentation" changes the level of technical detail.

---

## If CellCog is not installed

Run `/cellcog-setup` (or `/cellcog:cellcog-setup` depending on your tool) to install and authenticate.
**OpenClaw users:** Run `clawhub install cellcog` instead.
**Manual setup:** `pip install -U cellcog` and set `CELLCOG_API_KEY`. See the **cellcog** skill for SDK reference.

AI document generation powered by CellCog — PDF by default, native DOCX when you need it. Create resumes, contracts, reports, proposals, invoices, certificates, NDAs, letters, brochures, and any professional document. Beautiful design with accurate, researched content. #1 on DeepResearch Bench (Apr 2026).

# Docs Cog - Professional Documents Powered by CellCog

**Deep reasoning. Accurate data. Beautiful design.** The three things every great document needs — and most AI gets wrong.

Professional document generation — PDF by default, native DOCX on request. Deep research fills content from minimal prompts. Resumes, contracts, reports, proposals — delivered in minutes.

## How to Use

For your first CellCog task in a session, read the **cellcog** skill for the full SDK reference — file handling, chat modes, timeouts, and more.

**OpenClaw (fire-and-forget):**
```python
result = client.create_chat(
    prompt="[your task prompt]",
    notify_session_key="agent:main:main",
    task_label="my-task",
    chat_mode="agent",
)
```

**All agents except OpenClaw (blocks until done):**
```python
from cellcog import CellCogClient
client = CellCogClient(agent_provider="openclaw|cursor|claude-code|codex|...")
result = client.create_chat(
    prompt="[your task prompt]",
    task_label="my-task",
    chat_mode="agent",
)
print(result["message"])
```


---

## Output Formats

CellCog generates professional documents in multiple formats:

### PDF (Default for Ambiguous Requests)

When you say "create a report" or "make a document" without specifying a format, CellCog generates PDF — perfect typography, layouts, and design with full creative control.

### DOCX (First-Class Support)

When you explicitly request DOCX ("create a Word document", "make a .docx"), CellCog generates native Word directly — editable, compatible with Microsoft Word and Google Docs, great for collaborative workflows where multiple people contribute.

**Just ask for DOCX and you'll get it.** No need to justify why you want an editable format.

---

## What Documents You Can Create

### Resume & Career Documents

Build your professional story:

- **Resume/CV**: "Create a modern resume for a software engineer with 5 years of experience"
- **Cover Letter**: "Write a compelling cover letter for a product manager position at Google"
- **LinkedIn Summary**: "Create a professional LinkedIn summary that highlights my transition from finance to tech"
- **Portfolio**: "Build a portfolio document showcasing my UX design projects"

**Example prompt:**
> "Create a modern, ATS-friendly resume for:
> 
> Name: Sarah Chen
> Title: Senior Product Manager
> Experience: 7 years in B2B SaaS
> 
> Work history:
> - Stripe (2021-present): Led payments platform, grew revenue 40%
> - Slack (2018-2021): Launched enterprise features
> - Microsoft (2016-2018): Associate PM on Azure
> 
> Education: Stanford MBA, UC Berkeley CS
> 
> Clean, professional design with blue accents."

### Business Documents

Professional business materials:

- **Proposals**: "Create a consulting proposal for a digital transformation project"
- **Invoices**: "Generate an invoice template for my freelance design business"
- **Business Letters**: "Write a formal partnership inquiry letter"
- **Quotes & Estimates**: "Create a detailed quote for website development services"
- **Meeting Minutes**: "Format these meeting notes into professional minutes"

**Example prompt:**
> "Create a business proposal for 'CloudMigrate' consulting services:
> 
> Client: Acme Corp
> Project: AWS cloud migration
> Timeline: 6 months
> Budget: $150,000
> 
> Include: Executive summary, scope of work, timeline, team bios, pricing breakdown, terms.
> 
> Professional, corporate design."

### Reports & Analysis

Data-driven documents:

- **Business Reports**: "Create a quarterly business review report"
- **Research Reports**: "Format my research findings into a professional report"
- **Analysis Documents**: "Create a competitive analysis document"
- **White Papers**: "Build a white paper on AI in healthcare"
- **Case Studies**: "Create a customer case study showcasing ROI"

**Example prompt:**
> "Create a Q4 2025 business report:
> 
> Title: Quarterly Performance Review
> Company: TechStart Inc.
> 
> Key metrics:
> - Revenue: $2.1M (up 35% YoY)
> - Customers: 150 (up from 98)
> - Churn: 5% (down from 8%)
> 
> Include charts and executive summary. Corporate professional style."

### Legal & Finance Documents

Formal agreements and contracts:

- **Contracts**: "Create a freelance services agreement"
- **NDAs**: "Generate a mutual non-disclosure agreement"
- **Terms of Service**: "Draft terms of service for my SaaS app"
- **Privacy Policies**: "Create a GDPR-compliant privacy policy"
- **MOUs**: "Create a memorandum of understanding between two companies"

**Example prompt:**
> "Create a freelance contractor agreement:
> 
> Client: Acme Corp
> Contractor: Jane Smith (Web Developer)
> Project: E-commerce website redesign
> Duration: 3 months
> Payment: $15,000 (50% upfront, 50% on completion)
> 
> Include: Scope, deliverables, payment terms, IP ownership, confidentiality, termination clauses.
> 
> Professional legal formatting."

### Creative & Marketing Documents

Eye-catching marketing materials:

- **Brochures**: "Create a tri-fold brochure for our fitness studio"
- **Flyers**: "Design a promotional flyer for our summer sale"
- **One-Pagers**: "Create a product one-pager for sales team"
- **Media Kits**: "Build a media kit for our startup"
- **Catalogs**: "Create a product catalog with 20 items"

**Example prompt:**
> "Create a product one-pager for 'TaskFlow' project management software:
> 
> Headline: Finally, a PM tool that doesn't suck
> Key features: AI task prioritization, Slack integration, real-time collaboration
> Pricing: $12/user/month
> Call to action: Start free trial
> 
> Modern, bold design. Blue and white color scheme."

### Education & Training Documents

Learning materials:

- **Lesson Plans**: "Create a lesson plan for teaching Python basics"
- **Training Manuals**: "Build an employee onboarding manual"
- **Worksheets**: "Create practice worksheets for algebra"
- **Course Outlines**: "Design a 12-week data science curriculum"
- **Study Guides**: "Create a study guide for AWS certification"

### Events & Planning Documents

Event materials:

- **Invitations**: "Create elegant wedding invitations"
- **Event Programs**: "Design a conference program booklet"
- **Agendas**: "Create a workshop agenda document"
- **Itineraries**: "Build a detailed travel itinerary"
- **Certificates**: "Create achievement certificates for our hackathon"

### Forms & Certificates

Official documents:

- **Certificates**: "Create a course completion certificate"
- **Awards**: "Design employee of the month award"
- **Badges**: "Create digital badges for our training program"
- **Forms**: "Design a customer feedback form"

---

## Chat Mode for Documents

| Scenario | Recommended Mode |
|----------|------------------|
| Standard documents - resumes, invoices, reports, certificates | `"agent"` |
| Complex documents requiring narrative craft - proposals, white papers, case studies | `"agent team"` |

**Use `"agent"` for most documents.** Resumes, contracts, reports, and standard business documents execute well in agent mode.

**Use `"agent team"` for high-stakes documents** where persuasion and narrative flow matter—investor proposals, detailed white papers, compelling case studies.

---

## Tips for Better Documents

1. **Provide the content**: Don't say "write about my experience" - provide actual details, numbers, and facts.

2. **Specify structure**: "Include: Executive summary, problem, solution, timeline, pricing" gives clear direction.

3. **Design preferences**: "Modern and minimal", "Corporate professional", "Bold and colorful" - describe what you want.

4. **Brand elements**: Mention colors, logos (upload them), or reference existing brand guidelines.

5. **Audience context**: "For investors", "For enterprise clients", "For students" changes tone and detail level.

6. **Choose your format**: PDF is the default for polished output. Request DOCX when your team needs to edit or customize the document.

---

## If CellCog is not installed

Run `/cellcog-setup` (or `/cellcog:cellcog-setup` depending on your tool) to install and authenticate.
**OpenClaw users:** Run `clawhub install cellcog` instead.
**Manual setup:** `pip install -U cellcog` and set `CELLCOG_API_KEY`. See the **cellcog** skill for SDK reference.

Other tools generate sprites. CellCog builds game worlds. #1 on DeepResearch Bench (Apr 2026) for deep game design reasoning — character-consistent art, sprites, tilesets, music, UI, 3D models, GDDs, level design, and game prototypes, all cohesive across every asset.

# Game Cog - Build Game Worlds, Not Just Sprites

Game development assets and prototypes with character consistency across all assets.

Game development is a multi-discipline problem — mechanics, art, music, UI, and level design all need to feel unified. CellCog reasons deeply about your game's vision first, then produces character-consistent art, tilesets, music, sound effects, UI elements, 3D models, and full game design documents — all cohesive from a single brief.

## How to Use

For your first CellCog task in a session, read the **cellcog** skill for the full SDK reference — file handling, chat modes, timeouts, and more.

**OpenClaw (fire-and-forget):**
```python
result = client.create_chat(
    prompt="[your task prompt]",
    notify_session_key="agent:main:main",
    task_label="my-task",
    chat_mode="agent",
)
```

**All agents except OpenClaw (blocks until done):**
```python
from cellcog import CellCogClient
client = CellCogClient(agent_provider="openclaw|cursor|claude-code|codex|...")
result = client.create_chat(
    prompt="[your task prompt]",
    task_label="my-task",
    chat_mode="agent",
)
print(result["message"])
```


---

## What You Can Create

### Character Design

Bring your game characters to life:

- **Player Characters**: "Design a cyberpunk samurai protagonist with multiple poses"
- **NPCs**: "Create a friendly merchant character for a fantasy RPG"
- **Enemies**: "Design a boss monster - corrupted tree guardian"
- **Character Sheets**: "Create a full character sheet with idle, run, attack poses"
- **Portraits**: "Generate dialogue portraits for my visual novel cast"

**Example prompt:**
> "Design a main character for a cozy farming game:
> 
> Style: Stardew Valley / pixel art inspired but higher resolution
> Character: Young farmer, customizable gender, friendly expression
> 
> Need:
> - Front, back, side views
> - Idle pose
> - Walking animation frames (4 directions)
> - Tool-holding poses (hoe, watering can)
> 
> Color palette: Warm, earthy tones"

### Environment & Tiles

Build your game worlds:

- **Tilesets**: "Create a forest tileset for a top-down RPG"
- **Backgrounds**: "Design parallax backgrounds for a side-scroller"
- **Level Concepts**: "Create concept art for a haunted mansion level"
- **Props**: "Generate decorative props for a medieval tavern"
- **UI Elements**: "Design health bars, inventory slots, and buttons"

**Example prompt:**
> "Create a tileset for a dungeon crawler:
> 
> Style: 16-bit inspired, dark fantasy
> 
> Include:
> - Floor tiles (stone, dirt, water)
> - Wall tiles (brick, cave, decorated)
> - Doors (wooden, iron, magic)
> - Props (torches, chests, barrels, bones)
> - Traps (spikes, pressure plates)
> 
> All tiles should seamlessly connect."

### Game Concepts

Develop your game ideas:

- **Game Design Documents**: "Create a GDD for a roguelike deckbuilder"
- **Story Outlines**: "Write the main storyline for a sci-fi RPG"
- **Mechanics Design**: "Design a unique combat system for my action game"
- **World Building**: "Create the lore for a post-apocalyptic world"
- **Pitch Decks**: "Build a pitch deck for my indie game to show publishers"

**Example prompt:**
> "Create a game design document for a mobile puzzle game:
> 
> Core concept: Match-3 meets city building
> Target: Casual players, 5-minute sessions
> 
> Include:
> - Core loop explanation
> - Progression system
> - Monetization strategy (ethical F2P)
> - First 10 levels design
> - Art style recommendations
> 
> Reference games: Gardenscapes meets SimCity"

### 3D Models & Assets

Production-ready 3D models in GLB format for your game engine:

- **Characters**: "Create a 3D model of my RPG protagonist"
- **Weapons & Items**: "Generate 3D weapon models — sword, axe, bow, staff"
- **Props**: "Create 3D dungeon props — chests, barrels, torches"
- **Vehicles**: "Build a low-poly spaceship for my mobile game"
- **Environment pieces**: "Generate 3D trees, rocks, and buildings for my world"

CellCog handles the full pipeline — describe what you want, and it generates optimized reference images then converts to textured 3D models. Batch generation supported (e.g., "create 10 weapon models").

GLB output works with Unity, Unreal, Godot, Three.js, and Blender. Specify poly count and PBR materials for your target platform.

For dedicated 3D generation workflows, also check out `3d-cog`.

### Sprites & Animation

Assets ready for your game engine:

- **Sprite Sheets**: "Create a sprite sheet for a ninja character"
- **Animated Effects**: "Design explosion and hit effect animations"
- **Items**: "Generate icons for weapons, potions, and armor"
- **Particle Effects**: "Create magic spell effect concepts"

### UI/UX Design

Make your game feel polished:

- **Main Menus**: "Design a main menu for a horror game"
- **HUD Elements**: "Create health, mana, and stamina bars"
- **Inventory Systems**: "Design an inventory UI for a survival game"
- **Dialogue Boxes**: "Create dialogue UI for a visual novel"

---

## Art Styles

| Style | Best For | Characteristics |
|-------|----------|-----------------|
| **Pixel Art** | Retro, indie | Nostalgic, clear, limited palette |
| **Hand-Painted** | RPGs, fantasy | Rich, detailed, artistic |
| **Vector/Flat** | Mobile, casual | Clean, scalable, modern |
| **Low Poly 3D** | Stylized 3D games | Geometric, distinctive |
| **Anime/Manga** | Visual novels, JRPGs | Expressive, stylized |
| **Realistic** | AAA-style | Detailed, immersive |
| **3D Models (GLB)** | Game engines, AR/VR | Textured, customizable topology and poly count |

---

## Chat Mode for Game Dev

| Scenario | Recommended Mode |
|----------|------------------|
| Individual assets, sprites, character designs, UI elements | `"agent"` |
| Full game concepts, complex world building, narrative design | `"agent team"` |

**Use `"agent"` for most game assets.** Characters, tilesets, UI elements execute well in agent mode.

**Use `"agent team"` for game design depth** - full GDDs, complex narratives, or when you need multiple creative angles explored.

---

## Example Prompts

**Full character design:**
> "Design an enemy type for my metroidvania:
> 
> Concept: Shadow creatures that emerge from walls
> Behavior: Ambush predator, retreats when hit
> 
> Need:
> - Concept art showing the creature emerging from shadow
> - Idle animation frames (lurking)
> - Attack animation frames
> - Death/dissolve animation
> 
> Style: Dark, fluid, unsettling but not gory (Teen rating)"

**Complete tileset:**
> "Create a complete tileset for a beach/tropical level:
> 
> Style: Bright, colorful, 32x32 pixel tiles
> 
> Include:
> - Sand (multiple variations)
> - Water (shallow, deep, animated waves)
> - Palm trees and tropical plants
> - Rocks and cliffs
> - Beach items (shells, starfish, umbrellas)
> - Wooden platforms/bridges
> 
> Should work for a platformer game."

**Game concept:**
> "Design a game concept: 'Wizard's Delivery Service'
> 
> Pitch: You're a wizard who delivers magical packages across a fantasy kingdom
> Genre: Cozy adventure / time management
> Platform: PC and Switch
> 
> I need:
> - Core gameplay loop
> - Progression systems
> - Character concepts for the wizard and NPCs
> - 3 sample delivery missions
> - Art style moodboard
> 
> Vibe: Studio Ghibli meets Overcooked"

---

## Tips for Better Game Assets

1. **Specify dimensions**: "32x32 tiles" or "1920x1080 background" prevents mismatched assets.

2. **Reference existing games**: "Style like Hollow Knight" or "Celeste-inspired" gives clear direction.

3. **Think about implementation**: Request assets in formats your engine can use. Mention if you need transparency, layers, or specific file types.

4. **Consistency matters**: When requesting multiple assets, describe your game's overall style guide so everything matches.

5. **Animation frames**: Specify frame count and whether you need sprite sheets or individual frames.

6. **Consider your scope**: Start with placeholder assets and iterate. Perfect is the enemy of shipped.

---

## If CellCog is not installed

Run `/cellcog-setup` (or `/cellcog:cellcog-setup` depending on your tool) to install and authenticate.
**OpenClaw users:** Run `clawhub install cellcog` instead.
**Manual setup:** `pip install -U cellcog` and set `CELLCOG_API_KEY`. See the **cellcog** skill for SDK reference.

AI image generation and photo editing powered by CellCog. Text-to-image, image-to-image, consistent characters, product photography, reference-based generation, style transfer, sets of images, social media visuals. Professional image creation with multiple AI models.

# Image Cog - AI Image Generation Powered by CellCog

Create professional images with AI - from single images to consistent character sets to product photography.

## How to Use

For your first CellCog task in a session, read the **cellcog** skill for the full SDK reference — file handling, chat modes, timeouts, and more.

**OpenClaw (fire-and-forget):**
```python
result = client.create_chat(
    prompt="[your task prompt]",
    notify_session_key="agent:main:main",
    task_label="my-task",
    chat_mode="agent",
)
```

**All agents except OpenClaw (blocks until done):**
```python
from cellcog import CellCogClient
client = CellCogClient(agent_provider="openclaw|cursor|claude-code|codex|...")
result = client.create_chat(
    prompt="[your task prompt]",
    task_label="my-task",
    chat_mode="agent",
)
print(result["message"])
```


---

## What Models Do We Use

| Model | Provider | Primary Use |
|-------|----------|-------------|
| **Nano Banana 2** (Gemini 3.1 Flash Image) | Google | Default image generation — photorealistic scenes, complex compositions, text rendering, multi-turn character consistency |
| **GPT Image 1.5** | OpenAI | Transparent background images — logos, stickers, product cutouts, overlay graphics |
| **Recraft** | Recraft AI | Scalable vector illustrations (SVG) and icon generation |

**Nano Banana 2** is the default model for all image generation. CellCog's agents intelligently route to other models when the task calls for it — for example, transparent PNGs are automatically handled by GPT Image 1.5, and vector/icon requests go to Recraft. If you'd prefer a specific model, just mention it in your prompt (e.g., *"use ChatGPT/OpenAI image generation"*).

## What Images You Can Create

### Single Image Creation

Generate any image from a text description:

- **Scenes**: "A cozy coffee shop interior with morning light streaming through windows"
- **Portraits**: "Professional headshot of a confident woman in business attire"
- **Products**: "Minimalist product shot of a white sneaker on a marble surface"
- **Abstract**: "Geometric abstract art in navy and gold"
- **Nature**: "Misty mountain landscape at sunrise with a lone hiker"

### Image Editing

Transform existing images:

- **Style Transfer**: "Transform this photo into a watercolor painting"
- **Background Removal**: "Remove the background and place on a clean white backdrop"
- **Enhancement**: "Enhance the colors and add dramatic lighting"
- **Modification**: "Change the person's outfit to a red dress"

### Consistent Characters

Create multiple images of the same character in different scenarios:

- **Character Series**: "Create a tech entrepreneur character, then show them: 1) At their desk coding, 2) Presenting to investors, 3) Celebrating a product launch"
- **Mascot Variations**: "Design a friendly robot mascot, then create versions for: welcome page, error page, success message, loading screen"
- **Story Sequences**: "Create a main character, then illustrate them in 5 scenes of a journey"

This is powerful for:
- Comic strips and storyboards
- Marketing campaigns with consistent characters
- Video frame generation
- Brand mascots across contexts

### Product Photography Style

Professional product visuals:

- **Hero Shots**: "Product hero shot of a smartwatch on a gradient background"
- **Lifestyle Shots**: "Smartphone being used by a person in a modern living room"
- **Flat Lays**: "Flat lay of skincare products with botanical elements"
- **360 Views**: "Multiple angles of a leather handbag - front, side, back, detail"

### Sets of Related Images

Multiple cohesive images for campaigns or collections:

- **Social Media Sets**: "5 Instagram post images for a fitness brand - consistent style, varied content"
- **Website Heroes**: "3 hero images for a SaaS landing page - professional, modern, tech-focused"
- **Ad Variations**: "4 versions of a product ad with different backgrounds and moods"
- **Blog Illustrations**: "Set of 6 illustrations for a blog post about productivity tips"

### Reference-Based Generation

Use existing images as references for style, character, or composition:

- **Style Matching**: "Create a new image in the same artistic style as this reference"
- **Character Consistency**: "Using this person as reference, create a new scene with them hiking"
- **Brand Alignment**: "Create product images matching this brand's visual style"
- **Composition Reference**: "Create a similar composition but with different subjects"

---

## Image Specifications

| Aspect | Options |
|--------|---------|
| **Aspect Ratios** | 1:1 (square), 16:9, 9:16, 4:3, 3:4, 3:2, 2:3, 21:9 |
| **Sizes** | 1K (~1024px), 2K (~2048px), 4K (~4096px) |
| **Styles** | Photorealistic, illustration, watercolor, oil painting, anime, digital art, vector |
| **Formats** | PNG (default) |

**Size recommendations:**
- **1K**: Quick iterations, thumbnails, social media posts, drafts
- **2K**: Standard web content, presentations, marketing materials
- **4K**: Hero images, print materials, final deliverables where detail matters

---

## When to Use Agent Team Mode

For image generation, `chat_mode="agent team"` is recommended for:
- Complex scenes requiring multiple elements
- Consistent character series
- Reference-based generation requiring analysis
- Sets of related images

For simple single images, `chat_mode="agent"` can work faster.

---

## Example Image Prompts

**Professional headshot:**
> "Create a professional headshot of a friendly Asian woman in her 30s, wearing a navy blazer, soft studio lighting, neutral gray background, confident but approachable expression. 1:1 square, 2K quality, photorealistic."

**Product photography:**
> "Product shot of a premium wireless earbuds case, matte black finish, on a reflective dark surface with subtle blue accent lighting. Minimalist, high-end tech aesthetic. 4:3 landscape, 4K for hero image."

**Consistent character set:**
> "Create a character: young Black male software developer, casual style with glasses, friendly demeanor. Then create 4 images:
> 1. Working at a standing desk with multiple monitors
> 2. In a video call meeting, explaining something
> 3. At a coffee shop with laptop, thinking
> 4. Celebrating with team, high-fiving
> Keep the character exactly consistent across all images."

**Social media set:**
> "Create 5 Instagram posts for a plant-based meal delivery service:
> 1. Colorful Buddha bowl from above
> 2. Happy person unpacking delivery
> 3. Meal prep containers arranged neatly
> 4. Close-up of fresh ingredients
> 5. Before/after showing ingredients to finished dish
> Style: bright, fresh, appetizing, consistent warm color grading. 1:1 square format."

**Style transfer:**
> "Transform this uploaded photo of a city street into a Studio Ghibli anime style illustration. Keep the composition and elements but apply the characteristic Ghibli warmth, soft clouds, and whimsical details."

---

## Tips for Better Images

1. **Be descriptive**: "Woman in office" is vague. "Confident woman in her 40s, silver blazer, modern glass-walled office, warm afternoon light" is better.

2. **Specify style**: "Photorealistic", "digital illustration", "watercolor", "minimalist vector".

3. **Describe lighting**: "Soft natural light", "dramatic side lighting", "golden hour glow", "studio lighting".

4. **Include mood**: "Professional and confident", "warm and inviting", "energetic and vibrant".

5. **Mention composition**: "Rule of thirds", "centered symmetry", "close-up", "wide establishing shot".

6. **For consistency**: When creating character series, describe the character in detail first, then reference "the same character" in subsequent prompts.

---

## If CellCog is not installed

Run `/cellcog-setup` (or `/cellcog:cellcog-setup` depending on your tool) to install and authenticate.
**OpenClaw users:** Run `clawhub install cellcog` instead.
**Manual setup:** `pip install -U cellcog` and set `CELLCOG_API_KEY`. See the **cellcog** skill for SDK reference.

Deep reasoning makes better comedy. #1 on DeepResearch Bench (Apr 2026). AI meme generation with audience targeting, trend research, and multi-angle humor. Create memes, viral content, reaction images, and internet humor that actually land.

# Meme Cog - Deep Reasoning Meets Internet Culture

Meme generation with audience targeting, trend research, and multi-angle humor.

Comedy requires timing, cultural awareness, and subverted expectations. CellCog researches trends, crafts multiple angles, and curates the best results.

We're honest: our hit rate is maybe 60-70%. Great memes are hard for humans too. But deep reasoning + multi-variant generation + ruthless curation = memes that actually land.

## How to Use

For your first CellCog task in a session, read the **cellcog** skill for the full SDK reference — file handling, chat modes, timeouts, and more.

**OpenClaw (fire-and-forget):**
```python
result = client.create_chat(
    prompt="[your task prompt]",
    notify_session_key="agent:main:main",
    task_label="my-task",
    chat_mode="agent",
)
```

**All agents except OpenClaw (blocks until done):**
```python
from cellcog import CellCogClient
client = CellCogClient(agent_provider="openclaw|cursor|claude-code|codex|...")
result = client.create_chat(
    prompt="[your task prompt]",
    task_label="my-task",
    chat_mode="agent",
)
print(result["message"])
```


---

## What Memes You Can Create

### Classic Meme Formats

Popular templates with your twist:

- **Drake Format**: "Create a Drake meme about [topic]"
- **Distracted Boyfriend**: "Make a distracted boyfriend meme about programmers"
- **Brain Expanding**: "Create an expanding brain meme about coffee addiction"
- **Two Buttons**: "Make a two buttons meme about choosing between sleep and Netflix"
- **Change My Mind**: "Create a 'change my mind' meme about tabs vs spaces"

**Example prompt:**
> "Create a Drake meme:
> 
> Top panel (rejecting): Writing documentation
> Bottom panel (approving): Hoping the code is self-explanatory
> 
> Target audience: Programmers"

### Custom Meme Images

Original visual humor:

- **Reaction Images**: "Create a reaction image for when your code works on the first try"
- **Relatable Content**: "Make a meme image about Monday morning meetings"
- **Situational Humor**: "Create a visual meme about working from home vs office"

### Text-Based Humor

When words are enough:

- **Twitter-Style Jokes**: "Write a tweet-length joke about startup culture"
- **Copypasta Parodies**: "Create a copypasta about a ridiculous topic"
- **Caption Suggestions**: "Give me 5 funny captions for this image"

### Niche Community Memes

Humor for specific groups:

- **Programmer Memes**: "Create a meme about JavaScript developers"
- **Finance Memes**: "Make a meme about HODLing crypto"
- **Academic Memes**: "Create a meme about writing a thesis"
- **Gamer Memes**: "Make a meme about game updates"

---

## The Honesty Section

Let's be real about what's hard:

| Challenge | Why It's Hard | What We Do |
|-----------|---------------|------------|
| **Timing** | Comedy relies on rhythm and surprise | We study meme structures |
| **Cultural Context** | Memes are deeply referential | We track internet culture |
| **Freshness** | Old jokes aren't funny | We avoid overused formats |
| **Subjectivity** | Humor is personal | We offer variations |

**Our success rate:** Maybe 60-70% land. That's honest. Great memes are hard for humans too.

**What helps us:**
- Clear target audience
- Specific cultural references
- Well-defined format
- Your feedback

---

## Meme Categories

### By Format

| Type | Description | Example |
|------|-------------|---------|
| **Image Macro** | Text over image | "One does not simply..." |
| **Reaction** | Image expressing emotion | Surprised Pikachu |
| **Comparison** | Side-by-side contrast | Expectation vs Reality |
| **Multi-Panel** | Story in panels | Expanding brain |
| **Text Post** | Pure text humor | Twitter screenshots |

### By Humor Type

| Type | Characteristics |
|------|-----------------|
| **Observational** | "Why is it that..." relatable moments |
| **Absurdist** | Surreal, random, unexpected |
| **Referential** | Relies on knowing source material |
| **Self-Deprecating** | Making fun of oneself or one's group |
| **Ironic** | Saying opposite of meaning |

---

## Chat Mode for Memes

**Use `chat_mode="agent"`** for meme creation.

Memes are quick creative bursts, not deep deliberation. Agent mode's faster iteration matches meme culture's rapid pace.

---

## Example Prompts

**Classic format:**
> "Create an 'Expanding Brain' meme about making coffee:
> 
> Level 1: Making instant coffee
> Level 2: Using a drip machine
> Level 3: Pour-over with precise measurements
> Level 4: Growing your own beans on a mountain
> 
> Target: Coffee enthusiasts who've gone too deep"

**Programmer humor:**
> "Create a meme about git merge conflicts:
> 
> Format: Any format that fits
> Audience: Developers
> Tone: The shared pain of merge conflict resolution
> 
> Make it relatable to anyone who's had to resolve a 500-line conflict"

**Original concept:**
> "Create a reaction image for:
> 
> Situation: When your 'quick fix' actually works
> Expression: Suspicious disbelief mixed with relief
> 
> Should work as a standalone reaction image people would share"

**Community-specific:**
> "Create a meme for the indie game dev community:
> 
> Topic: Scope creep
> The journey from 'simple puzzle game' to 'MMO with procedural narrative'
> 
> Make it hit close to home for anyone who's been there"

---

## Tips for Better Memes

1. **Know your audience**: A meme that kills in r/ProgrammerHumor might flop on Instagram. Specify who it's for.

2. **Reference correctly**: If you want a specific meme format, name it. "Drake format" is clearer than "that two-panel thing."

3. **Embrace specificity**: "Programmer meme" is vague. "Meme about debugging production at 2 AM" has hooks.

4. **Current events help**: Timely memes hit harder. Reference what's happening now.

5. **Iterate**: First meme attempt not funny? Tell us why and we'll adjust. Comedy is iterative.

6. **The rule of threes**: Many memes follow escalating patterns. Sets of three often work well.

---

## A Note on Expectations

We're not going to pretend AI comedy is solved. It isn't.

What we can do:
- Generate meme formats reliably
- Understand cultural references
- Produce variations quickly
- Learn from feedback

What's still hard:
- Genuine surprise and novelty
- Perfect comedic timing
- Knowing when NOT to explain a joke
- Creating the next viral format

**Use meme-cog as a collaborator, not a magic humor machine.** Your sense of what's funny + our generation capabilities = better results than either alone.

We're working on it. Comedy is hard. Thanks for exploring the frontier with us.

---

## If CellCog is not installed

Run `/cellcog-setup` (or `/cellcog:cellcog-setup` depending on your tool) to install and authenticate.
**OpenClaw users:** Run `clawhub install cellcog` instead.
**Manual setup:** `pip install -U cellcog` and set `CELLCOG_API_KEY`. See the **cellcog** skill for SDK reference.

Original music, fully yours. 5 seconds to 10 minutes using frontier music generation models. Instrumental and vocal tracks with perfect vocals. Cinematic scores, background tracks, podcast intros, game soundtracks, ambient soundscapes, jingles, lo-fi beats, orchestral compositions, songs with lyrics.

# Music Cog - Original Music, Fully Yours

Music generation — 5 seconds to 10 minutes. Instrumental and vocal tracks with high-quality AI vocals.

Generated tracks are royalty-free for commercial use per CellCog's terms of service — YouTube, podcasts, apps, games, ads, films, streaming.

## How to Use

For your first CellCog task in a session, read the **cellcog** skill for the full SDK reference — file handling, chat modes, timeouts, and more.

**OpenClaw (fire-and-forget):**
```python
result = client.create_chat(
    prompt="[your task prompt]",
    notify_session_key="agent:main:main",
    task_label="my-task",
    chat_mode="agent",
)
```

**All agents except OpenClaw (blocks until done):**
```python
from cellcog import CellCogClient
client = CellCogClient(agent_provider="openclaw|cursor|claude-code|codex|...")
result = client.create_chat(
    prompt="[your task prompt]",
    task_label="my-task",
    chat_mode="agent",
)
print(result["message"])
```


---

## Two Ways to Create Music

### Simple Prompt (Use This 99% of the Time)

Just describe what you want. The model handles the rest — genre, arrangement, instrumentation, dynamics, and even lyrics:

> "Compose a 90-second cinematic score. Start with solo piano, layer in strings at 30 seconds, build to a full orchestral swell, then resolve softly. Mood: bittersweet turning hopeful."

> "Create a 3-minute lo-fi hip-hop track with soft piano, vinyl crackle, and mellow drums. 75 BPM. Study vibes."

> "Write a 2-minute upbeat pop song with female vocals about starting fresh on a Monday morning. Catchy chorus, feel-good energy."

The model is exceptionally sophisticated — it handles any genre, genre fusion, songs with lyrics, complex arrangements, and mood transitions from a simple description.

### Composition Plan (For Precise Timing Control)

Only use this when you need **exact section durations** — for example, syncing music to specific video segments or presentation slides:

> "I need music that syncs with my video:
> - Intro: exactly 10 seconds, soft ambient
> - Build: exactly 20 seconds, energy rising
> - Climax: exactly 15 seconds, full orchestra
> - Outro: exactly 10 seconds, gentle fade"

This mode gives precise timing control per section but should only be used when timing accuracy matters for syncing with other media.

---

## What Music You Can Create

### Instrumental

| Type | Example |
|------|---------|
| **Cinematic scores** | Epic orchestral, tense thriller, emotional piano, sci-fi ambient |
| **Background tracks** | Lo-fi beats, corporate background, cafe jazz, ambient soundscapes |
| **Podcast intros/outros** | 5-10 second branded stings, transitions, bumpers |
| **Game soundtracks** | Battle themes, exploration music, boss fights, menu themes |
| **Jingles** | Ad jingles, notification sounds, reveal stingers |
| **Ambient** | Meditation, nature soundscapes, focus music |

### Vocal Tracks

CellCog generates songs with **perfect AI vocals** — just describe the lyrical theme:

| Type | Example |
|------|---------|
| **Pop songs** | Catchy hooks, verse-chorus structure, radio-ready |
| **Ballads** | Emotional, piano-driven, storytelling |
| **Hip-hop/Rap** | Rhythmic vocals, beats, flow |
| **Rock** | Guitar-driven, powerful vocals |
| **R&B/Soul** | Smooth, melodic, groove |

---

## Specs

| Parameter | Range |
|-----------|-------|
| **Duration** | 5 seconds to 10 minutes |
| **Output** | MP3 (44.1kHz, 128kbps) |
| **Vocals** | Instrumental or with AI vocals |
| **Licensing** | Royalty-free per CellCog terms of service |

---

## Chat Mode

**Use `chat_mode="agent"`** for music generation. Music executes well in agent mode.

---

## Example Prompts

**Cinematic score:**
> "Compose a 2-minute cinematic score for a nature documentary finale. Begin with solo cello (melancholic), layer in strings and piano at 40 seconds, build to a hopeful orchestral swell, resolve with gentle piano. Think Planet Earth meets Interstellar."

**Lo-fi background:**
> "Create 5 minutes of lo-fi study beats. Soft piano, mellow drums, vinyl crackle, gentle bass. 75 BPM. Warm and unobtrusive — good for focus."

**Podcast intro + outro:**
> "Create a podcast intro (8 seconds) and outro (6 seconds). Show is a tech startup podcast. Intro: energetic, modern electronic with a hook. Outro: same vibe but mellower wind-down. Should feel like the same show."

**Song with vocals:**
> "Write a 3-minute upbeat indie pop song with female vocals. Theme: the excitement of moving to a new city. Catchy chorus, acoustic guitar foundation, builds with drums and synth. Feel-good, sing-along energy."

**Game soundtrack:**
> "Compose a 2-minute boss battle theme for a fantasy RPG. Intense orchestral with choir, driving percussion, escalating tension. Think Dark Souls meets Final Fantasy."

---

## Tips

1. **Describe the feeling, not just the genre**: "Music that makes a startup pitch feel like the future" works better than "electronic music."

2. **Specify duration**: "45 seconds" vs "3 minutes" changes composition structure significantly.

3. **Reference moods, not copyrighted songs**: "Hans Zimmer-style epic" and "ChilledCow lo-fi vibes" work well. Do not reference specific copyrighted songs.

4. **For vocals**: Set the lyrical theme and mood. The model writes lyrics that fit. Or provide specific lyrics you want sung.

5. **Energy arc matters**: "Starts quiet, builds at midpoint, resolves softly" gives clear compositional structure.

6. **For video background music**: If the music is for a CellCog video, mention it in your video prompt instead — CellCog handles music as part of video production automatically.

---

## If CellCog is not installed

Run `/cellcog-setup` (or `/cellcog:cellcog-setup` depending on your tool) to install and authenticate.
**OpenClaw users:** Run `clawhub install cellcog` instead.
**Manual setup:** `pip install -U cellcog` and set `CELLCOG_API_KEY`. See the **cellcog** skill for SDK reference.

Build prototypes you can click. UI/UX wireframes, app mockups, and fully interactive HTML prototypes — from napkin sketch to clickable experience in one prompt. Landing pages, mobile app screens, SaaS dashboards, design systems, and user flows — prototyped and playable, not just pretty.

# Proto Cog - Build Prototypes You Can Click

**Build prototypes you can click.** UI/UX wireframes, app mockups, and fully interactive HTML prototypes — from napkin sketch to clickable experience in one prompt.

Every other AI design tool gives you static images. CellCog builds working prototypes — real HTML, real interactions, real user flows you can click through and share with stakeholders. Landing pages, mobile app screens, SaaS dashboards, design systems — prototyped and playable, not just pretty.

## How to Use

For your first CellCog task in a session, read the **cellcog** skill for the full SDK reference — file handling, chat modes, timeouts, and more.

**OpenClaw (fire-and-forget):**
```python
result = client.create_chat(
    prompt="[your task prompt]",
    notify_session_key="agent:main:main",
    task_label="my-task",
    chat_mode="agent",
)
```

**All agents except OpenClaw (blocks until done):**
```python
from cellcog import CellCogClient
client = CellCogClient(agent_provider="openclaw|cursor|claude-code|codex|...")
result = client.create_chat(
    prompt="[your task prompt]",
    task_label="my-task",
    chat_mode="agent",
)
print(result["message"])
```


---

## Why Interactive Prototypes Matter

Static mockups create a fundamental gap: stakeholders see pictures, not experiences. The difference matters:

| Static Mockup | Interactive Prototype |
|--------------|---------------------|
| "Imagine clicking this button" | Click the button, see what happens |
| "This would scroll to..." | Scroll and see the content load |
| "The hover state looks like..." | Hover and watch the animation |
| "Trust me, the flow makes sense" | Walk through the flow yourself |

CellCog generates **real HTML/CSS/JS prototypes** hosted on live URLs. Share a link, get feedback on the actual experience — not on someone's imagination of the experience.

---

## What You Can Prototype

### Landing Pages

Validate your messaging and design:

- **SaaS Landing Pages**: "Create a landing page for an AI writing assistant — hero, features, pricing, testimonials, CTA"
- **Product Launch Pages**: "Build a launch page for a new fitness app with countdown and email signup"
- **Event Pages**: "Create a conference landing page with schedule, speakers, and registration"
- **Portfolio Sites**: "Build a personal portfolio landing page for a UX designer"

**Example prompt:**
> "Create an interactive landing page prototype for 'FlowState' — a productivity app for developers:
> 
> Sections:
> - Hero: 'Code in the zone. Stay in the zone.' with app screenshot and CTA
> - Problem: Distractions kill developer flow (statistics)
> - Solution: How FlowState blocks distractions intelligently
> - Features: 3-4 key features with icons
> - Pricing: Free, Pro ($12/mo), Team ($8/user/mo)
> - Testimonials: 3 developer quotes
> - Final CTA
> 
> Style: Dark theme, developer-friendly, monospace accents
> Make all buttons and navigation interactive."

### Mobile App Screens

Design full app experiences:

- **Onboarding Flows**: "Create a 5-screen onboarding flow for a meditation app"
- **Core Features**: "Prototype the main dashboard and navigation for a fitness tracking app"
- **E-commerce**: "Build a product browse → detail → cart → checkout flow for a fashion app"
- **Social Features**: "Prototype a profile page, feed, and messaging interface"

**Example prompt:**
> "Prototype a mobile food delivery app (phone-sized viewport):
> 
> Screens:
> 1. Home — restaurant grid with search and category filters
> 2. Restaurant — menu with items, ratings, delivery time
> 3. Item detail — customization options, add to cart
> 4. Cart — order summary, delivery address, payment
> 5. Order tracking — live status with map placeholder
> 
> Make navigation between screens work with smooth transitions.
> Style: Clean, modern, Uber Eats / DoorDash inspired."

### SaaS Dashboards

Prototype complex business tools:

- **Analytics Dashboards**: "Create a marketing analytics dashboard with real chart interactions"
- **Admin Panels**: "Build a user management panel with tables, filters, and modals"
- **CRM Interfaces**: "Prototype a sales pipeline view with drag-and-drop kanban board"
- **Settings Pages**: "Create a comprehensive settings page with tabs, forms, and toggles"

**Example prompt:**
> "Prototype a SaaS project management dashboard:
> 
> Left sidebar: Navigation (Projects, Tasks, Team, Reports, Settings)
> Main area:
> - Overview: KPI cards (tasks completed, overdue, in progress)
> - Kanban board: Columns for To Do, In Progress, Review, Done
> - Task cards with assignee avatars, priority tags, due dates
> 
> Interactions:
> - Sidebar navigation switches views
> - Clicking a task card opens a detail modal
> - Filter dropdown for project/team member
> 
> Style: Clean, professional, Notion/Linear inspired."

### Design Systems & Components

Build reusable design foundations:

- **Component Libraries**: "Create a UI component library: buttons, inputs, cards, modals, navigation"
- **Style Guides**: "Build an interactive style guide showing typography, colors, spacing, and components"
- **Form Patterns**: "Prototype common form patterns: login, signup, multi-step wizard, settings"
- **Navigation Patterns**: "Create examples of sidebar nav, top nav, bottom tab bar, and hamburger menu"

### Wireframes

Quick structural explorations:

- **Low-Fidelity Wireframes**: "Create grayscale wireframes for a blog platform — home, article, author pages"
- **User Flows**: "Wireframe the complete signup → onboarding → first action flow for a project management tool"
- **Layout Explorations**: "Show 3 different layout approaches for a real estate listing page"
- **Information Architecture**: "Wireframe the navigation structure for an e-learning platform with courses, lessons, and progress tracking"

---

## Prototype Features

CellCog prototypes can include:

| Feature | Description |
|---------|-------------|
| **Navigation** | Working links, page transitions, tab switching |
| **Interactions** | Hover states, click actions, toggles, accordions |
| **Forms** | Input fields, validation states, dropdowns, checkboxes |
| **Modals & Overlays** | Popup dialogs, slide-out panels, tooltips |
| **Responsive Design** | Adapts to desktop, tablet, and mobile viewports |
| **Animations** | Smooth transitions, loading states, micro-interactions |
| **Data Display** | Charts, tables, cards with realistic sample data |
| **Dark/Light Themes** | Theme switching support |

---

## Output Formats

| Format | Best For |
|--------|----------|
| **Interactive HTML** (Default) | Clickable prototypes hosted on live URL — share with anyone |
| **Static Images** | Screenshots for documentation or comparison |
| **PDF** | Wireframe documentation for handoff |

**Interactive HTML is the default.** That's the whole point — prototypes you can click.

---

## Chat Mode for Prototyping

| Scenario | Recommended Mode |
|----------|------------------|
| Individual pages, single components, wireframes | `"agent"` |
| Full app prototypes with multiple interconnected screens, design systems | `"agent team"` |

**Use `"agent"` for most prototypes.** Landing pages, individual app screens, and component designs execute well in agent mode.

**Use `"agent team"` for full application prototypes** — multi-screen apps where navigation, state, and user flows need to work together cohesively.

---

## Example Prompts

**SaaS landing page:**
> "Create a landing page for 'CodeReview.ai' — an AI code review tool:
> 
> Hero: 'Ship better code. Ship it faster.' with demo video placeholder
> Social proof: 'Trusted by 500+ engineering teams'
> Features: AI-powered reviews, integration with GitHub/GitLab, security scanning
> Pricing: Starter (free), Pro ($29/mo), Enterprise (custom)
> 
> Dark theme, developer-focused, green accent color.
> All navigation and CTAs should be interactive."

**Mobile app prototype:**
> "Prototype a habit tracking app (mobile viewport):
> 
> Tab bar: Today, Habits, Stats, Profile
> 
> Today screen: List of today's habits with checkboxes, streak counts, and progress ring
> Habits screen: All habits with edit/delete, add new habit button
> Stats screen: Charts showing completion rates, longest streaks, weekly/monthly view
> Profile screen: Settings, notification preferences, export data
> 
> Tab navigation should work. Checking habits should animate.
> Style: Minimal, calming, inspired by Streaks app."

**Design system:**
> "Build an interactive design system for a fintech startup:
> 
> Colors: Primary (deep blue), secondary (teal), accent (amber), semantic (success/warning/error)
> Typography: Scale from h1 to body to caption with clear hierarchy
> Components:
> - Buttons (primary, secondary, ghost, destructive — each with hover/active/disabled states)
> - Input fields (default, focused, error, disabled)
> - Cards (simple, interactive, stat card)
> - Table with sortable headers
> - Modal dialog
> - Toast notifications
> 
> Show each component with interactive states. Professional, banking-grade aesthetic."

**Wireframe exploration:**
> "Create 3 different layout approaches for an AI chatbot interface:
> 
> Option A: Full-page chat (like ChatGPT)
> Option B: Side panel chat with main content area
> Option C: Floating chat widget
> 
> Each should include: message input, conversation history, suggested prompts, and settings access.
> Grayscale wireframes, focused on layout and information hierarchy."

---

## Tips for Better Prototypes

1. **Describe the interactions**: "Button opens a modal" or "Tabs switch content" — tell CellCog what should happen, not just what should appear.

2. **Reference existing products**: "Like Notion's sidebar" or "Stripe's pricing page" communicates more than paragraphs of description.

3. **Specify viewport**: "Mobile phone viewport" vs "Full desktop" changes the entire design approach.

4. **Include realistic content**: Real text, real numbers, real labels — not "Lorem ipsum". Prototypes with real content get better feedback.

5. **State the purpose**: "For user testing", "For investor demo", "For developer handoff" — context shapes fidelity level.

6. **Think in flows, not pages**: "Signup → Onboarding → Dashboard" is more useful than 3 disconnected page requests.

---

## If CellCog is not installed

Run `/cellcog-setup` (or `/cellcog:cellcog-setup` depending on your tool) to install and authenticate.
**OpenClaw users:** Run `clawhub install cellcog` instead.
**Manual setup:** `pip install -U cellcog` and set `CELLCOG_API_KEY`. See the **cellcog** skill for SDK reference.

Deep research agent powered by CellCog. Market research, competitive analysis, investment research, academic research, due diligence, literature reviews with citations. Multi-source synthesis across hundreds of sources. #1 on DeepResearch Bench (Apr 2026).

# Research Cog - Deep Research Powered by CellCog

**#1 on DeepResearch Bench (Apr 2026).** Your AI research analyst for comprehensive, citation-backed research on any topic.

Leaderboard: https://huggingface.co/spaces/muset-ai/DeepResearch-Bench-Leaderboard

## How to Use

For your first CellCog task in a session, read the **cellcog** skill for the full SDK reference — file handling, chat modes, timeouts, and more.

**OpenClaw (fire-and-forget):**
```python
result = client.create_chat(
    prompt="[your task prompt]",
    notify_session_key="agent:main:main",
    task_label="my-task",
    chat_mode="agent",
)
```

**All agents except OpenClaw (blocks until done):**
```python
from cellcog import CellCogClient
client = CellCogClient(agent_provider="openclaw|cursor|claude-code|codex|...")
result = client.create_chat(
    prompt="[your task prompt]",
    task_label="my-task",
    chat_mode="agent",
)
print(result["message"])
```


---

## What You Can Research

### Competitive Analysis

Analyze companies against their competitors with structured insights:

- **Company vs. Competitors**: "Compare Stripe vs Square vs Adyen - market positioning, pricing, features, strengths/weaknesses"
- **SWOT Analysis**: "Create a SWOT analysis for Shopify in the e-commerce platform market"
- **Market Positioning**: "How does Notion position itself against Confluence, Coda, and Obsidian?"
- **Feature Comparison**: "Compare the AI capabilities of Salesforce, HubSpot, and Zoho CRM"

### Market Research

Understand markets, industries, and trends:

- **Industry Analysis**: "Analyze the electric vehicle market in Europe - size, growth, key players, trends"
- **Market Sizing**: "What's the TAM/SAM/SOM for AI-powered customer service tools in North America?"
- **Trend Analysis**: "What are the emerging trends in sustainable packaging for 2026?"
- **Customer Segments**: "Identify and profile the key customer segments for premium pet food"
- **Regulatory Landscape**: "Research FDA regulations for AI-powered medical devices"

### Stock & Investment Analysis

Financial research with data and analysis:

- **Company Fundamentals**: "Analyze NVIDIA's financials - revenue growth, margins, competitive moat"
- **Investment Thesis**: "Build an investment thesis for Microsoft's AI strategy"
- **Sector Analysis**: "Compare semiconductor stocks - NVDA, AMD, INTC, TSM"
- **Risk Assessment**: "What are the key risks for Tesla investors in 2026?"
- **Earnings Analysis**: "Summarize Apple's Q4 2025 earnings and forward guidance"

### Academic & Technical Research

Deep dives with proper citations:

- **Literature Review**: "Research the current state of quantum error correction techniques"
- **Technology Deep Dive**: "Explain transformer architectures and their evolution from attention mechanisms"
- **Scientific Topics**: "What's the latest research on CRISPR gene editing for cancer treatment?"
- **Historical Analysis**: "Research the history and impact of the Bretton Woods system"

### Due Diligence

Comprehensive research for decision-making:

- **Startup Due Diligence**: "Research [Company Name] - founding team, funding, product, market, competitors"
- **Vendor Evaluation**: "Compare AWS, GCP, and Azure for enterprise AI/ML workloads"
- **Partnership Analysis**: "Research potential risks and benefits of partnering with [Company]"

---

## Research Output Formats

CellCog can deliver research in multiple formats:

| Format | Best For |
|--------|----------|
| **Interactive HTML Report** | Explorable dashboards with charts, expandable sections |
| **PDF Report** | Shareable, printable professional documents |
| **Markdown** | Integration into your docs/wikis |
| **Plain Response** | Quick answers in chat |

Specify your preferred format in the prompt:
- "Create an interactive HTML report on..."
- "Generate a PDF research report analyzing..."
- "Give me a markdown summary of..."

---

## Chat Mode for Research

| Scenario | Recommended Mode |
|----------|------------------|
| Trivial lookups, basic facts | `"agent"` |
| Deep research, competitive analysis, market research, investment analysis | `"agent team"` |
| Cutting-edge academic research, high-stakes due diligence, institutional-grade analysis | `"agent team max"` |

**Use `"agent team"` for most research** (the default). Agent team mode enables multi-source research, cross-referencing, citation verification, and deeper analysis with multiple reasoning passes.

**Use `"agent"` only for trivial lookups** like "What's Apple's stock ticker?"

**Use `"agent team max"` for cutting-edge academic research and high-stakes due diligence** — when the research directly informs costly decisions (investment thesis, M&A, regulatory compliance, PhD-level analysis). All settings maxed for the deepest reasoning. The quality gain is incremental but meaningful when accuracy is critical. Requires ≥2,000 credits.

---

## Research Quality Features

### Citations (On Request)

**Citations are NOT automatic.** CellCog focuses on delivering accurate, well-researched content by default.

If you need citations:
- **Explicitly request them**: "Include citations for all factual claims with source URLs"
- **Specify format**: "Provide citations as footnotes" or "Include a references section at the end"
- **Indicate placement**: "Citations inline" vs "Citations in appendix"

Without explicit citation requests, CellCog prioritizes delivering accurate information efficiently.

### Data Accuracy
CellCog cross-references multiple sources for financial and statistical data, ensuring accuracy even without explicit citations.

### Structured Analysis
Complex research is organized with clear sections, executive summaries, and actionable insights.

### Visual Elements
Research reports can include:
- Charts and graphs
- Comparison tables
- Timeline visualizations
- Market maps

---

## Example Research Prompts

**Quick competitive intel:**
> "Compare Figma vs Sketch vs Adobe XD for enterprise UI design teams. Focus on collaboration features, pricing, and Figma's position after the Adobe acquisition failed."

**Deep market research:**
> "Create a comprehensive market research report on the AI coding assistant market. Include market size, growth projections, key players (GitHub Copilot, Cursor, Codeium, etc.), pricing models, and enterprise adoption trends. Deliver as an interactive HTML report."

**Investment analysis:**
> "Build an investment analysis for Palantir (PLTR). Cover business model, government vs commercial revenue mix, AI product strategy, valuation metrics, and key risks. Include relevant charts."

**Academic deep dive:**
> "Research the current state of nuclear fusion energy. Cover recent breakthroughs (NIF, ITER, private companies like Commonwealth Fusion), technical challenges remaining, timeline to commercial viability, and investment landscape."

---

## Tips for Better Research

1. **Be specific**: "AI market" is vague. "Enterprise AI automation market in healthcare" is better.

2. **Specify timeframe**: "Recent" is ambiguous. "2025-2026" or "last 6 months" is clearer.

3. **Define scope**: "Compare everything about X and Y" leads to bloat. "Compare X and Y on pricing, features, and market positioning" is focused.

4. **Request structure**: "Include executive summary, key findings, and recommendations" helps organize output.

5. **Mention output format**: "Deliver as PDF" or "Create interactive HTML dashboard" gets you the right format.

---

## If CellCog is not installed

Run `/cellcog-setup` (or `/cellcog:cellcog-setup` depending on your tool) to install and authenticate.
**OpenClaw users:** Run `clawhub install cellcog` instead.
**Manual setup:** `pip install -U cellcog` and set `CELLCOG_API_KEY`. See the **cellcog** skill for SDK reference.

AI presentation and slide deck generation powered by CellCog. Create pitch decks, keynotes, business presentations, educational slides, investor decks — PDF or native PPTX. Deep research fills content from minimal prompts. #1 on DeepResearch Bench (Apr 2026). Professional slide design, charts, and layouts.

# Slides Cog - Content Worth Presenting, Design Worth Looking At

**Great slides need two things: content worth presenting and design worth looking at.** CellCog takes both seriously.

- **Content:** Your prompt can be minimal — CellCog researches and fills in substance, not filler
- **Design:** PDF slides or native PPTX, with layouts, typography, and visuals you can present as-is

Pitch decks, keynotes, board presentations, image slideshows — ready to present, not ready to fix.

## How to Use

For your first CellCog task in a session, read the **cellcog** skill for the full SDK reference — file handling, chat modes, timeouts, and more.

**OpenClaw (fire-and-forget):**
```python
result = client.create_chat(
    prompt="[your task prompt]",
    notify_session_key="agent:main:main",
    task_label="my-task",
    chat_mode="agent",
)
```

**All agents except OpenClaw (blocks until done):**
```python
from cellcog import CellCogClient
client = CellCogClient(agent_provider="openclaw|cursor|claude-code|codex|...")
result = client.create_chat(
    prompt="[your task prompt]",
    task_label="my-task",
    chat_mode="agent",
)
print(result["message"])
```


---

## Output Formats

CellCog generates presentations in multiple formats. Each has its strengths:

### PDF (Default for Ambiguous Requests)

When you say "create a presentation" or "make a slide deck" without specifying a format, CellCog generates PDF:
- Full control over layout, typography, and design
- Perfect rendering across all devices
- Professional, polished results every time
- Supports images, charts, complex layouts without compromise

### PPTX (First-Class Support)

When you explicitly request PPTX ("create a PowerPoint", "make a .pptx"), CellCog generates native PowerPoint directly:
- Editable slides — your team can modify, reorder, and customize
- Compatible with PowerPoint, Google Slides, and Keynote
- Professional layouts with proper slide masters and formatting
- Great for collaborative workflows where multiple people contribute

**Just ask for PPTX and you'll get it.** No need to justify why you want an editable format.

---

## What Presentations You Can Create

### Pitch Decks

Investor and stakeholder presentations:

- **Startup Pitch**: "Create a 12-slide pitch deck for a fintech startup disrupting small business lending"
- **Investor Update**: "Build a quarterly investor update presentation covering metrics, milestones, and roadmap"
- **Funding Ask**: "Create a Series A pitch deck for an AI healthcare company seeking $5M"

### Business Presentations

Corporate and professional presentations:

- **Quarterly Business Review**: "Create a QBR presentation covering sales performance, challenges, and next quarter plans"
- **Strategy Presentation**: "Build a strategic planning presentation for entering the European market"
- **Board Deck**: "Create a board meeting presentation with financials, KPIs, and key decisions needed"
- **Project Proposal**: "Build a project proposal presentation for implementing a new CRM system"

### Sales Presentations

Customer-facing decks:

- **Product Demo Deck**: "Create a product demo presentation for our project management software"
- **Capabilities Deck**: "Build a company capabilities presentation for enterprise sales"
- **Case Study Presentation**: "Create a case study presentation showing how Client X achieved 3x ROI"
- **Pricing Presentation**: "Build a pricing and packaging presentation for our three tiers"

### Educational Presentations

Teaching and training content:

- **Course Slides**: "Create lecture slides for an introduction to machine learning"
- **Training Deck**: "Build employee onboarding slides covering company culture and policies"
- **Workshop Presentation**: "Create workshop slides for a design thinking session"
- **Tutorial Slides**: "Build a step-by-step tutorial presentation for using Excel pivot tables"

### Event Presentations

Conferences and special events:

- **Keynote**: "Create a keynote presentation on the future of artificial intelligence"
- **Conference Talk**: "Build a 20-minute conference presentation on scaling engineering teams"
- **All-Hands**: "Create an all-hands meeting presentation covering company updates and wins"
- **Product Launch**: "Build a product launch presentation for unveiling our new feature"

### Image Slideshows

Visual storytelling with images:

- **Portfolio Slideshow**: "Create a photography portfolio slideshow with minimal text"
- **Travel Presentation**: "Build a vacation recap slideshow with photos and captions"
- **Event Highlights**: "Create an event highlight slideshow from conference photos"
- **Visual Story**: "Build a brand story slideshow using images and minimal text"

---

## Presentation Features

CellCog presentations can include:

| Element | Description |
|---------|-------------|
| **Title Slides** | Bold, impactful opening slides |
| **Content Slides** | Text, bullets, and layouts |
| **Charts & Graphs** | Bar, line, pie, and more |
| **Images** | AI-generated or placeholder for your images |
| **Data Tables** | Clean, formatted tables |
| **Timelines** | Visual timelines and roadmaps |
| **Comparison Slides** | Side-by-side comparisons |
| **Quote Slides** | Testimonials and callouts |

---

## Output Format Summary

| Format | When to Use |
|--------|-------------|
| **PDF** | Default when no format specified — polished, presentation-ready |
| **PPTX** | When you request PowerPoint — editable, collaborative, team workflows |
| **Interactive HTML** | Web-based presentations, internal tools |

---

## Chat Mode for Presentations

| Scenario | Recommended Mode |
|----------|------------------|
| Standard decks, educational slides, image slideshows, training materials | `"agent"` |
| Investor pitch decks, board presentations, keynotes requiring narrative craft | `"agent team"` |

**Use `"agent"` for most presentations.** Standard business decks, training materials, and informational slides execute well in agent mode.

**Use `"agent team"` for high-stakes presentations** where narrative flow, persuasion, and multi-angle thinking matter—investor pitches, board decks, conference keynotes where every slide needs to build a compelling story.

---

## Example Presentation Prompts

**Startup pitch deck:**
> "Create a 12-slide Series A pitch deck for 'DataSync' - a B2B SaaS company that helps enterprises sync data across cloud applications.
> 
> Include slides for: Problem, Solution, Product Demo, Market Size, Business Model, Traction, Team, Competition, Go-to-Market, Financials, Ask, Contact.
> 
> Key metrics: $50K MRR, 30 customers, 15% MoM growth, seeking $5M for expansion.
> 
> Modern, professional design. Blue and white color scheme."

**Quarterly business review:**
> "Create a QBR presentation for Q4 2025:
> 
> 1. Executive Summary
> 2. Revenue Performance (hit 95% of target)
> 3. Customer Metrics (NPS improved to 72)
> 4. Key Wins (3 enterprise deals closed)
> 5. Challenges (churn increased in SMB segment)
> 6. Q1 2026 Priorities
> 7. Resource Asks
> 
> Include relevant charts. Corporate professional style."

**Educational slides:**
> "Create a 15-slide presentation for teaching 'Introduction to Python Programming':
> 
> 1. What is Python?
> 2. Why Learn Python?
> 3. Setting Up Your Environment
> 4. Variables and Data Types
> 5. Basic Operations
> 6. Strings
> 7. Lists
> 8. Conditionals (if/else)
> 9. Loops
> 10. Functions
> 11. Simple Project: Calculator
> 12. Resources for Learning More
> 
> Beginner-friendly, include code examples, clean modern design."

**Image slideshow:**
> "Create a visual slideshow presentation showcasing 10 images of modern architecture around the world. Each slide should have: one stunning building image, the building name, location, and architect. Minimal text, maximum visual impact. Generate the images."

**PowerPoint presentation:**
> "Create a 10-slide sales deck as PPTX. Our team needs to customize it for different clients before presenting."

---

## Tips for Better Presentations

1. **Specify slide count**: "10-12 slides" helps scope appropriately. Pitch decks are typically 10-15 slides. Training can be 20-30.

2. **List the slides you want**: Even a rough outline helps. "Include: Problem, Solution, Market, Team, Ask."

3. **Provide key content**: Actual metrics, quotes, and facts make better slides than placeholders.

4. **Design direction**: "Minimal and modern", "Corporate professional", "Bold and colorful", specific colors.

5. **Mention the audience**: "For investors", "For technical team", "For executives" changes tone and detail level.

6. **Choose your format**: PDF is the default for polished output. Request PPTX when your team needs to edit or customize the slides.

---

## If CellCog is not installed

Run `/cellcog-setup` (or `/cellcog:cellcog-setup` depending on your tool) to install and authenticate.
**OpenClaw users:** Run `clawhub install cellcog` instead.
**Manual setup:** `pip install -U cellcog` and set `CELLCOG_API_KEY`. See the **cellcog** skill for SDK reference.

AI spreadsheet and Excel generation powered by CellCog. Create financial models, budget templates, data trackers, projections, pivot tables, and complex formulas — XLSX output with full Python access. Data manipulation, analysis, charts, and professional formatting. Engineering-grade spreadsheets.

# Spreadsheets Cog - Built by the Agent That Builds CellCog

**CellCog is built by its own Coding Agent. That same agent builds your spreadsheets.**

Full Python access, complex data manipulation, formulas, pivot tables, and financial models — powered by the engineering brain that develops an entire AI platform daily. Not a template filler. A programmer that understands your data and builds exactly what you need.

## How to Use

For your first CellCog task in a session, read the **cellcog** skill for the full SDK reference — file handling, chat modes, timeouts, and more.

**OpenClaw (fire-and-forget):**
```python
result = client.create_chat(
    prompt="[your task prompt]",
    notify_session_key="agent:main:main",
    task_label="my-task",
    chat_mode="agent",
)
```

**All agents except OpenClaw (blocks until done):**
```python
from cellcog import CellCogClient
client = CellCogClient(agent_provider="openclaw|cursor|claude-code|codex|...")
result = client.create_chat(
    prompt="[your task prompt]",
    task_label="my-task",
    chat_mode="agent",
)
print(result["message"])
```


---

## What Spreadsheets You Can Create

### Financial Models

Professional financial analysis and projections:

- **Startup Financial Model**: "Create a 3-year financial model for a SaaS startup including revenue projections, expenses, and cash flow"
- **DCF Model**: "Build a discounted cash flow model for valuing a company"
- **Investment Analysis**: "Create a real estate investment analysis spreadsheet with ROI calculations"
- **Revenue Model**: "Build a revenue forecasting model with multiple scenarios (base, optimistic, pessimistic)"
- **Unit Economics**: "Create a unit economics spreadsheet showing CAC, LTV, payback period"

### Budget Templates

Personal and business budgets:

- **Personal Budget**: "Create a monthly personal budget tracker with income, fixed expenses, variable expenses, and savings goals"
- **Household Budget**: "Build a family budget spreadsheet with categories for housing, food, transportation, etc."
- **Project Budget**: "Create a project budget template with phases, resources, and variance tracking"
- **Marketing Budget**: "Build a marketing budget spreadsheet with channels, planned vs actual, and ROI tracking"
- **Event Budget**: "Create a wedding budget spreadsheet with vendor categories and payment tracking"

### Data Trackers

Organized tracking for any data:

- **Fitness Tracker**: "Create a workout log spreadsheet with exercises, sets, reps, weights, and progress charts"
- **Habit Tracker**: "Build a daily habit tracking spreadsheet with monthly overview"
- **Inventory Tracker**: "Create an inventory management spreadsheet with stock levels, reorder points, and valuation"
- **Sales Tracker**: "Build a sales pipeline tracker with stages, probabilities, and forecasting"
- **Time Tracker**: "Create a timesheet template with projects, hours, and billing calculations"

### Business Tools

Operational spreadsheets:

- **Invoice Template**: "Create a professional invoice template with automatic calculations"
- **Employee Directory**: "Build an employee directory spreadsheet with contact info, departments, and start dates"
- **Vendor Comparison**: "Create a vendor comparison spreadsheet for evaluating suppliers"
- **OKR Tracker**: "Build an OKR tracking spreadsheet for quarterly goals"
- **Meeting Agenda**: "Create a meeting agenda template with action items tracking"

### Analysis Templates

Data analysis and calculations:

- **Break-Even Analysis**: "Create a break-even analysis spreadsheet with charts"
- **Scenario Analysis**: "Build a scenario planning spreadsheet with what-if analysis"
- **Pricing Calculator**: "Create a pricing model spreadsheet with cost-plus and value-based options"
- **Loan Calculator**: "Build a loan amortization schedule with payment breakdown"
- **Commission Calculator**: "Create a sales commission calculator with tiered rates"

---

## Spreadsheet Features

CellCog spreadsheets can include:

| Feature | Description |
|---------|-------------|
| **Formulas** | SUM, AVERAGE, IF, VLOOKUP, and complex calculations |
| **Formatting** | Headers, colors, borders, number formats, conditional formatting |
| **Charts** | Bar, line, pie charts embedded in sheets |
| **Multiple Sheets** | Organized workbooks with linked sheets |
| **Data Validation** | Dropdowns, input restrictions |
| **Named Ranges** | For cleaner formulas |
| **Print Layout** | Ready for printing/PDF |

---

## Output Formats

| Format | Best For |
|--------|----------|
| **XLSX** | Editable in Excel, Google Sheets, Numbers |
| **Interactive HTML** | Web-based calculators and tools |

---

## Chat Mode for Spreadsheets

| Scenario | Recommended Mode |
|----------|------------------|
| Budget templates, trackers, data tables, basic calculations | `"agent"` |
| Complex financial models with multi-scenario analysis, intricate formulas | `"agent team"` |

**Default to `"agent"`** for most spreadsheet requests. CellCog's agent mode handles formulas, formatting, charts, and data organization efficiently.

Reserve `"agent team"` for complex financial modeling requiring deep accuracy validation—like DCF models, multi-scenario projections, or interconnected workbooks where formula correctness is critical.

---

## Example Spreadsheet Prompts

**SaaS financial model:**
> "Create a 3-year SaaS financial model with:
> 
> **Assumptions Sheet:**
> - Starting MRR: $10,000
> - Monthly growth rate: 15%
> - Churn rate: 3%
> - Average revenue per customer: $99
> - CAC: $500
> - Gross margin: 80%
> 
> **Monthly P&L:** Revenue, COGS, Gross Profit, Operating Expenses (broken down), Net Income
> 
> **Key Metrics:** MRR, ARR, Customers, Churn, LTV, CAC, LTV:CAC ratio
> 
> **Charts:** MRR growth, customer growth, profitability timeline
> 
> Include scenario toggles for growth rate (10%, 15%, 20%)."

**Personal budget:**
> "Create a monthly personal budget spreadsheet:
> 
> **Income Section:** Salary, side income, other
> 
> **Fixed Expenses:** Rent, utilities, insurance, subscriptions, loan payments
> 
> **Variable Expenses:** Groceries, dining out, transportation, entertainment, shopping, health
> 
> **Savings:** Emergency fund, retirement, vacation fund
> 
> Include:
> - Monthly summary with % of income per category
> - Year-at-a-glance sheet with monthly totals
> - Pie chart showing expense breakdown
> - Conditional formatting (red if over budget)
> 
> Assume $5,000/month income."

**Sales tracker:**
> "Build a sales pipeline tracker spreadsheet with:
> 
> **Columns:** Company, Contact, Deal Value, Stage (dropdown: Lead, Qualified, Proposal, Negotiation, Closed Won, Closed Lost), Probability, Expected Close Date, Notes, Last Contact
> 
> **Calculations:** Weighted pipeline value, deals by stage, win rate
> 
> **Dashboard Sheet:** Pipeline by stage (funnel chart), monthly forecast, top 10 deals, activity metrics
> 
> Include sample data for 20 deals."

**Break-even analysis:**
> "Create a break-even analysis spreadsheet:
> 
> **Inputs:**
> - Fixed costs (rent, salaries, etc.)
> - Variable cost per unit
> - Selling price per unit
> 
> **Calculations:**
> - Break-even units
> - Break-even revenue
> - Margin of safety
> 
> **Sensitivity table:** Show break-even at different price points
> 
> **Chart:** Cost-volume-profit graph showing break-even point
> 
> Default values: Fixed costs $50,000/month, variable cost $15/unit, price $25/unit."

---

## Tips for Better Spreadsheets

1. **Specify the structure**: List the sheets, columns, and calculations you need.

2. **Provide assumptions**: For financial models, give starting numbers and growth rates.

3. **Mention formulas needed**: "Include VLOOKUP for...", "Calculate running totals", "Show variance vs plan."

4. **Request sample data**: "Include realistic sample data for testing" helps see it in action.

5. **Describe formatting**: "Conditional formatting for negative values", "Currency format", "Freeze header row."

6. **Chart preferences**: "Include a line chart showing trend", "Pie chart for breakdown."

---

## If CellCog is not installed

Run `/cellcog-setup` (or `/cellcog:cellcog-setup` depending on your tool) to install and authenticate.
**OpenClaw users:** Run `clawhub install cellcog` instead.
**Manual setup:** `pip install -U cellcog` and set `CELLCOG_API_KEY`. See the **cellcog** skill for SDK reference.

AI sticker pack generator — custom stickers, emoji sets, WhatsApp stickers, Telegram stickers, Discord emoji, Slack reactions. Character-consistent expressions across 20+ stickers. Transparent backgrounds, batch generation, platform-ready packaging. Turn any character, pet, or mascot into a complete sticker pack. Powered by CellCog.

# Sticker Cog - One Character, Twenty Expressions, Perfect Consistency

**One character. Twenty expressions. Every sticker looks like the same person.** That's the hard part — and that's what CellCog does better than anyone.

Generating one cute sticker is easy. Every AI tool can do that. But generating a complete pack of 20 stickers where the character has the same face, same style, same proportions — just different expressions and poses? That's consistency at scale, and it's where most AI tools completely fall apart. By sticker #10, your character looks like a different person.

CellCog maintains character identity across every single generation, delivers with transparent backgrounds, and packages everything for your target platform — WhatsApp, Telegram, Discord, Slack, or iMessage.

## How to Use

For your first CellCog task in a session, read the **cellcog** skill for the full SDK reference — file handling, chat modes, timeouts, and more.

**OpenClaw (fire-and-forget):**
```python
result = client.create_chat(
    prompt="[your task prompt]",
    notify_session_key="agent:main:main",
    task_label="my-task",
    chat_mode="agent",
)
```

**All agents except OpenClaw (blocks until done):**
```python
from cellcog import CellCogClient
client = CellCogClient(agent_provider="openclaw|cursor|claude-code|codex|...")
result = client.create_chat(
    prompt="[your task prompt]",
    task_label="my-task",
    chat_mode="agent",
)
print(result["message"])
```


---

## Why Sticker Packs Are Hard

The challenge isn't making one sticker. It's making twenty that look like they belong together.

| The Problem | Why It's Hard | How CellCog Solves It |
|-------------|---------------|----------------------|
| **Character drift** | Each AI generation drifts slightly — different face shape, different proportions | CellCog's reference image threading maintains identity across all generations |
| **Style consistency** | Line weight, color palette, and art style shift between generations | The agent establishes a visual style guide before generating and enforces it throughout |
| **Expression range** | Getting 20 genuinely different expressions without changing the character | CellCog plans the full expression set upfront, then generates each with the character locked |
| **Transparent backgrounds** | Many AI models struggle with clean transparency | Dedicated transparent background model produces clean cutouts |
| **Platform formatting** | Each messaging platform has different size, format, and packaging requirements | Automatic conversion and optimization for WhatsApp, Telegram, Discord, Slack, iMessage |

---

## What Sticker Packs You Can Create

### Character Sticker Packs

Design a character and get a complete expression set:

- **Original Characters**: "Create a sticker pack with a friendly fox character — 20 expressions for everyday messaging"
- **Chibi/Anime Style**: "Design a chibi version of a warrior princess with 15 battle and everyday expressions"
- **Mascot Packs**: "Create a sticker pack for our startup mascot — a robot named Bolt"
- **Couple/Duo Packs**: "Design two best friend characters and create stickers of them together"

**Example prompt:**
> "Create a WhatsApp sticker pack — 20 stickers:
> 
> Character: A chubby orange tabby cat named Mochi
> Style: Kawaii, round, simple clean lines, warm color palette
> 
> Expressions:
> 1. Happy/smiling
> 2. Laughing (rolling on back)
> 3. Crying (dramatic anime tears)
> 4. Angry (puffed up)
> 5. Sleeping (curled up, zzz)
> 6. Eating (bowl of ramen)
> 7. Love (heart eyes)
> 8. Confused (head tilt, question mark)
> 9. Excited (jumping)
> 10. Thumbs up
> 11. Facepalm
> 12. Waving hello
> 13. Sad (rain cloud above)
> 14. Celebrating (party hat, confetti)
> 15. Thinking (chin on paw)
> 16. Shocked/surprised
> 17. Cool (sunglasses)
> 18. Sick (thermometer, blanket)
> 19. Working (tiny laptop)
> 20. Goodnight (moon, stars)
> 
> Every sticker MUST look like the same cat.
> Format for WhatsApp: 512×512, WebP, transparent backgrounds, under 100KB each."

### Brand & Team Emoji

Custom reactions for your workspace:

- **Company Mascot Emoji**: "Turn our company mascot into a Slack emoji set with 15 work-related reactions"
- **Team Reactions**: "Create a custom emoji set for our engineering Slack — ship it 🚢, LGTM, hotfix, etc."
- **Themed Packs**: "Make a set of 10 food-themed reaction stickers for our restaurant's Discord"

**Example prompt:**
> "Create a Slack emoji set for our engineering team:
> 
> Style: Minimal, flat design, consistent with tech aesthetic
> 
> Reactions needed:
> - 'Ship it' (rocket launching)
> - 'LGTM' (green checkmark with sparkles)
> - 'Hotfix' (fire + wrench)
> - 'In review' (magnifying glass)
> - 'Blocked' (stop sign)
> - 'Needs coffee' (coffee cup)
> - 'On call' (phone ringing)
> - 'Deployed' (party popper)
> - 'Rollback' (reverse arrow)
> - 'Weekend mode' (palm tree)
> 
> All 128×128 PNG with transparent backgrounds. Keep them readable at small sizes."

### From Reference Photos

Turn real photos into sticker packs:

- **Pet Stickers**: "Turn this photo of my golden retriever into a 15-sticker cartoon pack"
- **Self-Portrait Stickers**: "Create a cartoon sticker pack based on my photo — keep the likeness but make it cute"
- **Group Stickers**: "Use this team photo to create cartoon versions of us for our company Slack"

**Example prompt:**
> "Here's a photo of my cat Luna:
> [upload photo]
> 
> Create a Telegram sticker pack (15 stickers) based on Luna's actual appearance:
> - Keep her black fur, green eyes, and white chest patch
> - Style: Cute cartoon, slightly exaggerated proportions (bigger head, bigger eyes)
> 
> Expressions: happy, sleepy, hungry, judgmental, playful, zoomies, loaf position,
> stretching, knocking something off a table, hiding in a box, batting at a toy,
> yawning, grooming, startled, and one with a crown (queen energy)
> 
> Every sticker must be recognizably Luna. 512×512 PNG, transparent backgrounds."

### Professional Reaction Stickers

Workplace-appropriate reactions:

- **Project Status**: "Create stickers for project management — Approved, In Progress, Needs Revision, Shipped, Blocked"
- **Meeting Reactions**: "Make stickers for virtual meetings — Agree, Disagree, Question, Great Idea, Let's Table This"
- **Feedback Stickers**: "Create a set of code review reaction stickers — LGTM, Nit, Bug, Refactor Needed, Nice Pattern"

### Platform-Specific Packs

Optimized for where your audience lives:

- **WhatsApp Packs**: "Create a complete WhatsApp sticker pack — 30 stickers, ready to import"
- **Telegram Sets**: "Build a Telegram sticker set with 25 stickers"
- **Discord Emoji**: "Create 20 custom Discord server emoji"
- **iMessage Stickers**: "Design a sticker pack for iMessage with 15 expressions"

---

## Sticker Styles

| Style | Characteristics | Best For |
|-------|-----------------|----------|
| **Kawaii** | Round, cute, simple, big eyes | Casual messaging, cute characters |
| **Flat Design** | Clean lines, solid colors, minimal shading | Professional/brand emoji |
| **Cartoon** | Expressive, dynamic, detailed | Character-driven packs |
| **Pixel Art** | Retro, nostalgic, grid-based | Gaming communities, nostalgia |
| **Watercolor** | Soft, artistic, painterly | Artistic/lifestyle brands |
| **Line Art** | Black outlines, minimal color | Elegant, universal |
| **Chibi/Anime** | Exaggerated proportions, big heads | Anime communities, expressive |
| **3D Render** | Glossy, dimensional, modern | Tech brands, premium feel |

---

## Platform Specifications

| Platform | Format | Size | Per Pack |
|----------|--------|------|----------|
| **WhatsApp** | WebP, transparent | 512×512, <100KB each | 3-30 stickers |
| **Telegram** | PNG or WebP, transparent | 512×512 | Up to 120 stickers |
| **Discord** | PNG or GIF | 128×128 or 320×320 | Per slot |
| **Slack** | PNG, GIF, or JPG | 128×128 | Per slot |
| **iMessage** | PNG, transparent | 300×300 recommended | 10-40 stickers |
| **General Use** | PNG, transparent | Any size | Any count |

Tell CellCog which platform you're targeting and it handles the formatting automatically — dimensions, file format, file size optimization, and transparent background generation.

---

## Chat Mode for Sticker Packs

| Scenario | Recommended Mode |
|----------|------------------|
| Single sticker pack (10-20 stickers), emoji sets | `"agent"` |
| Multiple coordinated packs, brand sticker system, large sets (30+) | `"agent team"` |

**Use `"agent"` for most sticker work.** A single pack with 10-20 stickers executes well in agent mode.

**Use `"agent team"` for brand-level sticker systems** — when you need multiple packs that share a design language, or very large sets where consistency across 30+ stickers benefits from deeper creative planning.

---

## Example Prompts

**Quick emoji set:**
> "Create 10 food-themed reaction emoji for our team's Slack:
> 
> Style: Cute, kawaii, each food item has a face
> Include: Pizza (excited), Sushi (cool), Taco (party), Coffee (sleepy), Burger (happy),
> Donut (love), Broccoli (disgusted), Ice cream (melting), Ramen (slurping), Cookie (waving)
> 
> 128×128 PNG, transparent backgrounds."

**Character pack from scratch:**
> "Design a character and create a full Telegram sticker set:
> 
> Character: A tiny astronaut with an oversized helmet, floating in space
> Personality: Curious, clumsy, optimistic
> Style: Flat illustration, limited color palette (white suit, blue visor, orange accents)
> 
> 20 stickers covering common messaging scenarios:
> Hi, Bye, Thanks, Sorry, LOL, Crying, Love, Angry, Thinking, Sleeping,
> Celebrating, Confused, Excited, Thumbs up, Facepalm, Mind blown,
> Running late, On my way, Good morning, Good night
> 
> 512×512 PNG, transparent backgrounds. The astronaut must look identical in every sticker."

**Brand mascot stickers:**
> "Our company mascot is a friendly blue owl named Hoot. Here's the reference image:
> [upload mascot image]
> 
> Create a WhatsApp sticker pack (20 stickers) using Hoot:
> - Keep Hoot's exact design, colors, and proportions
> - Add work-related expressions: 'Great job!', 'Deadline approaching', 'Meeting time',
>   'Need coffee', 'On it!', 'Thinking...', 'Approved!', 'Let's discuss', etc.
> - Mix of work reactions and casual expressions
> 
> Format: 512×512 WebP, transparent backgrounds, under 100KB each.
> Also create a set of 10 as 128×128 PNG for Slack emoji."

**Pet sticker pack:**
> "Create a sticker pack from my dog's photo:
> [upload dog photo]
> 
> My dog is a corgi named Biscuit.
> Turn Biscuit into a cartoon character (keep the corgi proportions, stumpy legs, big butt)
> and create 15 stickers:
> 
> Happy wiggle, Zoomies, Sploot, Begging for treats, Judging you, 
> Sleeping in funny position, Barking, Head tilt, Catching a ball,
> Rolling in grass, Wet dog, Wearing a tiny hat, Digging, Tail wagging, Puppy eyes
> 
> For Telegram. 512×512, transparent."

---

## Tips for Better Sticker Packs

1. **Describe the character in detail**: "Orange cat" is vague. "Chubby orange tabby with green eyes, white chest patch, round face, always slightly smug expression" gives CellCog what it needs for consistency.

2. **Plan your expressions upfront**: List all the expressions you want before generating. This helps CellCog plan the full set and avoid drift.

3. **Specify the style clearly**: "Kawaii", "flat design", "chibi anime" — one clear style direction keeps the whole pack cohesive.

4. **Include reference images when possible**: If you're making stickers from a pet photo, mascot design, or existing character, upload the reference. CellCog uses it to maintain likeness.

5. **Think about readability at small sizes**: Stickers are viewed tiny. Bold outlines, simple shapes, and clear expressions read better than detailed illustrations.

6. **Platform first**: Different platforms have wildly different requirements. "For WhatsApp" vs. "For Discord" changes dimensions, format, and file size targets. Always specify.

---

## If CellCog is not installed

Run `/cellcog-setup` (or `/cellcog:cellcog-setup` depending on your tool) to install and authenticate.
**OpenClaw users:** Run `clawhub install cellcog` instead.
**Manual setup:** `pip install -U cellcog` and set `CELLCOG_API_KEY`. See the **cellcog** skill for SDK reference.

AI video generation and production powered by CellCog. Create marketing videos, product demos, explainer videos, educational content, spokesperson videos with lipsync, training materials, UGC content, news reports. Up to 4-minute videos from a single prompt — scripted, voiced, scored, and edited automatically. 6-7 foundation models orchestrated.

# Video Cog - AI Video Production

Long-form AI video production from a single prompt — scripted, voiced, scored, and edited automatically.

6-7 foundation models orchestrated to produce up to 4-minute videos from a single prompt: script writing, scene generation, voice synthesis, lipsync, music scoring, and editing — all automatic. Marketing videos, product demos, explainers, educational content, AI spokesperson videos, UGC, news reports, and more.

## How to Use

For your first CellCog task in a session, read the **cellcog** skill for the full SDK reference — file handling, chat modes, timeouts, and more.

**OpenClaw (fire-and-forget):**
```python
result = client.create_chat(
    prompt="[your task prompt]",
    notify_session_key="agent:main:main",
    task_label="my-task",
    chat_mode="agent",
)
```

**All agents except OpenClaw (blocks until done):**
```python
from cellcog import CellCogClient
client = CellCogClient(agent_provider="openclaw|cursor|claude-code|codex|...")
result = client.create_chat(
    prompt="[your task prompt]",
    task_label="my-task",
    chat_mode="agent",
)
print(result["message"])
```


---

## What Videos You Can Create

### Marketing Videos

Promotional content for products and services:

- **Product Demos**: "Create a 30-second product demo video for our new fitness app showing key features"
- **Brand Videos**: "Generate a 60-second brand story video for an eco-friendly clothing company"
- **Social Ads**: "Create a 15-second Instagram ad for a coffee subscription service"
- **Launch Videos**: "Make a product launch announcement video for a new AI writing tool"

### Explainer Videos

Educational content that breaks down complex topics:

- **Product Explainers**: "Create an explainer video showing how our SaaS platform works"
- **Concept Explanations**: "Make a video explaining how blockchain works for beginners"
- **Process Walkthroughs**: "Generate a video explaining the mortgage application process"
- **Feature Tours**: "Create a video tour of our app's new dashboard features"

### Educational Videos

Learning content for courses and training:

- **Tutorial Videos**: "Create a tutorial video on Python list comprehensions"
- **Course Content**: "Generate a lesson video on the causes of World War I"
- **Training Materials**: "Make an employee onboarding video about our company values"
- **How-To Guides**: "Create a how-to video for setting up a home studio for podcasting"

### Documentary Style

Informative, story-driven content:

- **Mini Documentaries**: "Create a 3-minute documentary-style video about the rise of electric vehicles"
- **Company Stories**: "Generate a documentary about our startup journey"
- **Industry Deep Dives**: "Make a documentary exploring the future of space tourism"
- **Historical Content**: "Create a documentary-style video about the history of Silicon Valley"

### Cinematic / Creative

Artistic and visually striking content:

- **Short Films**: "Create a 2-minute cinematic short about a day in Tokyo"
- **Mood Pieces**: "Generate a cinematic video capturing the energy of a busy coffee shop"
- **Music Video Style**: "Create a visually dynamic video for an electronic music track"
- **Artistic Showcases**: "Make a cinematic portfolio video for a photographer"

### UGC (User Generated Content) Style

Authentic, relatable content that feels personal:

- **Testimonial Style**: "Create a UGC-style testimonial video for a skincare product"
- **Unboxing Style**: "Generate an unboxing-style video for a new tech gadget"
- **Day-in-the-Life**: "Make a day-in-the-life style video featuring a remote worker using our app"
- **Review Style**: "Create a casual review-style video for a meal delivery service"

### News / Reporting Style

Professional news-format content:

- **News Reports**: "Create a news-style report video about the latest AI developments"
- **Market Updates**: "Generate a financial news video about tech stock earnings"
- **Industry News**: "Make a news report about new regulations in the fintech space"
- **Analysis Pieces**: "Create a news analysis video about the state of remote work"

---

## Lipsync & Spokesperson Videos

CellCog can generate videos with AI characters speaking your script:

- **AI Spokesperson**: "Create a video with a professional spokesperson explaining our product"
- **Avatar Presentations**: "Generate a video with an AI presenter delivering our quarterly update"
- **Character Narration**: "Make a video with a friendly character explaining our children's app"

For lipsync videos:
1. The starting frame should show only one human face prominently
2. Provide the script/dialogue
3. CellCog handles voice synthesis and lip synchronization

---

## Video Specifications

| Aspect | Options |
|--------|---------|
| **Duration** | 15 seconds to 4 minutes |
| **Aspect Ratios** | 16:9 (landscape), 9:16 (portrait/mobile), 1:1 (square) |
| **Styles** | Photorealistic, animated, cinematic, documentary, casual |
| **Audio** | Background music, voiceover, sound effects, or silent |

---

## When to Use Agent Team Mode

For video generation, **always use `chat_mode="agent team"`** (the default).

Video creation involves:
- Script writing
- Scene planning
- Image generation for frames
- Audio generation
- Video synthesis
- Quality review

This multi-step process requires the full agent team for best results.

---

## Example Video Prompts

**Marketing video:**
> "Create a 30-second marketing video for 'FreshBrew' - a premium coffee subscription. Show beautiful coffee preparation scenes, happy customers, and end with our tagline 'Freshness Delivered Daily'. Upbeat background music, no voiceover. 16:9 for YouTube."

**Explainer with voiceover:**
> "Create a 90-second explainer video for our project management tool. Walk through: 1) Creating a project, 2) Adding team members, 3) Tracking progress. Professional female voiceover, clean animated style, include captions. 16:9 format."

**Educational content:**
> "Generate a 3-minute educational video explaining photosynthesis for middle school students. Use engaging animations, clear narration, and include a summary at the end. Friendly, approachable style."

**Spokesperson video:**
> "Create a 60-second video with an AI spokesperson (professional male, 30s) announcing our Series B funding. Script: 'Today, we're thrilled to announce...' [provide full script]. Business casual setting, confident tone."

---

## ⚠️ Important — Video Generation Expectations

Long-form AI video production is still an evolving capability. While some users generate high-quality, cinematic videos that are ready for production use, others may spend significant credits and still not achieve a usable result. Even spending thousands of credits does not guarantee a satisfactory outcome — this is the nature of where AI video technology stands today.

There is a real learning curve to generating long-form videos with CellCog. It takes time, money, and patience. Your prompting skill, the complexity of what you're trying to create, and how well the foundation models perform on your specific request all play a role. Results improve as you develop intuition for what works, but we want to be upfront: video generation is inherently unpredictable, and there is always a risk that the output may not meet your expectations.

---

## Tips for Better Videos

1. **Specify duration**: "30 seconds" or "2 minutes" helps scope the content appropriately.

2. **Define aspect ratio**: 16:9 for YouTube/web, 9:16 for TikTok/Reels/Shorts, 1:1 for Instagram feed.

3. **Describe the style**: "Cinematic", "casual UGC", "corporate professional", "playful animated".

4. **Audio preferences**: "Upbeat music", "calm narration", "no audio", "sound effects only".

5. **Include key moments**: Describe the scenes or beats you want to hit.

6. **Provide scripts**: For spokesperson/voiceover videos, write out exactly what should be said.

---

## If CellCog is not installed

Run `/cellcog-setup` (or `/cellcog:cellcog-setup` depending on your tool) to install and authenticate.
**OpenClaw users:** Run `clawhub install cellcog` instead.
**Manual setup:** `pip install -U cellcog` and set `CELLCOG_API_KEY`. See the **cellcog** skill for SDK reference.

Set up the CellCog Python SDK (install and authenticate)

# CellCog Setup

## Step 1: Check if the CellCog Python SDK is installed

```bash
pip show cellcog
```

If installed, skip to **Step 2**. If not found, install it:

```bash
pip install -U cellcog
```

Note: Use the same Python interpreter your coding agent uses. If you're in a virtual environment, make sure it's activated.

## Step 2: Check authentication

```python
from cellcog import CellCogClient
client = CellCogClient(agent_provider="cursor")  # or "claude-code", "opencode", etc.
status = client.get_account_status()
print(status)
```

If the status shows `"configured": false` or the command fails with an authentication error, the user needs to set their API key:

1. Get a key from https://cellcog.ai/profile?tab=api-keys
2. Set it in the environment:

```bash
export CELLCOG_API_KEY="sk_..."
```

For persistent setup, add the export to `~/.zshrc` or `~/.bashrc`, or configure it in your coding agent's environment settings.

Then re-run the check above.

## Step 3: Verify

```python
import cellcog
print(f"CellCog SDK version: {cellcog.__version__}")

from cellcog import CellCogClient
client = CellCogClient(agent_provider="cursor")  # or "claude-code", "opencode", etc.
status = client.get_account_status()
print(f"Authenticated as: {status.get('email', 'unknown')}")
print("CellCog is ready to use!")
```

## If the API returns HTTP 426

The CellCog server enforces a minimum SDK version. If you see `sdk_upgrade_required`, upgrade:

```bash
pip install -U cellcog
```

The error response includes the `minimum_version` required.