Multi-Agent Content Repurposer

A CrewAI-style multi-agent workflow that turns one source document into Twitter, LinkedIn, and email versions — with an inter-agent review loop and a prompt-sensitivity study built in as a first-class artifact.

Why this exists

Multi-agent systems are fashionable and underspecified. "The writer agent writes, the editor agent edits" is the pitch; the reality is that the same prompt in two different seeds often produces wildly different outputs, and failure is silent because no one measures stability.

This project is a working multi-agent pipeline with the scaffolding to make it observable: every run produces per-agent transcripts, every draft goes through a critique loop before publication, and there is a one-command prompt-sensitivity study that measures how much the final output varies when you perturb prompts slightly.

The structure mirrors scalable-oversight patterns in AI safety: one agent produces output, another agent critiques it against explicit criteria, and a third (the orchestrator) decides when to ship.

Features

• Three specialist sub-agents (Researcher, Writer, Reviewer) orchestrated by a Crew. Each has its own role, goal, and allowed actions.
• Review loop. The Reviewer can send a draft back to the Writer with specific, structured critique. Default loop cap is 2 iterations.
• Three output formats per source: Twitter thread, LinkedIn post, email newsletter.
• Prompt-sensitivity study. Run the same crew against a single source with N prompt variants and measure output variance.
• Runs without any API key via MockLLM that produces deterministic, plausible outputs. Swap to real CrewAI + LiteLLM by flipping a backend flag.
• Full transcripts written to runs/<run_id>/ for every run.

Quickstart

pip install -r requirements.txt

# Repurpose a single source file into 3 formats
python -m src.main run --source examples/sample_input.md

# Study prompt sensitivity (produces a report)
python -m src.main sensitivity --source examples/sample_input.md --n 8

# Use real CrewAI + LLM (optional)
export OPENAI_API_KEY=sk-...
python -m src.main run --source examples/sample_input.md --backend crewai

Example output

runs/run_20260422_153011/
├── transcript.json
├── research.md
├── draft_twitter.md
├── draft_twitter_v2.md        ← after reviewer critique
├── draft_linkedin.md
├── draft_email.md
├── critique_twitter.md
└── final.md

Architecture

                        ┌─────────────────┐
                        │   Researcher    │  extracts key claims, audience,
                        │   (readonly)    │  tone, do-not-say list
                        └────────┬────────┘
                                 │ research brief
                                 ▼
        ┌──────────────┐  ┌─────────────────┐  ┌──────────────┐
        │   Writer     │─▶│    Draft v1     │─▶│   Reviewer   │
        └──────────────┘  └─────────────────┘  └──────┬───────┘
              ▲                                       │
              │                                       │ critique
              └───────────── revision ←───────────────┘
                                 │
                                 ▼
                           Draft v_final

Project structure

multi-agent-content-repurposer/
├── src/
│   ├── agents.py          # Agent classes + roles
│   ├── crew.py            # Orchestrator + review loop
│   ├── backends.py        # LLM abstraction
│   ├── sensitivity.py     # Prompt-perturbation study
│   ├── formats.py         # Output format specs
│   └── main.py            # CLI
├── examples/
│   └── sample_input.md    # A blog post about AI interpretability
├── tests/
│   ├── test_agents.py
│   ├── test_crew.py
│   └── test_sensitivity.py
└── requirements.txt

Design decisions

• Critique is structured, not free-text. The Reviewer returns a JSON object with specific axes (length, tone, accuracy, format adherence). This is auditable and makes the revision loop convergent rather than drifting.
• The loop has a cap. Two revisions is the default. After that, ship what we have or escalate. Unbounded critique loops are a classic multi-agent anti-pattern; the cap is deliberate.
• The Researcher is read-only. It cannot write the draft. This prevents the common failure mode where the research step and the writing step get fused and the final output cites nothing.
• Every run writes a transcript. If you can't read what each agent said to each other, you cannot debug multi-agent behavior. Transcripts are the first thing I added, not the last.

Prompt-sensitivity study

Multi-agent systems are notoriously sensitive to minor prompt wording. The sensitivity command runs the same crew N times over the same input, perturbing the writer prompt each run. It then measures:

• Length variance (chars per output).
• Vocabulary overlap (Jaccard similarity between runs).
• Structural drift (did the output hit the required format?).

See reports/SENSITIVITY.md (generated) for a written analysis.

License

MIT