InteractiveManaging and Reducing AI Agent Costs: Complete Guide to Cost Optimization Strategies

1def calculate_interaction_cost(input_tokens, output_tokens, model="claude-sonnet-4.5"):
2    """Calculate the cost of a single model interaction."""
3    # Pricing per million tokens (November 2025 rates)
4    pricing = {
5        "claude-sonnet-4.5": {"input": 3.00, "output": 15.00},
6        "gpt-5": {"input": 2.50, "output": 10.00},
7        "gemini-2.5-flash": {"input": 0.40, "output": 1.20},
8        "gemini-2.5-pro": {"input": 1.25, "output": 5.00}
9    }
10    
11    rates = pricing[model]
12    
13    # Calculate cost (rates are per million tokens)
14    input_cost = (input_tokens / 1_000_000) * rates["input"]
15    output_cost = (output_tokens / 1_000_000) * rates["output"]
16    total_cost = input_cost + output_cost
17    
18    return {
19        "input_cost": input_cost,
20        "output_cost": output_cost,
21        "total_cost": total_cost
22    }
23
24## Example: A conversation with context
25input_tokens = 1500  # System prompt + conversation history + query
26output_tokens = 500  # Agent's response
27
28cost = calculate_interaction_cost(input_tokens, output_tokens, "claude-sonnet-4.5")
29print(f"Input cost: ${cost['input_cost']:.6f}")
30print(f"Output cost: ${cost['output_cost']:.6f}")
31print(f"Total cost: ${cost['total_cost']:.6f}")
32print(f"\nCost per 1000 interactions: ${cost['total_cost'] * 1000:.2f}")

1Input cost: $0.004500
2Output cost: $0.007500
3Total cost: $0.012000
4
5Cost per 1000 interactions: $12.00

1from anthropic import Anthropic
2from datetime import datetime
3
4class CostTrackingAgent:
5    """Agent that tracks API costs for monitoring and optimization."""
6    
7    def __init__(self):
8        self.client = Anthropic(api_key="YOUR_API_KEY")
9        self.cost_log = []
10        
11        # Pricing per million tokens
12        self.pricing = {
13            "claude-sonnet-4.5": {"input": 3.00, "output": 15.00}
14        }
15    
16    def _calculate_cost(self, usage, model):
17        """Calculate cost from token usage."""
18        rates = self.pricing[model]
19        input_cost = (usage.input_tokens / 1_000_000) * rates["input"]
20        output_cost = (usage.output_tokens / 1_000_000) * rates["output"]
21        return input_cost + output_cost
22    
23    def respond(self, query):
24        """Generate response and track costs."""
25        model = "claude-sonnet-4.5"
26        
27        response = self.client.messages.create(
28            model=model,
29            max_tokens=1024,
30            messages=[{"role": "user", "content": query}]
31        )
32        
33        # Calculate and log cost
34        cost = self._calculate_cost(response.usage, model)
35        
36        self.cost_log.append({
37            "timestamp": datetime.now(),
38            "query": query[:50] + "..." if len(query) > 50 else query,
39            "input_tokens": response.usage.input_tokens,
40            "output_tokens": response.usage.output_tokens,
41            "cost": cost,
42            "model": model
43        })
44        
45        return response.content[0].text
46    
47    def get_cost_summary(self):
48        """Get summary of costs."""
49        if not self.cost_log:
50            return "No interactions yet."
51        
52        total_cost = sum(entry["cost"] for entry in self.cost_log)
53        total_tokens = sum(
54            entry["input_tokens"] + entry["output_tokens"] 
55            for entry in self.cost_log
56        )
57        
58        return {
59            "total_interactions": len(self.cost_log),
60            "total_cost": total_cost,
61            "total_tokens": total_tokens,
62            "average_cost_per_interaction": total_cost / len(self.cost_log),
63            "most_expensive": max(self.cost_log, key=lambda x: x["cost"])
64        }
65
66## Test the tracking
67agent = CostTrackingAgent()
68
69agent.respond("What is Python?")
70agent.respond("Explain machine learning in simple terms.")
71agent.respond("How do neural networks work?")
72
73summary = agent.get_cost_summary()
74print(f"Total interactions: {summary['total_interactions']}")
75print(f"Total cost: ${summary['total_cost']:.4f}")
76print(f"Average cost: ${summary['average_cost_per_interaction']:.4f}")
77print(f"\nMost expensive query: {summary['most_expensive']['query']}")
78print(f"Cost: ${summary['most_expensive']['cost']:.4f}")

