Value Modeling

While costs are automatically tracked by LensAI, value requires deliberate measurement. Value modeling is the practice of defining what constitutes meaningful benefit to your users, quantifying that benefit (ideally in dollar terms), and tracking it alongside costs and operational metrics. This transforms AI analytics from "what did we spend?" to "what did we gain?"—the foundation of ROI analysis.

Why Value Modeling Matters

AI systems consume resources (API costs, compute, engineering time). To justify these investments, you need to demonstrate tangible returns. Value modeling answers questions like:

• Is our customer support agent saving more money than it costs to operate?
• How much revenue can we attribute to our AI-powered recommendation engine?
• Which agents deliver the highest value relative to their cost?
• Are we profitable at the customer level when accounting for AI usage?

Without value modeling, you're flying blind. You might optimize for low costs but sacrifice valuable features. Or you might tolerate high costs without realizing they're not generating proportional value.

Types of Value

Value comes in many forms. LensAI supports flexible value modeling to capture different benefit types:

Direct Economic Value

The clearest form of value is direct economic benefit expressed in dollars:

Time Saved If your AI agent automates a task that would take a human 15 minutes at $50/hour, the value is:

15 minutes × ($50/hour ÷ 60 minutes/hour) = $12.50

Example: A code assistant generates boilerplate that would take a developer 20 minutes to write manually. At a fully-loaded developer cost of $90/hour, each generation delivers $30 in value.

Cost Avoided If your AI prevents an expensive outcome (support escalation, customer churn, security incident), the value is the cost that would have been incurred:

Example: A customer support agent resolves an issue that would have required a $200 truck roll or a $50 phone support session. Value delivered: $200 (if truck roll avoided) or $50 (if phone support avoided).

Revenue Enabled If your AI directly generates or facilitates revenue:

Example: A sales assistant qualifies a lead that converts to a $5,000 contract. If the assistant's qualification increases conversion rate by 20%, the value attributable to the AI is $1,000 (20% of $5,000).

Churn Prevented If your AI intervention prevents customer churn:

Example: A proactive support agent detects an at-risk customer and resolves their issue, preventing churn. If the customer's lifetime value is $2,000 and the intervention had a 30% probability of preventing churn, the expected value is $600.

Indirect and Proxy Value

Not all value is easily monetized, but you can use proxy metrics that correlate with business value:

Engagement and Satisfaction User engagement (time spent, features used, return visits) and satisfaction (NPS, CSAT scores) correlate with retention and lifetime value. You can map these proxies to dollar values:

Example: A one-point increase in NPS correlates with 5% higher retention, worth $50/customer/year. An AI feature that increases NPS by 2 points delivers $100/year in value per customer.

Productivity Gains Measure output improvements (more code written, more content created, more queries answered) and translate to economic value:

Example: A content generation agent helps a marketer produce 3 blog posts per week instead of 2, a 50% productivity gain worth $15,000/year in additional output at market content rates.

Quality Improvements Reduced error rates, higher approval rates, fewer revisions—these quality gains translate to time and cost savings:

Example: An AI code reviewer reduces bugs escaping to production by 30%, saving an estimated 10 hours/month of debugging time. At $90/hour, that's $900/month in value.

Recording Value

LensAI provides flexible APIs for recording value at multiple levels:

Request-Level Value

For interactions where value is created per request:

const response = await client.chat.completions.create({
  model: 'gpt-4',
  messages: [...],
  metadata: {
    value: 12.50, // USD value of time saved
    value_type: 'time_saved',
    value_description: 'Automated data entry task'
  }
});

Session-Level Value

For value that accumulates over a complete interaction:

await client.sessions.recordValue({
  session_id: 'session_123',
  value: 200.00,
  value_type: 'cost_avoided',
  description: 'Resolved issue without truck roll',
  metadata: {
    issue_severity: 'high',
    resolution_method: 'remote_troubleshooting'
  }
});

Batch Value Recording

For bulk value attribution (e.g., after nightly batch processing):

await client.value.recordBatch([
  {
    session_id: 'session_001',
    value: 50.00,
    value_type: 'productivity_gain'
  },
  {
    session_id: 'session_002',
    value: 75.00,
    value_type: 'revenue_enabled'
  },
  // ... hundreds or thousands of records
]);

Value Attribution to Customers

