from autonomy import Agent, Model, Node


async def main(node):
 await Agent.start(
 node=node,
 name="manager",
 instructions="""
 You are a project manager who coordinates research and writing tasks.

 When given a topic:
 1. Delegate research to the researcher subagent
 2. Delegate writing to the writer subagent
 3. Combine their work into a final response
 """,
 model=Model("claude-sonnet-4-v1"),
 subagents={
 "researcher": {
 "instructions": "You are a researcher who finds accurate information on topics.",
 "model": Model("claude-sonnet-4-v1"),
 "auto_start": True
 },
 "writer": {
 "instructions": "You are a writer who creates clear, engaging content.",
 "model": Model("nova-pro-v1"),
 "auto_start": True
 }
 }
 )


Node.start(main)

FROM ghcr.io/build-trust/autonomy-python
COPY . .
ENTRYPOINT ["python", "main.py"]

name: subagent-example
pods:
 - name: main-pod
 public: true
 containers:
 - name: main
 image: main

curl --request POST \
 --header "Content-Type: application/json" \
 --data '{"message":"Write a report about quantum computing"}' \
 "https://CLUSTER-ZONE.cluster.autonomy.computer/agents/manager"

await Agent.start(
 node=node,
 name="parent",
 instructions="You coordinate work across specialized subagents",
 model=Model("claude-sonnet-4-v1"),
 subagents={
 "role_name": {
 "instructions": "Subagent instructions",
 "model": Model("model-name"),
 "auto_start": True, # Optional: start automatically on first use
 "tools": [...], # Optional: subagent-specific tools
 "max_iterations": 10, # Optional: override default
 "max_execution_time": 60, # Optional: timeout in seconds
 "enable_long_term_memory": True, # Optional: persistent memory
 }
 }
)

# Agent calls: start_subagent(role="researcher")
# Returns: Confirmation that subagent started

# Agent calls: delegate_to_subagent(
# role="researcher",
# task="Research the history of quantum computing"
# )
# Returns: The researcher's response

# Agent calls: delegate_to_subagents_parallel(
# role="researcher",
# tasks=[
# "Research quantum computing history",
# "Research quantum computing applications",
# "Research quantum computing challenges"
# ]
# )
# Returns: Array of results in the same order as tasks

# Agent calls: list_subagents()
# Returns: Information about configured and running subagents

# Agent calls: stop_subagent(role="researcher")
# Returns: Confirmation that subagent stopped

await Agent.start(
 node=node,
 name="sequential_manager",
 instructions="""
 When given a topic to analyze:
 1. First, delegate to 'researcher' to gather information
 2. Then, delegate to 'analyst' to analyze the research
 3. Finally, delegate to 'writer' to create a report

 Use delegate_to_subagent for each step. Wait for results before proceeding.
 """,
 model=Model("claude-sonnet-4-v1"),
 subagents={
 "researcher": {
 "instructions": "Research topics thoroughly and provide factual information",
 "auto_start": True
 },
 "analyst": {
 "instructions": "Analyze research data and identify key insights",
 "auto_start": True
 },
 "writer": {
 "instructions": "Write clear, engaging reports from analysis",
 "auto_start": True
 }
 }
)

await Agent.start(
 node=node,
 name="parallel_manager",
 instructions="""
 When given a list of topics to research:
 1. Use delegate_to_subagents_parallel to research all topics at once
 2. Each topic will be processed by a separate researcher instance
 3. Combine the results into a comprehensive summary
 """,
 model=Model("claude-sonnet-4-v1"),
 subagents={
 "researcher": {
 "instructions": "Research a single topic and provide detailed findings",
 "model": Model("claude-sonnet-4-v1"),
 "auto_start": True
 }
 }
)

curl --request POST \
 --header "Content-Type: application/json" \
 --data '{"message":"Research these topics: quantum computing, AI ethics, blockchain"}' \
 "https://CLUSTER-ZONE.cluster.autonomy.computer/agents/parallel_manager"

await Agent.start(
 node=node,
 name="content_manager",
 instructions="""
 You coordinate content creation:
 - Use 'researcher' for fact-finding
 - Use 'writer' for drafting content
 - Use 'editor' for reviewing and improving content
 - Use 'fact_checker' to verify claims

 Choose the right subagent based on the task at hand.
 """,
 model=Model("claude-sonnet-4-v1"),
 subagents={
 "researcher": {
 "instructions": "Research topics and gather accurate information",
 "tools": [McpTool("brave_search", "brave_web_search")],
 "auto_start": True
 },
 "writer": {
 "instructions": "Write engaging, clear content",
 "model": Model("claude-sonnet-4-v1"),
 "auto_start": True
 },
 "editor": {
 "instructions": "Review content for clarity, grammar, and style",
 "model": Model("claude-sonnet-4-v1"),
 "auto_start": True
 },
 "fact_checker": {
 "instructions": "Verify factual claims and identify unsupported statements",
 "tools": [McpTool("brave_search", "brave_web_search")],
 "auto_start": True
 }
 }
)

subagents={
 "researcher": {
 "instructions": "You are a researcher",
 "auto_start": True # Starts automatically when first delegated to
 }
}

