Feature: Cost Tracking and Reporting for SlashSense Agents

[shakestzd]

Problem

After completing parallel workflows with SlashSense agents, users have no visibility into:

• Total cost incurred
• Cost breakdown per agent
• Potential savings vs alternatives
• ROI of using specialized agents

Impact

• 📊 No metrics: Can't measure cost optimization
• 🎯 No validation: Can't verify if SlashSense saves money
• 📈 No optimization: Can't improve future workflows
• 🤷 No awareness: Users don't know they're saving money

Example

After DocuColab parallel workflow, I had zero cost visibility:

• How much did it cost? Unknown
• How much did I save? Unknown
• What was the breakdown? Unknown

Expected Behavior

At end of parallel execution:

SlashSense Final Report
======================

Workflow: DocuColab Phase 1
Tasks Completed: 5/5
Time Elapsed: 22 minutes

Cost Breakdown:
┌──────────────────────────────────────────────┐
│ Main Agent (Sonnet):              $0.05      │
│ 5 × parallel-task-executor:       $0.20      │
│ ├─ Abstract Core:                 $0.04      │
│ ├─ PPTX Plugin:                   $0.04      │
│ ├─ DOCX Plugin:                   $0.04      │
│ ├─ Unified Schema:                $0.04      │
│ └─ Knowledge Base:                $0.04      │
│                                               │
│ Total: $0.25                                 │
│                                               │
│ vs. general-purpose: $1.40                   │
│ Savings: $1.15 (82%)                         │
└──────────────────────────────────────────────┘

💡 You saved $1.15 by using optimized agents!

Proposed Solution

Add cost tracking to all SlashSense agents:

1. Agent Reporting

Each agent tracks and reports:

{
  "model": "haiku-4.5",
  "input_tokens": 1234,
  "output_tokens": 567,
  "cost": "$0.04"
}

2. Orchestrator Aggregation

Main agent collects reports:

• Sum total costs
• Calculate vs baseline (general-purpose or sequential)
• Show savings percentage
• Identify most expensive agents

3. Display Format

Use table format with:

• Per-agent costs
• Total cost
• Baseline comparison
• Savings achieved
• Recommendations

Implementation

1. Add to each agent:

   ## Final Report
   
   Cost Metrics:
   - Model: {model}
   - Input tokens: {input}
   - Output tokens: {output}
   - Calculated cost: ${cost}

2. Pricing table:

   PRICING = {
       "haiku-4.5": {"input": 0.80, "output": 4.00},
       "sonnet-4.5": {"input": 3.00, "output": 15.00}
   }

3. Cost calculator:

   def calculate_cost(model, input_tokens, output_tokens):
       pricing = PRICING[model]
       return (input_tokens * pricing["input"] + 
               output_tokens * pricing["output"]) / 1_000_000

4. Aggregate and display:

   • Collect from all agents
   • Calculate total
   • Compare to baseline
   • Format table
   • Show recommendations

Acceptance Criteria

• All agents track token usage
• Costs calculated using current pricing
• Orchestrator aggregates costs
• Final report displayed with savings
• Baseline comparison shown
• Recommendations provided

Estimated Effort

4-5 hours

Benefits

• Users see ROI of SlashSense agents
• Can validate 82% cost savings claim
• Identify expensive operations for optimization
• Motivates continued use of specialized agents

Priority: Medium
Labels: enhancement, metrics