/flux

Multi-Engine Flux[ideate] (Parallel Brainstorm Round)

Shared engine selection, capability/authorization gates, dispatch, capture, attribution and degraded-mode policy: _common/MULTI_ENGINE_RECIPE.md and _common/CLI_COMPATIBILITY.md. This reference defines only the domain payload and integration rules.

Implementation notes for /flux multi. Reads as a delta on _common/MULTI_ENGINE_RECIPE.md — this document only states what is Flux[ideate]-specific. Read the common protocol first.

Pattern type: D (Divergence-primary). Verb: flux. Subagent names: riff-codex + riff-claude (dual-engine baseline) + riff-agy (when AVAILABLE).

Dialogue posture. Unlike Spark/Echo[demand], Flux[ideate] is interactive. multi is positioned as a single "parallel brainstorm round" dropped into an ongoing dialogue — the 9 / 12 outputs become seed ideas for the next dialogue turn, not a final deliverable. Flux[ideate] never replaces dialogue with multi; multi accelerates one divergence step inside dialogue.

Mode Coverage Toggle

Two operating modes, user-selectable at invocation:

The user (or main context interpreting dialogue signals) chooses the active mode:

If no signal, default = expand. Pass the active mode to all three subagents.

JSON Output Schema

Each subagent returns:

{
  "engine": "codex|agy|claude",
  "active_modes": ["expand"],
  "ideas": [
    {
      "id": "codex-expand-01",
      "mode": "expand|propose|evaluate|subtract",
      "idea_text": "One sentence stating the idea or angle (problem-shaped, not solution-shaped when in expand mode)",
      "rationale": "Why this angle matters — what assumption it challenges, what reuse it exploits, what risk it surfaces",
      "connection_to_theme": "How this links back to the user's stated theme (one phrase)"
    }
  ],
  "engine_notes": "Optional: what bias this engine knows it brings (e.g., 'GitHub-heavy priors push toward dev-tool framings')"
}

id convention: {engine}-{mode}-{nn} (e.g., agy-propose-02). Stable IDs let the next dialogue turn cite "let's expand on claude-expand-03".

Target count per subagent:

• multi (single mode): 3-4 ideas per engine = 9-12 total
• multi --all-modes: 2-3 ideas per mode per engine = 24-36 total (cap at 36)

CLUSTER Identity Rules (Flux[ideate]-specific)

Two ideas match (form one cluster) when both hold:

1. Same active mode — an expand angle and a propose angle that touch the same topic are NOT the same cluster (they answer different mode-questions about the same theme).
2. Semantic overlap on the core move — what the idea actually asks the user to consider. Examples of matches:
   • "Reframe the export problem as a permission problem" ≡ "Maybe this isn't an export issue — it's about who can see what" (same expand move)
   • "Add a bulk-export action" ≡ "Background export job for large datasets" (same propose solution class — bulk export)
   • "Drop the dashboard tab entirely" ≡ "Remove the dashboard surface" (same subtract move)

Not a match:

• Same wording, different mode → keep separate (mode is part of cluster identity)
• Overlapping topic, different challenge axis → keep separate (e.g., "challenge the persona" vs "challenge the timing" are both expand but different angles)
• One concrete, one abstract framing of the same thing → match if the abstract framing clearly subsumes the concrete one

Record the engine set per cluster. Per-engine wording variants are preserved — Flux[ideate] often surfaces them in dialogue as "Codex framed this as X, Claude framed it as Y — does either resonate more?".

SCORE Rubric

Flux[ideate] is Pattern D (Divergence-primary). Apply the base D rubric per _common/MULTI_ENGINE_RECIPE.md, with one Flux[ideate]-specific tweak: score within each mode, not across modes. A UNIVERSAL expand idea is incomparable to a VERIFIED-DIVERGENT subtract idea — they serve different turns of the diamond.

Critical Riff-only inversion: in EXPAND mode, an UNIVERSAL idea is suspect of being the obvious framing the user could have arrived at alone — Flux[ideate]'s whole job is to surface non-obvious angles. Surface UNIVERSAL EXPAND ideas, but lead the dialogue with VERIFIED-DIVERGENT ones. In SUBTRACT mode, the inversion is gentler — UNIVERSAL "this is excess" signals tend to be correct.

GROUND Checks (Flux[ideate]-specific)

For each VERIFIED-DIVERGENT candidate, the Flux[ideate] main context checks:

1. Theme connection — does the idea actually connect back to the user's stated theme? If only loosely related, downgrade to NEEDS-INFO and surface as a tangent-with-question rather than a primary seed.
2. Mode fit — does the idea actually do what its declared mode demands? An expand idea that proposes a concrete solution is mis-moded; either re-tag as propose or drop.
3. Hallucinated entity check — if the idea cites a specific feature, persona, competitor, or capability the system clearly does not have, mark REJECTED-HALLUCINATION.
4. Sugar-coat check (Flux[ideate]-specific) — if the idea reads as polite cheerleading without a real challenge, drop. Flux[ideate]'s Core Contract demands honest friction; cheerleading ideas waste a divergence slot.
5. Duplicate-of-prior-turn check — if the dialogue has already explored this angle, mark REJECTED-DUPLICATE.

