Editorial Model - Wire as a Newsroom Team

5 min read

You're looking at an AI content system and wondering why it has three separate pieces instead of one. The answer changes depending on what broke.

Wire splits its work across three roles: a Chief that plans, a Reporter that gathers news, and an Editor that writes. Most systems collapse this into one prompt. Wire tried that first and abandoned it. The reason it failed is not obvious until you've seen the specific ways a single prompt degrades under real workloads. Which part of that tradeoff matters most to you right now?

When a single prompt handles both evaluation and writing, the evaluation criteria bleed into the writing style. Pages start reading like analysis reports. That's one failure mode. There's another: when output is wrong, you can't tell where it went wrong. Was it the news evaluation? The synthesis? The integration? The writing? Wire separates these so each stage is inspectable independently. But there's a cost dimension here too, and it's not what most people expect.

The Reporter doesn't just fetch articles. It reads each one individually before synthesizing across all of them. Wire's first approach batched everything together. Important details got lost in volume. The individual-then-synthesis pattern came from an observational study of actual journalists, which found that source checking accounts for only 0.9% of research actions. Wire forces the step that working journalists almost never perform. That changes what the Editor receives, which changes what ends up on the page.

The roles communicate through files, not memory. Every intermediate state sits on disk between steps. The news file exists before the Editor touches it. You can read it, edit it, or delete it. If a batch run crashes at step 47 of 200, the first 46 items have their news files saved and the run resumes at 47. Nothing is lost. This also means the pipeline is interruptible by design, not by accident. Which part of that matters to your situation?

The three roles are classes running in the same process, not microservices. No message queues, no API gateways. `Chief.audit()` tells you the site state. `NewsReporter.cover_item()` returns evaluated news for a single content item. `ContentEditor.improve()` takes an amendment brief and produces a page. Each method is a single Claude call with predictable cost. If you have your own sources, you can write news files directly and skip the Reporter entirely. The Editor does not check where the news came from.

Customizing Wire means customizing each role independently. The Chief reads `wire.yml` for thresholds and intervals. The Reporter reads `news_search.md` and `news_evaluate.md` to decide what counts as relevant. The Editor reads `_styleguide.md` and topic-level action overrides to match the site's voice. Changing one does not affect the others. A German B2B agency and an English vendor directory run the same Chief and Reporter code. Only the Editor prompts differ. If your site has an unusual editorial voice, that's the only file you're changing.

Wire is not one agent doing everything. It is three roles collaborating, the same way a newsroom operates. The design is not a metaphor layered on top of the code. The code was built this way because the newsroom model solves a real problem: content operations require different capabilities at different stages, and mixing them in one prompt produces worse output than separating them.

The Three Roles

Chief

wire/chief.py — the editor-in-chief. Dispatches reporters, routes results to editors, runs audits, detects keyword cannibalization, produces weekly reports.

When you run python -m wire.chief news guides, the Chief does not write content. It assigns the beats: which pages need updating, which topics have stale news, which overlaps need resolving. It reads the GSC database, computes opportunity scores, and decides what work gets done and in what order. Every batch operation flows through the Chief.

The Chief enforces workflow gates. Merges happen before differentiation. Differentiation before refinement. Refinement before rewriting. This ordering exists because each step changes the content landscape for the next. Running them out of order wastes API calls or produces conflicts.

NewsReporter

wire/news.py — the beat reporter. Searches independently for articles, fetches each result, and evaluates it for relevance and substance.

Each article gets a full-text evaluation — the "junior analyst" read. One article at a time, evaluated against explicit criteria: concrete facts, dates, specifications, quotes, partnerships, benchmarks. Marketing fluff and old news get filtered. Then all relevant evaluations are synthesized into a single briefing — the "senior editor" pass that catches contradictions between sources and produces an executive summary.

This junior-senior pattern was not an arbitrary design choice. Wire's first approach sent all articles to Claude in one batch. The results were mediocre. Important details got lost in volume. Splitting into individual evaluations followed by synthesis produces noticeably better output. Each article gets proper attention.

The pattern encodes a finding from the LfM-Band 60 study, Germany's largest observational study of journalistic behavior: source checking accounts for only 0.9% of journalist research actions. Wire forces a verification step that working journalists almost never perform.

