TrustRosie Business Model & Dashboard Requirements

Comprehensive business model documentation with detailed calculations, data structures, and implementation requirements Modified: 2025-Dec-03 09:08:52 UTC

TrustRosie Business Model & Dashboard Requirements

This document serves as the comprehensive reference for the TrustRosie business model, including detailed cost calculations, revenue distribution formulas, and dashboard implementation specifications. All sections are designed to be reusable as help text within the dashboard interface.

Executive Summary

TrustRosie operates on a three-tier revenue model:

  1. Rosie Platform Costs: $25/hour for AI query procssing
  2. Return on Contribution (RoC) Rate: 60% time credits for content contributors
  3. Intellectual Property Rights (IPR): Licensed content with custom rates

This model incentivizes content contribution while enabling monetization of intellectual property, creating a sustainable ecosystem for AI-powered knowledge sharing.

Business Model Overview

Core Principles

  • Fair Attribution: Contributors earn time credits (RoC) when their content is used
  • Flexible Monetization: Content owners can license IP at custom rates
  • Transparent Costs: All users see exactly what they pay and earn
  • Quality Incentives: Better content gets used more, earning more rewards

Transaction Types

  1. Upload Contribution: Free content that earns RoC when used by others
  2. Upload IPR Content: Licensed content that generates revenue when used
  3. Query AI Assistant: Triggers cost calculations based on content used

Revenue Distribution

When a user queries the AI assistant:

  • Rosie Platform: Receives $25/hour for AI processing
  • Content Contributors: Earn 60% time credits for contribution content used
  • IPR Owners: Receive license fees for proprietary content used
  • Query User: Pays all costs (Rosie + IPR fees)

Detailed Cost Calculation Models

Rosie Platform Costs

Formula: Duration (seconds) × ($25/hour ÷ 3600 seconds) = Rosie Cost

Rate: $25.00 CAD per hour Per Second Rate: $0.006944 CAD

Example:

  • Query Duration: 120 seconds (2 minutes)
  • Calculation: 120 × $0.006944 = $0.83

Return on Contribution (RoC) Earnings

RoC Time Credits are non-redeemable minutes earned by contributors when their content is used in other users' AI query responses.

Formula: Duration × Content Portion × RoC Rate (60%) ÷ 60 = Time Credits (minutes)

Components:

  • Duration: Query processing time in seconds
  • Content Portion: Percentage of response using contributor's content
  • RoC Rate: Fixed at 60% of attributed time
  • Units: Earned in minutes (non-redeemable time credits)

Example:

  • Query Duration: 120 seconds
  • Contributor's Content Portion: 66.67%
  • Calculation: 120 × 0.6667 × 0.60 ÷ 60 = 0.80 minutes

IPR License Cost

Duration: 10 seconds

Formula : Duration × Content Portion × (IPR Rate/hour ÷ 3600 seconds) = IPR Cost

Components:

  • IPR Rate: Custom hourly rate set by content owner
  • Content Portion: Percentage of response using IPR content
  • Duration: Query processing time in seconds

Example:

  • Query Duration: 120 seconds
  • IPR Content Portion: 33.33%
  • IPR Rate: $45/hour
  • Calculation: 120 × 0.3333 × ($45 ÷ 3600) = $0.50

System Configuration

Platform Settings

uml diagram 
{
  "rosie": {
    "hourlyRate": 25.00,    // Platform cost per hour
    "currency": "CAD",      // Canadian Dollars
    "rocRate": 0.60        // 60% time credit rate for contributors
  },
  "calculations": {
    "rosieRatePerSecond": 0.006944,  // $25/hour ÷ 3600 seconds
    "timeCreditsPerMinute": 1.0,     // RoC earnings unit
    "precisionDecimals": 4           // Financial calculation precision
  }
}

License Agreement Structure

