The Threat How It Works On-Device vs. Cloud Use Cases Privacy Pricing Developers About Us

On-Device, Continuous Bot Detection

A purpose-built on-device intelligence engine with a proprietary architecture. Rather than routing device data to the cloud, Cynopta AI human behavior models run locally - delivering instant, continuous bot detection scoring. Cynopta tells your app whether a human is present. Your policy decides which agents to admit and which to stop.

Touch rhythm
Movement and place
Touch & motion
Routine timing
0.987
Human score
Continuous
Scored on-device
01

Inside the App - Zero Friction

Runs silently as a lightweight SDK inside your mobile app. A single integration point for iOS and Android. No cloud integration is needed for scoring. No separate agent to install, no user interaction required, no perceptible performance impact.

02

Continuous Monitoring

Continuously monitors device behavior and context in real time, in an ultra-low footprint. Behavioral context is already available when interaction begins, not only at login or payment checkpoints.

03

Context That Builds Over Time

Device and session checks apply to every assessment. Longitudinal behavioral context takes from 3 days to 3 months to become meaningful, so confidence grows as the phone's daily routine builds up.

04

Privacy by Design - Scored on the device

Cynopta computes its score on the phone, and computing it doesn't require raw behavioral data to leave the device. What the SDK sends to Cynopta depends on your settings and is listed in our data-flow documentation.

05

Battery Efficiency

A mini-OS design keeps battery use below 1% over a full working day. It is designed to stay within the OS's background and battery limits, with no noticeable impact on UX.

06

No Prompts, No Ad IDs

Operates without user-facing permission prompts and without advertising identifiers. Scoring runs on-device using the app's own runtime.

Engine metrics
59
Cynopta patents
16,000
On-device data points
50+
Device signal sources
<1%
Battery over a full working day
  Scored on the phone, with no call to Cynopta
Four technical advantages
On-Device Visibility Beyond the Perimeter Accesses behavioral, sensor, and runtime signals unavailable to perimeter, API, or cloud-based security tools.
Behavioral Inference at Scale Evaluates thousands of fine-grained measurements locally - high-dimensional analysis that does not need raw data to leave the phone.
Continuous Detection Without User Impact Detection runs continuously under strict mobile constraints with no noticeable impact on battery, CPU, or UX.
Detection That Is Harder to Evade Dynamic behavioral context vs. static identifiers reduces false positives and makes evasion materially harder.

Every Layer Asks a Question.
One Was Never Asked.

Mobile apps are already defended in depth: the perimeter judges traffic, cloud engines judge requests, the OS guards itself, attestation certifies genuineness, shielding protects code, and authentication proves identity at a moment. Each layer is worth keeping - and not one of them can see who, or what, is physically operating the device. Cynopta sits in the one position closest to the human hand, asking the question the rest of the stack was never built to ask.

Beyond the device
Network perimeter (CDN, WAF, anti-DDoS)
Asks: is the traffic clean?
Cloud risk and fraud engines
Asks: does this request look risky?
↓
On the device
OS platform security (sandbox, permissions, enclave)
Asks: is the operating system protecting itself?
OS attestation (integrity APIs)
Asks: are the app and OS genuine?
App shielding and RASP
Asks: has my code been tampered with?
Authentication (biometrics, MFA, challenges)
Asks: can identity be proven at this one moment?
The shared blind spot of every layer above: who is operating the device?
Cynopta, the human layer, fills the gap
Asks: is a human behind the phone glass, right now, continuously?
Depth = proximity to the human hand. The closest seat was empty. Now it isn't.

CDN = Content Delivery Network · WAF = Web Application Firewall

DDoS = Distributed Denial of Service · RASP = Runtime Application Self-Protection

MFA = Multi-Factor Authentication · OS = Operating System

Signals Invisible to Cloud-Based Systems

Cynopta analyzes thousands of on-device signals and data points that cloud-based fraud systems cannot observe. These signals span both device integrity and real-time behavioral context - providing a uniquely rich picture of whether a user is human or an automated bot.

Device Integrity Signals

Continuous analysis of the device itself - hardware state, runtime environment, motion sensor patterns, and timing signals that help distinguish genuine human operation from automated scripts.

Motion sensorsSensor patternsTiming signalsRuntime stateDevice state

Real-Time Behavioral Context

Human life has a consistent rhythm. Cynopta reads the physical life of the phone, on the phone: is it carried, does it commute, does it rest somewhere at night. None of this is sent as a location. Automation finds this kind of lived context hard to fake.

CarriedCommutingAt restTravellingUnusual hour
Routine & Commuting

Wake-up time, commute frequency, driving patterns, daily schedule outliers

Connected Device Ecosystem