ContentEditor

wire/content.py — the section editor. Integrates news into pages with inline citations, handles SEO optimization, builds comparison pages, creates new content, and manages the page lifecycle.

The ContentEditor receives its instructions through the three-layer prompt system. The styleguide ensures every page matches the site's voice. The action prompt defines what to do. The variables provide context: current page content, news to integrate, GSC keywords, site directory for internal linking.

The ContentEditor does not decide what to work on. The Chief decides. The ContentEditor does not search for news. The Reporter does. The ContentEditor takes what it receives and produces the best possible page from it. This separation means you can improve news quality without touching the editor, or change editorial rules without affecting news gathering.

Why Three Roles, Not One

A single "do everything" prompt would be simpler to build and cheaper to run. Wire tried this early on. The problems:

Context pollution. When the same prompt handles news evaluation and content writing, the evaluation criteria bleed into the writing style. Pages start reading like analysis reports instead of editorial content.

Uneven quality. Some articles deserve 500 words of evaluation. Others deserve 2 sentences. A batch prompt gives each article the same attention, which means the important ones get too little and the unimportant ones get too much.

Debugging opacity. When the output is wrong, you cannot tell if the problem was in the news evaluation, the synthesis, the integration, or the writing. With separate roles, you can inspect each stage independently. --dry-run on the Chief shows what work was planned. The news files show what the Reporter found. The preview shows what the Editor produced.

Cost control. The Chief runs locally — zero API cost. The Reporter makes targeted calls per article. The Editor makes one call per page. If a page has no news, the Editor call is skipped. A monolithic prompt would burn tokens on every page regardless.

How the Roles Communicate

The roles communicate through files, not through shared memory or message passing.

Chief decides: "guides/seo-strategy needs news"
  ↓
Reporter searches, evaluates, saves:
  docs/guides/seo-strategy/2026-03-10.md
  ↓
Chief dispatches Editor:
  "Integrate pending news into this page"
  ↓
Editor reads: index.md + 2026-03-10.md + styleguide
Editor writes: updated index.md
Editor archives: news/2026-03-10.md

This file-based communication has a practical advantage: every intermediate state is inspectable. You can read the news file before the Editor integrates it. You can edit it. You can delete it and the page stays unchanged. The pipeline is interruptible at every stage.

If a batch run crashes at step 47 of 200, the first 46 items have their news files saved. --resume picks up at 47. No work is lost because the state is on disk, not in memory.

The Agentic Pattern

For developers building on Wire's Python API or connecting it through a bot or agent layer, the three roles map directly to the integration surface:

Chief as orchestrator. Call Chief.audit() to understand the site state. Call Chief.enrich() to improve pages. The Chief handles batching, filtering, and progress tracking. Your integration only needs to start it and report results.

Reporter as information gatherer. NewsReporter.cover_item() takes a content item and returns evaluated news. If you have your own sources (RSS feeds, social media, customer questions), you can write news files directly and skip the Reporter. The Editor does not care where news came from.

Editor as content producer. ContentEditor.improve() takes an amendment brief and produces an improved page. ContentEditor.create() takes a topic and slug and produces a new page. Each method is a single Claude call with predictable cost. Your integration calls the method and handles the output.

The roles are classes, not microservices. They run in the same process, share the same database, and communicate through function calls. The separation is architectural, not infrastructural. No message queues, no API gateways, no deployment complexity.

What This Means for Customization

When you customize Wire for a new site, you are not configuring a monolithic system. You are customizing each role independently:

  • Chief: wire.yml controls refresh intervals, reword tiers, opportunity thresholds. The Chief reads these and plans accordingly.
  • Reporter: news_search.md and news_evaluate.md prompts control how news is found and judged. You can make the Reporter more or less selective without changing the Editor.
  • Editor: _styleguide.md and topic-level _{action}.md overrides control writing quality. You can change the editorial voice without affecting news gathering.

This independence is why Wire serves sites with radically different editorial voices through the same pipeline. A German B2B agency and an English vendor directory share the Chief and Reporter code. Only the Editor prompts differ.