One engine, every platform

The idea: write once at the level of intent ("announce the rate-limit change"), and let the engine produce a distinct, platform-native piece for each destination, then fan those out to your direct channels and the third-party tools where the rest of your social lives (Vista Social, Hootsuite), plus your blog and email.

The trap this avoids is cross-posting: taking one blob of text and stamping it onto X, LinkedIn, and a newsletter unchanged. Cross-posted content is the most obvious slop tell there is: the LinkedIn paragraph wrapped in X's character limit, the hashtags that make sense on one network and look desperate on another. Reactor generates for each channel instead of reformatting between them.

Native, not cross-posted

When you brief a topic across several channels, each one is generated against its own platform tone and format rules, and each is checked by the similarity guard per channel, so multi-account X or a custom "Podcast notes" channel keeps its own "recent posts" history and never collides with another channel's stream. The result: an X thread that reads like X, a LinkedIn post that reads like LinkedIn, and a blog post that reads like a blog post. All unmistakably the same brand, none of them a reheated copy of the others.

:::tip Set per-platform tone once set_platform_tone lets you encode how each channel should sound (punchier on X, more context on LinkedIn, no emoji on the newsletter). This is what makes the fan-out read native instead of copy-pasted. Do it once; every future generation inherits it. :::

Step 1: connect your destinations

Reactor publishes directly to channels you connect (X, LinkedIn, Discord, Reddit, YouTube, and more), hands off to aggregators (Vista Social, Hootsuite) for everything attached there, commits blog posts to Webflow or GitHub, and drafts email campaigns into your ESP. Connect what you need in Integrations, then confirm over MCP:

1. get_connected_channels        // Direct channels that are ready
2. list_aggregator_accounts      // e.g. provider: "vista_social" → the profiles attached there
3. list_github_repos             // Repos available as blog targets

Step 2: brief once, generate native variants

Create a single brief that requests several channels. Generation produces a separate, channel-native piece for each.

1. create_brief
   // topic: "New API rate limits: what changes and why"
   // channels: ["x", "linkedin", "blog"]
2. generate_content              // Generates all requested channels
3. get_generation_status         // Poll until done
4. list_content                  // See the per-channel pieces that were produced

Read a couple and notice they're genuinely different pieces, not one text trimmed three ways.

Step 3: fan out to direct + third-party destinations

Publish or schedule each piece to the right place. publish_now and schedule_content take a destination and the account/repo identifiers, so the same piece can go direct or through an aggregator.

// Direct to X now:
publish_now        // content_id: <x piece>, platform: "x"

// Through Vista Social to a specific attached profile:
schedule_content   // content_id: <linkedin piece>, platform: "linkedin",
                   // destination: "vista_social", external_account_id: <from list_aggregator_accounts>,
                   // scheduled_at: <ISO time>

// Blog post as a commit to a repo:
publish_now        // content_id: <blog piece>, platform: "github", github_repo_id: <from list_github_repos>

// Newsletter as an ESP draft you review and send:
create_email_draft // connection_id, list_id, subject, content_id: <blog piece or a dedicated one>

Scheduling upserts in place, so re-running a schedule never creates duplicate posts, and moving a calendar card shifts its linked posts with it.

Step 4: pull it all back into one view

However many platforms you publish to, the analytics come back to one dashboard, so you compare X against LinkedIn against the blog on equal footing.

1. generate_utm_link        // Tag blog/newsletter URLs so web analytics attribute them to the piece
2. get_analytics_overview   // One cross-platform view
3. get_content_performance  // How a single idea did across every channel it ran on

The payoff

You brief at the level of ideas and publish at the level of platforms. One engine reaches every destination you care about (direct networks, the aggregators your team already uses, your blog, and your list), and because each piece is generated native and de-duplicated per channel, "being everywhere" never turns into "posting the same thing everywhere."

Next: make each of those pieces smarter with the research and analytics feedback loop, or run the whole thing hands-off on a schedule.