Swarms for Real Estate

import os
from swarms_client import SwarmsClient

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

# The lease and its amendments as text, already OCR'd by your document system.
lease_text = open("leases/riverside-plaza-suite-410.txt").read()

# The abstract schema the Abstract Writer must fill. This is your own shape,
# sent in the prompt, so the output drops straight into the asset system.
ABSTRACT_FIELDS = (
    "tenant, premises, rentable_sf, commencement, expiration, base_rent (list of "
    "{from, to, annual_psf}), renewal_options (list of {term_months, notice_by, "
    "rent_basis}), termination_option, security_deposit, cam_structure, "
    "exclusive_use, assignment_rights, critical_dates (list of {date, event}), "
    "flags_for_counsel (list of {clause, page, reason})"
)

response = client.swarms.run(
    name="Lease Abstraction",
    description="Lease to a structured abstract with page citations and counsel flags.",
    swarm_type="SequentialWorkflow",
    task=f"Abstract this lease into the fields {ABSTRACT_FIELDS}.\n\n{lease_text}",
    rules=(
        "Quote the page for every extracted term. Never infer a date that is not "
        "stated or computable from stated terms. Where the lease and an amendment "
        "conflict, the later document wins and the conflict is flagged."
    ),
    agents=[
        {
            "agent_name": "Lease Reader",
            "system_prompt": (
                "You read commercial leases. Identify the base lease and every amendment, "
                "order them by date, and produce a clause map: section, title, page range."
            ),
            "model_name": "gemini-2.5-flash",  # long context, cheap for a first pass
            "max_loops": 1,
        },
        {
            "agent_name": "Term Extractor",
            "system_prompt": (
                "Using the clause map, extract premises, term, base rent schedule, options, "
                "deposit, CAM, exclusive use and assignment terms. Cite a page for each."
            ),
            "model_name": "gpt-4.1-mini",
            "max_loops": 1,
        },
        {
            "agent_name": "Critical Dates",
            "system_prompt": (
                "Compute every critical date from the extracted terms: rent steps, option "
                "notice windows, expiration, termination windows. Show the arithmetic."
            ),
            "model_name": "claude-haiku-5-5",
            "max_loops": 1,
        },
        {
            "agent_name": "Abstract Writer",
            "system_prompt": (
                "Assemble the final abstract as JSON with exactly the requested fields. Put "
                "any ambiguous or unusual clause in flags_for_counsel with its page."
            ),
            "model_name": "claude-sonnet-5-5",  # the document a person will read
            "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": "Lease Abstraction",
    "description": "Lease to a structured abstract with page citations and counsel flags.",
    "swarm_type": "SequentialWorkflow",
    "task": "Abstract the attached lease into: tenant, premises, rentable_sf, commencement, expiration, base_rent schedule, renewal_options, termination_option, security_deposit, cam_structure, exclusive_use, assignment_rights, critical_dates, flags_for_counsel. LEASE TEXT: ...",
    "rules": "Quote the page for every extracted term. Never infer a date that is not stated or computable. Where the lease and an amendment conflict, the later document wins and the conflict is flagged.",
    "agents": [
      {
        "agent_name": "Lease Reader",
        "system_prompt": "Identify the base lease and every amendment, order them by date, and produce a clause map with page ranges.",
        "model_name": "gemini-2.5-flash",
        "max_loops": 1
      },
      {
        "agent_name": "Term Extractor",
        "system_prompt": "Extract premises, term, base rent schedule, options, deposit, CAM, exclusive use and assignment terms. Cite a page for each.",
        "model_name": "gpt-4.1-mini",
        "max_loops": 1
      },
      {
        "agent_name": "Critical Dates",
        "system_prompt": "Compute rent steps, option notice windows, expiration and termination windows from the extracted terms. Show the arithmetic.",
        "model_name": "claude-haiku-5-5",
        "max_loops": 1
      },
      {
        "agent_name": "Abstract Writer",
        "system_prompt": "Assemble the abstract as JSON with exactly the requested fields. Put ambiguous or unusual clauses in flags_for_counsel with their page.",
        "model_name": "claude-sonnet-5-5",
        "max_loops": 1
      }
    ],
    "max_loops": 1
  }'

# The response carries "output" (the abstract) and "usage" with
# input_tokens, output_tokens and total_tokens for the run.

// Acquisition due diligence as a hierarchical swarm: the director splits the
// data room into workstreams, the workers draft findings, the director
// integrates them. The memo is a draft for the deal team and counsel.
const SWARMS_API = "https://api.swarms.world/v1/swarm/completions"

type DataRoom = { property: string; folders: Record<string, string[]> }

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

const worker = (name: string, folder: string, focus: string, model: string) => ({
  agent_name: name,
  description: "Reads the " + folder + " folder of the data room.",
  system_prompt:
    "You are a due diligence analyst. Read the documents listed for the " + folder + " folder " +
    "and draft findings on: " + focus + " For each finding give the document, the page and " +
    "whether it is a closing condition, a price adjustment or a note. Mark anything that " +
    "needs outside counsel or a consultant.",
  model_name: model,
  max_loops: 1,
})

export async function runDiligence(room: DataRoom): Promise<SwarmResponse> {
  const index = Object.entries(room.folders)
    .map(([folder, docs]) => folder + ":\n  " + docs.join("\n  "))
    .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: "Acquisition Diligence " + room.property,
      description: "Director-led diligence across four workstreams.",
      swarm_type: "HierarchicalSwarm",
      task:
        "Run due diligence on " + room.property + ". Data room index:\n" + index +
        "\nReturn a diligence memo with findings by workstream, open items and a closing checklist.",
      rules: "Cite the document and page for every finding. Do not estimate values that are not in the documents.",
      agents: [
        worker("Title Agent", "title", "vesting, easements, encroachments, exceptions on the commitment, survey conflicts.", "gpt-4.1-mini"),
        worker("Environmental Agent", "environmental", "Phase I findings, RECs, tank records, remediation history, next steps.", "claude-haiku-5-5"),
        worker("Financials Agent", "financials", "rent roll vs leases, trailing twelve, recoveries, arrears, capital spend.", "gpt-5.4"),
        worker("Physical Agent", "physical", "roof and structure, mechanical age, deferred maintenance, ADA, code items.", "gemini-2.5-flash"),
      ],
      max_loops: 1,
    }),
  })

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