Nearby devices are summarized on the phone; full device addresses are never sent. A real person's device ecosystem is distinctive

Travel & Place

Country changes and travel patterns from network and motion context, without a location permission - phone farms stand out

Human or bot? What Cynopta seesIllustration
SleepWake upLeave home, driveAt workLunch walkDrive homeHomeSleepNo daily schedule: the same script every hour, on a charger, no movementRealpersonMobilebotAppAppApp closedApp closedApp closedCynopta, continuous00:0006:0012:0018:0024:00HUMAN SCORE0.96HumanHUMAN SCORE0.03Mobile botApp open: when most checks happenCynopta keeps context while the app is closed
A real person's phone follows a daily rhythm; a farm phone repeats the same script. On Android, Cynopta keeps building this context while your app is closed; on iOS, while your app is in use.

This depth of on-device context enables security decisions that are effective even when devices are clean and network traffic appears legitimate. Cloud and perimeter systems cannot directly observe these on-device signals - they are only accessible from inside the running app, on the device itself.

From Raw Signals to a Local Score

On-device and continuous are not slogans - they are a pipeline. Eight independent families of passive signals converge in a fusion stage where, like a synapse, no single signal decides anything and all of them together decide everything. The engine runs on the phone and asks the user for no permissions. Its output - a local human-likelihood score - does two jobs at once: the app reads it locally and can act before any network request, and for server-side enforcement the SDK can optionally attach a result token for your backend. Computing the score doesn't require raw behavioral data to leave the device. Each score is computed on the phone, with no call to Cynopta. The SDK renews its license with Cynopta once a day; what else it sends depends on your settings and is listed in our data-flow documentation.

Device boundary

Eight signal families, 16,000 on-device data points, all analyzed locally

Movement
Motion, transport
Daily rhythm
Routine patterns
Usage texture
Interaction pace
Device profile
Settings, state
Connectivity
Network context
Nearby devices
Device world
Place context
Situation, travel
Derived insights
Built over time
↓↓↓↓
Cross-family fusion: eight witnesses must agree
↓
Detection engine
Local ML, no permission prompts
↓
In-app gate
Act before any call
←
Local Score
→
Result token
Optional, for your backend
↓
Sent with the request
↓
Your backend reads it
Customer-side policy
Computing the score doesn't require raw behavioral data to leave the device.

One Integration, Full Coverage

A single SDK integration gives you continuous protection on Android and iOS, within what each platform allows (see the specifications below). You need no server of your own to get a score - one assessment equals one local SDK call. And because the score exists before any server round-trip, automated traffic can be stopped at the edge - inside the app - before it ever touches your backend.

1

Install the SDK

Single integration point for iOS and Android. No mandatory cloud integration for local scoring. Less than 1% battery over a full working day, transparent to the user.

2

Set Your Policy

Decide in your app what happens at each score: step-up authentication, silent flagging, block, or challenge. The rules live in your code.

3

Call the Assessment API

At any decision point, request a local human-likelihood score via a single API call. One assessment equals one API call.

4

Act on the Score

Use the returned risk score to trigger downstream actions in your app or backend. Pipe it into the fraud engine, risk orchestration, and step-up flows you already run - Cynopta strengthens your existing stack, it doesn't replace it.

Built for Production Mobile Environments

SDK and Integration

Platform supportiOS and Android (native)
Integration modelSingle SDK, single integration point
Cloud integration requiredNone for scoring. The SDK contacts Cynopta for licensing and usage counts.
User permissions requiredNone asked of the user
Context buildingAndroid: keeps building context while your app is not active. iOS: builds context while your app is in use.

Detection engine

On-device data points16,000
Device signal sources50+
Longitudinal contextMeaningful after 3 days to 3 months
Patent portfolio59 Cynopta patents

Performance and Efficiency

Battery over a full working dayLess than 1%
OS limitsDesigned to stay within the OS's background and battery limits
ArchitectureProprietary mini-OS design

Privacy and Output

Never collectedNames, email addresses, phone numbers, contacts, photos, messages or advertising IDs
Data leaving deviceNot required to compute the score. What the SDK sends depends on your settings and is listed in our data-flow documentation
OutputHuman-likelihood score (1.0 = human), classification, device realness, session bot risk, reason codes, optional result token
Tracking identifiers usedNone (no IDFA, no GAID)
iOS ATT prompt triggeredNone
Sample response (Android, illustrative values)
{
  "score": 0.97,
  "device_realness_score": 0.94,
  "session_bot_risk": 0.03,
  "reasons": [],
  "action_name": "login",
  "timestamp": 1794326400000,
  "latency_ms": 9
}

Your app reads the result locally. Classification and reason codes explain why a session was flagged.