Use Reactor in your codebase

Reactor's engine doesn't have to live in a browser tab. Connect the MCP server inside the repo you're already working in (through Claude Code, Cursor, or any MCP client) and run the copy in your codebase through your brand engine and the Anti-Slop Guard, without leaving your editor.

Say "review the docs with Reactor" or "rewrite the landing copy using Reactor", and your agent pulls the copy out of your files, sends it to Reactor, and writes the improved version back.

How it works

The split is simple: your client owns the files, Reactor owns the brand.

1. Your agent (Claude Code, Cursor, …) reads the copy from your repo: a landing page, a README, docs, UI strings.
2. It calls a Reactor tool with that copy.
3. Reactor runs the text through the same weighted engine and Guard that power generation in the app: your voice, positioning, audiences, writing rules, per-platform tone, importance weighting, workspace memory, and analytics performance signals.
4. Your agent writes the result back into your files.

Reactor never reads your filesystem, and nothing is stored as a library piece; it's a stateless pass through your brand brain.

Prerequisites

• Connect the MCP. Follow Install the MCP and Authentication to add the reactor server with your API key. The key scopes every call to one workspace.
• Configure your engine. The value comes from your engine: set up at least your voice and brand, and ideally positioning, audiences, and writing rules. An empty engine still runs, but with thin context.

Once connected, ask your client to "list the Reactor tools"; the server is self-describing, so review_copy and revise_copy appear with their full schemas.

The two tools

review_copy: read-only critique

Reviews copy and returns findings without changing anything. For each segment you get:

• slop: deterministic Anti-Slop Guard violations (the tells of AI writing, banned phrases, broken writing rules), with counts and samples.
• findings: a weighted critique against your engine: off-voice lines, weak positioning, wrong audience, anything that contradicts a rule or a remembered preference.
• suggestions: concrete, actionable directions.

Use it to audit a surface before you touch it. Your agent decides what to change, but the rewriting itself belongs to revise_copy, so the words that land in your files come from your engine, not from the agent's own paraphrase of the findings.

"Review the copy in docs/ with Reactor and summarize what's off-brand."

revise_copy: rewrite through the engine

Rewrites copy in your brand voice and returns the improved version per segment, having run it through the Guard's lint-and-repair pass. Each result includes the original, the revised text, whether it changed, and the slop count before and after.

revise_copy preserves each segment's role and length and any Markdown, HTML, or {{placeholders}}, so the result drops straight back into the same slot in your file. Pass an optional instruction to steer the pass (for example, "tighten and make more benefit-led").

The returned revised text is the deliverable: apply it verbatim. An agent that rephrases, trims, or "improves" the engine's output on the way to the file reintroduces exactly the drift the engine exists to remove. If a segment comes back with a note saying it wasn't revised, retry it in a new revise_copy call rather than substituting the agent's own rewrite.

"Rewrite all the copy on the landing page using Reactor, then apply the changes."

Segments

Both tools take a batch of segments (one per string or section), each with a stable id and its text:

{
  "surface": "the landing page hero",
  "segments": [
    { "id": "hero.title", "text": "The best content tool ever" },
    { "id": "hero.subtitle", "text": "We help you make amazing content fast" },
    { "id": "cta.primary", "text": "Get started now" }
  ]
}

The id is how each result maps back to its place in your file; use something stable and descriptive (hero.title, README#intro, a key path). Send a whole page's worth of segments in one call and Reactor revises them coherently, as one surface. You can also pass a single text blob instead of segments, which is handy for one document.

Tell your agent how to segment: pull out the human-readable copy, keep code and identifiers out, and keep one logical string per segment.

Limits

A single call accepts up to 40 segments, 8,000 characters per segment, and 40,000 characters total; split larger jobs into batches (a page or a doc at a time works well). Optionally set platform (default blog, the right choice for websites, docs, and product copy) to review against a specific channel's tone.

Cost

review_copy and revise_copy draw on your workspace's allowance exactly like generation in the app, and default to Auto model selection. They don't create library pieces and don't consume a content brief; they're stateless transforms. Pass a model to override the model for a single call.

A typical loop

"Review the landing copy in app/page.tsx with Reactor, then rewrite whatever it flags and apply the edits."

Your agent reads the file, calls review_copy, sees the findings, calls revise_copy on the weak segments, and writes the returned text into the file verbatim: every line now shaped by your voice, positioning, and the Anti-Slop Guard.

See the MCP overview for everything else the server can do, and example workflows for multi-step recipes.