Find-Create-Critique Cycle

Duration: 45 minutes Difficulty: Beginner Pattern: Sequential Chain

This scenario walks through the foundational FCC cycle using three core personas. You will see how a research question flows from discovery through creation to quality review, with full message passing and simulation trace output.

Scenario Overview

Problem: A team needs to produce a well-researched, well-structured documentation deliverable on metadata standards for research data management.

Goal: Execute a complete Find-Create-Critique cycle and produce a reviewed deliverable with quality scores.

Persona Team

Persona	ID	Phase	Role
Research Crafter	RC	Find	Discovers relevant sources, synthesizes background research
Blueprint Crafter	BC	Create	Structures findings into a coherent deliverable
Documentation Evangelist	DE	Critique	Reviews for quality, completeness, and clarity

Setup

from fcc.personas.registry import PersonaRegistry
from fcc.simulation.engine import SimulationEngine
from fcc.simulation.messages import SimulationMessage
from fcc.messaging.bus import EventBus
from fcc.messaging.events import EventType

# Load the persona registry
registry = PersonaRegistry.from_yaml_directory("src/fcc/data/personas")

# Create an event bus for observability
bus = EventBus()
collected_events = []
bus.subscribe(
    EventType.SIMULATION_STEP_COMPLETED,
    lambda event: collected_events.append(event),
)

# Create the simulation engine in deterministic mode
engine = SimulationEngine(registry=registry, mode="deterministic")

topic = "Metadata standards for research data management"

Phase 1: Find

The Research Crafter (RC) conducts discovery, identifying relevant sources, standards, and background material:

find_message = SimulationMessage(
    sender="orchestrator",
    receiver="RC",
    content=(
        f"Research the following topic: {topic}. "
        "Identify key standards (Dublin Core, DataCite, Schema.org), "
        "recent publications, and community best practices. "
        "Synthesize findings into a structured research brief."
    ),
    phase="find",
)

find_result = engine.step(find_message)
print(f"Find phase complete.")
print(f"  Sender: {find_result.sender}")
print(f"  Phase: {find_result.phase}")
print(f"  Content length: {len(find_result.content)} chars")
print(f"  Preview: {find_result.content[:200]}...")

Phase 2: Create

The Blueprint Crafter (BC) takes the research findings and structures them into a deliverable:

create_message = SimulationMessage(
    sender="RC",
    receiver="BC",
    content=(
        f"Based on the following research findings, create a structured "
        f"documentation deliverable on '{topic}':\n\n"
        f"{find_result.content}\n\n"
        "The deliverable should include: executive summary, standards "
        "comparison table, implementation guidelines, and recommendations."
    ),
    phase="create",
)

create_result = engine.step(create_message)
print(f"Create phase complete.")
print(f"  Content length: {len(create_result.content)} chars")
print(f"  Preview: {create_result.content[:200]}...")

Phase 3: Critique

The Documentation Evangelist (DE) reviews the deliverable for quality, completeness, and clarity:

critique_message = SimulationMessage(
    sender="BC",
    receiver="DE",
    content=(
        f"Review the following documentation deliverable for quality, "
        f"completeness, clarity, and adherence to documentation standards:\n\n"
        f"{create_result.content}\n\n"
        "Provide: overall quality score (0-1), specific feedback on "
        "each section, and actionable improvement recommendations."
    ),
    phase="critique",
)

critique_result = engine.step(critique_message)
print(f"Critique phase complete.")
print(f"  Content length: {len(critique_result.content)} chars")
print(f"  Preview: {critique_result.content[:200]}...")

Message Flow Diagram

The message flow follows a strict sequential pattern:

orchestrator --> [RC] Find
                  |
                  | research findings
                  v
                [BC] Create
                  |
                  | structured deliverable
                  v
                [DE] Critique
                  |
                  | quality review + score
                  v
               COMPLETE

Examining the Simulation Trace

After executing all three phases, examine the collected events and build a trace:

print(f"Events collected: {len(collected_events)}")
for i, event in enumerate(collected_events):
    print(f"  [{i+1}] {event.event_type.value}: "
          f"source={event.source}, "
          f"timestamp={event.timestamp[:19]}")

# Build a summary trace
trace = {
    "scenario": "find-create-critique-cycle",
    "topic": topic,
    "phases": [
        {
            "phase": "find",
            "persona": "RC",
            "input_length": len(find_message.content),
            "output_length": len(find_result.content),
        },
        {
            "phase": "create",
            "persona": "BC",
            "input_length": len(create_message.content),
            "output_length": len(create_result.content),
        },
        {
            "phase": "critique",
            "persona": "DE",
            "input_length": len(critique_message.content),
            "output_length": len(critique_result.content),
        },
    ],
}

import json
print(json.dumps(trace, indent=2))

Quality Scoring

Use the collaboration scoring engine to evaluate the deliverable:

from fcc.collaboration.scoring import ScoringEngine

scorer = ScoringEngine()
score = scorer.score_text(create_result.content)
print(f"Deliverable quality score: {score:.2f}")

Exercises

1. Add a feedback loop: If the critique score is below 0.8, send the feedback back to BC for revision and repeat the critique phase.
2. Expand the team: Add a fourth persona (e.g., STE - Semantic Taxonomy Expert) between Find and Create to organize the research into a taxonomy.
3. Compare modes: Run the same scenario with mode="ai" (requires API key) and compare output quality.
4. Event monitoring: Subscribe to additional event types and build a more detailed trace.

Summary

In this scenario you executed the foundational Find-Create-Critique cycle:

• RC discovered and synthesized research on metadata standards
• BC structured the findings into a documentation deliverable
• DE reviewed the deliverable and provided quality feedback
• The full message flow was traced through the event bus

This pattern is the building block for all FCC workflows. Every more complex scenario builds on this core cycle.

Next Steps

• Champion Team Sprint -- Add champion orchestration
• Persona Composition Patterns -- See 8 patterns