1from anthropic import Anthropic
2from openai import OpenAI
3from google import generativeai as genai
4
5class CostOptimizedAgent:
6    """Agent that chooses the most cost-effective model for each task."""
7    
8    def __init__(self):
9        # Initialize clients for different providers
10        self.anthropic = Anthropic(api_key="YOUR_ANTHROPIC_KEY")
11        self.openai = OpenAI(api_key="YOUR_OPENAI_KEY")
12        genai.configure(api_key="YOUR_GOOGLE_KEY")
13        self.gemini = genai.GenerativeModel('gemini-2.5-flash')
14    
15    def _classify_task_complexity(self, query):
16        """Determine what level of model capability is needed."""
17        # High complexity: needs reasoning, tool use, or complex understanding
18        high_complexity_indicators = [
19            "explain why", "analyze", "compare and contrast",
20            "step by step", "reasoning", "pros and cons",
21            "evaluate", "critique"
22        ]
23        
24        # Medium complexity: straightforward questions or tasks
25        medium_complexity_indicators = [
26            "how to", "what is", "describe", "summarize"
27        ]
28        
29        query_lower = query.lower()
30        
31        if any(ind in query_lower for ind in high_complexity_indicators):
32            return "high"
33        elif any(ind in query_lower for ind in medium_complexity_indicators):
34            return "medium"
35        else:
36            return "low"
37    
38    def respond(self, query):
39        """Route to the most cost-effective model."""
40        complexity = self._classify_task_complexity(query)
41        
42        if complexity == "high":
43            # Use Claude Sonnet 4.5 for complex reasoning
44            # Cost: ~$0.012 per interaction
45            response = self.anthropic.messages.create(
46                model="claude-sonnet-4.5",
47                max_tokens=1024,
48                messages=[{"role": "user", "content": query}]
49            )
50            return response.content[0].text, "claude-sonnet-4.5", "high"
51        
52        elif complexity == "medium":
53            # Use GPT-5 for general tasks
54            # Cost: ~$0.008 per interaction (33% savings)
55            response = self.openai.chat.completions.create(
56                model="gpt-5",
57                max_tokens=512,
58                messages=[{"role": "user", "content": query}]
59            )
60            return response.choices[0].message.content, "gpt-5", "medium"
61        
62        else:
63            # Use Gemini 2.5 Flash for simple queries
64            # Cost: ~$0.001 per interaction (92% savings!)
65            response = self.gemini.generate_content(query)
66            return response.text, "gemini-2.5-flash", "low"
67
68## Test with different complexity levels
69agent = CostOptimizedAgent()
70
71queries = [
72    ("What's the capital of France?", "low"),
73    ("What is machine learning?", "medium"),
74    ("Analyze the pros and cons of different database architectures", "high")
75]
76
77for query, expected in queries:
78    result, model, complexity = agent.respond(query)
79    print(f"Query: {query}")
80    print(f"Complexity: {complexity} (expected: {expected})")
81    print(f"Model: {model}")
82    print(f"Response: {result[:100]}...")
83    print()

1from anthropic import Anthropic
2
3client = Anthropic(api_key="YOUR_API_KEY")
4
5def compare_response_costs(query):
6    """Compare costs of verbose vs concise responses."""
7    
8    # Verbose response (default behavior)
9    verbose_response = client.messages.create(
10        model="claude-sonnet-4.5",
11        max_tokens=1024,
12        messages=[{"role": "user", "content": query}]
13    )
14    
15    # Concise response (optimized)
16    concise_system = """You are a helpful assistant. Provide concise, direct answers.
17    Use 1-2 sentences for simple questions. Avoid unnecessary elaboration."""
18    
19    concise_response = client.messages.create(
20        model="claude-sonnet-4.5",
21        max_tokens=200,  # Hard limit
22        system=concise_system,
23        messages=[{"role": "user", "content": query}]
24    )
25    
26    # Calculate costs
27    def calc_cost(usage):
28        input_cost = (usage.input_tokens / 1_000_000) * 3.00
29        output_cost = (usage.output_tokens / 1_000_000) * 15.00
30        return input_cost + output_cost
31    
32    verbose_cost = calc_cost(verbose_response.usage)
33    concise_cost = calc_cost(concise_response.usage)
34    savings = ((verbose_cost - concise_cost) / verbose_cost) * 100
35    
36    return {
37        "verbose": {
38            "response": verbose_response.content[0].text,
39            "tokens": verbose_response.usage.output_tokens,
40            "cost": verbose_cost
41        },
42        "concise": {
43            "response": concise_response.content[0].text,
44            "tokens": concise_response.usage.output_tokens,
45            "cost": concise_cost
46        },
47        "savings_percent": savings
48    }
49
50## Test with a simple query
51result = compare_response_costs("What is Python?")
52
53print("Verbose response:")
54print(f"Tokens: {result['verbose']['tokens']}")
55print(f"Cost: ${result['verbose']['cost']:.6f}")
56print(f"Response: {result['verbose']['response'][:150]}...")
57print()
58
59print("Concise response:")
60print(f"Tokens: {result['concise']['tokens']}")
61print(f"Cost: ${result['concise']['cost']:.6f}")
62print(f"Response: {result['concise']['response']}")
63print()
64
65print(f"Cost savings: {result['savings_percent']:.1f}%")

