Token Usage

from swarms import Agent

agent = Agent(
    agent_name="Usage-Demo",
    system_prompt="You answer in one short paragraph.",
    model_name="gpt-5.4",
    max_loops=1,
)

print(agent.usage)  # all zeros before the first call

agent.run("Explain what a token is, for someone new to language models.")
print(agent.usage)
# {'input_tokens': ..., 'output_tokens': ..., 'cached_tokens': ...,
#  'reasoning_tokens': ..., 'total_tokens': ...}

sub_agents = [entry["agent"] for entry in getattr(agent, "sub_agents", {}).values()]
total = agent.usage["total_tokens"] + sum(a.usage["total_tokens"] for a in sub_agents)

before = agent.usage
agent.run("Now explain a context window, the same way.")
after = agent.usage

this_run = {key: after[key] - before[key] for key in after}
print(this_run)

# $ per 1M tokens; use your provider's price list
INPUT_PRICE = 2.50
CACHED_INPUT_PRICE = 1.25
OUTPUT_PRICE = 10.00


def cost(usage: dict) -> float:
    """Dollar cost of a usage dict at the rates above."""
    uncached = usage["input_tokens"] - usage["cached_tokens"]
    return (
        uncached * INPUT_PRICE
        + usage["cached_tokens"] * CACHED_INPUT_PRICE
        + usage["output_tokens"] * OUTPUT_PRICE
    ) / 1_000_000


print(f"${cost(agent.usage):.5f}")

from swarms import Agent


def word_count(text: str) -> int:
    """Count the words in a piece of text.

    Args:
        text: The text to count.
    """
    return len(text.split())


tool_agent = Agent(
    agent_name="Usage-Tool-Demo",
    system_prompt="Use the word_count tool when asked about length.",
    model_name="gpt-5.4",
    tools=[word_count],
    max_loops=3,
)

tool_agent.run(
    "How many words are in this sentence: 'The quick brown fox jumps "
    "over the lazy dog'? Then tell me whether that is a long sentence."
)
print(tool_agent.usage)

from swarms import Agent

agent = Agent(agent_name="Window-Check", model_name="gpt-5.4", max_loops=1)
agent.run("Summarize the plot of Hamlet in five sentences.")

used = agent.input_tokens
print(f"{used} of {agent.context_length} tokens ({used / agent.context_length:.1%})")

from swarms import Agent, SwarmRouter

agents = [
    Agent(agent_name="Researcher", system_prompt="Gather the key facts. Be brief.", model_name="gpt-5.4", max_loops=1),
    Agent(agent_name="Analyst", system_prompt="Weigh the facts you were given. Be brief.", model_name="gpt-5.4", max_loops=1),
    Agent(agent_name="Writer", system_prompt="Write a three-sentence brief from the analysis.", model_name="gpt-5.4", max_loops=1),
]

router = SwarmRouter(
    name="usage-hierarchical",
    agents=agents,
    swarm_type="HierarchicalSwarm",
    max_loops=1,
)
router.run("Should a small team adopt a monorepo? Give a recommendation.")

workers = sum(agent.usage["total_tokens"] for agent in agents)
print(router.usage)
print("director:", router.usage["total_tokens"] - workers)

from swarms import Agent, GraphWorkflow

researcher = Agent(agent_name="Researcher", model_name="gpt-5.4-mini", max_loops=1)
writer = Agent(agent_name="Writer", model_name="gpt-5.4-mini", max_loops=1)

workflow = GraphWorkflow(name="usage-graph")
workflow.add_node(researcher)
workflow.add_node(writer)
workflow.add_edge("Researcher", "Writer")

workflow.run("Produce a short market note on AI chips.")
print(workflow.usage)

from swarms import HeavySwarm

swarm = HeavySwarm(
    question_agent_model_name="gpt-5.4-mini",
    worker_model_name="gpt-5.4-mini",
)
swarm.run("What are the main risks of building a data center in a hot climate?")
print(swarm.usage)

from swarms import TreeOfThoughts

tot = TreeOfThoughts(model_name="gpt-5.4-mini", max_depth=2)
tot.run("Use 4, 9, 10 and 13 with + - * / to make 24.")

print(tot.last_result.usage, tot.last_result.llm_calls)
print(tot.usage)

def total_usage(agents) -> dict:
    """Sum agent.usage over a list of agents."""
    total = {}
    for agent in agents:
        for key, value in agent.usage.items():
            total[key] = total.get(key, 0) + value
    return total