Skip to main content

Predictive Models

Moveo One includes a built-in AI engine that converts behavioral data into predictive models — allowing you to anticipate user actions such as drop-off, conversion, or churn.

These models continuously learn from event data and automatically retrain as new patterns emerge.

Predictive models in Moveo One are designed to answer questions like:

  • Will the user complete checkout or abandon it?
  • What option will user select?
  • Will user churn in next X seconds/minutes?

Each model is created around a target event (e.g. checkout_complete) and trained on conditional context (e.g. item_added_to_cart, page_view sequence, or on all events).

Predictive models power the Predict, Explain, and Experiment pillars (and feed Simulate / Quantum). For a visual tour of all four, see Key Concepts. This page covers how models are built, deployed, monitored, and called from the SDKs.

Model LifecycleDirect link to Model Lifecycle

  1. Data Collection — SDKs gather event and session data.
  2. Model Training — Moveo One backend automatically trains models on aggregated datasets.
  3. Validation & Scoring — Models are scored for accuracy, recall, and stability.
  4. Deployment — Once validated, the model becomes active for real-time inference.
  5. Monitoring — Models continuously adapt as new user behavior data arrives.

Example Model UIDirect link to Example Model UI

Example internal representation (for illustration only):

Moveo dashboard validation screenshot

Real-Time PredictionsDirect link to Real-Time Predictions

Once deployed, predictive models can respond to live sessions through the SDKs.

SDK Integration (Client-side)Direct link to SDK Integration (Client-side)

The MoveoOne SDKs provide a unified predict() method across all platforms to get real-time predictions from your trained models using the current user's session data.

PrerequisitesDirect link to Prerequisites

Before using the predict method, ensure:

  1. Session is started: Call start() before making predictions
  2. Valid token: The MoveoOne instance must be initialized with a valid API token
  3. Model access: Your token must have access to the specified model

Web (JavaScript)Direct link to Web (JavaScript)

// Get prediction from a model
const result = await MoveoOne.predict("your-model-id");

if (result.success) {
  console.log("Prediction probability:", result.prediction_probability);
  console.log("Binary result:", result.prediction_binary);
} else {
  console.log("Status:", result.status);
  console.log("Message:", result.message);
}

Prediction Response FormatDirect link to Prediction Response Format

All SDKs return a consistent response format for prediction requests:

Successful PredictionDirect link to Successful Prediction

{
  "success": true,
  "status": "success",
  "prediction_probability": 0.85,
  "prediction_binary": true,
  "message": null
}

Error ResponsesDirect link to Error Responses

Pending Model LoadingDirect link to Pending Model Loading

{
  "success": false,
  "status": "pending",
  "message": "Model is loading"
}

Invalid Model IDDirect link to Invalid Model ID

{
  "success": false,
  "status": "invalid_model_id",
  "message": "Model ID is required and must be a non-empty string"
}

Not InitializedDirect link to Not Initialized

{
  "success": false,
  "status": "not_initialized",
  "message": "MoveoOne must be initialized with a valid token before using predict method"
}

No Session StartedDirect link to No Session Started

{
  "success": false,
  "status": "no_session",
  "message": "Session must be started before making predictions. Call start() method first."
}

Model Not FoundDirect link to Model Not Found

{
  "success": false,
  "status": "not_found",
  "message": "Model not found or not accessible"
}

Conflict (Conditional Event Not Found)Direct link to Conflict (Conditional Event Not Found)

{
  "success": false,
  "status": "conflict",
  "message": "Conditional event not found"
}

Target Already ReachedDirect link to Target Already Reached

{
  "success": false,
  "status": "target_already_reached",
  "message": "Completion target already reached - prediction not applicable"
}

Server ErrorDirect link to Server Error

{
  "success": false,
  "status": "server_error",
  "message": "Server error processing prediction request"
}

Network ErrorDirect link to Network Error

{
  "success": false,
  "status": "network_error",
  "message": "Network error - please check your connection"
}

Request TimeoutDirect link to Request Timeout

{
  "success": false,
  "status": "timeout",
  "message": "Request timed out after 500ms"
}

A/B Test ControlDirect link to A/B Test Control

{
  "success": false,
  "status": "ab_test_control",
  "message": "Prediction skipped due to A/B test configuration"
}