runDiligence({
  property: "Riverside Plaza, 212 Market St",
  folders: {
    title: ["commitment-2026-02.pdf", "alta-survey-2025.pdf", "recorded-easements.pdf"],
    environmental: ["phase-i-2026-01.pdf", "ust-closure-1998.pdf"],
    financials: ["rent-roll-2026-03.xlsx", "t12-2026-02.xlsx", "cam-recon-2025.pdf"],
    physical: ["pca-2026-01.pdf", "roof-warranty.pdf", "elevator-inspection-2025.pdf"],
  },
}).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"]}

# After a portfolio abstraction run, pull the request history from Swarms
# Cloud and reconcile it: every lease that was submitted should have a
# completed run, and the token usage per property goes to the cost report.
# Request names follow "Lease Abstraction <property> <suite>".
logs = requests.get(f"{BASE}/v1/swarm/logs", headers=HEADERS, timeout=60).json()
metrics = requests.get(f"{BASE}/v1/metrics/summary", headers=HEADERS, timeout=30).json()


def walk(node, key):
    """Yield every value stored under key anywhere in a nested JSON document."""
    if isinstance(node, dict):
        for k, v in node.items():
            if k == key:
                yield v
            yield from walk(v, key)
    elif isinstance(node, list):
        for item in node:
            yield from walk(item, key)


submitted = {
    ("Riverside Plaza", "410"), ("Riverside Plaza", "520"), ("Riverside Plaza", "600"),
    ("Harbor Point", "100"), ("Harbor Point", "210"), ("Harbor Point", "300"),
}

seen: set[tuple[str, str]] = set()
tokens_by_property: dict[str, int] = {}

for entry in walk(logs, "data"):
    if not isinstance(entry, dict):
        continue
    name = str(entry.get("name", ""))
    if not name.startswith("Lease Abstraction "):
        continue
    rest = name.removeprefix("Lease Abstraction ")
    prop, _, suite = rest.rpartition(" ")
    seen.add((prop, suite))
    total = sum(int(t) for t in walk(entry, "total_tokens") if isinstance(t, (int, float)))
    tokens_by_property[prop] = tokens_by_property.get(prop, 0) + total

missing = submitted - seen
for prop, suite in sorted(missing):
    print(f"no run found for {prop} suite {suite}: resubmit")

for prop, total in sorted(tokens_by_property.items()):
    print(f"{prop:24s} {total:>10,} tokens")

print("account metrics:", metrics)

from swarms import Agent, ConcurrentWorkflow

# The open-source swarms package runs the listing writers in-process. Three
# writers work from one fact sheet at the same time; the output is a draft
# the leasing team reviews before it goes to the portals.
FACT_SHEET = """
Unit 7B, 1180 Elm Street. 2 bed, 2 bath, 1,140 sf, 7th floor, south-facing.
Renovated 2024: quartz counters, induction range, in-unit washer and dryer.
Building: 2008, elevator, bike room, roof deck, 24-hour entry system.
Rent 3,250 USD per month, 12-month minimum, available 1 June. One cat permitted.
Transit: 6-minute walk to the Elm Street station. Parking space 175 USD per month.
"""

RULES = (
    "Fair housing: describe the property, never the ideal tenant. No references to "
    "families, religion, national origin, disability or any protected class. State "
    "only facts in the sheet. No superlatives."
)

description = Agent(
    agent_name="Description Writer",
    system_prompt="Write a 120 to 160 word listing description from the facts. " + RULES,
    model_name="claude-sonnet-5-5",
    max_loops=1,
)

highlights = Agent(
    agent_name="Highlights Writer",
    system_prompt="Write eight bullet highlights, each under 60 characters, from the facts. " + RULES,
    model_name="gpt-4.1-mini",
    max_loops=1,
)

snippets = Agent(
    agent_name="Portal Snippets Writer",
    system_prompt=(
        "Write a 70-character headline and a 150-character summary for listing portals, "
        "plus a two-line social post. " + RULES
    ),
    model_name="gpt-5.4-mini",
    max_loops=1,
)

workflow = ConcurrentWorkflow(
    name="Listing Writers",
    description="Description, highlights and portal snippets from one fact sheet.",
    agents=[description, highlights, snippets],
    max_loops=1,
)

draft = workflow.run(FACT_SHEET)
print(draft)  # reviewed by the leasing team before publishing