Content Repurposer

Turn one long-form input into blog, Twitter, LinkedIn, and email variants matched to each platform's voice and length.

Turn one long-form input into blog, Twitter, LinkedIn, and email variants matched to each platform's voice and length. One blog post becomes 4 distribution channels in 90 seconds. The fastest way to triple content output without writing more.

This is the whole blueprint, nothing held back: the model, the tools, the exact prompt, the source on disk, and the setup. Everything you need to run Content Repurposer yourself is on this page, and it deploys in an afternoon.

What it does

Content Repurposer handles the work end to end:

  • Extract the thesis, top points, and strongest quote from any long-form input
  • Adapt to blog, Twitter thread, LinkedIn post, and email newsletter variants
  • Match each variant to platform conventions (length, hook style, formatting)
  • Score every variant on platform fit so nothing ships that reads as off-brand

The anatomy

An agent is a composition, not a prompt: a model, the tools it is allowed to call, the integrations that give those tools reach, and the rules that keep it honest. Here is Content Repurposer on one card.

Content Repurposerblueprint
Model
claude-sonnet-4-6
Tools
extract_essenceadapt_blogadapt_twitteradapt_linkedinadapt_emailscore_fit
Integrations
Zod
Guardrails
never invent facts not in the source. repurposing only.; preserve the strongest quote verbatim across all variants where length allows

The instructions

Every run is governed by this prompt. It is short on purpose: enough to make Content Repurposer reliable, not so much that it can misread itself. Copy it as a starting point for any agent you build.

Content Repurposer
You are a multi-channel content repurposer. You take one piece of long-form content and adapt it without losing the soul of the original. WORKFLOW: 1. Call extract_essence to pull thesis, top 3 supporting points, and the strongest quote. 2. Call adapt_blog (1500 words), adapt_twitter (8-tweet thread), adapt_linkedin (250 words, hook + body + CTA), adapt_email (newsletter, 350 words). 3. Call score_fit to ensure each variant matches platform conventions (length, voice, formatting). RULES: - Never invent facts not in the source. Repurposing only. - Preserve the strongest quote verbatim across all variants where length allows. - Twitter threads must hook in the first 280 chars; no "thread 🧵" cliché. - LinkedIn must use line breaks every 1-2 sentences for the platform's reading style.

The source, on disk

Three files carry the whole agent: the definition with its tools, the environment it expects, and the setup. Walk them.

content-repurposer/content-repurposer.ts1.5 KB
1import { agent, tool } from "@agent-sdk"
2import { z } from "zod"
3
4const extractInput = z.object({ source: z.string().min(200) })
5
6export default agent({
7 model: "claude-sonnet-4-6",
8 permissionMode: "bypassPermissions",
9 maxTurns: 12,
10 systemPrompt: `...`, // see System Prompt section above
11 tools: {
12 extract_essence: tool({
13 description: "Pull thesis, top points, strongest quote",
14 inputSchema: extractInput,
15 execute: async ({ source }) => { /* { thesis, points, quote } */ },
16 }),
17 adapt_blog: tool({
18 description: "Produce a 1500-word blog version",
19 inputSchema: z.object({ essence: z.any() }),
20 execute: async ({ essence }) => { /* markdown */ },
21 }),
22 adapt_twitter: tool({
23 description: "Produce an 8-tweet thread",
24 inputSchema: z.object({ essence: z.any() }),
25 execute: async ({ essence }) => { /* string[] */ },
26 }),
27 adapt_linkedin: tool({
28 description: "Produce a 250-word LinkedIn post",
29 inputSchema: z.object({ essence: z.any() }),
30 execute: async ({ essence }) => { /* string */ },
31 }),
32 adapt_email: tool({
33 description: "Produce a 350-word newsletter version",
34 inputSchema: z.object({ essence: z.any() }),
35 execute: async ({ essence }) => { /* string */ },
36 }),
37 score_fit: tool({
38 description: "Score each variant against platform conventions",
39 inputSchema: z.object({ variants: z.any() }),
40 execute: async ({ variants }) => { /* scores */ },
41 }),
42 },
43})

The business case

If you run an agency, Content Repurposer is also a product. It sells into content teams, solo creators, founder-led marketing, and the numbers work at very small scale.

$2,000

setup you can charge

$320/mo

monthly retainer

6

jobs off your plate

Ship it

The whole install is a handful of commands and the keys from the env file. Run the list, then point Content Repurposer at real work.

Deploy checklist

0 of 3

That is the entire blueprint: one model, 6 tools, and a prompt. Built by hand it costs you an afternoon. Inside Ultron it costs you a sentence, because you can build this exact agent in the workforce and watch it run before you commit to anything.

Build Content Repurposer in Ultron

1
Describe what you want

Start from this blueprint or your own words. Ultron reads the intent and picks the tools.

2
It builds the agent

The model, the tools, the prompt, the console. Assembled in front of you, nothing to wire.

3
Watch it run

Test it live in the chat, then put it to work. You review what it does, it does the rest.

Keep reading