Jenny
A local-first personal AI agent that lives on your Android phone.
It remembers you permanently, acts on a schedule without being asked, writes its own mini-apps on request, and can be your phone's home screen. Your memory, files and conversations stay on the device. Bring your own API key — or run a model on your own hardware and keep the whole loop offline.
Captured on a Unihertz Titan 2 (1440×1440 square display). Unretouched framebuffer grabs.
Why local-first
Mainstream assistants are guests, not hosts
They live in an app among many, forget you between sessions, and send your life to someone else's servers. Jenny inverts all three.
Presence
It can be the home screen. Apps live inside the assistant, not the reverse.
Continuity
One conversation that never resets, backed by structured on-device memory that gets better the longer you use it.
Ownership
No account, no sign-up, no telemetry, no subscription, no server of ours in the loop. Your key, your model, your storage.
| Cloud assistant (ChatGPT, Gemini, Siri) | Self-hosted agent on a VPS | Jenny | |
|---|---|---|---|
| Where your data lives | the vendor's servers | your server, your ops burden | the phone in your pocket |
| Memory across sessions | limited, vendor-controlled | whatever you build yourself | permanent, on-device, plain Markdown |
| Acts while you're not looking | no | if you wire it up | built in |
| Recurring hardware cost | free tier, then a subscription | monthly | a phone you already own |
| Model choice | the vendor's | yours | yours — 40+ providers, or local |
| Works with no internet | no | no | yes, with a local model on your LAN |
| Setup effort | none | real | build an APK, paste a key |
Permanent on-device memory · "Dream"
It gets better the longer you use it
Every couple of hours, a background pass replays the recent conversation and distills it into structured files on disk. Noise is pruned, signal accumulates — and it's plain Markdown on the device, so switching model provider doesn't cost you your memory.
What it can do
It acts on its own — and it writes its own apps
Time and initiative
Reminders, one-shot scheduled actions, recurring jobs ("every Monday, summarise my week"). When one fires, it messages you first, screen off.
Files and documents
Read, write, organise and edit inside a workspace, with a real file browser and an editor in the UI.
It writes its own mini-apps
Describe one in chat — "something to track my plants" — and it builds the UI, storage and a callable tool, so cron can act on it later.
It can be your launcher
HOME + DEFAULT + LAUNCHER, seven visual themes, an animated mascot. Judged purely as a launcher it would be a bad one — the launcher is the how, not the what.
Daily launcher
Your main phone's home screen becomes the agent. This is the whole point: presence, memory, proactivity, all day.
Dedicated device
A spare Android on your desk becomes an always-on AI device. Zero-risk trial: always powered, battery is a built-in UPS, own screen, already paid for. Reach it via the optional Telegram bridge.
The one honest exception to local-first
If the agent lives on a phone on your desk, connect your own Telegram bot token and its proactive messages reach wherever you are. Messages routed through the bridge pass through Telegram's servers — your memory, files, conversations and generated apps do not, whether the bridge is on or off. Off by default, and it requires an explicit pairing step.
Privacy
Every outbound connection Jenny can make
Not "we promise not to look" — there is nowhere for us to look from. No account, no sign-up, no sync, no telemetry, no analytics SDK, no crash reporter. The claim is checkable: no phone-home in the code.
- Your configured LLM provider. Messages, session history, tool results, and any workspace file the agent reads — plus your last-known location, on every turn, if location sharing and the Android permission are both on.
- Bing. Your web_search queries, only when the agent actually calls the tool. The engine is fixed to Bing — there's no picker.
- Sites reached by web_fetch / download_file. Whatever a normal visit reveals: a real, hidden WebView with the phone's own IP, user-agent and cookies.
- api.telegram.org. Only if you paired a bot. Off by default. Your conversation transits Telegram's servers under Telegram's terms.
The one caveat we won't hide
android:allowBackup="true" is set on purpose — losing your agent's memory when you change phones would be worse than the alternative. The consequence is real: with Google's automatic backup enabled, the app's private storage — including config.json, which holds API keys in plain text — is eligible for backup to your Google account. Turn app backup off for Jenny if you don't want that, and use the app's own encrypted export instead.
Full privacy model, with every gating condition → · Security model →
Security, without a discount
Four containment levels — one of them real, three of them guards
Jenny reads and writes files, executes Python, fetches from the network and acts on a schedule while you're not watching. Pretending that's risk-free would be the fastest way to lose your trust.
- Only the Android app sandbox is OS-enforced. The other three levels — the workspace boundary, the SSRF filter, and
python_exec's module guardrails — are application code, not a jail. The code says so in as many words. python_execis not a sandbox. It runs arbitrary Python in-process, on the same interpreter as the gateway. If you don't trust the model you're running, turn it off.- Provider API keys are stored in plain text in the workspace config, protected by the app sandbox — and, being a workspace file, readable by the agent's own file tools.
- Prompt injection is not solved. Nobody's is. Tool-level guards limit the blast radius; they do not stop a model from being talked into a bad call.
SECURITY.md — the real trust model, every level, and the known limitations →
Bring your own key
40+ providers, two real integrations
First-run onboarding is a short wizard: pick a provider format, paste a key, choose a model. Under the hood there are only two real integrations — an Anthropic-format client and an OpenAI-compatible one — and every catalog entry is a preset on top of one of them.
That's the useful part: anything speaking either API works, including something that ships after this page. Point it at Ollama or LM Studio on your own LAN and the whole loop runs offline — no request ever leaves your network.
Seven themes, one agent
Try a theme on this page
A draggable animated mascot you can also just switch off, and a full visual identity underneath it — not just an accent color swap.
Seven built-in themes, chosen from the same Settings screen as everything else. This button row previews them on this page — the app itself has the full picker with live thumbnails.
Quick start
Build it and install it
The whole thing builds from this repository with no extra steps. JDK 17, Android SDK Platform 34, adb, and network access on the first build (Gradle downloads the Chaquopy Python 3.11 runtime and every pinned wheel).
git clone https://github.com/flagdizero/jenny-android-ai-agent.git jenny
cd jenny/android
echo "sdk.dir=/path/to/your/Android/sdk" > local.properties
./gradlew app:installDebugThen: launch, follow onboarding, paste your API key. Optionally set it as your default launcher. No account to create, at any point.
Is it for you?
Probably yes
- You want an assistant that actually remembers you.
- You have a spare Android phone doing nothing.
- You'd rather hold your own API key than rent a subscription.
- You enjoy reading the source of things you run.
Probably not
- You want a polished one-tap install today.
- You're on iOS.
- You want a feature-complete launcher.
- You need something audited and hardened to run models or content you don't trust.
FAQ
Questions, answered plainly
Is this a launcher like Nova or Niagara?
No — the launcher is the how, not the what. Jenny is a personal AI agent; being the home screen is what makes it present instead of an app you remember to open.
Can I use it from my laptop?
Not the UI — it binds loopback by default, with nothing exposed to your network. You can talk to the agent from anywhere through the optional Telegram bridge. Android is the only supported runtime.
Does it really work offline, with local models?
Yes — Ollama and LM Studio through the OpenAI-compatible engine. With the model on your LAN and the bridge off, no traffic leaves your network at all. Expect quality to track the model.
What does it cost?
The app is free and open source. You pay your provider directly, or nothing with a local model. There's no incentive to ration your usage — that's architectural, not a pricing promise.
Why AGPL, if it never touches a server?
So a hosted fork can't take the work closed. Personal use is unaffected.
Is my data really on the device?
Yes, with two disclosures worth hearing directly: your prompts go to whichever model provider you chose, and Android Auto Backup is on by default — both covered in the privacy section above.
Is there a downloadable APK?
Not yet. Today the only path is building from source with Gradle and adb — see the install guide. If a signed release APK with a published hash becomes available, this answer changes with it.
Two promises
On the record, so they can be held against us
BYOK is free, forever
Using Jenny with your own key will never require a subscription, an account, or a payment to us. If a managed tier ever exists for people who don't want to handle API keys, it will be an addition, never a replacement.
Local-first, forever
Your data living on your device is the architecture, not a launch feature. Don't trust that sentence — check the permissions and the source. That's why they're public.