AgentOS in your hand.

A budget-friendly Android phone, a full Linux desktop computer, and an assistant that does the work for you.

_{“Make a little rocket in Blender and render it for me.” The whole task took about 2½ minutes. The animation plays faster.}

Rungic turns a compatible Android phone into a Linux desktop computer. It offers a budget-friendly way to use the hardware you already own. It opens the KDE Plasma desktop and runs desktop software such as Firefox, Blender, Krita and VS Code. Connect a TV to use it as a desktop PC.

Rungic includes an AI assistant that can see, speak and act. Tell it what you need. It opens apps and does the work while you watch.

Rungic supports your choice of agent. The bundled assistant is a working demonstration and the default implementation. It currently uses Codex. Other agents can use the desktop, phone interfaces and system services independently. Connecting another agent to the bundled assistant's voice, tasks and widgets requires an adapter. There is no universal one-click switch yet.

Once agents become lasting participants in our work, what should the relationship between people and computers look like?

We imagine persistent workspaces where agents explore, build and learn. People can join the work, understand decisions and discoveries, and discuss what happens. They can take over a step, change direction and return the work to the agent. The aim is to free people's attention for understanding, judgment, learning and creation. Our Agent OS philosophy describes this direction.

Hold the Home button and ask: “Make a little rocket in Blender and render it for me.” “Install Krita for me.” “Put your screen on the TV.” “Send Mom a WeChat voice message: I'll be home for dinner.” The assistant presents a plan first and speaks its progress updates. It opens apps, clicks buttons and types for you. When the task ends, its pictures and files appear in the conversation. You can open them there. By default, Codex reads the screen and decides each desktop action using the model and sign-in selected for the Agent. In Settings → Desktop operation, you can choose the separate Luna API executor instead. Codex uses its existing ChatGPT or API-key sign-in; selecting a desktop executor does not change that sign-in. Voice services, speech synthesis and the optional Luna executor use the configured OpenAI API key. The implementation and acceptance record lists what has been tested on the development G100.

The assistant works on its own desktop. You can continue using your phone. Its screen appears in a small floating window. You can resize the window or place it against the screen edge. Ask the assistant to send it to the TV. Its clicks and typing stay in that workspace while it works there. You can continue using your phone. In desktop mode or while casting to a TV, the assistant works on your desktop with you. You can also tell it where to work. Up to four agent workspaces can run at once. Each has its own floating window and sound. You hear a workspace's sound only while its window is visible. The windows stack down the screen so you can watch them all. The close button asks the workspace's apps to quit and closes the workspace. An app with unsaved work keeps the workspace open. Rungic tells you when this happens. If an agent is still working there, the button only hides the window. Rungic pauses apps in a hidden, idle workspace and closes it after a long idle period.

