agent = Agent(
    routing={
        "simple": {
            "model": "llama-3",
            "conditions": ["length < 100", "complexity < 0.3"]
        },
        "medium": {
            "model": "gpt-3.5-turbo",
            "conditions": ["length < 500", "complexity < 0.7"]
        },
        "complex": {
            "model": "gpt-4",
            "conditions": ["length >= 500", "complexity >= 0.7"]
        }
    }
)

# Bad: Verbose system prompt
system_prompt = """
You are a helpful AI assistant designed to help users
with their questions. Please provide detailed and
accurate responses...
"""

# Good: Concise system prompt
system_prompt = "You are a helpful AI assistant."

# Limit response length
agent = Agent(
    model="gpt-4",
    max_tokens=500  # Limit response size
)

# Truncate old messages
def manage_context(messages, max_tokens=4000):
    total_tokens = sum(count_tokens(m) for m in messages)
    
    if total_tokens > max_tokens:
        # Keep system message and recent messages
        return [messages[0]] + messages[-10:]
    
    return messages

@agent.cache(ttl="1h")
async def handle_faq(question: str):
    return await agent.generate(question)

@agent.cache(
    strategy="semantic",
    similarity_threshold=0.95,
    ttl="1h"
)
async def handle_query(query: str):
    return await agent.generate(query)

# Bad: Individual requests
for message in messages:
    await agent.generate(message)

# Good: Batch processing
await agent.generate_batch(messages)

{
  "scaling": {
    "minInstances": 1,
    "maxInstances": 10,
    "scaleDownDelay": "5m",
    "targetCPU": 70
  }
}

{
  "scaling": {
    "strategy": "cost-optimized",
    "schedule": {
      "weekday": {
        "minInstances": 2,
        "maxInstances": 10
      },
      "weekend": {
        "minInstances": 1,
        "maxInstances": 5
      },
      "night": {
        "minInstances": 1,
        "maxInstances": 3
      }
    }
  }
}

{
  "memory": {
    "shortTerm": {
      "ttl": "30m",
      "maxSize": "10MB"
    },
    "longTerm": {
      "ttl": "7d",
      "maxSize": "50MB"
    }
  }
}

# Automatic cleanup of old data
@agent.schedule("0 0 * * *")  # Daily at midnight
async def cleanup_memory():
    await agent.memory.cleanup(older_than="30d")

# Cache external API results
@cache(ttl="1h")
async def fetch_weather(city: str):
    return await weather_api.get(city)

# Batch API calls
async def fetch_multiple_cities(cities: list):
    return await weather_api.batch_get(cities)

# View cost breakdown
swiftclaw costs my-agent --period 30d

# Output:
# CATEGORY        COST      PERCENTAGE
# Model Usage     $150.00   60%
# Infrastructure  $75.00    30%
# Storage         $25.00    10%
# Total           $250.00   100%

# Alert when daily cost exceeds threshold
swiftclaw alerts create \
  --agent my-agent \
  --metric daily-cost \
  --threshold 50 \
  --action notify

{
  "model": {
    "primary": "gpt-4",
    "fallbacks": [
      "claude-3-sonnet",
      "gpt-3.5-turbo"
    ]
  }
}

@agent.throttle(rate="100/hour")
async def expensive_operation():
    return await agent.generate(complex_prompt)

@agent.schedule("0 2 * * *")  # 2 AM daily
async def batch_analysis():
    await process_daily_reports()