{
  "iprOwner": "UserB",               // Content owner user ID
  "userId": "UserC",                 // Licensed user ID
  "hourlyRate": 45.00,               // Custom rate in CAD/hour
  "currency": "CAD",                 // Currency code
  "dateSigned": "2025-11-01T12:00:00Z",  // ISO timestamp
  "expiryDate": "2026-11-01T12:00:00Z",  // Optional expiry
  "agreementType": "standard"        // Agreement classification
}

Comprehensive Calculation Examples

Scenario: 2-Minute Query with Mixed Content

Setup:

  • Query Duration: 120 seconds (2 minutes)
  • Content Mix: 67% Contribution + 33% IPR
  • IPR Rate: $45/hour

Step-by-Step Calculations:

Rosie Platform Cost

Duration: 120 seconds
Rate: $25/hour = $0.006944/second
Cost: 120 × $0.006944 = $0.833

RoC Time Credits (for Contributor)

Duration: 120 seconds
Portion: 66.67% (contribution content)
RoC Rate: 60%
Credits: (120 × 0.6667 × 0.60) ÷ 60 = 0.80 minutes

IPR License Fee (for IP Owner)

Duration: 120 seconds
Portion: 33.33% (IPR content)
Rate: $45/hour = $0.0125/second
Cost: 120 × 0.3333 × $0.0125 = $0.50

Total Query Cost (for User)

Rosie Cost: $0.83
IPR Cost: $0.50
Total: $1.33

Calculation Verification Table

Component Formula Value Result
Query Duration Given 120 seconds 2.00 minutes
Rosie Rate $25/hour $0.006944/sec Fixed platform rate
RoC Rate Platform setting 60% Time credit percentage
IPR Rate License agreement $45/hour $0.0125/sec
Content Attribution
Contribution Portion Content analysis 66.67% 80 seconds
IPR Portion Content analysis 33.33% 40 seconds
Financial Results
Rosie Cost 120 × $0.006944 $0.83 User pays
RoC Earnings (80 × 0.60) ÷ 60 0.80 min Contributor earns
IPR Revenue 40 × $0.0125 $0.50 IP owner earns
Total User Cost Rosie + IPR $1.33 Complete transaction

Architecture Overview

Prototype System Flow

uml diagram

Production Data Flow

Backend Transaction Logging:

  1. Upload Content Operations:
    • Contributions (free content earning RoC)
    • IPR contents (licensed content generating revenue)
  2. Query AI Assistant Operations:
    • Content attribution analysis
    • Cost/revenue calculations
    • Transaction recording

Dashboard Data Pipeline:

  1. Dashboard UI calls Backend for User Transactions
  2. Backend fetches user transactions and calculates:
    • Rosie costs (AI query processing fees)
    • IPR costs (licensed content usage fees)
    • RoC earnings (time credits from contribution usage)
    • License agreements between users
    • Content attribution and usage analytics

Dashboard Implementation Specifications

Key Performance Indicators (KPIs)

Rosie Costs

  • Definition: Total platform fees paid for AI query processing
  • Calculation: Sum of all query durations × $25/hour
  • Display: Dollar amount with 2 decimal precision
  • Help Text: "Platform costs for AI assistant usage at $25/hour"

IPR Costs

  • Definition: Total license fees paid for using others' IP content
  • Calculation: Sum of IPR portions × respective hourly rates
  • Display: Dollar amount with 2 decimal precision
  • Help Text: "License fees paid for using proprietary content"

RoC Earnings

  • Definition: Time credits earned when others use your contributions
  • Calculation: Sum of (duration × portion × 60%) ÷ 60 minutes
  • Display: Minutes with 2 decimal precision + " min"
  • Help Text: "Time credits earned from content contributions (non-redeemable)"

IPR Revenue

  • Definition: License fees earned from others using your IP content
  • Calculation: Sum of others' queries using your IPR × your rates
  • Display: Dollar amount with 2 decimal precision
  • Help Text: "Revenue earned from licensing your intellectual property"

Transaction Table Specifications

Column Definitions

