Swarms for Marketing

import os
from swarms_client import SwarmsClient

client = SwarmsClient(api_key=os.environ["SWARMS_API_KEY"])

# The style guide becomes the rules string. Every agent in the swarm sees it,
# and the Brand Reviewer is told to enforce it line by line.
BRAND_RULES = """
- Voice: direct, specific, second person. No exclamation marks.
- Never claim 'the best', 'the fastest' or any superlative without a source.
- Do not name competitors. Describe the category instead.
- Prices are always written with the currency symbol and no decimals.
- Product name is 'Ledgerline' with a capital L, never 'LedgerLine'.
"""

response = client.swarms.run(
    name="Spring Launch Pipeline",
    description="Research, draft, brand review and channel formatting for one campaign.",
    swarm_type="SequentialWorkflow",
    task=(
        "Campaign: Ledgerline invoicing for freelancers, spring launch. Offer: three "
        "months free on annual plans. Audience: freelance designers and developers in "
        "the US and UK. Deliver a landing page hero, a three-email welcome sequence and "
        "six paid social variants (two per platform: LinkedIn, Instagram, X)."
    ),
    rules=BRAND_RULES,
    agents=[
        {
            "agent_name": "Audience Researcher",
            "description": "Segments, pains and competitor claims to avoid.",
            "system_prompt": (
                "You are a marketing researcher. Describe the audience segments, the "
                "words they use for the problem, and the claims competitors already make "
                "so the copy can avoid them. Return a short brief with headings."
            ),
            "model_name": "gemini-2.5-flash",  # fast and cheap for a summary pass
            "max_loops": 1,
        },
        {
            "agent_name": "Copywriter",
            "description": "Drafts for every channel from the brief.",
            "system_prompt": (
                "You are a senior copywriter. Using the research brief, write the landing "
                "hero (headline, subhead, CTA), three welcome emails (subject, preview, "
                "body) and six paid social variants. Label each piece."
            ),
            "model_name": "claude-sonnet-5-5",  # strongest writer in the pipeline
            "max_loops": 1,
        },
        {
            "agent_name": "Brand Reviewer",
            "description": "Enforces the rules on every line.",
            "system_prompt": (
                "You are the brand editor. Check every line of the drafts against the "
                "rules. Rewrite anything that breaks a rule and list each change with the "
                "rule it broke. Keep pieces that pass unchanged."
            ),
            "model_name": "gpt-5.4",
            "max_loops": 1,
        },
        {
            "agent_name": "Channel Formatter",
            "description": "Character limits and tracking.",
            "system_prompt": (
                "You format approved copy per channel. Enforce character limits for each "
                "platform, append UTM parameters to every link, and return JSON keyed by "
                "channel and variant."
            ),
            "model_name": "gpt-4.1-mini",  # mechanical step, small model
            "max_loops": 1,
        },
    ],
    max_loops=1,
)

print(response)

curl -X POST https://api.swarms.world/v1/swarm/completions \
  -H "x-api-key: $SWARMS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Spring Launch Pipeline",
    "description": "Research, draft, brand review and channel formatting for one campaign.",
    "swarm_type": "SequentialWorkflow",
    "task": "Campaign: Ledgerline invoicing for freelancers, spring launch. Offer: three months free on annual plans. Audience: freelance designers and developers in the US and UK. Deliver a landing page hero, a three-email welcome sequence and six paid social variants.",
    "rules": "Voice: direct, specific, second person. No exclamation marks. Never claim the best or the fastest without a source. Do not name competitors. Prices carry the currency symbol and no decimals. The product name is Ledgerline with a capital L.",
    "agents": [
      {
        "agent_name": "Audience Researcher",
        "system_prompt": "You are a marketing researcher. Describe the audience segments, the words they use for the problem, and the claims competitors already make. Return a short brief with headings.",
        "model_name": "gemini-2.5-flash",
        "max_loops": 1
      },
      {
        "agent_name": "Copywriter",
        "system_prompt": "You are a senior copywriter. From the brief, write the landing hero, three welcome emails and six paid social variants. Label each piece.",
        "model_name": "claude-sonnet-5-5",
        "max_loops": 1
      },
      {
        "agent_name": "Brand Reviewer",
        "system_prompt": "You are the brand editor. Check every line against the rules. Rewrite anything that breaks a rule and list each change with the rule it broke.",
        "model_name": "gpt-5.4",
        "max_loops": 1
      },
      {
        "agent_name": "Channel Formatter",
        "system_prompt": "Enforce per-platform character limits, append UTM parameters to every link, and return JSON keyed by channel and variant.",
        "model_name": "gpt-4.1-mini",
        "max_loops": 1
      }
    ],
    "max_loops": 1
  }'

# The response carries "output" (the formatted copy and the reviewer's change
# list) and "usage" with input_tokens, output_tokens and total_tokens.

// Subject line selection as a council: three judges score every candidate
// on one dimension each and the aggregator writes the ruling.
const SWARMS_API = "https://api.swarms.world/v1/swarm/completions"

type Candidate = { id: string; subject: string; preview: string }

type SwarmResponse = {
  output: unknown
  usage: { input_tokens: number; output_tokens: number; total_tokens: number }
}

const judge = (name: string, model: string, dimension: string) => ({
  agent_name: name,
  system_prompt:
    "You judge email subject lines for a B2B software company. Score each candidate " +
    "from 1 to 10 on this dimension only: " + dimension + " " +
    "Return one line per candidate: id, score, one reason.",
  model_name: model,
  max_loops: 1,
})

