Swarms for Legal

import os
from swarms_client import SwarmsClient

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

# Council as a judge: the drafter produces the candidate review, the judges
# score it, and the ruling writer writes the memo. Nothing is redlined by agents.
PLAYBOOK = """
PB-03 Term: auto-renewal acceptable only with a 60-day opt-out notice.
PB-05 Termination: we require termination for convenience on 90 days notice.
PB-07 Limitation of liability: cap at 12 months of fees; carve-outs limited to
      confidentiality, IP indemnity, gross negligence and wilful misconduct.
PB-09 Governing law: Delaware or New York preferred; England and Wales acceptable.
PB-11 Non-compete: no non-compete binding on us; employee non-solicit up to 12 months.
PB-12 Data protection: breach notice within 72 hours, sub-processor list on request.
"""

response = client.swarms.run(
    name="Contract Review Council",
    description="Clause-by-clause review against the playbook, scored by judges, written as a memo for the attorney.",
    swarm_type="CouncilAsAJudge",
    task=(
        "Review the attached master services agreement (counterparty paper) "
        "against the playbook. For every clause that departs from a rule, quote "
        "the clause, name the rule and propose a fallback position.\n\n"
        + PLAYBOOK
        + "\n\nAGREEMENT TEXT:\n" + open("msa_counterparty_draft.txt").read()
    ),
    agents=[
        {
            "agent_name": "Review Drafter",
            "description": "Produces the candidate clause-by-clause review.",
            "system_prompt": (
                "You are a commercial contracts reviewer. Go through the agreement "
                "clause by clause. For each departure from the playbook, quote the "
                "clause text, cite the playbook rule by id, rate the risk high, "
                "medium or low, and propose a fallback. Say when a clause is silent."
            ),
            "model_name": "claude-sonnet-5-5",
            "max_loops": 1,
        },
        {
            "agent_name": "Playbook Judge",
            "description": "Checks the review against the playbook rules.",
            "system_prompt": (
                "Score the review for completeness against the playbook: every rule "
                "that the agreement touches must have a finding. List missed rules "
                "and false flags, each with the clause text."
            ),
            "model_name": "gpt-5.4",  # judges get stronger models than the drafter
            "max_loops": 1,
        },
        {
            "agent_name": "Precedent Judge",
            "description": "Checks fallbacks against the clause library.",
            "system_prompt": (
                "Score the proposed fallbacks against the firm's standard positions "
                "described in the playbook. Flag any fallback that goes beyond what "
                "the playbook allows."
            ),
            "model_name": "gemini-2.5-pro",
            "max_loops": 1,
        },
        {
            "agent_name": "Consistency Judge",
            "description": "Checks defined terms and cross-references.",
            "system_prompt": (
                "Score the review for internal consistency: defined terms used as "
                "defined, section references that resolve, and risk ratings that "
                "match the playbook's severity."
            ),
            "model_name": "deepseek-v4-pro",
            "max_loops": 1,
        },
        {
            "agent_name": "Ruling Writer",
            "description": "Writes the memo from the judges' scores.",
            "system_prompt": (
                "Write the review memo for the supervising attorney: flags ranked by "
                "risk, each with the quoted clause, the rule and the fallback, then "
                "the judges' dissents. This memo is a draft for a lawyer's review."
            ),
            "model_name": "claude-opus-5-5",  # final writing on the strongest 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": "Contract Review Council",
    "description": "Clause-by-clause review against the playbook, scored by judges, written as a memo for the attorney.",
    "swarm_type": "CouncilAsAJudge",
    "task": "Review the master services agreement below against the playbook. PB-07: liability cap at 12 months of fees, carve-outs limited to confidentiality, IP indemnity, gross negligence and wilful misconduct. PB-09: governing law Delaware or New York preferred, England and Wales acceptable. PB-11: no non-compete binding on us. For every departure quote the clause, name the rule and propose a fallback. AGREEMENT TEXT: [paste the agreement here]",
    "agents": [
      {
        "agent_name": "Review Drafter",
        "system_prompt": "You are a commercial contracts reviewer. For each departure from the playbook quote the clause, cite the rule id, rate the risk high, medium or low and propose a fallback. Say when a clause is silent.",
        "model_name": "claude-sonnet-5-5",
        "max_loops": 1
      },
      {
        "agent_name": "Playbook Judge",
        "system_prompt": "Score the review for completeness against the playbook. List missed rules and false flags with the clause text.",
        "model_name": "gpt-5.4",
        "max_loops": 1
      },
      {
        "agent_name": "Precedent Judge",
        "system_prompt": "Score the proposed fallbacks against the standard positions in the playbook. Flag any fallback that goes beyond what the playbook allows.",
        "model_name": "gemini-2.5-pro",
        "max_loops": 1
      },
      {
        "agent_name": "Consistency Judge",
        "system_prompt": "Score the review for internal consistency: defined terms, section references that resolve, risk ratings that match the playbook severity.",
        "model_name": "deepseek-v4-pro",
        "max_loops": 1
      },
      {
        "agent_name": "Ruling Writer",
        "system_prompt": "Write the review memo for the supervising attorney: flags ranked by risk with the quoted clause, rule and fallback, then the judges dissents. This is a draft for a lawyer to review.",
        "model_name": "claude-opus-5-5",
        "max_loops": 1
      }
    ],
    "max_loops": 1
  }'

# "output" is the memo; "usage" has input_tokens, output_tokens and total_tokens.

// Citation verification as a vote: three verifiers check each citation
// independently and the Swarms API returns the majority call per citation.
// The associate confirms every citation against the reporter before filing.
const SWARMS_API = "https://api.swarms.world/v1/swarm/completions"

type Draft = { matter: string; text: string; citations: string[] }

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

const VERIFIER_PROMPT =
  "You verify citations in legal drafts. For each citation return one line: the citation, then " +
  "VERIFIED, NEEDS SOURCE or WRONG PIN CITE, then one sentence. VERIFIED means the authority exists, " +
  "the pin cite points at the quoted proposition and the proposition is stated accurately. If you " +
  "cannot confirm existence from the materials you are given, answer NEEDS SOURCE; never guess."

const verifier = (name: string, model: string) => ({
  agent_name: name,
  system_prompt: VERIFIER_PROMPT,
  model_name: model,
  max_loops: 1,
})

export async function checkCitations(draft: Draft): Promise<{ calls: unknown; tokens: number }> {
  const list = draft.citations.map((c, i) => String(i + 1) + ". " + c).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: "Citation Check " + draft.matter,
      description: "Independent verification of every citation in a draft; majority call per citation.",
      swarm_type: "MajorityVoting",
      task: "Draft text:\n\n" + draft.text + "\n\nCitations to verify:\n" + list,
      agents: [
        verifier("Verifier A", "gpt-5.4"), // three different providers, so one model's blind spot is outvoted
        verifier("Verifier B", "claude-sonnet-5-5"),
        verifier("Verifier C", "gemini-2.5-pro"),
      ],
      max_loops: 1,
    }),
  })

  if (!res.ok) throw new Error("Swarms API " + res.status + ": " + (await res.text()))
  const data = (await res.json()) as SwarmResponse
  return { calls: data.output, tokens: data.usage.total_tokens }
}