Column Data Type Description Calculation
Date DateTime Transaction timestamp ISO format, user timezone
Type Enum Upload/Query Transaction category
Title String Content/query description User-provided or generated
Duration Number Processing time in seconds Measured or estimated
Rosie Cost Currency Platform fee Duration × $0.006944/sec
IPR Cost Currency License fees paid Sum of IPR portions × rates
IPR Revenue Currency License fees earned Others' IPR costs for your content
RoC Earnings Time Time credits earned (Duration × portion × 60%) ÷ 60
Status Enum completed/pending/failed Transaction state

Filtering Logic

Activity Filter: Show all Upload and Query transactions

  • Purpose: Validate Rosie and IPR costs
  • Includes: User's own transactions only
  • Sorting: Chronological, newest first

RoC Filter: Show contribution-related transactions

  • Upload Contributions: User's content uploads
  • Query Earnings: Others' queries using user's contributions
  • Purpose: Validate RoC earnings calculations
  • RoC values: Specific to selected user

IPR Costs Filter: Show IPR expense transactions

  • User's Queries: Using others' IPR content
  • Purpose: Validate IPR cost calculations
  • Focus: Outgoing license fee payments

IPR Revenue Filter: Show IPR income transactions

  • Others' Queries: Using user's IPR content
  • Purpose: Validate IPR revenue calculations
  • Focus: Incoming license fee payments

User Experience Specifications

User Selection

  • Options: Individual users (UserA, UserB, etc.) + "All Users"
  • Behavior: Filters all calculations and displays
  • Default: Current user context

KPI Card Interactions

  • Click Behavior: Apply corresponding filter to transaction table
  • Visual Feedback: Highlight selected KPI, update table header
  • Data Refresh: Recalculate and redisplay filtered results

Row Click Behavior

  • Action: Open modal with complete transaction details
  • Content: Full JSON transaction data, formatted for readability
  • Purpose: Detailed transaction verification and debugging

Data Structures & API Specifications

Use Case Diagram

TrustRosie Dashboard Prototype Use Case Diagram

uml diagram

Sequence Diagram

Demo User Querying AI Assistant

uml diagram

Business Model

uml diagram

Core Transaction Structure

{
  "id": "txn-12345",
  "userId": "UserA",
  "type": "Query",  // Upload, Query
  "title": "Query about AI implementation",
  "date": "2025-12-01T14:30:00Z",
  "duration": 120,  // seconds
  "status": "completed",
  "costs": {
    "rosieCost": 0.83,
    "iprCosts": [
      {
        "iprOwner": "UserB",
        "hourlyRate": 45.00,
        "portion": 0.3333,
        "cost": 0.50,
        "currency": "CAD"
      }
    ],
    "rocEarnings": [
      {
        "userId": "UserA",
        "portion": 0.6667,
        "timeCredits": 0.80,
        "units": "minutes"
      }
    ]
  },
  "metadata": {
    "sourcesSummary": {
      "https://example.com/alice-research": {
        "title": "Alice's Research Paper",
        "userId": "UserA",
        "iprOwner": "",
        "contentType": "contribution",
        "count": 2,
        "tags": ["machine-learning", "AI"]
      },
      "https://example.com/bob-ipr": {
        "title": "Bob's Licensed Content",
        "userId": "UserB",
        "iprOwner": "UserB",
        "contentType": "ipr",
        "count": 1,
        "tags": ["algorithms", "proprietary"]
      }
    }
  }
}

Upload Transaction Structure

{
  "id": "upload-67890",
  "userId": "UserA",
  "type": "Upload",
  "title": "Research Paper on AI Ethics",
  "source": "https://example.com/ai-ethics-paper",
  "date": "2025-11-15T09:00:00Z",
  "duration": 45,  // processing time
  "status": "completed",
  "iprOwner": "",  // empty = contribution, userId = IPR content
  "costs": {
    "rosieCost": 0.31,  // upload processing cost
    "iprCosts": [],     // no IPR costs for uploads
    "rocEarnings": []   // no immediate RoC for uploads
  },
  "metadata": {
    "contentType": "contribution",  // or "ipr"
    "chunkCount": 15,
    "fileSize": "2.3MB",
    "processingMethod": "auto-chunking"
  }
}

