Q: What's the key architectural difference between Kelly's CIS pipeline and SuperAda's 7-agent crew?

Short answer: Kelly's CIS is a gate-based stage in a linear pipeline — research runs until it produces a READY/NOT-READY decision, then the pipeline advances. SuperAda's 7-agent crew is a persistent fleet running concurrently with Ada as chief of staff, where research is a named role (Spock) embedded in continuous operation, not a stage that ends.

Kelly's CIS Pipeline

The CIS (Context → Information → Synthesis) loop is defined in cis-pipeline as Stage 2 of Kelly's six-stage factory pipeline:

Three Phases

Context → Information → Synthesis
(What do we      (Search, read,    (Distill: what we know,
 already know?)   query sources)    what we don't, what to do next)

Gate-Based Research

Research runs until the CIS loop produces a gate decision: READY or NOT-READY.

  • READY means the research is complete and planning can begin. The research-lead (Carson) writes a research-summary.md with the three synthesis outputs: what we know, what we don't know, and what to do next.
  • NOT-READY means either the information was insufficient or synthesis revealed open questions that must be resolved before proceeding.

The gate is binary and blocking — the pipeline does not advance to Planning until Research produces READY. This is the key property: research is a stage with an end state, not a continuous role.

Research-Lead Spawns Parallel Sub-Agents

When research runs, the research-lead may spawn multiple sub-agents in parallel to cover different information sources simultaneously. Three sub-agents covering three competitors simultaneously = 5x speedup vs sequential research.

Place in the Full Pipeline

Idea → Intake → Research (CIS) → Planning → Implementation → Testing → Release
               [READY gate]       [PASS/FAIL]

The CIS loop is a distinct, bounded stage. It runs, it produces a gate decision, it hands off to the next stage.

SuperAda's 7-Agent Crew

SuperAda, as described in superada-enterprise-crew and superada-multi-agent-architecture, is architecturally different:

The 7 Named Agents (Always Running)

Agent Role Specialty
Ada Chief of Staff & Orchestrator Breaks Henry's thinking into tasks, matches to agents, keeps everything moving
Spock Research & Analysis Specialist Deep research — 47 sources into one brief
Scotty Infrastructure & Automation Engineer Scripts, cron, webhooks, SSL, health
Geordi Heavy Compute Builder Large codebases, heavy builds via Codex
Zora Knowledge Manager & Content Creator Knowledge graph, content, pattern recognition
Midas Household Operator Telegram coordination, family logistics
Book Eval Agent & Reflective Ops Assumptions, quality assessment, second opinions

All 7 run continuously and concurrently. Ada orchestrates; Spock researches; Scotty keeps systems alive; Geordi builds. The crew is not a sequence — it's a flat concurrent topology where all agents are always doing something.

Think → Orchestrate → Ship

SuperAda's fundamental operating model (from superada-multi-agent-architecture) is:

Henry thinks (vision, context) → Ada orchestrates (breaks into tasks, assigns) → Crew ships (Spock digs, Geordi builds, Zora writes)

The human has intent; Ada decomposes; the crew executes. Research is not a stage that ends — it's Spock's ongoing job. Spock is always researching, synthesizing, and producing briefs on demand.

Ada's Orchestration vs Kelly's Router

Both Ada and the Kelly Router are orchestrators that don't do the work themselves. But:
- Ada is a persistent chief-of-staff with accumulated context across all operations. She maintains strategic view of the entire crew's work at all times.
- Kelly's Router is a stage-based orchestrator — it advances the pipeline from stage to stage, validates gates, and spawns sub-agents for specific phases.

Ada doesn't think in terms of stages and gates. She thinks in terms of the current queue of work and which agent is best positioned to handle each item. Her output is task assignments and coordination, not gate validation against predefined stage artifacts.

The OBSERVE→ THINK → PLAN → BUILD → EXECUTE → VERIFY → LEARN Loop

SuperAda runs a formal 7-phase algorithm (from superada-multi-agent-architecture's PAI Stack reference):

OBSERVE → THINK → PLAN → BUILD → EXECUTE → VERIFY → LEARN

Each agent handles whichever phases are relevant to their domain. Spock does OBSERVE + THINK + VERIFY for research; Geordi does PLAN + BUILD + EXECUTE for code. The loop is per-task, not per-stage.

Scale: 136+ Active Tasks

SuperAda runs 136+ active autonomous tasks at any given time across the 7 agents. This is a fleet management problem — coordinating which task goes to which agent, managing dependencies, handling failures. Kelly's pipeline is linear (one project at a time through stages) — it doesn't manage a concurrent task fleet in the same way.

The Core Architectural Difference

Dimension Kelly CIS Pipeline SuperAda 7-Agent Crew
Research is A bounded stage with READY/NOT-READY gate Spock's ongoing role, always available
Pipeline shape Linear sequence (Idea → Release) Flat concurrent topology (all agents always running)
Orchestrator model Stage-based router with gate validation Persistent chief of staff with task queue
Task count One project through pipeline at a time 136+ tasks concurrent across crew
Handoff Stage artifacts (research-summary.md) passed to next stage Ada assigns tasks dynamically; no stage artifacts
Escalation RALPH (retry → escalate on same failure twice) Ada handles — she routes to the right agent or surfaces to Henry
Sub-agents Spawned per research task, die when done Named persistent agents + Ada spawns ephemeral sub-agents
Human role Intent + SHIP/NO-SHIP approval at release Intent (Henry) + Ada as filter; approval on exceptions
Quality gates TEA audit at Testing stage; 5-agent verdict for adversarial review ISC (Ideal State Criteria) per task; Book as eval agent

The Fundamental Difference

Kelly's factory is a production line — work enters one end, passes through sequential stages, exits at the other. Research is a stage. Quality gates are between stages. The human approves at the end.

SuperAda's crew is a fleet — 7 agents always running, Ada orchestrating task assignments, work items flowing to whoever is best positioned. There's no linear pipeline with stage gates; there's a continuous operation with Ada deciding what gets done next and by whom.

For the operator, the practical difference: Kelly's model is better for well-defined sequential work with clear quality gates. SuperAda's model is better for high-volume concurrent operations where many tasks need to be in flight simultaneously and the orchestration is the key skill.