Attribute value to specific customers for customer-level profitability analysis:

await client.value.record({
  customer_id: 'user_456',
  session_id: 'session_789',
  value: 30.00,
  value_type: 'time_saved',
  metadata: {
    task: 'invoice_generation',
    time_saved_minutes: 20
  }
});

Value Calculation Strategies

Different use cases require different approaches to calculating value:

Rule-Based Value Models

Define explicit rules that map outcomes to value:

function calculateValue(outcome) {
  const valueRules = {
    'issue_resolved_self_service': 50,    // Avoided support ticket
    'issue_resolved_chat': 20,             // Avoided phone call
    'lead_qualified_enterprise': 500,      // High-value lead
    'lead_qualified_smb': 50,              // Lower-value lead
    'code_generated_accepted': 30,         // Developer time saved
    'content_generated_published': 100     // Content creation value
  };

  return valueRules[outcome] || 0;
}

await client.sessions.recordValue({
  session_id: session.id,
  value: calculateValue('issue_resolved_self_service'),
  value_type: 'cost_avoided'
});

Time-Based Value Models

Calculate value based on time saved and hourly rates:

function calculateTimeSavedValue(minutes, role) {
  const hourlyRates = {
    'developer': 90,
    'customer': 25,      // Customer's time value
    'support_agent': 40,
    'sales_rep': 60
  };

  const hourlyRate = hourlyRates[role] || 50;
  return (minutes / 60) * hourlyRate;
}

await client.sessions.recordValue({
  session_id: session.id,
  value: calculateTimeSavedValue(15, 'developer'),
  value_type: 'time_saved',
  metadata: {
    time_saved_minutes: 15,
    role: 'developer'
  }
});

Probabilistic Value Models

For uncertain outcomes, use expected value:

function calculateExpectedValue(outcome, probability) {
  const outcomValues = {
    'churn_prevented': 2000,     // Customer LTV
    'upsell_opportunity': 5000,  // Average upsell value
    'bug_prevented': 500         // Cost of production bug
  };

  const maxValue = outcomeValues[outcome] || 0;
  return maxValue * probability;
}

// Agent detected at-risk customer, 40% chance intervention prevents churn
await client.sessions.recordValue({
  session_id: session.id,
  value: calculateExpectedValue('churn_prevented', 0.40), // $800 expected value
  value_type: 'churn_prevention',
  metadata: {
    max_value: 2000,
    probability: 0.40,
    risk_score: 0.75
  }
});

A/B Testing for Value Measurement

Run controlled experiments to measure value impact:

// Control group: no AI assistance
// Treatment group: with AI assistance
// Measure difference in outcomes (conversion, retention, satisfaction)

const controlConversion = 0.05;      // 5% conversion
const treatmentConversion = 0.065;   // 6.5% conversion
const lift = treatmentConversion - controlConversion; // 1.5 percentage points

const avgDealValue = 5000;
const valuePerSession = lift * avgDealValue; // $75 per session

await client.sessions.recordValue({
  session_id: session.id,
  value: valuePerSession,
  value_type: 'revenue_lift',
  metadata: {
    experiment: 'ai_sales_assistant',
    variant: 'treatment',
    lift_percentage: lift * 100
  }
});

Value Metrics and Dashboards

Once you're tracking value, LensAI provides analytics that connect value to costs and operational metrics:

Total Value Delivered

Aggregate value across all sessions, agents, or customers:

Total Value = Σ(Value Recorded)

Track this over time to measure cumulative benefit delivered by your AI systems.

Value-to-Cost Ratio (ROI)

The most critical metric for justifying AI investments:

Value-to-Cost Ratio = Total Value Delivered / Total Cost

Example: If your customer support agent delivered $50,000 in value (time saved, costs avoided) at a total cost of $8,000 (LLM + infrastructure), your value-to-cost ratio is 6.25. For every dollar spent, you deliver $6.25 in value.

A ratio above 1.0 means positive ROI. A ratio above 3.0 is typically considered strong ROI. A ratio below 1.0 means you're spending more than the value delivered—a signal to optimize or reconsider the agent.

Value per Session

Average value delivered per customer interaction:

Value per Session = Total Value / Total Sessions

Example: 820 support sessions delivered $41,000 in value, so average value per session is $50.