export async function pickSubjectLine(candidates: Candidate[]): Promise<SwarmResponse> {
  const list = candidates
    .map((c) => "[" + c.id + "] " + c.subject + " | preview: " + c.preview)
    .join("\n")

  const res = await fetch(SWARMS_API, {
    method: "POST",
    headers: {
      "x-api-key": process.env.SWARMS_API_KEY!,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      name: "Subject Line Council",
      description: "Judges score candidates, aggregator picks and explains.",
      swarm_type: "CouncilAsAJudge",
      task:
        "Pick the subject line for the Ledgerline spring launch email to freelancers. " +
        "Candidates:\n" + list + "\nReturn the winner, the runner-up and the reasons.",
      rules: "No exclamation marks. No superlatives without a source. Do not name competitors.",
      agents: [
        judge("Clarity Judge", "gpt-5.4-mini", "Clarity: does the reader know what they get in five words?"),
        judge("Brand Fit Judge", "claude-haiku-5-5", "Brand fit: direct, specific, second person, calm."),
        judge("Claims Judge", "gpt-4.1-mini", "Claims: is every promise one the product page supports?"),
      ],
      max_loops: 1,
    }),
  })

  if (!res.ok) throw new Error("Swarms API " + res.status + ": " + (await res.text()))
  return (await res.json()) as SwarmResponse
}

pickSubjectLine([
  { id: "A", subject: "Three months of Ledgerline, free", preview: "Annual plans only, until 30 April" },
  { id: "B", subject: "Invoices that chase themselves", preview: "Automatic reminders are on by default" },
  { id: "C", subject: "Your spring offer is inside", preview: "A smaller bill for a year of invoicing" },
]).then((r) => {
  console.log(r.output)
  console.log("tokens:", r.usage.total_tokens)
})

import os
import requests

BASE = "https://api.swarms.world"
HEADERS = {"x-api-key": os.environ["SWARMS_API_KEY"], "Content-Type": "application/json"}

# One approved campaign, several markets. Each market is its own swarm
# request, and the batch endpoint runs them all in one call. The runs land
# in Swarms Cloud under the names below, so spend per market is visible.
APPROVED_COPY = open("approved/spring_launch_en.md").read()

MARKETS = {
    "DE": "German, formal Sie. Prices in EUR. Mention the 14-day withdrawal right.",
    "FR": "French, vous. Prices in EUR. Avoid anglicisms where a French term exists.",
    "JP": "Japanese, polite desu/masu register. Prices in JPY with no decimals.",
    "BR": "Brazilian Portuguese, informal voce. Prices in BRL. Pix as a payment option.",
}


def market_request(code: str, notes: str) -> dict:
    return {
        "name": f"Spring Launch Localization {code}",
        "description": f"Adapt the approved spring launch copy for {code}.",
        "swarm_type": "SequentialWorkflow",
        "task": f"Adapt this approved campaign for the {code} market.\n\n{APPROVED_COPY}",
        "rules": "Keep the offer and the product name unchanged. Keep every link and UTM tag.",
        "agents": [
            {
                "agent_name": "Market Adapter",
                "system_prompt": (
                    "You localize marketing copy. Adapt tone, idiom, currency and legal lines "
                    f"for this market: {notes} Keep the structure and labels of the source."
                ),
                "model_name": "gemini-2.5-pro",
                "max_loops": 1,
            },
            {
                "agent_name": "Market Reviewer",
                "system_prompt": (
                    "You are a native-speaking brand editor for this market. Fix anything that "
                    "reads as translated, and list the changes you made."
                ),
                "model_name": "claude-sonnet-5-5",
                "max_loops": 1,
            },
        ],
        "max_loops": 1,
    }


batch = [market_request(code, notes) for code, notes in MARKETS.items()]

resp = requests.post(f"{BASE}/v1/swarm/batch/completions", headers=HEADERS, json=batch, timeout=600)
resp.raise_for_status()
results = resp.json()

for code, result in zip(MARKETS, results):
    usage = result.get("usage", {})
    print(f"== {code}: {usage.get('total_tokens', '?')} tokens")
    print(result.get("output"))

from swarms import Agent, ConcurrentWorkflow

# The open-source swarms package runs the same roles in-process. Here three
# channel writers work on one brief at the same time and the workflow returns
# all of their drafts together.
BRIEF = """
Product: Ledgerline invoicing for freelancers.
Offer: three months free on annual plans, until 30 April.
Audience: freelance designers and developers in the US and UK.
Rules: direct, specific, second person, no exclamation marks, no superlatives.
"""

linkedin = Agent(
    agent_name="LinkedIn Writer",
    system_prompt=(
        "You write LinkedIn ads for B2B software. Write two variants: a 150-character "
        "intro line, a headline under 70 characters and a CTA. Professional, no hype."
    ),
    model_name="claude-sonnet-5-5",
    max_loops=1,
)

instagram = Agent(
    agent_name="Instagram Writer",
    system_prompt=(
        "You write Instagram ad captions for software products. Write two variants under "
        "125 characters with one concrete benefit each and no hashtags."
    ),
    model_name="gpt-5.4-mini",
    max_loops=1,
)

search = Agent(
    agent_name="Search Ads Writer",
    system_prompt=(
        "You write responsive search ads. Return eight headlines under 30 characters and "
        "four descriptions under 90 characters, each a complete thought."
    ),
    model_name="gpt-4.1-mini",
    max_loops=1,
)

workflow = ConcurrentWorkflow(
    name="Channel Variants",
    description="Three channel writers draft from one brief at the same time.",
    agents=[linkedin, instagram, search],
    max_loops=1,
)

result = workflow.run(BRIEF)
print(result)