运行一个多智能体系统要花多少钱？来自 Swarms API 的真实数字

# swarm_cost_benchmark.py
# Runs the same task through one agent and four swarm architectures, then
# prints what each one cost. Requires: pip install requests
import os
import requests

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

TASK = (
    "Write a competitive brief on the shared electric scooter market in Berlin for an "
    "operator considering entry in 2027. Cover market size, three main competitors, "
    "regulatory risks and a recommendation. Keep the final brief under 500 words."
)

AGENTS = [
    {
        "agent_name": "Researcher",
        "system_prompt": "You are a market researcher. List the facts, figures and competitor details relevant to the task as concise bullet points. Do not write the brief.",
        "model_name": "gpt-5.4-mini",
        "max_loops": 1,
        "max_tokens": 1200,
    },
    {
        "agent_name": "Analyst",
        "system_prompt": "You are a strategy analyst. Turn the research into structured findings: market size, competitors, regulatory risks, and a recommendation with reasoning. Concise bullet points.",
        "model_name": "claude-haiku-5-5",
        "max_loops": 1,
        "max_tokens": 1200,
    },
    {
        "agent_name": "Writer",
        "system_prompt": "You are a business writer. Write the final competitive brief under 500 words with the sections: Market size, Main competitors, Regulatory risks, Recommendation.",
        "model_name": "claude-sonnet-5-5",
        "max_loops": 1,
        "max_tokens": 1500,
    },
]

ARCHITECTURES = ["SequentialWorkflow", "ConcurrentWorkflow", "HierarchicalSwarm", "MixtureOfAgents"]


def run_single_agent() -> dict:
    body = {
        "agent_config": {
            "agent_name": "Solo Analyst",
            "system_prompt": "You are a market analyst. Write a competitive brief with these sections: Market size, Main competitors (three), Regulatory risks, Recommendation. Keep it under 500 words and be specific.",
            "model_name": "claude-sonnet-5-5",
            "max_loops": 1,
            "max_tokens": 1500,
        },
        "task": TASK,
    }
    r = requests.post(f"{API}/v1/agent/completions", headers=HEADERS, json=body, timeout=300)
    r.raise_for_status()
    return r.json()


def run_swarm(swarm_type: str) -> dict:
    body = {
        "name": f"Cost Benchmark {swarm_type}",
        "swarm_type": swarm_type,
        "task": TASK,
        "agents": AGENTS,
        "max_loops": 1,
    }
    r = requests.post(f"{API}/v1/swarm/completions", headers=HEADERS, json=body, timeout=300)
    r.raise_for_status()
    return r.json()


def price(model_name: str) -> tuple[float, float]:
    r = requests.get(f"{API}/v1/models/pricing", headers=HEADERS, params={"model_name": model_name}, timeout=30)
    r.raise_for_status()
    data = r.json()
    return data["input_cost_per_1m"], data["output_cost_per_1m"]


if __name__ == "__main__":
    print("Model prices per 1M tokens (service fee included):")
    for model in sorted({a["model_name"] for a in AGENTS}):
        inp, out = price(model)
        print(f"  {model}: ${inp:.4f} in, ${out:.4f} out")

    rows = []
    single = run_single_agent()
    rows.append(("Single agent", 1, single["usage"], None))

    for swarm_type in ARCHITECTURES:
        data = run_swarm(swarm_type)
        rows.append((swarm_type, data["number_of_agents"], data["usage"], data["execution_time"]))

    print("\n| Architecture | Agents | Tokens | Agent fee | Per run | Per 1,000 | Time |")
    print("|---|---|---|---|---|---|---|")
    for name, agents, usage, seconds in rows:
        fee = usage.get("billing_info", {}).get("cost_breakdown", {}).get("agent_cost", 0.0)
        time_str = f"{seconds:.1f}s" if seconds else "n/a"
        print(
            f"| {name} | {agents} | {usage['total_tokens']:,} | ${fee:.2f} | "
            f"${usage['total_cost']:.4f} | ${usage['total_cost'] * 1000:,.2f} | {time_str} |"
        )

pip install requests
export SWARMS_API_KEY=your_key
python swarm_cost_benchmark.py

# cost_table.py
# Turns the usage blocks returned by the Swarms API into a per-run and
# per-1,000-run cost table. Paste in the "usage" object from each response.

RUNS = {
    "SequentialWorkflow": {
        "agents": 3, "seconds": 22.2,
        "usage": {"input_tokens": 5064, "output_tokens": 3424, "total_tokens": 8488, "total_cost": 0.058763,
                  "billing_info": {"cost_breakdown": {"agent_cost": 0.03, "input_token_cost": 0.007076, "output_token_cost": 0.021687}}},
    },
    "ConcurrentWorkflow": {
        "agents": 3, "seconds": 13.7,
        "usage": {"input_tokens": 355, "output_tokens": 3289, "total_tokens": 3644, "total_cost": 0.051382,
                  "billing_info": {"cost_breakdown": {"agent_cost": 0.03, "input_token_cost": 0.000394, "output_token_cost": 0.020988}}},
    },
}


def row(name: str, run: dict) -> str:
    u = run["usage"]
    breakdown = u.get("billing_info", {}).get("cost_breakdown", {})
    agent_fee = breakdown.get("agent_cost", 0.0)
    token_cost = u["total_cost"] - agent_fee
    per_1k = u["total_cost"] * 1000
    secs = f"{run['seconds']:.1f}s" if run["seconds"] else "n/a"
    return (
        f"| {name} | {run['agents']} | {u['input_tokens']:,} | {u['output_tokens']:,} | "
        f"${agent_fee:.3f} | ${token_cost:.4f} | ${u['total_cost']:.4f} | ${per_1k:,.2f} | {secs} |"
    )


print("| Architecture | Agents | Input tokens | Output tokens | Agent fee | Token cost | Per run | Per 1,000 runs | Time |")
print("|---|---|---|---|---|---|---|---|---|")
for name, run in RUNS.items():
    print(row(name, run))

curl -H "x-api-key: $SWARMS_API_KEY" \
  "https://api.swarms.world/v1/models/pricing?model_name=claude-haiku-5-5"