await Agent.start(
 node=node,
 name="batch_processor",
 instructions="""
 When given a batch of documents to analyze:
 1. Use delegate_to_subagents_parallel with the 'analyzer' role
 2. Pass all documents as separate tasks
 3. Each document will be analyzed by a separate instance
 4. Results come back in the same order as the input
 """,
 model=Model("claude-sonnet-4-v1"),
 subagents={
 "analyzer": {
 "instructions": "Analyze a single document and extract key insights",
 "model": Model("claude-sonnet-4-v1")
 }
 }
)

# Parent agent calls:
delegate_to_subagents_parallel(
 role="analyzer",
 tasks=[
 "Analyze document 1: [content...]",
 "Analyze document 2: [content...]",
 "Analyze document 3: [content...]"
 ]
)

# Framework creates 3 analyzer instances, processes all 3 documents concurrently,
# and returns array of results: [result1, result2, result3]

await Agent.start(
 node=node,
 name="distributed_manager",
 instructions="Coordinate work across distributed workers",
 model=Model("claude-sonnet-4-v1"),
 subagent_runner_filter="role=worker", # Apply to all subagents
 subagents={
 "worker": {
 "instructions": "Process tasks assigned to you",
 "runner_filter": "role=worker,cpu=high" # Override for this subagent
 }
 }
)

name: distributed-app
pods:
 - name: manager-pod
 public: true
 containers:
 - name: manager
 image: manager

 - name: worker-pod
 replicas: 3 # Multiple worker nodes
 labels:
 role: worker
 cpu: high
 containers:
 - name: worker
 image: worker

subagents={
 "researcher": {
 "instructions": "You are a researcher",
 "enable_long_term_memory": True, # Enable persistent memory
 "max_messages_in_short_term_memory": 50, # Limit short-term memory
 "max_tokens_in_short_term_memory": 4000
 }
}

from autonomy import Agent, Model, Node, McpClient, McpTool


async def main(node):
 await Agent.start(
 node=node,
 name="research_coordinator",
 instructions="""
 You coordinate research and writing projects.

 When given a topic with multiple aspects:
 1. Break it into specific research questions
 2. Use delegate_to_subagents_parallel to research all questions at once
 3. Synthesize the research findings
 4. Delegate to the writer to create a comprehensive article
 5. Return the final article
 """,
 model=Model("claude-sonnet-4-v1"),
 subagents={
 "researcher": {
 "instructions": """
 You are a thorough researcher who finds accurate, current information.
 Use the brave_web_search tool to find reliable sources.
 Cite your sources in your responses.
 """,
 "model": Model("claude-sonnet-4-v1"),
 "tools": [McpTool("brave_search", "brave_web_search")],
 "auto_start": True,
 "max_execution_time": 120
 },
 "writer": {
 "instructions": """
 You are a skilled writer who creates clear, engaging articles.
 Structure content with clear headings and logical flow.
 Write in an accessible but authoritative tone.
 """,
 "model": Model("claude-sonnet-4-v1"),
 "auto_start": True,
 "max_execution_time": 90
 }
 }
 )


Node.start(
 main,
 mcp_clients=[
 McpClient(name="brave_search", address="http://localhost:8001/sse")
 ]
)

name: research-system
pods:
 - name: main-pod
 public: true
 containers:
 - name: main
 image: main

 - name: mcp
 image: ghcr.io/build-trust/mcp-proxy
 env:
 - BRAVE_API_KEY: secrets.BRAVE_API_KEY
 args:
 ["--sse-port", "8001", "--pass-environment", "--",
 "npx", "-y", "@modelcontextprotocol/server-brave-search"]

BRAVE_API_KEY: "YOUR_BRAVE_API_KEY"

# Use the system
curl --request POST \
 --header "Content-Type: application/json" \
 --data '{"message":"Write a comprehensive article about renewable energy, covering solar, wind, and hydroelectric power"}' \
 "https://CLUSTER-ZONE.cluster.autonomy.computer/agents/research_coordinator"

subagents={
 "quick_classifier": {
 "instructions": "Classify inputs into categories",
 "model": Model("nova-micro-v1") # Fast, cheap for simple tasks
 },
 "deep_analyzer": {
 "instructions": "Perform deep analysis",
 "model": Model("claude-opus-4-v1") # Powerful for complex reasoning
 }
}

subagents={
 "web_searcher": {
 "instructions": "Search the web for information",
 "max_execution_time": 120, # Web searches may take longer
 "tools": [McpTool("brave_search", "brave_web_search")]
 },
 "calculator": {
 "instructions": "Perform calculations",
 "max_execution_time": 30 # Quick operations
 }
}

subagents={
 "helper": {
 "instructions": "Help with tasks",
 "auto_start": True # Simpler agent logic
 }
}

subagents={
 "researcher": {
 "instructions": """
 You are a researcher focused solely on gathering information.

 Your job:
 - Find accurate, current information on the given topic
 - Use web search when needed
 - Cite sources
 - DO NOT write articles or summaries
 - DO NOT provide opinions, only facts
 """
 }
}

instructions="""
You coordinate subagents. If a subagent task fails:
1. Check if the error can be resolved (e.g., retry with different parameters)
2. Try an alternative approach if available
3. If all attempts fail, inform the user clearly about what went wrong
"""