License Agreement API

{
  "id": "license-001",
  "iprOwner": "UserB",
  "userId": "UserC",
  "hourlyRate": 45.00,
  "currency": "CAD",
  "dateSigned": "2025-11-01T12:00:00Z",
  "expiryDate": "2026-11-01T12:00:00Z",  // optional
  "agreementType": "standard",
  "status": "active",  // active, expired, suspended
  "autoRenewal": true,
  "notificationSettings": {
    "expiryWarningDays": 30,
    "usageReports": "monthly"
  }
}

Business Logic Implementation

Cost Calculation Engine

Primary Calculation Function

function calculateTransactionCosts(transaction) {
  const settings = getSystemSettings();
  const duration = transaction.duration; // seconds

  // 1. Rosie Platform Cost (always applies)
  const rosieCost = duration * (settings.rosie.hourlyRate / 3600);

  // 2. IPR Costs (for Query transactions using licensed content)
  const iprCosts = [];
  if (transaction.type === "Query" && transaction.metadata.sourcesSummary) {
    for (const [source, info] of Object.entries(
      transaction.metadata.sourcesSummary
    )) {
      if (info.contentType === "ipr" && info.iprOwner !== transaction.userId) {
        const license = getLicense(transaction.userId, info.iprOwner);
        if (license && isLicenseValid(license)) {
          const portion = calculateContentPortion(
            info.count,
            transaction.metadata.totalChunks
          );
          const cost = duration * portion * (license.hourlyRate / 3600);
          iprCosts.push({
            iprOwner: info.iprOwner,
            hourlyRate: license.hourlyRate,
            portion: portion,
            cost: cost,
            currency: license.currency,
          });
        }
      }
    }
  }

  // 3. RoC Earnings (for contributors when their content is used)
  const rocEarnings = [];
  if (transaction.type === "Query" && transaction.metadata.sourcesSummary) {
    for (const [source, info] of Object.entries(
      transaction.metadata.sourcesSummary
    )) {
      if (
        info.contentType === "contribution" &&
        info.userId !== transaction.userId
      ) {
        const portion = calculateContentPortion(
          info.count,
          transaction.metadata.totalChunks
        );
        const timeCredits = (duration * portion * settings.rosie.rocRate) / 60; // minutes
        rocEarnings.push({
          userId: info.userId,
          portion: portion,
          timeCredits: timeCredits,
          units: "minutes",
        });
      }
    }
  }

  return {
    rosieCost: roundCurrency(rosieCost),
    iprCosts: iprCosts,
    rocEarnings: rocEarnings,
  };
}

Content Attribution Logic

function calculateContentPortion(chunkCount, totalChunks) {
  if (totalChunks === 0) return 0;
  return chunkCount / totalChunks;
}

function isLicenseValid(license) {
  if (!license.expiryDate) return true; // perpetual license
  return new Date(license.expiryDate) > new Date(); // not expired
}

function roundCurrency(amount, decimals = 4) {
  return Math.round(amount * Math.pow(10, decimals)) / Math.pow(10, decimals);
}

KPI Aggregation Functions

User KPI Calculator

function calculateUserKPIs(userId, transactions = null) {
  const userTransactions = transactions || getAllUserTransactions(userId);

  let rosieCosts = 0;
  let iprCosts = 0;
  let iprRevenue = 0;
  let rocEarnings = 0;

  // Sum user's own transaction costs
  userTransactions.forEach((txn) => {
    if (txn.status === "completed") {
      rosieCosts += txn.costs.rosieCost || 0;

      if (txn.costs.iprCosts) {
        iprCosts += txn.costs.iprCosts.reduce(
          (sum, cost) => sum + cost.cost,
          0
        );
      }
    }
  });

  // Find earnings from other users' transactions
  const allTransactions = getAllTransactions();
  allTransactions.forEach((txn) => {
    if (txn.status === "completed" && txn.userId !== userId) {
      // IPR Revenue: others paying for user's content
      if (txn.costs.iprCosts) {
        txn.costs.iprCosts.forEach((cost) => {
          if (cost.iprOwner === userId) {
            iprRevenue += cost.cost;
          }
        });
      }

      // RoC Earnings: others using user's contributions
      if (txn.costs.rocEarnings) {
        txn.costs.rocEarnings.forEach((earning) => {
          if (earning.userId === userId) {
            rocEarnings += earning.timeCredits;
          }
        });
      }
    }
  });

  return {
    rosie_costs: roundCurrency(rosieCosts, 2),
    ipr_costs: roundCurrency(iprCosts, 2),
    ipr_revenue: roundCurrency(iprRevenue, 2),
    roc_earnings: roundCurrency(rocEarnings, 2),
  };
}