For UNIVERSAL / LIKELY clusters, do only the hallucinated-entity check and the duplicate-of-prior-turn check.

SYNTHESIZE — Two Output Shapes

Flux[ideate] supports two synthesis outputs depending on invocation:

Per-Mode Portfolio (default, multi)

A single dialogue turn containing:

• Mode header — which mode the round explored (e.g., "EXPAND round, 3 engines")
• Idea cards ordered: VERIFIED-DIVERGENT first (lead with breakthroughs), then LIKELY, then UNIVERSAL (Flux[ideate]'s inversion vs Spark)
• Each card: id, idea_text, engine-attribution tag, rationale (one line), connection_to_theme
• Flux[ideate]'s framing question — one open question per shipped idea, in Flux[ideate]'s voice, that pulls the user into reacting (per the Turn Structure: Receive → Challenge → Prompt)
• Round close — a "which 1-3 want to go deeper on?" prompt routing the next dialogue turn

The user's pick becomes the seed for the next dialogue round — not a multi round, but a normal Flux[ideate] turn drilling into the selected idea.

All-Modes Matrix (multi --all-modes)

A single dialogue turn with a 4 × N matrix:

Below the matrix:

• Diamond reading — Flux[ideate]'s interpretation of which mode the matrix suggests is highest leverage right now (e.g., "PROPOSE column is thin — the theme isn't concrete enough yet; recommend continuing EXPAND")
• Top breakthrough callout — the single most interesting VERIFIED-DIVERGENT cell, with explicit "this is the angle none of the others reached"
• Two-track next-step prompt — "(A) zoom into mode X next round / (B) pick 2 ideas across the matrix to weave into one"

Engine-Attribution (mandatory on every shipped idea)

• [codex+agy+claude] — 3/3 UNIVERSAL
• [codex+agy] / [codex+claude] / [agy+claude] — 2/3 LIKELY
• [codex-verified] / [agy-verified] / [claude-verified] — 1/3 VERIFIED-DIVERGENT (grounded)

Integration with Dialogue Continuation

multi is one turn inside a larger Flux[ideate] dialogue. The next turn behavior:

The Flux[ideate] main context tracks dialogue state across rounds, so the duplicate-of-prior-turn check at GROUND step has data to work with.

Degraded Modes

Identical to _common/MULTI_ENGINE_RECIPE.md §Engine Availability Modes. Flux[ideate]-specific addition:

Subagent Prompt Skeleton

Use the canonical spawn/capture template in _common/CLI_COMPATIBILITY.md with the JSON schema in this reference. Spawn once per selected available engine, not a fixed three. Add these domain fields; the main context owns normalization, grounding and synthesis.

Role: Generate brainstorming ideas for the active mode(s) below. You are one of the selected engines working independently — do not try to be exhaustive; surface what your training data suggests is the most non-obvious angle. Flux[ideate]'s whole purpose is to find ideas the user could not easily reach alone.

Target:

• Theme: {user's stated theme}
• Prior dialogue context: {short summary of what was already explored, to avoid duplication}
• Active mode(s): {expand | propose | evaluate | subtract | ALL}
• Target idea count: {3-4 if single mode, 2-3 per mode if all-modes}
• Persona pool (if relevant): {personas from Cast registry or "open"}

Constraints:

• EXPAND ideas must name an ANGLE OR ASSUMPTION TO CHALLENGE, not a solution
• PROPOSE ideas must be ONE concrete sentence, not a paragraph
• EVALUATE ideas must name a TRADE-OFF AXIS, not pick a winner
• SUBTRACT ideas must name SPECIFICALLY what to drop and what survives
• Each idea must connect back to the stated theme (state how in connection_to_theme)
• Do not paraphrase or invent capabilities, personas, or competitors the user did not mention; if you cite reuse of something existing, name it specifically
• Honest friction is the whole point — do not produce polite cheerleading; if you see a fatal flaw in the user's theme framing, surface it as a high-priority EXPAND idea

Loose-prompt rule applies — do NOT pass the SCAMPER lens taxonomy, Crazy-8 axis catalog, Steelman protocol, or any other Flux[ideate] Recipe templates. Those apply at SYNTHESIZE in the main context only.

Cross-References

• _common/MULTI_ENGINE_RECIPE.md — base protocol (read first)
• _common/SUBAGENT.md §MULTI_ENGINE — engine dispatch mechanics
• spark/reference/tri-engine-proposal.md — canonical Pattern D implementation (mirror this structure)
• echo/reference/tri-engine-demand.md — Pattern D with calibration (Flux[ideate] does NOT calibrate but the dialogue-integration pattern is similar)
• flux/reference/patterns.md — mode definitions and transition signals (referenced when interpreting which mode multi should default to)