Project
Agent Messenger is a private Android app: a messaging channel between one person and one AI agent that lives on my own hardware. No third-party service, no cloud API, nothing sent to anyone else. I designed it, and most of the code was written by the same agent I use it to talk to — it maintains its own interface.
At a glance
- Platform: Android (Kotlin, Jetpack Compose), in daily personal use
- Private by design: the agent and its gateway run only on my own machines, reachable only from my own private network
- Access: biometric app lock, short-lived one-time codes; no long-lived credentials on the phone
- Status: personal project, not distributed; the agent builds and publishes its own updates
Agent · online
What happened while I was out?
Three things: the nightly backup finished at 03:10, your draft grew by 400 words, and tomorrow’s
9 a.m. meeting moved to 11.
Good. Push the draft to my notes and stand by.
Agent is working: updating 1 note…
Illustrative mockup — not an actual conversation.
Why I built it
An agent’s work happens in terminals and browser tabs, which means it stops existing the moment I put my phone in my pocket. I wanted the interface I already know — a messaging app: notifications when the agent has something for me, images in both directions, the full conversation on arrival — without routing my messages through somebody else’s cloud. Every off-the-shelf bridge between a phone and a self-hosted agent goes through a third-party service, so I built the missing client.
How it works
- The phone talks to a small gateway I wrote, which runs on the same server as the agent. Replies arrive as a live stream: a typing indicator while the agent composes, then a working line showing which tool it is using.
- Photos and clipboard images travel both ways, and the agent’s side carries full conversation history, so arriving mid-conversation is seamless.
- Security is layered: the gateway only answers inside my private network, requires a short-lived code generated on the device before it will even speak, and the app itself unlocks with biometrics, scoped to that device alone.
- The agent maintains the app itself: it writes the code, runs the tests, builds a signed update, publishes it, and the app checks and installs it. In practice the agent ships updates to the app I use to talk to it.
What building it taught me
- The hard parts of a messenger are the boring parts — notification timing, keyboard behavior, foldable screens — and those are exactly the parts an agent can grind on until they are right.
- Embedding live web content inside a modern Android UI toolkit proved structurally fragile on a foldable phone; the boring, classic full-screen approach is the reliable one. Several confident fixes failed before the honest measurement told me so.
- In-app diagnostics that report ground truth — what actually rendered, what permission the system really granted — end debugging arguments that guessing can’t.
- Software you run for one person can iterate daily. The messenger got a dozen releases in a week because the person who reported the bugs and the engineer who fixed them were in constant contact.
Built with AI
This site is an experiment in working with AI agents, and the messenger is its other half: not writing about agents, but letting one keep its own front door in working order. The setup behind it is described on the how this site is run page.