Compare this to cost per session ($0.18 in our earlier example) to understand session-level profitability: $50 value - $0.18 cost = $49.82 net value per session.

Value by Customer Segment

Break down value delivery by customer attributes:

• High-value customers may receive more AI assistance and generate more value
• Enterprise customers may have higher value per interaction than SMB customers
• Engaged users may extract more value from AI features

This segmentation helps you prioritize where to focus AI investments.

Value by Agent

Compare value delivery across different agents:

Example:

• Onboarding agent: $30 value/session, $0.25 cost/session → 120:1 ratio
• Support agent: $50 value/session, $0.18 cost/session → 278:1 ratio
• Sales assistant: $200 value/session, $2.00 cost/session → 100:1 ratio

All three agents have strong ROI, but the support agent has the best value-to-cost ratio.

Combining Value with Goals

Value and goals are complementary:

Goals measure whether you achieved an intended outcome Value quantifies the benefit of that outcome

Together, they provide the complete picture:

await client.goals.record({
  session_id: 'session_123',
  goal: 'issue_resolved',
  achieved: true
});

await client.sessions.recordValue({
  session_id: 'session_123',
  value: 50.00,
  value_type: 'cost_avoided'
});

Now you can calculate:

• Goal achievement rate: 82%
• Average value when goal achieved: $50
• Average value when goal not achieved: $0
• Expected value per attempt: $41 (82% × $50)

This informs whether it's worth attempting the goal given the costs and uncertainty.

Best Practices for Value Modeling

Start simple. Don't try to model every nuance initially. Begin with one or two clear value types (time saved, cost avoided) and expand as you learn.

Be conservative. Overestimating value undermines credibility. Use lower-bound estimates and clearly document assumptions.

Document your value models. Write down the logic, formulas, and assumptions behind value calculations so stakeholders understand and trust the numbers.

Validate with business stakeholders. Work with finance, product, and business teams to ensure your value models reflect real economic benefits, not hypothetical or inflated numbers.

Use consistent units. Express value in a common currency (USD) so you can compare across value types and calculate meaningful ratios.

Separate realized vs potential value. Some value is immediate and certain (time saved right now). Other value is potential and probabilistic (churn prevented if the customer would have churned). Track these separately.

Refine based on actual outcomes. If you modeled $50 value for issue resolution, validate this against actual downstream metrics (customer satisfaction, retention). Adjust your models as you gather real-world evidence.

Combine quantitative and qualitative data. Not everything can be perfectly monetized. Use qualitative feedback (user testimonials, satisfaction surveys) alongside quantitative value metrics to tell the complete story.

Advanced Value Modeling Scenarios

Multi-Touch Attribution

When multiple agents contribute to a valuable outcome:

// Onboarding agent introduces feature
await client.value.record({
  session_id: 'onboarding_session',
  customer_id: 'user_123',
  value: 10.00,
  attribution_weight: 0.20 // 20% credit
});

// Support agent helps user adopt feature
await client.value.record({
  session_id: 'support_session',
  customer_id: 'user_123',
  value: 10.00,
  attribution_weight: 0.30 // 30% credit
});

// Feature agent delivers ongoing value
await client.value.record({
  session_id: 'feature_session',
  customer_id: 'user_123',
  value: 10.00,
  attribution_weight: 0.50 // 50% credit
});

LensAI can track contribution of each touchpoint and allocate value accordingly.

Cohort-Based Value Analysis

Track how value evolves over customer lifetime:

await client.value.record({
  customer_id: 'user_123',
  value: 100.00,
  metadata: {
    cohort: '2025-01',           // Customer joined January 2025
    days_since_signup: 30,       // Value delivered in first 30 days
    value_stage: 'activation'    // Onboarding/activation value
  }
});

Analyze how quickly AI features deliver value and whether value compounds over time.

Opportunity Cost Modeling

Not just value created, but value preserved:

// Agent prevented user from churning to competitor
await client.value.record({
  customer_id: 'user_456',
  value: 2000, // LTV that would have been lost
  value_type: 'opportunity_cost',
  description: 'Prevented churn to competitor by resolving critical issue'
});

Next Steps

Now that you understand value modeling, explore:

• Revenue Mapping: Connect customer payments to AI usage for profitability analysis
• Cost Attribution: Calculate value-to-cost ratios at every level
• Goal Tracking: Measure whether the outcomes that generate value are being achieved