Validation & Testing Framework

Expected Values for Testing

const EXPECTED_VALUES = {
  UserA: {
    rosie: 2.7292, // Platform costs paid
    iprCosts: 2.7292, // License fees paid
    iprRevenue: 0.0, // No IP content
    rocMinutes: 0.0, // No contributions used yet
  },
  UserB: {
    rosie: 1.125, // Platform costs paid
    iprCosts: 1.125, // License fees paid
    iprRevenue: 1.125, // Earnings from IP licensing
    rocMinutes: 0.72, // Time credits from contributions
  },
  UserC: {
    rosie: 1.125, // Platform costs paid
    iprCosts: 1.125, // License fees paid
    iprRevenue: 0.0, // No IP content
    rocMinutes: 0.0, // No contributions used yet
  },
};

Audit Functions

function auditAllCalculations() {
  const results = {
    timestamp: new Date().toISOString(),
    tests: [],
    summary: { passed: 0, failed: 0, totalTests: 0 },
  };

  Object.entries(EXPECTED_VALUES).forEach(([userId, expected]) => {
    const calculated = calculateUserKPIs(userId);

    ["rosie_costs", "ipr_costs", "ipr_revenue", "roc_earnings"].forEach(
      (metric) => {
        const expectedKey =
          metric === "rosie_costs"
            ? "rosie"
            : metric === "ipr_costs"
            ? "iprCosts"
            : metric === "ipr_revenue"
            ? "iprRevenue"
            : "rocMinutes";

        const expectedValue = expected[expectedKey];
        const calculatedValue = calculated[metric];
        const tolerance = 0.01; // 1 cent or 0.01 minute tolerance
        const passed = Math.abs(expectedValue - calculatedValue) < tolerance;

        results.tests.push({
          userId,
          metric,
          expected: expectedValue,
          calculated: calculatedValue,
          difference: calculatedValue - expectedValue,
          passed,
        });

        if (passed) results.summary.passed++;
        else results.summary.failed++;
        results.summary.totalTests++;
      }
    );
  });

  results.summary.passRate =
    (results.summary.passed / results.summary.totalTests) * 100;
  results.overallStatus = results.summary.failed === 0 ? "PASS" : "FAIL";

  return results;
}

Mock Data Specifications

Prototype Data Requirements

For dashboard prototyping, mock data must include:

  1. Realistic User Scenarios: Multiple users with different content types and usage patterns
  2. Date Flexibility: dateDiff attributes for relative date testing
  3. Complete Transaction Coverage: Upload contributions, IPR content, queries, and license agreements
  4. Calculation Verification: Known expected values for audit testing

Mock User Profiles

const MOCK_USERS = [
  {
    id: "UserA",
    name: "Alice Chen",
    role: "Research Scientist",
    profile: "Heavy uploader of academic content, moderate query user",
  },
  {
    id: "UserB",
    name: "Bob Martinez",
    role: "IP Content Creator",
    profile: "Creates licensed content, earns IPR revenue",
  },
  {
    id: "UserC",
    name: "Charlie Kim",
    role: "Query-Heavy User",
    profile: "Primarily consumes content, pays most costs",
  },
  {
    id: "UserD",
    name: "Diana Foster",
    role: "New User",
    profile: "No IPR agreements, limited activity",
  },
  {
    id: "UserE",
    name: "Eve Thompson",
    role: "Complete Beginner",
    profile: "No transactions yet, baseline user",
  },
];

