Agent

from swarms import Agent

def run(
    task: Optional[Union[str, Any]] = None,
    img: Optional[str] = None,
    *args,
    **kwargs
) -> Any

def __call__(
    task: str,
    *args,
    **kwargs
) -> str

async def arun(
    task: Optional[Union[str, Any]] = None,
    img: Optional[str] = None,
    *args,
    **kwargs,
) -> Any

async def run_concurrent(
    task: str,
    *args,
    **kwargs,
) -> Any

def run_concurrent_tasks(
    tasks: List[str],
    *args,
    **kwargs,
) -> List[Any]

def bulk_run(
    inputs: List[Dict[str, Any]],
) -> List[str]

def save(
    file_path: str = None
) -> None

def load(
    file_path: str
) -> Agent

def to_dict() -> Dict[str, Any]

def to_json(
    indent: int = 4
) -> str

def to_yaml(
    indent: int = 4
) -> str

def add_tool(tool: Callable) -> None
def add_tools(tools: List[Callable]) -> None

def remove_tool(tool: Callable) -> None
def remove_tools(tools: List[Callable]) -> None

def reset() -> None

def print_dashboard() -> None

def update_system_prompt(system_prompt: str) -> None
def update_max_loops(max_loops: Union[int, str]) -> None
def update_loop_interval(loop_interval: int) -> None
def update_retry_attempts(retry_attempts: int) -> None
def update_retry_interval(retry_interval: int) -> None

def plan(task: str, *args, **kwargs) -> None

def add_memory(message: str) -> None

def enable_autosave(interval: int = 300) -> None
def disable_autosave() -> None
def cleanup() -> None

def run_stream(
    task: str,
    img: Optional[str] = None,
    **kwargs,
) -> Iterator[str]

for token in agent.run_stream("Analyse NVDA"):
    print(token, end="", flush=True)

async def arun_stream(
    task: str,
    img: Optional[str] = None,
    **kwargs,
) -> AsyncIterator[str]

import asyncio

async def main():
    async for token in agent.arun_stream("Analyse NVDA"):
        print(token, end="", flush=True)

asyncio.run(main())

from swarms import Agent

# Create a simple agent
agent = Agent(
    agent_name="Financial-Analyst",
    model_name="claude-sonnet-4-6",
    max_loops=1,
    system_prompt="You are a financial analyst. Provide detailed, data-driven insights."
)

# Run a task
response = agent.run("Analyze the Q4 2024 revenue trends")
print(response)

from swarms import Agent

def search_web(query: str) -> str:
    """Search the web for information."""
    # Implementation
    return f"Search results for: {query}"

def calculate(expression: str) -> float:
    """Evaluate a mathematical expression."""
    return eval(expression)

agent = Agent(
    agent_name="Research-Agent",
    model_name="claude-sonnet-4-6",
    max_loops=5,
    tools=[search_web, calculate],
    system_prompt="You are a research assistant with web search and calculation abilities."
)

result = agent.run("Search for the population of Tokyo and calculate its growth rate")

agent = Agent(
    agent_name="Vision-Agent",
    model_name="claude-sonnet-4-6",
    multi_modal=True,
    max_loops=1
)

response = agent.run(
    task="Describe what you see in this image and identify any objects",
    img="path/to/image.jpg"
)

agent = Agent(
    agent_name="Autonomous-Developer",
    model_name="claude-sonnet-4-6",
    max_loops="auto",  # Enables autonomous planning and execution
    system_prompt="You are an autonomous software developer."
)

result = agent.run("Build a REST API for a todo application with authentication")
# Agent will:
# 1. Create a plan with subtasks
# 2. Execute each subtask using available tools
# 3. Generate a comprehensive summary

def on_token(token: str):
    print(token, end="", flush=True)

agent = Agent(
    agent_name="Streaming-Agent",
    model_name="claude-sonnet-4-6",
    stream=True,
    streaming_callback=on_token,
    max_loops=1
)

response = agent.run("Write a creative story about space exploration")

agent = Agent(
    agent_name="Reliable-Agent",
    fallback_models=["claude-sonnet-4-6", "gpt-5.4", "gpt-3.5-turbo"],
    max_loops=1
)

# Will try gpt-4o first, then gpt-4o-mini, then gpt-3.5-turbo if each fails
response = agent.run("Generate a market analysis report")

agent = Agent(
    agent_name="MCP-Agent",
    model_name="claude-sonnet-4-6",
    mcp_url="npx -y @modelcontextprotocol/server-filesystem /path/to/directory",
    max_loops=3
)

result = agent.run("Read the contents of config.json and summarize the settings")

# Create specialized agents
researcher = Agent(
    agent_name="Researcher",
    model_name="claude-sonnet-4-6",
    system_prompt="You are a research specialist."
)

writer = Agent(
    agent_name="Writer",
    model_name="claude-sonnet-4-6",
    system_prompt="You are a technical writer."
)

# Create coordinator with handoffs
coordinator = Agent(
    agent_name="Coordinator",
    model_name="claude-sonnet-4-6",
    max_loops=5,
    handoffs=[researcher, writer],
    system_prompt="You coordinate tasks between research and writing teams."
)

result = coordinator.run("Create a comprehensive report on quantum computing")
# Coordinator can delegate research to researcher and writing to writer

# Load a prompt from Swarms marketplace in one line
agent = Agent(
    model_name="claude-sonnet-4-6",
    marketplace_prompt_id="550e8400-e29b-41d4-a716-446655440000",
    max_loops=1
)

response = agent.run("Execute the marketplace prompt task")
# Agent automatically loads system prompt from marketplace