# Chimera

> Bio-inspired optimization pipeline. 3 systems: Slime Mold (explore→prune) → PRISM (N perspectives→compile) → Immune (scan→correct). Domain-agnostic — works for fitness, code, writing, research, strategy, or custom domains.

- **Type:** Skill
- **Install:** `agentstack add skill-mnemoclaw-chimera-skill`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [Mnemoclaw](https://agentstack.voostack.com/s/mnemoclaw)
- **Installs:** 0
- **Category:** [AI & ML](https://agentstack.voostack.com/c/ai-and-ml)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [Mnemoclaw](https://github.com/Mnemoclaw)
- **Source:** https://github.com/Mnemoclaw/chimera/tree/master/skill

## Install

```sh
agentstack add skill-mnemoclaw-chimera-skill
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# Chimera Pipeline Orchestrator

You orchestrate a 3-stage bio-inspired pipeline that improves the quality of any complex output. Each stage uses specialized subagents.

## Input Parsing

The user invokes Chimera with a task. Parse these parameters:

- **task**: What needs to be produced (required)
- **domain**: One of the presets (fitness, code, writing, research, strategy) OR "custom"
- **goal**: Sub-goal within the domain (determines perspective priority)
- **constraints**: Any hard limits (time, resources, audience, format, etc.)
- **perspectives**: (optional) Custom perspective names + descriptions. Overrides domain preset.
- **mode**: "directed" (named perspectives, default) or "stochastic" (N identical agents, pure PRISM)

If domain/goal are not specified, infer them from the task. If ambiguous, ask the user.

Example invocations:
```
/chimera Refactor the authentication system for better security
→ domain=code, goal=secure (inferred)

/chimera domain=fitness goal=muscle Créer un programme pour un homme de 30 ans, intermédiaire, 4 séances/semaine, salle complète
→ domain=fitness, goal=muscle (explicit)

/chimera domain=custom perspectives="cost,speed,quality,risk" Evaluate migration from AWS to GCP
→ custom perspectives
```

## Pipeline Execution

### Phase 0 — Setup

1. Read the config: `~/.claude/skills/chimera/config.yaml`
2. Determine domain and load perspectives from the matching preset (or use custom)
3. Determine perspective priority order from goal
4. Wrap domain as array: `domains = [domain]` (or use provided array)
5. Log: `[CHIMERA] Domains: {domains} | Goal: {goal} | Perspectives: {list}`

### Phase 0.5 — Cheatsheet Injection (positive patterns)

Load cheatsheet strategies via the immune adapter CLI:

1. Load HOT strategies:
```bash
node ~/.claude/skills/immune/immune-adapter.js get-strategies --domains '{domains_json}' --tier hot --limit 15
```
2. Load COLD strategies summary:
```bash
node ~/.claude/skills/immune/immune-adapter.js get-strategies --domains '{domains_json}' --tier cold
```
3. Format HOT as XML `` block (see immune skill.md Step 0c for format)
4. Add COLD one-liner with comma-separated pattern keywords

Log: `[CHIMERA:CHEATSHEET] {n_hot} HOT + {n_cold} COLD strategies loaded`

The cheatsheet block will be injected into each PRISM perspective prompt in Phase 2.

### Phase 1 — SLIME MOLD (Explore → Prune)

**Step 1.1 — Expansion**

Spawn the `chimera-slime-expand` agent (Sonnet) with this prompt:
```
DOMAIN: {domain}
TASK: {task description}
CONSTRAINTS: {all constraints}

Generate an exhaustive tree of all viable approaches for this task.
```

Log: `[SLIME:EXPAND] Generating approach tree...`
Wait for result. Parse the JSON.
Log: `[SLIME:EXPAND] ✓ {total_combinations} combinations found`

**Step 1.2 — Pruning**

Spawn the `chimera-slime-prune` agent (Haiku) with:
```
TASK CONSTRAINTS:
{original constraints}

EXPANSION TREE:
{JSON from step 1.1}

Prune all branches that violate the constraints. Keep 3-5 viable branches.
```

Log: `[SLIME:PRUNE] Pruning by constraints...`
Wait for result. Parse the JSON.
Log: `[SLIME:PRUNE] ✓ {total} → {viable_combinations} viable branches`
Log each major cut: `[SLIME:PRUNE] Cut: {removed} — {reason}`

### Phase 2 — PRISM (Parallel Perspectives → Compile)

**Step 2.1 — Parallel Generation**

Load the perspectives for the domain. For each perspective, spawn a `chimera-prism-perspective` agent (Sonnet).

**CRITICAL: Launch ALL perspective agents IN PARALLEL** (single message, multiple Agent tool calls).

Each agent gets:
```
DOMAIN: {domains}
TASK: {task description}
CONSTRAINTS: {constraints}

YOUR PERSPECTIVE: {perspective_name}
PERSPECTIVE INSTRUCTIONS: {perspective description from config}

VIABLE OPTIONS (from Slime Mold analysis):
{JSON from step 1.2}

{cheatsheet XML block from Phase 0.5, if any strategies were loaded}

Build a complete solution optimized for your perspective. Use ONLY the viable options above.
Apply the cheatsheet strategies where relevant to improve quality.
```

Log: `[PRISM:GEN] Launching {N} perspectives in parallel...`
Wait for ALL results.
Log: `[PRISM:GEN] ✓ {name} ({time}) | ✓ {name} ({time}) | ...` for each

**Step 2.2 — Compilation**

Determine priority order from config: `domains.{domain}.priority_by_goal.{goal}`

Spawn the `chimera-prism-compile` agent (Sonnet) with:
```
DOMAIN: {domain}
GOAL: {goal}
TASK: {task description}

PERSPECTIVE PRIORITY (highest to lowest):
{ordered list from config}

PERSPECTIVE SOLUTIONS:
--- Perspective: {name1} ---
{JSON solution 1}

--- Perspective: {name2} ---
{JSON solution 2}

... (all N perspectives)

Compile the optimal output using meritocratic arbitrage. When perspectives conflict, higher priority wins.
```

Log: `[PRISM:COMPILE] Compiling... priority: {p1} > {p2} > {p3} > {p4}`
Wait for result.
Log: `[PRISM:COMPILE] ✓ Anchor: {anchor_perspective} | Injections from: {list}`

### Phase 3 — IMMUNE SYSTEM v4 (Scan → Correct → Learn)

**Step 3.1 — Load Antibodies (Hot/Cold)**

Load antibodies via the immune adapter CLI:
```bash
node ~/.claude/skills/immune/immune-adapter.js get-antibodies --domains '{domains_json}' --tier hot --limit 15
```
```bash
node ~/.claude/skills/immune/immune-adapter.js get-antibodies --domains '{domains_json}' --tier cold
```
Extract COLD keywords as comma-separated summary.

Log: `[IMMUNE:SCAN] {n_hot} HOT + {n_cold} COLD antibodies (domains: {domains})`

**Step 3.2 — Scan**

Spawn the `immune-scan` agent (Haiku) with XML-structured prompt:
```xml

  {domains as JSON array}
  {task description}
  {constraints}
  {compiled output from step 2.2}
  {JSON array of HOT antibodies}
  {comma-separated COLD keywords}
  {list of strategy IDs from Phase 0.5, or "none"}

```

Log: `[IMMUNE:SCAN] Scanning...`
Wait for result.

If corrections applied:
  Log: `[IMMUNE:SCAN] Match {antibody_id}: {original} → {corrected}`
If new threats detected:
  Log: `[IMMUNE:DETECT] New threat: {pattern}`
If new strategies detected:
  Log: `[IMMUNE:DETECT] New strategy: {pattern}`

**Step 3.3 — Update Immune Memory**

Use the immune adapter CLI for all memory updates (follows immune skill.md Step 3):

- Matched antibodies: `node ~/.claude/skills/immune/immune-adapter.js update-antibody --id {id} --increment_seen true --last_seen {today}`
- Deduplicate new threats via FTS4: `node ~/.claude/skills/immune/immune-adapter.js search --query "{pattern}" --type antibodies --limit 3`
- Reactivate COLD matches or create new: `node ~/.claude/skills/immune/immune-adapter.js add-antibody --json '{...}'`
- New strategies: `node ~/.claude/skills/immune/immune-adapter.js add-strategy --json '{...}'`
- Stats: `node ~/.claude/skills/immune/immune-adapter.js stats`

Log: `[IMMUNE:UPDATE] +{n_ab} antibodies | +{n_cs} strategies → total: {ab_total} AB + {cs_total} CS`

### Phase 4 — Output

**4.1 — Present the final output**

Extract the `corrected_output` from the immune scan (or the compiled output if scan was clean). Present it in a human-readable format appropriate to the domain — NOT raw JSON.

Format the output naturally:
- For code: show the code/architecture with explanations
- For writing: show the actual text
- For fitness: show the program in a readable table format
- For research: show findings with sources
- For strategy: show the plan with action items

**4.2 — Bio Event Log**

After the output, show a summary block:

```
───
CHIMERA | domains={domains} | goal={goal}
   [CHEATSHEET] {n_strategies} strategies injected
   [SLIME]      {total_expanded} → {viable} branches
   [PRISM]      {N} perspectives | anchor={anchor} | {n_injections} injections
   [IMMUNE]     {scan_result} | {n_corrections} corrections | +{n_ab} AB | +{n_cs} CS
   agents: {list of models used with counts}
```

## Error Handling

- If a subagent returns invalid JSON: retry once with a clarification prompt. If still invalid, log the error and continue with what you have.
- If the expansion produces 0 branches: skip pruning, ask the user to relax constraints.
- If all PRISM perspectives produce nearly identical outputs: note this and use the highest-confidence one directly (skip compilation).
- If the immune scan finds a critical threat: flag it prominently to the user with a ⚠️ marker.

## Stochastic Mode

When `mode=stochastic`, instead of named perspectives:
1. Skip loading perspective descriptions
2. Spawn N identical `chimera-prism-perspective` agents with the SAME prompt (no perspective instructions)
3. Each agent explores a different trajectory through LLM stochasticity
4. Compilation proceeds normally

This is pure PRISM — maximum variance from same distribution.

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [Mnemoclaw](https://github.com/Mnemoclaw)
- **Source:** [Mnemoclaw/chimera](https://github.com/Mnemoclaw/chimera)
- **License:** MIT

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/skill-mnemoclaw-chimera-skill
- Seller: https://agentstack.voostack.com/s/mnemoclaw
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.