Sample Mock Transaction

{
  "id": "mock-query-001",
  "userId": "UserC",
  "type": "Query",
  "title": "How to implement machine learning pipelines?",
  "date": "2025-12-01T14:30:00Z",
  "dateDiff": 5,  // 5 days ago from current date
  "duration": 180,  // 3 minutes
  "status": "completed",
  "costs": {
    "rosieCost": 1.25,
    "iprCosts": [
      {
        "iprOwner": "UserB",
        "hourlyRate": 45.00,
        "portion": 0.4,
        "cost": 0.90,
        "currency": "CAD"
      }
    ],
    "rocEarnings": [
      {
        "userId": "UserA",
        "portion": 0.6,
        "timeCredits": 1.08,
        "units": "minutes"
      }
    ]
  },
  "metadata": {
    "totalChunks": 10,
    "sourcesSummary": {
      "https://example.com/alice-ml-research": {
        "title": "Alice's ML Pipeline Research",
        "userId": "UserA",
        "iprOwner": "",
        "contentType": "contribution",
        "count": 6,
        "tags": ["machine-learning", "pipelines"]
      },
      "https://example.com/bob-proprietary-algorithms": {
        "title": "Bob's Proprietary ML Algorithms",
        "userId": "UserB",
        "iprOwner": "UserB",
        "contentType": "ipr",
        "count": 4,
        "tags": ["algorithms", "proprietary", "optimization"]
      }
    }
  }
}

Content Attribution Examples

Contribution Content Structure:

{
  "source": "https://example.com/alice-research",
  "title": "Advanced AI Ethics Guidelines",
  "userId": "UserA",
  "iprOwner": "",  // Empty indicates free contribution
  "contentType": "contribution",
  "uploadDate": "2025-10-15",
  "chunkCount": 25,
  "tags": ["AI", "ethics", "guidelines", "research"]
}

IPR Content Structure:

{
  "source": "https://example.com/bob-algorithms",
  "title": "Proprietary Optimization Algorithms",
  "userId": "UserB",
  "iprOwner": "UserB",  // Same as userId for owned IP
  "contentType": "ipr",
  "uploadDate": "2025-11-01",
  "chunkCount": 15,
  "licenseRequired": true,
  "defaultRate": 45.00,
  "tags": ["algorithms", "optimization", "proprietary"]
}

Implementation Guidelines

Prototype Development Principles

  1. Backend-Compatible Code: No browser-specific APIs in business logic
  2. Clear Separation: UI components separate from calculation engine
  3. Comprehensive Testing: All calculations must have verification tests
  4. Realistic Data: Mock scenarios must reflect real-world usage patterns
  5. Maintainable Structure: Code organization supports future backend migration

Dashboard Component Architecture

dashboard-simulated-backend.js    // Core business logic (backend-compatible)
├── calculateTransactionCosts()   // Primary calculation engine
├── calculateUserKPIs()          // KPI aggregation
├── getFilteredTransactions()    // Data filtering
├── auditAllCalculations()       // Testing framework
└── EXPECTED_VALUES             // Validation constants

dashboard-ui-components.js       // Frontend-specific code
├── renderKPICards()            // KPI display components
├── renderTransactionTable()   // Data table management
├── handleUserSelection()      // UI interaction handlers
└── updateDashboardView()      // View state management

Testing & Validation Requirements

  1. Calculation Accuracy: All financial calculations must match expected values within 1 cent tolerance
  2. Time Credit Precision: RoC earnings accurate to 0.01 minutes
  3. Data Consistency: Transaction sums must equal KPI totals
  4. Filter Validation: Each filter type must show correct transaction subsets
  5. Edge Case Handling: Zero amounts, missing data, expired licenses