1from google import generativeai as genai
2import hashlib
3import time
4from datetime import datetime, timedelta
5
6genai.configure(api_key="YOUR_GOOGLE_API_KEY")
7
8class CachingAgent:
9    """Agent with intelligent caching to minimize API calls."""
10    
11    def __init__(self):
12        self.model = genai.GenerativeModel('gemini-2.5-flash')
13        
14        # Short-term cache: exact query matches
15        self.exact_cache = {}
16        
17        # Long-term cache: common queries that rarely change
18        self.persistent_cache = {
19            "what is python": "Python is a high-level programming language...",
20            "what is machine learning": "Machine learning is a subset of AI...",
21            # Preload common queries
22        }
23        
24        # Cache metadata
25        self.cache_stats = {
26            "hits": 0,
27            "misses": 0,
28            "api_calls": 0,
29            "cost_saved": 0.0
30        }
31    
32    def _hash_query(self, query):
33        """Create cache key from query."""
34        return hashlib.md5(query.lower().strip().encode()).hexdigest()
35    
36    def _estimate_cost_saved(self, query):
37        """Estimate cost saved by cache hit."""
38        # Rough estimate: 100 input tokens + 200 output tokens
39        input_cost = (100 / 1_000_000) * 0.40
40        output_cost = (200 / 1_000_000) * 1.20
41        return input_cost + output_cost
42    
43    def respond(self, query):
44        """Get response, using cache when possible."""
45        cache_key = self._hash_query(query)
46        query_normalized = query.lower().strip()
47        
48        # Check persistent cache first (common queries)
49        if query_normalized in self.persistent_cache:
50            self.cache_stats["hits"] += 1
51            self.cache_stats["cost_saved"] += self._estimate_cost_saved(query)
52            return self.persistent_cache[query_normalized], "persistent_cache"
53        
54        # Check exact cache (recent queries)
55        if cache_key in self.exact_cache:
56            self.cache_stats["hits"] += 1
57            self.cache_stats["cost_saved"] += self._estimate_cost_saved(query)
58            return self.exact_cache[cache_key], "exact_cache"
59        
60        # Cache miss: call the model
61        self.cache_stats["misses"] += 1
62        self.cache_stats["api_calls"] += 1
63        
64        response = self.model.generate_content(query)
65        result = response.text
66        
67        # Store in exact cache
68        self.exact_cache[cache_key] = result
69        
70        # If cache is getting large, prune old entries
71        if len(self.exact_cache) > 1000:
72            # Keep only the most recent 500
73            keys_to_remove = list(self.exact_cache.keys())[:-500]
74            for key in keys_to_remove:
75                del self.exact_cache[key]
76        
77        return result, "api_call"
78    
79    def get_cache_stats(self):
80        """Get caching performance metrics."""
81        total_requests = self.cache_stats["hits"] + self.cache_stats["misses"]
82        hit_rate = (self.cache_stats["hits"] / total_requests * 100) if total_requests > 0 else 0
83        
84        return {
85            "total_requests": total_requests,
86            "cache_hits": self.cache_stats["hits"],
87            "cache_misses": self.cache_stats["misses"],
88            "hit_rate": hit_rate,
89            "api_calls": self.cache_stats["api_calls"],
90            "estimated_cost_saved": self.cache_stats["cost_saved"]
91        }
92
93## Test the caching agent
94agent = CachingAgent()
95
96## Simulate user queries (with some repetition)
97queries = [
98    "What is Python?",
99    "What is machine learning?",
100    "How do I learn programming?",
101    "What is Python?",  # Duplicate
102    "What is machine learning?",  # Duplicate
103    "How do I learn programming?",  # Duplicate
104    "What are data structures?",
105    "What is Python?",  # Duplicate again
106]
107
108for query in queries:
109    result, source = agent.respond(query)
110    print(f"Q: {query}")
111    print(f"Source: {source}")
112    print()
113
114## Show cache performance
115stats = agent.get_cache_stats()
116print("Cache Performance:")
117print(f"Total requests: {stats['total_requests']}")
118print(f"Cache hits: {stats['cache_hits']} ({stats['hit_rate']:.1f}%)")
119print(f"API calls: {stats['api_calls']}")
120print(f"Estimated cost saved: ${stats['estimated_cost_saved']:.4f}")