_{The assistant's screen at full size: Blender with the rocket it just built.}

Several agents can work together and share a project folder. Each agent has its own workspace and apps. One Codex agent leads the team. It writes a brief and starts a team member for each part of the work. It collects one round of review, makes decisions and combines the results.

_{The director during a team run on a moto g100s, sped up: art in Krita, sound in Ardour, the game in Godot.}

The request was for a small Flappy Bird game. It specified Godot for the game, Krita for the art and Ardour for the sound. The lead agent followed these steps:

1. It wrote a brief that specified pixel art, three short sound effects and touch controls. It started three team members in separate workspaces.
2. It collected one round of review with eight points from the three members. It resolved those points and started the work.
3. The members worked in parallel. The Krita member finished the art after about 7 minutes. The Ardour member finished the effects after about 8 minutes. After about 11 minutes, the Godot member integrated the art and sound. Its gameplay, asset and audio-output checks passed.
4. The lead checked the result. It opened the game, Sunny Flap, on the phone for play.

From the request to a playable game took about 15 minutes.

All at once: Godot in focus, Krita and Ardour beside it

Then you play

While a team works, its screens appear in a director view. The selected screen appears large, with the other screens in a column beside it. Each tile names its member and state. A short ticker describes the agent's activity, such as "Paint and export layered Krita game assets". Reviews, finished deliveries and other milestones from members appear as tags in the same ticker.

Tap a tile to select its screen. The director uses the same layout fullscreen on the phone and when cast to a TV. It appears over a blurred version of the phone's wallpaper.

This run started from a single request through tools/team/run-lead.sh. The conversation does not show team progress or announce handovers yet. The agent workspaces document records the first team run, which used manual leadership and a written contract. It also records the experiments behind the Codex lead. The document is in Chinese.

The initial scope is system care. It covers faults that need attention, known software compatibility issues and opportunities to optimize software. Rungic keeps local records of each issue, its evidence, your decision and any investigation or repair task.

1. Detect issues. Rungic collects evidence of recent Linux crashes, failed services, incomplete package operations and low storage. It checks installed software against the repository's compatibility knowledge base. The checks use exact package versions and recorded environment constraints. Rungic preserves intentional settings as policy and does not flag them for optimization.

2. Show suggestions. Suggestions appear on the assistant's Suggestions page and in native Plasma home-screen widgets. The widgets preserve the wallpaper, favorite apps and app drawer. Rungic combines repeated evidence for the same issue. Related cards form a stack you can swipe up or down, with separate groups for different issues. Tap a card to open its issue in the app.

3. Choose when to act. You can keep an issue for later, set a reminder or dismiss it. Notifications respect system settings that suppress them and avoid repeating progress you already saw. Rungic limits the frequency of ordinary suggestions and waits for a suitable context. Results remain available to revisit.

4. Investigate before making changes. Give a suggestion to the agent. Its result explains what happened, what the evidence supports, its confidence in the conclusion and the next steps. It leaves unknown causes unresolved. Repairs require a proposed plan and your confirmation. Approval applies to a specific revision of the plan and evidence, so Rungic cannot silently apply an outdated plan.

5. Check results and keep history. Rungic separately records investigation, repair progress, issue status and reminder choices. These records survive service restarts. A completed agent task alone does not prove that the underlying problem is resolved.

   Upstream feedback starts with a local facts bundle and an issue or PR record. External submission requires an explicit request. An upstream merge does not prove that your installed version contains the repair.

A separate Agent widget shows the bundled Codex integration's activity and usage with small pixel illustrations. It shows the token usage that the integration observes. It shows account quotas and reset times when the account provides them. It does not invent subscription reset times for accounts that use API keys. Tap the widget to open the assistant or usage details. Another agent must supply its own usage data to support this widget.

Rungic implements these system-care features within the scope described above. Rungic does not yet detect every Android fault or automatically determine whether every app uses hardware acceleration. Compatibility suggestions depend on reviewed knowledge entries. Automatic upstream PR submission and status synchronization remain unimplemented. The implementation and acceptance record distinguishes behavior tested on devices from remaining work.

• It asks first. Before it closes an app you are using, deletes or overwrites your files, or sends a message, it asks you.
• Your password stays yours. When an action needs administrator rights, the system shows a password dialog on your screen. You type the password. The assistant never sees it.
• You choose how to continue. If the plan cannot proceed, the assistant explains the options and their consequences. You choose the next step. It does not silently reduce the scope of the result.
• You set the rules. The assistant's guidelines and skills are plain text files in your home folder. Changes to these files apply immediately.

These rules describe the bundled assistant's workflow. Its separate desktop isolates the work session's display and input. It shares your Linux account and files. The agent follows instructions to ask first. Administrator authentication uses the system's authorization dialog. A replacement agent needs corresponding policies and integration.

• A complete Linux desktop. Ubuntu 26.04 with KDE Plasma Mobile 6.6. Install software with apt, Flatpak or the Discover app store.
• GPU acceleration. The desktop, browser and 3D software use the phone's GPU. This includes older X11 programs and Flatpak apps. Video decoding uses hardware acceleration.
• Your phone's hardware. Use the speaker, microphone, front and rear cameras, and a clipboard shared with Android. Rime provides Chinese input.
• Desktop mode and casting. Open the full desktop in a floating window. You can also cast it wirelessly to a TV. Use the phone as the TV desktop's touchpad and keyboard.
• Display performance. Frames pass directly to the display without copying. Refresh rates reach up to 120 Hz while you touch the screen.
• System care. Home-screen suggestions show faults and known compatibility issues. You can investigate and address them when convenient.

Desktop apps on the phone

Desktop mode in a floating window

_{The same desktop on a TV or in the floating window.}

Rungic opens as an Android app after device preparation. Preparation starts with the manufacturer's original firmware for the exact model and version. It requires a matching GKI kernel rebuilt for LXC. Our delivery direction separates device preparation from RungicOS installation. Once the Android base is compatible, Rungic can be built and updated independently. Android remains the phone's operating system alongside the Linux desktop.

After installation, account setup and device checks finish, tap the Rungic icon to open the desktop. Return to Android to use your phone. Both environments run together and share the clipboard, photos, videos and downloads.

Bootloader unlocking or the required device-preparation procedure can erase user data. Separate Rungic installation keeps the Android base and its data. Testing on the moto X70 Air Pro confirmed this behavior with a developer USB installer. See Choose what to build and install. Make a backup before starting. Read Before you install for app and manufacturer restrictions.

flowchart TB
    subgraph container["Linux desktop (Ubuntu container)"]
        desktop["Plasma desktop and apps"]
        agent["AI assistant"]
        workspace["Assistant's screen"]
        agent -- operates apps --> workspace
        agent -. in desktop mode or when casting .-> desktop
    end
    app["Rungic Android app<br/>display · touch · sound · camera"]
    desktop --> app
    workspace --> app
    app --> phone["Phone screen"]
    app --> tv["Floating window and TV"]

Rungic does not replace the phone's operating system. Android continues to handle calls, networking, the camera and other hardware. The Linux desktop runs in a container. The Rungic app connects its display, touch input, sound and camera to Android.

The bundled assistant has two parts. A realtime voice model talks with you. Codex runs tasks in the background. This is the reference integration. Other agents can reuse the system capabilities described below.

Linux programs run at the phone's native CPU speed. The desktop runs in an LXC container on Android's Linux kernel. Ubuntu's ARM64 programs run directly on the phone's CPU cores. The same kernel schedules them alongside Android apps. There is no virtual machine, emulator or instruction translation.

The container gives Linux programs their own namespaces for files, processes and users, plus resource groups. Their display, touch input, sound and camera use the Rungic app. Their computation runs as it does on other ARM64 Linux machines.

Geekbench 7 ran once as an Android app and once in Rungic's Linux desktop on the same moto g100s. See the comparison.

• Same processor. Both runs report a Snapdragon SM6435 CPU with 8 cores and processor ID part 3393. Both report 7.3 GB of memory. Geekbench names the phone "moto g57 power" on Android and "mumba", its codename, on Linux.
• Individual workloads.
  • Single-core: the 16 workloads score between 88% and 111% of Android's results. Rungic scores higher in Video Encoder (+11%), Audio Encoder (+10%) and Photo Library (+9%). It scores lower in Asset Compression (−13%), Ray Tracer (−12%) and HDR (−8%).
  • Multi-core: six of the eight workloads score within ±7% of Android's results. Text Processing scores 2.6× Android's result (2998 against 1165). Photo Editor scores 58% of Android's result (974 against 1678). These differences remain uninvestigated.
• Limits of the comparison. Each environment ran the benchmark once. Android used Geekbench 7.1.0 and bionic. Linux used Geekbench 7.0.0 Preview and Ubuntu's glibc. These builds and system libraries differ. Treat the overall result as similar performance, not a performance gain.

All scores for individual workloads are in benchmarks/geekbench7-cpu-20261001. Graphics use the phone's GPU through Mesa. The benchmark notes contain display and renderer measurements.

Rungic gives agents workspaces, tools, evidence and a way to deliver results. These system capabilities support different agents.

The bundled assistant connects these capabilities. It turns a request into a plan, visible actions, progress updates and files you can open from the conversation. Diagnostic MCP tools and the repository's build and installation skills also support development agents. Assistance on the phone and device management from a development computer require different access.

Agent and model choices are independent of these system capabilities. A replacement agent can use Linux tools and supported MCP, command-line and D-Bus interfaces. Its integration must provide execution, conversation and authorization behavior. The integration map lists reusable interfaces and the parts currently connected to Codex.

Rungic exposes two MCP (Model Context Protocol) servers, command-line tools, D-Bus services and standard Linux interfaces. MCP provides one way to connect an agent. These capabilities do not require Codex.

The Agent Ready interface reference lists MCP startup examples, tools, D-Bus methods, session requirements and integration limits. Screenshot and action tools use the connecting agent's own reasoning. This is the bundled Codex assistant's default path. The desktop_goal helper is available in explicit API mode and uses its configured model backend. Separating display and input does not isolate the agent from files owned by the same Linux user.

Bring your agent, keep your workflow. Rungic can provide the Linux desktop, apps, files and phone interfaces. Another project can provide conversations, an agent runtime or a collaboration space. You can use that project's Android or web client alongside Rungic. You can also connect its execution tools to the Rungic desktop.

The following paths describe possible integrations. The four combinations still need end-to-end validation on Rungic.

Before running an agent locally, check its ARM64 dependencies and runtime requirements. An agent running elsewhere needs a bridge to Rungic's local tools. The desktop MCP currently uses stdio. Showing another agent's progress, suggestions and usage in Rungic's assistant and widgets requires a separate adapter. Read the system interface reference and agent integration map.

Rungic is under active development and in private preview. Current limits and ongoing work include:

• The interface uses the desktop's language, currently English or Chinese. The assistant answers in the language you speak to it. Account setup and some technical documents are still in Chinese.
• Larger tasks, such as 3D modelling, take the assistant about two minutes. Work to reduce this time continues.
• The default Codex desktop path has passed screenshot, click and result checks on the development G100. The Luna API alternative has passed a read-only screen check. Full call and voice-message workflows still need validation with the new default; see the acceptance record.
• Vulkan desktop rendering flickers on this GPU family, so the desktop uses OpenGL ES for now.

Rungic's architecture supports adaptation to different phones. The Linux desktop runs in an LXC container that shares Android's kernel. The Rungic app uses Android interfaces for the display, touch input, sound and cameras.

For each device, we pin kernel sources and a build configuration that match its stock firmware. We enable missing container capabilities, including System V IPC, POSIX message queues, IPC/PID/user namespaces and devtmpfs. To retain the manufacturer's drivers, we check the rebuilt kernel's module ABI and signature trust, then test on the device.

Full flash packages also include root, the Rungic app and first-boot installation. The device's release manifest records their partition changes.

The current official adaptation path requires:

• An unlockable bootloader and a supported root setup. Current device integrations use Magisk. Eligibility and consequences depend on the manufacturer and device variant.
• A GKI kernel with matching sources and compatible vendor modules. Builds so far use android15-6.6 and android16-6.12. Other branches require adaptation and checks. The Android version alone does not establish compatibility.
• A Snapdragon chip with an Adreno GPU, for the hardware-accelerated desktop (Mesa's Turnip and freedreno on Adreno's KGSL driver). Phones with other GPUs need their own graphics work first.
• ARM64 and enough free storage for the Linux system.

Each new phone or firmware needs a kernel built from its exact sources. It also needs device checks. The rungic-three-stage-image skill guides this work.

Tested so far:

The Redmi K40S community port uses device-specific kernel and compatibility changes for Linux 4.19. Its complete Rungic release package and full feature set remain unverified; the report records the working desktop and remaining issues.

1. Make a complete backup outside the phone. The previously validated full-flash path erases user data. Bootloader unlocking normally triggers a factory reset. Back up photos, files, contacts and messages. Export app-specific data. Make sure you can restore access to your accounts.

   Device preparation and Rungic installation are separate operations. Retaining the manufacturer's Android base does not preserve your data during unlocking or a firmware reset.

2. Retaining normal Android functionality is a design goal. Calls, messages, networking, cameras and other phone functions should remain available alongside RungicOS after adaptation and validation. This goal does not guarantee those functions on every phone or firmware. Check the device's acceptance record and release notes. Check which preinstalled apps its firmware profile removes or disables.

3. Some apps may reject the modified device. Apps or their services can check root, bootloader state or device integrity. They can restrict access even when Android itself works normally. For example, Play Integrity lets developers apply their own access policies.

   The app or service imposes these restrictions. Rungic cannot guarantee that every app will accept the device. Other app failures still need diagnosis before attributing them to security policies.

4. Research the manufacturer's policies for your exact model and variant. Before unlocking or rooting, check eligibility and the required procedure. Check whether protected features or update support will change. Some effects can persist after restoring stock firmware. For example, Samsung's Knox documentation describes restrictions on Knox-dependent services after its Warranty Bit is tripped.

   This example applies to that manufacturer's policies. It does not establish Rungic support for Samsung devices.

Skills are reusable instructions that an agent reads to complete a task. Rungic provides three project skills:

The desktop skill ships with the bundled assistant. Its editable copy lives at ~/.codex/skills/rungic-phone-desktop/ on the phone. Package updates preserve your changes to that copy. These locations and invocation examples describe the current Codex integration. Claude Code finds linked repository skills through .claude/skills/. Other agents can reuse the instructions and tools by adapting skill loading to their own format.

Invoke $rungic-three-stage-image in Codex from the repository root. Specify the device and firmware spec. Describe the work and state whether it includes installation. The skill supports the full workflow or a selected stage:

Example requests for Codex — replace the placeholders with your chosen inputs:

Use $rungic-three-stage-image to run CI1 only for <device-spec>.
Build the kernel/boot candidate and check its OEM module compatibility.

Use $rungic-three-stage-image to run CI2 only for <device-spec>, using
<package-release>. Produce a clean RungicOS rootfs image and package lock.

Use $rungic-three-stage-image to run CI3 for <device-spec> with
<verified-rootfs-artifacts>: pack and verify the standalone payload, then
install it on <device-serial> and run the first-install acceptance.

For installation, name the exact artifact and target device serial. State whether the task is a first installation or an upgrade. A build request produces artifacts. It does not flash the phone. Rungic installation should preserve the existing Android base and user data. Any necessary bootloader or firmware work belongs to the separate device-preparation step.

The Linux rootfs is a container filesystem image that shares Android's kernel. It is not an Android system.img.

For incremental work, request a package update. For example: “Build and deploy the updated suggestion widget to my existing Rungic installation on <device-serial>. Then verify its desktop interactions.” Project packages use rungic_package.py. Modified upstream packages use build_on_device.py.

These build and installation skills guide the existing tools. The complete process still needs several tools and device-specific inputs. In particular, build_rootfs_image.py packages an already prepared root tree and checks its package versions. The current delivery contract separates device preparation from Rungic installation.

Use these guides for the relevant stage:

• The tool map lists stage entry points.
• The new-device guide covers adaptation.
• The first-boot guide covers installation and recovery.

The X70 Air Pro records cover standalone installation in three conditions:

• 91: installation on a reused Android base.
• 92: installation after reflashing and wiping Android.
• 93: a rebuilt image that passed three cold reboots.

The G100 acceptance record documents the older full-flash path. Legacy full-flash tools remain for explicitly selected recovery or reproduction work. These detailed engineering guides are currently in Chinese.

• Source layout: Android host, agents, desktop integration, system services, package definitions and upstream patches
• Developer guide and documentation index: repository layout, development entry points, and the design and acceptance documents for each capability
• Integrating another agent · Proactive system care · Compatibility knowledge
• Voice assistant · Computer use · Assistant's screen · Agent workspaces and teams · Standalone install on X70 · Development deploys (in Chinese)
• Engineering conventions (in Chinese)