// Placeholder parties and reporters; use your own draft and the sources the
// agents should check against.
checkCitations({
  matter: "M-4471",
  text: "A limitation of liability clause is enforced as written between sophisticated parties ...",
  citations: [
    "Northwind Traders v. Contoso Ltd., 412 F.3d 118, 124 (2d Cir. 2005)",
    "Litware, Inc. v. Tailspin Toys, 230 Cal. App. 4th 455, 462 (2014)",
  ],
}).then((r) => console.log(r.calls, r.tokens + " tokens"))

import json
import os

import requests

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

# Before the nightly data room run: check the credit balance and that the
# models the swarm needs are available, then submit every agreement as one
# batch. Each item becomes its own run in the account's swarm logs, named
# after the matter and the document.
credits = requests.get(f"{BASE}/v1/account/credits", headers=HEADERS, timeout=30).json()
models = requests.get(f"{BASE}/v1/models/available", headers=HEADERS, timeout=30).json()
print("credits:", credits)
print("models:", models)

with open("data_room_index.json") as f:
    documents = json.load(f)  # [{"doc_id": "DR-0412", "title": "...", "text": "..."}, ...]

MATTER = "M-4471"

AGENTS = [
    {
        "agent_name": "Clause Locator",
        "system_prompt": (
            "Locate the term, termination, change of control, assignment, "
            "exclusivity, most-favoured-customer and governing law clauses. Return "
            "the section number and the full clause text for each; write ABSENT "
            "when a clause is not present."
        ),
        "model_name": "gemini-2.5-flash",  # fast, long context, cheap across a data room
        "max_loops": 1,
    },
    {
        "agent_name": "Term Extractor",
        "system_prompt": (
            "From the located clauses extract parties, effective date, term end, "
            "renewal mechanics, notice periods, change of control consequences and "
            "exclusivity scope. Quote the source text for every value."
        ),
        "model_name": "claude-haiku-5-5",
        "max_loops": 1,
    },
    {
        "agent_name": "Abstract Writer",
        "system_prompt": (
            "Fill the diligence abstract template from the extracted terms and list "
            "issues for the deal team. Leave fields blank where the extractor found "
            "nothing. A paralegal and an attorney review every abstract."
        ),
        "model_name": "gpt-5.4-mini",
        "max_loops": 1,
    },
]