Note: Based on the configuration selected during model training, some portion of sessions will be skipped in order to conduct A/B testing of model effects and performance. When a session is assigned to the control group, the prediction request will return this status code (412) with the ab_test_control status, indicating that the prediction was intentionally skipped for A/B test purposes.

Latency TrackingDirect link to Latency Tracking

All SDKs include built-in latency tracking for prediction requests. This feature helps monitor model performance and identify optimization opportunities.

Key FeaturesDirect link to Key Features

  • Automatic latency measurement for all prediction requests
  • Asynchronous data transmission (doesn't affect prediction response time)
  • Tracks all scenarios including successful predictions and error cases
  • Configurable via platform-specific methods

Platform-Specific ConfigurationDirect link to Platform-Specific Configuration

JavaScript/WebDirect link to JavaScript/Web

// Enable latency tracking (default: true)
moveoOne.calculateLatency(true);

// Disable latency tracking
moveoOne.calculateLatency(false);

Advanced Usage ExamplesDirect link to Advanced Usage Examples

Personalized RecommendationsDirect link to Personalized Recommendations

JavaScriptDirect link to JavaScript

async function getPersonalizedRecommendations(userId) {
  try {
    const prediction = await MoveoOne.predict(`recommendation-model-${userId}`);
    
    if (prediction.success) {
      if (prediction.prediction_binary) {
        return {
          showRecommendations: true,
          confidence: prediction.prediction_probability
        };
      } else {
        return {
          showRecommendations: false,
          reason: "Low confidence prediction"
        };
      }
    } else {
      console.log(`Prediction status: ${prediction.status}`);
      return {
        showRecommendations: false,
        reason: `Prediction not available: ${prediction.message}`
      };
    }
  } catch (error) {
    console.error("Unexpected error during prediction:", error);
    return null;
  }
}

Checkout Completion PredictionDirect link to Checkout Completion Prediction

JavaScriptDirect link to JavaScript

async function shouldShowCheckoutIncentive() {
  try {
    const result = await MoveoOne.predict("checkout-completion-model");
    
    if (result.success) {
      // Show incentive if probability is below 70%
      return (result.prediction_probability ?? 1.0) < 0.7;
    } else {
      // Default to showing incentive on error
      return true;
    }
  } catch (error) {
    return true;
  }
}

Important NotesDirect link to Important Notes

Performance & ReliabilityDirect link to Performance & Reliability

  • The predict() method is non-blocking and won't affect your application's performance
  • All requests have a 500ms timeout (except Flutter which uses 5 seconds) to prevent hanging
  • The method automatically uses the current session ID and sends all buffered events to the prediction service
  • Active session required - Make sure to call start() before using predict method

Response HandlingDirect link to Response Handling

  • Always check success: true for complete predictions
  • predictionProbability and predictionBinary are optional - they will be null for error responses
  • Handle all error states gracefully, including pending states
  • Use appropriate timeout handling for your platform

Best PracticesDirect link to Best Practices

  • Initialize properly: Always initialize MoveoOne with a valid token before use
  • Start sessions: Call start() before making predictions
  • Handle errors: Implement proper error handling for all response states
  • Monitor performance: Use latency tracking to monitor prediction performance
  • Test thoroughly: Test prediction flows in different network conditions

Accuracy & MonitoringDirect link to Accuracy & Monitoring

Each model’s quality is continuously monitored using:

  • Precision / Recall
  • F1-score
  • Temporal drift analysis
  • Feature relevance tracking

You can view performance graphs in the Moveo One dashboard under AI → Predictive Models.

Building Custom ModelsDirect link to Building Custom Models

Moveo One also supports building your own models directly from the dashboard.

Example workflow:

  1. Select a Target Event (e.g., checkout_complete)
  2. Choose Conditional Events (e.g., add_to_cart, view_product)
  3. Define Observation Window (e.g., 30 minutes before target event)
  4. Click Build Model

The backend automatically:

  • Extracts relevant features
  • Splits data into train/test sets
  • Tunes hyperparameters
  • Deploys the model to production

Best PracticesDirect link to Best Practices

✅ Recommended

  • Use meaningful target events (e.g., purchase_complete, not button_click)
  • Retrain models after major UX changes
  • Compare prediction distributions pre/post feature release

❌ Avoid

  • Training on rare or one-time events
  • Mixing unrelated behaviors in one model
  • Ignoring feature drift over time