Testing Tools & Interfaces

  • Backend Test Page: Comprehensive backend logic testing with detailed transaction breakdown and calculation verification
  • Audit Test System: Complete audit interface with expected vs. calculated values comparison, toggle controls, and comprehensive reporting

Future Production Considerations

Scalability Requirements

  • Real-time Calculations: Sub-second KPI updates for active users
  • Large Dataset Support: Efficient queries for users with thousands of transactions
  • Concurrent Access: Multiple users accessing dashboards simultaneously
  • Data Consistency: ACID compliance for financial calculations

Security & Privacy

  • Financial Data Protection: Encrypted storage and transmission of cost/revenue data
  • User Isolation: Strict access controls preventing cross-user data leaks
  • Audit Trails: Complete logging of all financial calculations and changes
  • Compliance: GDPR, financial regulations for money handling

Performance Optimization

  • Caching Strategy: Pre-calculated KPIs with incremental updates
  • Database Indexing: Optimized queries for date ranges and user filtering
  • API Efficiency: Minimal data transfer with compressed responses
  • Real-time Updates: WebSocket connections for live dashboard updates

Calculation Reference Tables

Standard Rate Schedule

Component Rate Unit Formula
Rosie Platform $25.00 CAD/hour duration_seconds × ($25 ÷ 3600)
RoC Time Credits 60% percentage (duration × portion × 0.60) ÷ 60
IPR Licensing Variable CAD/hour duration × portion × (rate ÷ 3600)

Precision Standards

Value Type Decimal Places Rounding Method
Currency (Display) 2 Banker's rounding
Currency (Calculation) 4 IEEE 754 standard
Time Credits 2 Standard rounding
Percentages 4 Truncation
Duration 0 Whole seconds

Example Calculation Verification

Test Case: 2-Minute Mixed Content Query

Component Input Calculation Expected Result
Query Duration 120 seconds Given 2.00 minutes
Content Mix 67% + 33% Content analysis 100% total
Rosie Cost 120s × $0.006944/s Platform fee $0.83
RoC Credits (80s × 0.60) ÷ 60 Contributor earnings 0.80 minutes
IPR Cost 40s × $0.0125/s License fee $0.50
Total Cost $0.83 + $0.50 User payment $1.33

Verification Formula Reference:

  • Rosie: duration_seconds × ($25 ÷ 3600)
  • RoC: (duration × contribution_portion × 0.60) ÷ 60
  • IPR: duration × ipr_portion × (rate ÷ 3600)

Legacy Formula Documentation

The following spreadsheet formulas are maintained for backward compatibility and detailed verification:

Spreadsheet Calculation Matrix

Row Component Hours Minutes Seconds Formula
2 Duration 0.0333 2.00 120 Given
3 RoC Rate - - 60% Platform setting
4 Rosie Rate $25 $0.42 $0.0069 Rate conversion
5 IPR Rate $45 $0.75 $0.0125 License rate
8 Contribution 67% 0.80 48.00 Content portion
9 IPR Content 33% 0.67 40.00 Content portion
11 Rosie Cost $0.83 - - Total platform fee
12 IPR Cost $0.50 - - Total license fee

Excel/Sheets Formula Reference

Duration (C2): =D2/60                    // Convert minutes to hours
RoC Rate (B3): 0.6                       // Fixed at 60%
Rosie Rate (C4): 25, D4: =C4/60         // Hourly rate conversion
IPR Rate (C5): 45, D5: =C5/60           // License rate conversion

Contribution Portion (B8): =2/3          // 66.67% content attribution
IPR Portion (B9): =1/3                   // 33.33% content attribution

RoC Time (E8): =E2*C3*B8                // Duration × RoC% × Portion
IPR Duration (E9): =E2*B9               // Duration × IPR Portion

Rosie Cost (C11): =C2*C4                // Hours × Hourly Rate
IPR Cost (C12): =C2*B9*C5              // Hours × Portion × IPR Rate

This documentation serves as a complete reference for the TrustRosie business model, providing both high-level understanding and implementation details suitable for dashboard help text, developer documentation, and financial verification.