Serve your customer within the life they’re actually living.

On their terms. In their lived context.
With permission to act.

Most personalisation platforms work from one side of the relationship. They know what you sell, and what a customer bought. They never know the life your customer is actually living. DataSapien is the layer that bridges the two, running natively on your customer’s own device, with permission, powered by your shared context.

Start Now

Book a Demo

01 . REACH

Reach every customer in their real moment.

Acting on lived context, not last week’s segment. Relevance becomes a property of the interaction, not the campaign.

02. RETAIN

Earn loyalty by being useful, not louder.

Disengagement and intent surface on the device, weeks before they show up in your CRM. You act while it still matters.

03. REINFORCE

Add the missing layer, keep the stack you have.

Your CDP, campaign tools and loyalty engine stay where they are. DataSapien adds live human context, on the device, governed by your customer, designed by you.

1.5 billion smartphones

can now run generative AI on-device. The customer relationship is moving with them.

44×

uplift in activation effectiveness when personalisation runs on the customer’s device.

[methodologies]

The Platform

DNA³
One orchestration layer for Device Native:
Attributes, AI and Agents.

Running where your customer is. Designed by you.

DataSapien DNA³ is the context layer your customer platforms have been missing. It collects, structures and acts on first-party signal where it is freshest, on your customer’s own device, and makes that intelligence composable with your existing CDP, campaign, loyalty and analytics tools. Attributes, AI models and agents in one orchestration layer. Your team composes. The platform runs.

A1

Attributes

One live profile per device, no new silo.

Behavioural, transactional, declared and inferred signals merge into a single live customer profile on the device. Every tool downstream reads from the same source. Your CDP and warehouse stay where they are.

A2

AI

Models that run where the data lives.

Personalisation models, scoring, classification and ranking execute natively on the device. No round-trip to the cloud. No latency tax. No data lake to defend.

A3

AGENTS

Orchestrate action across your tools, on your terms.

Trigger workflows, compose interactions, and route actions across your existing systems through a no-code interface. You define what acts, where, and under what conditions.

On-device by default. Exportable by design.
Governed by you.

The architecture gives you the controls. Your policies set them. SOC 2 Type II. GDPR by construction. Model-agnostic. Works alongside: Salesforce, Adobe, Braze, Segment, and your ops stack.

Designed for tomorrow’s regulation, beyond: GDPR, CCPA, HIPAA, DSA

SOC 2 II & ISO 27001 underway

See the platform architecture →

Developers

A native SDK for real-time, on-device customer context.

Drop DataSapien into your iOS, Android, React Native or Flutter app. A small language model, context store and agent runtime, all on-device, with a typed API and a sync layer you control.

import DataSapien
func application(
    _ application: UIApplication,
    didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?
) -> Bool {
    let config = DataSapienConfig.Builder()
        .setAuth(
            url: "<YOUR_AUTH_URL>",
            clientId: "<YOUR_CLIENT_ID>",
            clientSecret: "<YOUR_CLIENT_SECRET>",
            scope: "<YOUR_AUTH_SCOPE>"
        )
        .setHost(
            baseUrl: "<YOUR_HOST_URL>",
            mediaUrl: "<YOUR_MEDIA_URL>"
        )
        .build()
    DataSapien.initialize(dataSapienConfig: config)
    DataSapien.setup { result in
        // Handle success or error
    }
    return true
}
// Launches an authored journey instantly inside your app.
// DataSapien handles the UI flow on-device and returns the result as JSON.
DataSapien.getJourneyService().runJourney("your-user-journey", [])
// Runs an on-device model session with your prompts.
// Stream tokens in real time, then receive the final response when generation completes.
DataSapien.getIntelligenceService().invokeModel(
    key: "your-model-key",
    prompts: prompts,
    onStream: { token in
        // Render streamed output
    },
    onSuccess: { output in
        // Use final model output
    },
    onError: { error in
        // Handle generation error
    }
)