1from openai import OpenAI
2
3client = OpenAI(api_key="YOUR_API_KEY")
4
5def process_individually(queries):
6    """Process each query separately (expensive)."""
7    results = []
8    total_cost = 0.0
9    
10    for query in queries:
11        response = client.chat.completions.create(
12            model="gpt-5",
13            max_tokens=100,
14            messages=[{"role": "user", "content": query}]
15        )
16        
17        # Estimate cost (rough approximation)
18        tokens = response.usage.total_tokens
19        cost = (tokens / 1_000_000) * 6.25  # Average of input/output rates
20        total_cost += cost
21        
22        results.append(response.choices[0].message.content)
23    
24    return results, total_cost
25
26def process_batched(queries):
27    """Process all queries in a single call (cheaper)."""
28    # Combine queries into a single prompt
29    batch_prompt = "Answer each of the following questions concisely:\n\n"
30    for i, query in enumerate(queries, 1):
31        batch_prompt += f"{i}. {query}\n"
32    
33    response = client.chat.completions.create(
34        model="gpt-5",
35        max_tokens=500,
36        messages=[{"role": "user", "content": batch_prompt}]
37    )
38    
39    # Estimate cost
40    tokens = response.usage.total_tokens
41    cost = (tokens / 1_000_000) * 6.25
42    
43    # Parse the batched response
44    result = response.choices[0].message.content
45    
46    return result, cost
47
48## Test both approaches
49queries = [
50    "What is Python?",
51    "What is JavaScript?",
52    "What is Ruby?",
53    "What is Go?",
54    "What is Rust?"
55]
56
57print("Individual processing:")
58results_individual, cost_individual = process_individually(queries)
59print(f"Cost: ${cost_individual:.4f}")
60print()
61
62print("Batched processing:")
63result_batched, cost_batched = process_batched(queries)
64print(f"Cost: ${cost_batched:.4f}")
65print(f"Savings: ${cost_individual - cost_batched:.4f} ({((cost_individual - cost_batched) / cost_individual * 100):.1f}%)")
66print()
67print("Batched response:")
68print(result_batched)

1from anthropic import Anthropic
2
3client = Anthropic(api_key="YOUR_API_KEY")
4
5class HistoryOptimizedAgent:
6    """Agent that manages conversation history efficiently."""
7    
8    def __init__(self):
9        self.conversation_history = []
10        self.max_history_messages = 6  # Keep last 3 exchanges
11    
12    def _trim_history(self):
13        """Keep only recent messages to reduce token costs."""
14        if len(self.conversation_history) > self.max_history_messages:
15            # Keep only the most recent messages
16            self.conversation_history = self.conversation_history[-self.max_history_messages:]
17    
18    def _estimate_tokens(self, text):
19        """Rough token estimate (4 chars ≈ 1 token)."""
20        return len(text) // 4
21    
22    def respond(self, user_message):
23        """Generate response with optimized history."""
24        # Add user message to history
25        self.conversation_history.append({
26            "role": "user",
27            "content": user_message
28        })
29        
30        # Trim history before sending
31        self._trim_history()
32        
33        # Calculate token usage
34        total_input_chars = sum(
35            len(msg["content"]) for msg in self.conversation_history
36        )
37        estimated_input_tokens = total_input_chars // 4
38        
39        # Make the call
40        response = client.messages.create(
41            model="claude-sonnet-4.5",
42            max_tokens=512,
43            messages=self.conversation_history
44        )
45        
46        # Add assistant response to history
47        assistant_message = response.content[0].text
48        self.conversation_history.append({
49            "role": "assistant",
50            "content": assistant_message
51        })
52        
53        # Calculate cost
54        input_cost = (response.usage.input_tokens / 1_000_000) * 3.00
55        output_cost = (response.usage.output_tokens / 1_000_000) * 15.00
56        total_cost = input_cost + output_cost
57        
58        return {
59            "response": assistant_message,
60            "input_tokens": response.usage.input_tokens,
61            "output_tokens": response.usage.output_tokens,
62            "cost": total_cost,
63            "history_length": len(self.conversation_history)
64        }
65
66## Test with a multi-turn conversation
67agent = HistoryOptimizedAgent()
68
69queries = [
70    "What is Python?",
71    "What are its main features?",
72    "How does it compare to Java?",
73    "What about performance?",
74    "Should I learn it?",
75    "What resources do you recommend?",
76    "How long will it take?",
77    "What projects should I build?"
78]
79
80total_cost = 0.0
81
82for query in queries:
83    result = agent.respond(query)
84    total_cost += result["cost"]
85    
86    print(f"Q: {query}")
87    print(f"Input tokens: {result['input_tokens']}")
88    print(f"History length: {result['history_length']} messages")
89    print(f"Cost: ${result['cost']:.6f}")
90    print()
91
92print(f"Total conversation cost: ${total_cost:.4f}")
93print("\nNote: Without trimming, costs would be ~40% higher")