NO RADAR

A local-first Android auto-reply system and an experimental add-on for OpenKsenax.

English · Русский

---

What is NO RADAR?

NO RADAR watches Android notifications, applies user-defined rules, prepares a reply with an on-device language model, and sends it through the notification's standard RemoteInput action when the source application supports replies.

The name has a double meaning:

• in Portuguese, “no radar” can be read as “on the radar”;
• in English, it means “not on the radar.”

The system stays on the phone's radar while the user can step away from it.

NO RADAR is being developed as a first-party add-on for the future OpenKsenax add-on ecosystem. The repository also contains a standalone Android preview application used to develop and validate the complete runtime before equivalent host capabilities are exposed through the OpenKsenax add-on API.

Current capabilities

The Android preview harness currently implements:

• notification access through NotificationListenerService;
• rule-based filtering by channel, schedule, days and contact text;
• delayed reply jobs with visible countdown and cancellation controls;
• local text generation through LiteRT-LM;
• model selection through Android's Storage Access Framework;
• SHA-256 verification of the selected model file;
• reply delivery through Android RemoteInput;
• persistent rules and execution logs;
• runtime locking while the master switch is active;
• a custom pixel-art interface built with Jetpack Compose.

The standalone add-on module currently provides:

• the OpenKsenax v0.3 factory and lifecycle boundary;
• command registration through the host-owned API;
• a raw standalone DEX artifact;
• a separately packaged asset archive;
• deterministic SHA-256 sidecars;
• build-time validation of DEX headers, embedded checksums, size limits and class-loader boundaries.

Architecture

Incoming Android notification
          │
          ▼
Notification listener
          │
          ▼
Rule matching and scheduling
          │
          ▼
Deferred reply task
          │
          ▼
On-device LiteRT-LM inference
          │
          ▼
User-visible pending state
          │
          ▼
RemoteInput reply or recorded non-send result

The repository intentionally separates two execution targets:

:app
└── Android preview harness
    ├── full UI
    ├── notification listener
    ├── local model runtime
    ├── rules, queue and logs
    └── end-to-end MVP validation

:addon
└── OpenKsenax add-on artifact
    ├── compile-only host contracts
    ├── standalone DEX
    ├── external asset ZIP
    ├── integrity verification
    └── restricted v0.3 host capabilities

This split is deliberate. A dynamically loaded DEX runs inside the host process and cannot safely declare Android components or permissions on its own. Notification access, model execution and reply delivery must therefore be exposed by OpenKsenax through narrow host-owned capabilities rather than obtained through reflection or unrestricted Context access.

Safety model

NO RADAR is designed around explicit boundaries:

• add-on API and Compose contracts are compileOnly and must not be bundled into the DEX;
• release artifacts are accepted only with matching SHA-256 sidecars;
• DEX magic, file size, header size, endian tag, Adler-32 and SHA-1 are verified;
• DEX and asset archives have strict size limits;
• asset paths and formats are validated before publication;
• the host uses a first-party catalog instead of arbitrary user-provided URLs;
• the add-on does not attempt to bypass Android manifest or permission boundaries;
• automatic agentic routing is not treated as an implicit privilege.

A checksum protects artifact integrity relative to the published sidecar. It is not a replacement for publisher signatures or a signed marketplace protocol.

Technology stack

• Kotlin
• Android SDK
• Jetpack Compose
• Kotlin Coroutines
• LiteRT-LM for on-device inference
• Gradle Kotlin DSL
• D8 for standalone DEX generation
• Android NotificationListenerService
• Android RemoteInput
• Storage Access Framework

Project status

Pre-release / active development

The end-to-end behavior is implemented and tested through the Android preview harness. The OpenKsenax v0.3 add-on artifact currently exposes only the lifecycle and command bootstrap supported by the host API.

The add-on cannot yet receive notifications, run the model, render its complete UI or send replies from the dynamically loaded DEX alone. Those features require explicit capability APIs in OpenKsenax.

This repository should be treated as an engineering preview, not as a production-ready unattended messaging system.

Requirements

For the Android preview application:

• Android Studio with a recent Android SDK;
• Android SDK Platform 36.1;
• JDK compatible with the configured Android Gradle Plugin;
• Android 7.0 or newer for the preview APK;
• a compatible .litertlm model file stored locally on the device.

For the standalone OpenKsenax add-on:

• Android SDK Build Tools 36.1.0;
• Android Platform 36.1;
• the exact OpenKsenax API JARs in libs/;
• Android 9 or newer at runtime.

The model is not distributed in this repository.

Build the Android preview

On Windows:

.\gradlew.bat --no-configuration-cache :app:testDebugUnitTest :app:assembleDebug

Generated APK:

app/build/outputs/apk/debug/app-debug.apk

After installation:

1. choose a compatible LiteRT-LM model file;
2. create at least one reply rule;
3. enable the master switch;
4. grant notification access when Android requests it;
5. verify generated and delivered replies in LOGS.

See the detailed live MVP test guide.

Build the standalone add-on release

.\gradlew.bat --no-configuration-cache :addon:prepareNoRadarDexRelease

Generated artifacts are written to:

addon/build/outputs/
├── no-radar-0.3.dex
├── no-radar-0.3.dex.sha256
├── no-radar-0.3.assets.zip
└── no-radar-0.3.assets.zip.sha256

Publish each artifact together with its newly generated sidecar. Never publish an unchecked or renamed APK/AAB as an add-on DEX.

See the DEX release guide and the complete OpenKsenax add-on specification.

Repository structure

.
├── addon/                  # Standalone OpenKsenax DEX module
├── app/                    # Android preview and end-to-end runtime
├── docs/                   # MVP and release procedures
├── libs/                   # Compile-only OpenKsenax API contracts
├── scripts/                # Supporting automation
├── SPECIFICATION.md        # Host/add-on contract and security boundary
└── AGENTS.md               # Repository engineering rules

Important limitations

• Notification contents and reply actions depend on what each source application exposes through Android.
• Aggregated or summary notifications may not contain a safe, replyable child message.
• Some applications do not provide a RemoteInput action.
• Generated text must be reviewed against the configured rules and model behavior.
• Android may stop or reconnect notification services according to system policy.
• The current add-on protocol is first-party and is not a general third-party marketplace.

License

Released under the Apache License 2.0.

---

NO RADAR is not about replying faster. It is about making absence explicit, local and controllable.