my-agent/
  agent.py            # Agent + tools definition
  requirements.txt
  Dockerfile          # you wrote this
  fly.toml            # or render.yaml, or ECS task def...

my-agent/
  agent.py            # UNCHANGED
  requirements.txt    # UNCHANGED
  agent.yaml          # NEW -- the AG config

# agent.py
from agents import Agent, function_tool

@function_tool
def lookup_order(order_id: str) -> str:
    """Look up an order by ID."""
    return f"Order {order_id}: shipped, arriving tomorrow"

agent = Agent(
    name="Support Agent",
    instructions="You are a helpful customer support agent...",
    tools=[lookup_order],
)

my_bot = Agent(name="My Bot", ...)
agent = my_bot  # alias for AgentBreeder

name: support-agent
version: 1.0.0
description: "Customer support agent with order lookup"
team: support
owner: you@company.com
tags: [openai-agents, support, production]

framework: openai_agents

model:
  primary: gpt-4o
  fallback: gpt-4o-mini

tools:
  - name: lookup_order
    type: function
    description: "Look up an order by ID"

deploy:
  cloud: local
  secrets:
    - OPENAI_API_KEY

agentbreeder validate agent.yaml

agentbreeder deploy agent.yaml --target local

curl -X POST http://localhost:8080/invoke \
  -d '{"input": {"message": "Where is order #12345?"}}' \
  -H 'Content-Type: application/json'

deploy:
  cloud: aws
  runtime: ecs-fargate
  region: us-east-1
  scaling:
    min: 1
    max: 10
    target_cpu: 70
  resources:
    cpu: "0.5"
    memory: "1Gi"
  secrets:
    - OPENAI_API_KEY

agentbreeder deploy agent.yaml --target aws

# agent.py
from agents import Agent, Handoff, function_tool

billing_agent = Agent(
    name="Billing",
    instructions="Handle billing and payment questions.",
    tools=[lookup_invoice],
)

tech_agent = Agent(
    name="Tech Support",
    instructions="Handle technical issues.",
    tools=[check_status, restart_service],
)

triage_agent = Agent(
    name="Triage",
    instructions="Route customer requests to the right specialist.",
    handoffs=[
        Handoff(target=billing_agent, description="Billing questions"),
        Handoff(target=tech_agent, description="Technical support"),
    ],
)

# Export the entry point agent
agent = triage_agent

# agent.yaml
name: support-triage
framework: openai_agents
model:
  primary: gpt-4o
deploy:
  cloud: local
  secrets:
    - OPENAI_API_KEY

# orchestration.yaml
name: support-router
version: 1.0.0
team: support
owner: you@company.com
strategy: router

agents:
  triage:
    ref: agents/triage-agent
    routes:
      - condition: "billing"
        target: billing
      - condition: "technical"
        target: tech-support
  billing:
    ref: agents/billing-agent
  tech-support:
    ref: agents/tech-support-agent

deploy:
  target: local

from agents import Agent, Runner, function_tool

@function_tool
def get_weather(city: str) -> str:
    """Get current weather for a city."""
    return f"72F and sunny in {city}"

agent = Agent(
    name="Weather Bot",
    instructions="Help users check the weather.",
    tools=[get_weather],
)

# Local testing
result = await Runner.run(agent, "What's the weather in SF?")
print(result.final_output)

# Exactly the same file. Zero changes.

model:
  primary: gpt-4o
  fallback: claude-sonnet-4
  gateway: litellm

guardrails:
  - pii_detection
  - content_filter
  - hallucination_check

access:
  visibility: team
  allowed_callers:
    - team:support
  require_approval: false

mcp_servers:
  - ref: mcp/zendesk
    transport: stdio
  - ref: mcp/order-management

knowledge_bases:
  - ref: kb/product-docs
  - ref: kb/faq-database

# agent.py
from my_bot import agent  # re-export

agent = Agent(name="My Agent", ...)  # must be at module level, not inside a function

deploy:
  secrets:
    - OPENAI_API_KEY

agent = triage_agent  # the first agent that receives input

from __future__ import annotations
import math
from agents import Agent, Runner, function_tool


@function_tool
def web_search(query: str) -> str:
    """Search the web for information on a given query."""
    return (
        f"Search results for '{query}':\n"
        f"1. Wikipedia article on {query}\n"
        f"2. Recent news about {query}\n"
        f"3. Academic papers related to {query}"
    )


@function_tool
def calculator(expression: str) -> str:
    """Evaluate a mathematical expression safely."""
    allowed_names = {
        "abs": abs, "round": round, "min": min, "max": max,
        "pow": pow, "sqrt": math.sqrt, "pi": math.pi, "e": math.e,
    }
    try:
        result = eval(expression, {"__builtins__": {}}, allowed_names)
        return str(result)
    except Exception as e:
        return f"Error: {e}"


agent = Agent(
    name="Research Assistant",
    instructions=(
        "You are a helpful research assistant. Use your tools to find "
        "accurate information and provide well-structured answers."
    ),
    tools=[web_search, calculator],
)


async def main() -> None:
    """Run the agent interactively for local testing."""
    result = await Runner.run(agent, "What is the square root of 144 plus 25?")
    print(f"Agent response: {result.final_output}")


if __name__ == "__main__":
    import asyncio
    asyncio.run(main())

openai-agents>=0.1.0
openai>=1.60.0

name: research-assistant
version: 0.1.0
description: "A research assistant agent built with the OpenAI Agents SDK"
team: examples
owner: dev@agentbreeder.com
tags: [example, openai-agents, research, tools]

framework: openai_agents

model:
  primary: gpt-4o-mini

tools:
  - name: web_search
    type: function
    description: "Search the web for information"
  - name: calculator
    type: function
    description: "Evaluate mathematical expressions"

deploy:
  cloud: local
  secrets:
    - OPENAI_API_KEY

agentbreeder deploy agent.yaml