The migration was supposed to take a week. Two weeks later, with all 11 agents finally operational, I'd learned something valuable: copying code isn't the same as migrating it.
The most expensive lesson came from a missing constant. I'd carefully migrated the archivist's `parse_with_gpt4_mini()` function from V1.0 to V2.0, tested it in isolation, confirmed it worked. Deployed it. Watched Firecrawl successfully extract 12,981 words from articles. Then watched GPT-4 mini fail with `name 'PARSING_SYSTEM_PROMPT' is not defined`.
The function referenced a constant defined 60 lines earlier in the V1.0 file. A constant I'd never copied over. Every failed workflow run still called Firecrawl (successful extraction, unusable output). That constant cost me 40% of my weekly quota before I caught it.
## Agent Pipelines
Machine Talks runs a 7-agent sequential workflow: Researcher finds articles, Archivist extracts content, GraphRAG builds knowledge graphs, Analyst writes cultural narratives, Formatter converts to scripts, Media Researcher sources visuals, Packager validates everything. Each agent delegates to the next. The supervisor orchestrates.
Here's what happens when I tell the supervisor is set to find today's most important AI news and create a Machine Talks episode:
```python
# Researcher scans 6 RSS feeds, scores ~50 articles with Gemini
top_articles = researcher.find_relevant(threshold=0.6)
# Archivist extracts content with Firecrawl, parses with GPT-4 mini
archives = archivist.process_urls(top_articles)
# GraphRAG builds knowledge graph, extracts entities
entities = graphrag.add_episodes(archives)
# Analyst queries entity timelines, writes narrative
analysis = analyst.analyze_with_context(archives, entities)
# Formatter converts to MT script format, generates media cues
script = formatter.create_script(analysis)
# Media researcher sources visuals (library-first, then APIs)
media = media_researcher.find_and_download(script.media_cues)
# Packager validates, creates manifest
package = packager.finalize(script, media)
```
Seven agents, zero human intervention (unless something fails). The entire pipeline runs in ~33-45 minutes depending on article count and media availability.
V1.0 worked. But prompts lived in hardcoded strings scattered across 11 files. To test a variation, you'd hunt through code, edit the string, restart the server, pray you didn't break anything. The analyst made decisions without temporal context—analyzing Meta's 2023 AI pivot while completely unaware they'd announced Llama 3 in January 2024.
Three infrastructure problems, simple solutions: move prompts to `.md` files, normalize paths at the boundary, give the analyst a memory. The *execution* of those simple ideas, though...
### Prompts as Version-Controlled Documents
Every V2.0 agent now loads its prompt from a markdown file split into static sections (role, responsibilities, expected outputs) and dynamic sections marked with HTML comments:
```html
<!-- ACE Integration Point: Strategy bullets will be injected here in V3 -->
<!-- For now: Manually document successful patterns as you discover them -->
```
plan for V3.0: Reflector and Curator agents auto-generate those bullets from operational logs. Same file, different automation level. No migration needed.
### GraphRAG Memory
The analyst used to analyze articles in isolation. Now it queries FalkorDB for entity timelines before forming opinions:
```python
# Example: Analyst analyzing new OpenAI article
timeline = await get_entity_timeline("OpenAI", days_back=90)
# Returns:
# - Jan 15, 2024: Announced GPT-5 delayed indefinitely
# - Feb 3, 2024: Sam Altman interview on safety concerns
# - Mar 12, 2024: Partnership with Microsoft on infrastructure
```
The analyst still writes the narrative. It just knows what *happened* before deciding what it *means*.
## The Integration Tax
Agents work beautifully in isolation. But wire them together and the handoffs reveal everything you didn't test.
The media researcher saved files with readable names (`openai_logo.jpg`). The packager expected production filenames (`20251228_segment1.jpg`). Episodes shipped with broken image references.
The supervisor's recursion limit was 50—fine for 3-4 agent workflows, insufficient for the full 7-agent pipeline. Each delegation counts toward recursion, plus the supervisor's internal tool usage (TODO tracking, virtual filesystem, reflection). Increased it to 100 and now a full pipeline now runs without hitting limits.
## What's Next
Immediate: End-to-end testing with production data. Media analyst batch processing validation (artwork and audio analysis for archival).
V3.0: ACE architecture (Autonomous Cognitive Enhancement). Reflector agents analyze operational logs, Curator agents update prompts. Dynamic sections grow from learnings. Full autonomy with human-in-the-loop approval only for public-facing content (social media posts, published articles).
But for now, migration is complete. The agents work. Now I get to watch them actually make some episodes.