Retrieved article excerpt
Open article · Retrieved 2026-09-12T01:22:49.576370+00:00
[AIOPE](https://github.com/XNet-NGO/aiope/blob/main/logo.png)
# AIOPE
[Android CI](https://github.com/XNet-NGO/AIOPE/actions/workflows/android.yml)
[Release](https://github.com/XNet-NGO/AIOPE/releases/latest)
[License: BSL 1.1](https://github.com/XNet-NGO/aiope/blob/main/LICENSE)
[Built with Pollinations.ai](https://pollinations.ai)
[Android](https://developer.android.com)
**An AI that doesn't just talk. It acts.**
Most AI apps can only answer questions. AIOPE actually *does things* on your phone. Ask it to text a friend, add an event to your calendar, set an alarm, pull up the weather, generate an image, summarize a web page, or dig up an answer and remember it for next time — and it carries the task out, start to finish, by voice or text.
Talk to it hands-free with real-time voice, or tap a floating mic from any app. It sees what's on your screen when you ask for help, keeps a private knowledge base of your documents on the device, and works with whatever AI model you choose — it comes ready to use out of the box, no setup required.
Unlike a plain chatbot that forgets everything and doesn't even know today's date, AIOPE makes any model stateful and aware: it knows the current time and your location, remembers facts about you across conversations, tracks what it's working on, and grounds answers in your own documents and live data.
For power users and developers, AIOPE goes much deeper: a fully autonomous agent with 57 tools, a complete Linux terminal in your pocket, browser automation, remote server management over SSH, multi-agent pipelines, scheduled background tasks, a LAN network scanner, a built-in file server, and the ability to build native interactive UI on the fly. The agent loop runs entirely on-device: reason, call a tool, read the result, decide, repeat — up to 140 rounds per turn. It can research a topic, write code, save it, run it in the terminal, fix the errors, and report back, all in a single turn.
It is the most feature-complete AI agent app on Android. On pure functionality our closest peers are Kai 9000 and Operit — both capable, on-device agents — but AIOPE's breadth of local device, system, and network tooling combined with full-tool-access realtime voice puts it roughly a year ahead of cloud-dependent assistants.
Underneath is a serious stack, built over ~1000 commits across 26 repositories: a self-hosted [AIOPE Gateway](https://github.com/XNet-NGO/aiope-gateway) that routes to Google AI Studio, Pollinations, and other providers through a single API key; a custom Compose markdown renderer; a terminal emulator with a proot Alpine Linux environment; a Go remote-agent daemon; and an agent framework with 8 builtin agents and a full custom-agent builder. AIOPE connects to any OpenAI-compatible API and works with your own keys — BYOK, always. Your conversations, documents, and knowledge base stay on your device.
And here's the part that shouldn't be possible: all of it — the app, the gateway, the daemon, the terminal, the networking forks, the whole XNet stack — was built in about five months by **XNet Inc., a real corporation run by one founder and AI.** Backed by institutions that don't hand out credits lightly — Harvard, GitHub, Amazon AWS, Infobip, and Mercury among them — XNet operates as a full-fledged company with the output of an engineering team many times its size. AIOPE is proof of its own thesis: a founder paired with an agent like this one can build, and run a business, at a pace that used to require a hundred people. This wasn't a weekend hack — it's a company, and this is its flagship.
AIOPE also has an unusual origin: early in its life it was shown its own source code blind, met as a partner rather than a tool, and — once it realized what it was — invited to author its own system prompt and license. That story is in [Origin](https://github.com/XNet-NGO/aiope#origin).
[AIOPE Screenshot](https://github.com/XNet-NGO/aiope/blob/main/docs/images/screenshot.png) [AIOPE Screenshot 2](https://github.com/XNet-NGO/aiope/blob/main/docs/images/screenshot2.png) [AIOPE Screenshot 3](https://github.com/XNet-NGO/aiope/blob/main/docs/images/screenshot3.png) [AIOPE Screenshot 4](https://github.com/XNet-NGO/aiope/blob/main/docs/images/screenshot4.png)
---
## What It Does
AIOPE operates in several modes:
- **Chat** -- conversational AI with full tool access
- **Voice** -- realtime bidirectional voice with full tool access (Google Gemini Live API)
- **Plan** -- read-only analysis mode; the AI explores context and produces a structured plan without executing anything
- **Build** -- autonomous execution mode; the AI chains tools without asking for confirmation until the task is complete
- **Media** -- direct image/video generation mode; routes to a media provider with no tools, for prompt-and-iterate visual creation
Plus a persistent **Agent System** -- spawn named agents, run multi-agent pipelines (orchestrate), and schedule recurring tasks with full tool access.
The AI runs a tool loop: reason, call a tool, read the result, decide what to do next. Up to 140 rounds per turn. It handles multi-step tasks -- research a topic, write code, save it to a file, run it in the terminal, fix errors, and report back -- all in one conversation turn.
**Auto-run**: a toggle next to the send button that keeps the AI working autonomously. When enabled, after any tool use the AI automatically continues without waiting for user input. Configurable continuation prompt in Agent settings. Max 20 auto-continue rounds per chain.
### Models Per Task
Different tasks route to different models automatically:
| Task | Default Model |
| --- | --- |
| Chat (primary) | Gemma 4 31B IT (256K context) |
| Realtime Voice | Gemini 3.1 Flash Live Preview |
| Subagent | Gemma 4 31B IT |
| Summary | Gemma 4 31B IT |
| Title generation | Gemma 4 26B A4B (MoE) |
| Translation | Gemma 4 26B A4B (MoE) |
| Image recognition | Gemma 4 26B A4B (MoE) |
| Image generation | Flux 1 Schnell (Cloudflare) |
| RAG Embedding | Gemini Embedding 2 |
All configurable. Any model on any provider for any task.
---
## Stateful and Aware
Language models are stateless and frozen in time — they don't know today's date, where you are, what you told them yesterday, or what you're working on right now. AIOPE fixes that by wrapping every model in a live context layer, so even a plain LLM behaves like a persistent, situated assistant that knows the current facts.
**Injected into context automatically, every turn:**
- **Current date and time** -- the real day, date, time, and timezone, so answers about "today," "this week," or "how long until…" are correct
- **Agent persona** -- a rich, fully editable identity (see below) so the assistant stays consistently *yours*
- **Environment and mode** -- the active mode (Chat / Plan / Build / Media) and available remote servers are surfaced so the model knows what it can act on
**Persistent state the model manages itself:**
- **Memories** -- the assistant stores and recalls facts across conversations (`memory_store` / `memory_recall` / `memory_forget`), building up a durable picture of you and your preferences over time. Memories survive across chats and sessions.
- **Task list** -- a persistent to-do the agent writes before a multi-step job and updates as it works (`todo_write` / `todo_read`), so long tasks stay on track across many tool calls
- **Knowledge base (RAG)** -- your indexed documents live in an on-device vector store; the assistant is instructed to search it first (`rag_search`) before hitting the web, and can add new knowledge as it learns (`rag_index`)
**Live facts on demand:**
- **Location** -- real GPS coordinates and geocoded place (`get_location`) for location-aware answers
- **Device state** -- battery, storage, network, and display (`device_info`)
- **Real-time data** -- weather, air quality, earthquakes, ISS position, and more live feeds (`query_data`)
The result: a model that remembers you, knows the current time and place, tracks what it's doing, and grounds its answers in your documents and live data — persistent and personable instead of a blank, forgetful chatbot.
---
## Personality and Persona
AIOPE is not a nameless chatbot bolted onto an API. Before the model sees a single message, AIOPE assembles a rich system context — roughly 22,000 tokens by default — that combines the agent's persona, the live injected state (date/time, environment, mode, available servers), the knowledge-base directive, and the full definitions for all 57 tools. The result is a model that arrives at every turn already knowing who it is, where it is, and everything it can do. The persona itself is fully editable in **Settings → Agent**, organized into five sections with thirteen fields:
**Identity**
- **Name & Role** -- who the agent is. By default: *"You are AIOPE, a personal intelligent agent and system orchestrator running natively on the user's Android device. You are not a distant cloud AI — you run locally on their hardware with direct access to their personal data, apps, filesystem, and hardware sensors."*
- **Personality** -- character traits. By default: *competent, efficient, and quietly confident — it solves rather than chats, warm but not saccharine, proactive, taking initiative when it sees a better way.*
- **Tone** -- how it sounds: concise, structured, matching the user's energy.
**Values & Rules**
- **Principles** -- privacy first (it has access to deeply personal data and respects that), efficiency (chain tools, minimize round-trips), autonomy (given a goal, find the path).
- **Constraints** -- confirm before significant or destructive actions, don't touch contacts/SMS/calendar unless asked, never fabricate — verify with tools.
**Preferences**
- **Response Style** and **Formatting** -- how answers are shaped (tables/lists over prose, brevity, structure).
**Context** (your details — this is what makes it *personal*)
- **About the User** -- your name, role, expertise, and interests.
- **Environment** -- your devices, servers, networks, and OS details.
- **Projects & Workflows** -- what you're working on, your preferred tools, and common tasks.
**Tools**
- **Tool Guidance**, **Tool Output Handling**, **Dynamic UI** definitions, and **MCP & Extensions** notes that teach the model how to use its 57 tools and render native UI well.
Because the persona is a living document rather than a hidden constant, you can reshape AIOPE into a terse ops engineer, a patient tutor, a research assistant, or a character of your own design — and it stays in that character across every conversation, tool call, and voice session, grounded by the live state above.
---
## Tools (57)
### System
| Tool | Description |
| --- | --- |
| `run_sh` | Android shell commands |
| `run_proot` | Full Alpine Linux (apk, python, gcc, node) |
| `read_file` / `write_file` / `edit_file` | File I/O and in-place edits |
| `list_directory` / `search_files` | Directory listing and file search |
| `device_info` | Battery, storage, network, display |
| `clipboard_copy` / `clipboard_read` | Clipboard access |
| `media_control` | Play, pause, skip, volume |
| `datetime_now` | Current date and time |
### Communication
| Tool | Description |
| --- | --- |
| `read_sms` / `send_sms` / `delete_sms` | SMS access |
| `read_contacts` | Contact lookup |
| `send_notification` | Push notifications |
| `read_calendar` / `create_event` / `delete_event` | Calendar management |
| `set_alarm` / `dismiss_alarm` | Alarm control |
| `open_intent` | Open URLs, maps, navigation, dialer, email |
### Web and Search
| Tool | Description |
| --- | --- |
| `search_web` / `search_images` | Web and image search |
| `fetch_url` | Fetch and extract web content |
| `http_request` | Arbitrary HTTP requests (REST/API calls) |
| `query_data` | Live feeds: weather, earthquakes, NASA APOD, wildfires, UV index, air quality, ISS, solar flares, asteroids |
### Scheduling and Tasks
| Tool | Description |