import com.datasapien.dssdk.DataSapien
class MyApplication : Application() {
    private val applicationScope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
    override fun onCreate() {
        super.onCreate()
        val config = DataSapienConfig.Builder()
            .setAuth(
                authUrl = "<YOUR_AUTH_URL>",
                authClientId = "<YOUR_CLIENT_ID>",
                authClientSecret = "<YOUR_CLIENT_SECRET>",
                authScope = "<YOUR_AUTH_SCOPE>"
            )
            .setHostUrl("<YOUR_HOST_URL>")
            .setMediaUrl("<YOUR_MEDIA_URL>")
            .build()
        DataSapien.initialize(this, config)
        applicationScope.launch {
            DataSapien.setup(this@MyApplication)
                .onSuccess {
                    // Handle success
                }
                .onFailure { error ->
                    // Handle error
                }
        }
    }
}
// Launches an authored journey instantly inside your app.
// DataSapien handles the UI flow on-device and returns the result as JSON.
DataSapien.getJourneyService().runJourney(
    context = context,
    name = "your-user-journey",
    data = emptyMap()
)
// Runs an on-device model session with your prompts.
// Stream tokens in real time as the model generates the response.
DataSapien.getIntelligenceService().invokeModel(
    key = "your-model-key",
    prompts = prompts,
    onStream = { token ->
        // Render streamed output
    }
)

import React, { useEffect } from 'react';
import DataSapien from 'react-native-datasapien';
export default function App() {
  useEffect(() => {
    async function setupDataSapien() {
      const config = {
        auth: {
          url: '<YOUR_AUTH_URL>',
          clientId: '<YOUR_CLIENT_ID>',
          clientSecret: '<YOUR_CLIENT_SECRET>',
          scope: '<YOUR_AUTH_SCOPE>',
        },
        host: {
          url: '<YOUR_HOST_URL>',
          mediaUrl: '<YOUR_MEDIA_URL>',
        },
      };
      try {
        await DataSapien.initialize(config);
        await DataSapien.setup();
        // Handle success
      } catch (error) {
        // Handle error
      }
    }
    setupDataSapien();
  }, []);
  return null;
}
// Launches an authored journey instantly inside your app.
// DataSapien handles the UI flow on-device and returns the result as JSON.
await DataSapien.getJourneyService().runJourney(
  'your-user-journey',
  {}
);
// Runs an on-device model session with your prompts.
// Stream chunks in real time, then receive the final response when generation completes.
await DataSapien.getIntelligenceService().invokeModel(
  'your-model-key',
  prompts,
  undefined,
  chunk => {
    // Render streamed output
  }
);

import 'package:datasapien_sdk/datasapien_sdk.dart';
Future<void> initializeDataSapien() async {
  final config = DataSapienConfig.builder()
      .setAuth(
        authUrl: '<YOUR_AUTH_URL>',
        authClientId: '<YOUR_CLIENT_ID>',
        authClientSecret: '<YOUR_CLIENT_SECRET>',
        authScope: '<YOUR_AUTH_SCOPE>',
      )
      .setHostUrl('<YOUR_HOST_URL>')
      .setMediaUrl('<YOUR_MEDIA_URL>')
      .build();
  await DataSapien.initialize(config);
  try {
    await DataSapien.setup();
    // Handle success
  } catch (error) {
    // Handle error
  }
}
// Launches an authored journey instantly inside your app.
// DataSapien handles the UI flow on-device and returns the result as JSON.
await DataSapien.getJourneyService().runJourney(
  'your-user-journey',
  {},
);
// Runs an on-device model session with your prompts.
// Stream chunks in real time, then receive the final response when generation completes.
await DataSapien.getIntelligenceService().invokeModel(
  'your-model-key',
  prompts,
  onStream: (chunk) {
    // Render streamed output
  },
);

SWIFT · iOS 17+

Speed: Context query latency, median, on-device; < 50 ms; Median latency for on-device context queries, measured on iOS and Android.
Footprint: SDK footprint, includes context store and model environment; ~20 MB; Real-world footprint at current build. Includes the on-device runtime, context store, and bundled small language model.
Availability: Uptime, deployed devices, trailing 90 days; 99.97%; Uptime across deployed devices, measured via on-device observability.

Measured on SDK v1.0, production builds, trailing 90 days.

Developer Site and Documentation

← Back

Thank you for your response. ✨

Thank you. We'll be in touch shortly.