batch = [
    {
        "name": f"{MATTER} abstract {doc['doc_id']}",
        "description": "Nightly data room abstraction for the deal team's review.",
        "swarm_type": "SequentialWorkflow",
        "task": f"Document {doc['doc_id']}: {doc['title']}\n\n{doc['text']}",
        "agents": AGENTS,
        "max_loops": 1,
    }
    for doc in documents
]

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

os.makedirs("abstracts", exist_ok=True)
for doc, result in zip(documents, results):
    with open(f"abstracts/{doc['doc_id']}.json", "w") as out:
        json.dump(result, out, indent=2)
    print(doc["doc_id"], result.get("usage", {}).get("total_tokens"), "tokens")

print(len(results), "abstracts ready for the deal team")

from swarms import Agent, SequentialWorkflow

# The open-source swarms package runs the same pipeline inside your own
# environment, for documents that cannot leave the firm's network.
# pip install swarms

locator = Agent(
    agent_name="Clause Locator",
    system_prompt=(
        "Locate the term, termination, indemnification, limitation of liability, "
        "assignment, governing law, data protection and non-compete clauses. Return "
        "the section number and full clause text for each, or ABSENT."
    ),
    model_name="gemini-2.5-flash",
    max_loops=1,
)

extractor = Agent(
    agent_name="Term Extractor",
    system_prompt=(
        "From the located clauses extract: parties, effective date, initial term, "
        "renewal mechanics, termination rights and notice periods, liability cap and "
        "carve-outs, governing law and forum, breach notice deadline, restrictive "
        "covenants and their duration. Quote the source text for every value."
    ),
    model_name="claude-haiku-5-5",
    max_loops=1,
)

writer = Agent(
    agent_name="Abstract Writer",
    system_prompt=(
        "Fill the firm's contract abstract template from the extracted terms. Leave "
        "a field blank when the extractor found nothing and list it under Open "
        "Items. A paralegal completes the open items and an attorney reviews."
    ),
    model_name="gpt-5.4-mini",
    max_loops=1,
)

workflow = SequentialWorkflow(
    name="Contract Abstract",
    description="Locate, extract and abstract the key terms of one agreement.",
    agents=[locator, extractor, writer],
    max_loops=1,
)

with open("msa_counterparty_draft.txt") as f:
    agreement = f.read()

abstract = workflow.run(
    "Abstract the following master services agreement for the deal file.\n\n" + agreement
)
print(abstract)