Devlog: Google Workspace Integration

This week I worked on integrating Google Workspace into Zero-Assist, allowing the AI to securely access services like Gmail, Google Drive, Google Docs, and Google Sheets after the user grants permission.

The ZeroClaw engine already supports Google Workspace CLI (GWS), but it was originally built for desktop Linux and expects a desktop environment with GWS already installed. Since Zero-Assist runs inside an Alpine Linux sandbox on Android using PRoot, that approach doesn’t work directly.

Instead of rewriting the integration, I kept the existing architecture and adapted it for Android.

What I Implemented

I modified the sandbox installation process so that GWS is installed automatically whenever the user installs the standard sandbox packages. This means users don’t need to manually install or configure the CLI.

Inside the app, I added a new Google Workspace plugin under:

Connections → Plugins → Installed → Google Workspace

When the user signs in, the Android app completes the OAuth flow and generates the required Google Workspace configuration files.

To bridge Android and the Linux sandbox, I use the existing Android ↔ PRoot bridge. The plan is:

User Login
    ↓
Android creates GWS credentials
    ↓
Credentials copied into PRoot sandbox
    ↓
Sandbox GWS CLI uses the same credentials
    ↓
AI can access approved Google services

This keeps authentication native while allowing the Linux CLI to work without requiring the user to touch the terminal.

Google Cloud Setup

I also created a dedicated Google Cloud Console project for Zero-Assist.

The project uses a Web Application OAuth client, which is required by the Google Workspace CLI authentication flow. I enabled the necessary APIs, including:

• Gmail API
• Google Drive API
• Google Docs API
• Google Sheets API

More APIs can be enabled as additional integrations are added.

Current Problem

The authentication flow itself works correctly, and users can successfully sign in.

The issue is that the generated credential/configuration files are not being copied correctly into the Linux sandbox. Because of this, the sandboxed GWS CLI cannot find the required authentication files, causing every Google Workspace command to fail.

The current challenge isn’t OAuth—it’s reliably synchronizing credentials between Android and the PRoot environment.

Once this bridge is working, users will simply sign in once, choose which Google services they want to grant access to, and Zero-Assist will be able to securely interact with those services without any manual setup. note:This devlog is written with hands and then passed to the chatgpt to format it with the .md because im very lazy to play with those colons and #’s

Device Control Development Update

Yesterday I worked on expanding the Device Control system in my AI assistant.

The idea behind this feature is to allow the AI to perform real actions on an Android device using the Accessibility Service. When the user gives a command such as “Subscribe to MrBeast on YouTube”, the main AI analyzes the request and delegates it to the Device Control tool.

Current Workflow

1. Launch the required application using:
   • PackageManager.getLaunchIntentForPackage()
   • startActivity()
2. Capture a compressed screenshot of the current screen.
3. Analyze the screenshot to identify UI elements and their screen coordinates.
4. Navigate the interface and perform actions through the Android Accessibility APIs.

Current Features

• Open applications
• Tap at (x, y)
• Swipe gestures
• Type text

These core primitives allow the AI to interact with almost any Android application through UI automation.

Future Improvements

My main goals are to improve both speed and accuracy.

Instead of navigating through multiple screens for simple system operations, I plan to add native high-level commands directly into the Device Control tool, such as:

• flashlight_toggle
• wifi_toggle
• bluetooth_toggle
• mobile_data_toggle
• volume_set
• brightness_set
• take_screenshot
• lock_screen
• open_notifications
• open_quick_settings
• go_home
• go_back
• open_recents

These commands will allow the AI to execute common Android actions instantly without relying on visual navigation.

For more complex tasks—such as interacting with third-party applications—the tool will continue using the screenshot + coordinate-based navigation pipeline.

Long-Term Vision

The goal is to build a hybrid Device Control system:

• Native commands for common Android operations (fast, reliable, and efficient).
• Vision-guided UI automation for complex interactions within any application.

This architecture will significantly reduce execution time, improve reliability, and make the assistant capable of handling virtually any task on an Android device.

So i basically went through the whole device control system and hardened it. the planner was splitting compound goals like “open instagram and message rohit” into separate calls which broke everything. also fixed it so the loop doesn’t just bail on the first response - it actually executes the action first. scroll was crashing if the planner didn’t send a direction so now it defaults down. and exceptions in the callback handler were just silently killing the process so now everything is caught and logged properly. added loop detection so it doesn’t get stuck repeating the same thing, post-action screen verification, and 44 tests to cover it all. very happy that it worked , it took lots of time but eventually i think the results are very very good though this thing not works great on the local ai’s but with the cheap api like openrouter/free , this thing can give pretty good results

okay so after spending lots of time on this issue , im finally able to make this work again , the problem was that (bin/sh, ust/bin/env) never extracted because of one code issue where i accidently mentioned them as the read only memory in the apps storage so the distro was installing also getting extracted but becacuse of the read only type of file , the app was not able to perform any actions on it , so now after taking the help from the open code now the sandbox is fully functional and working on every devices , also ive added some default packages which will get installed during the setup of the sandbox such as (wget, git , python3, jq, py3-pip, nodejs ,lftp and the openssh-client) just using the single command (apk add –no-cache bash curl wget git jq python3 py3-pip nodejs openssh-client lftp rsync)

Hello guys, devlog here!I finally got the Linux sandbox in Zero-Assist working end-to-end! The sandbox runs Alpine Linux through PRoot directly on Android without requiring root.Getting it working was harder than expected, though. I ran into several Android-specific issues.Fixing the SandboxThe first problem was Alpine’s heavy use of BusyBox hardlinks. My TAR extractor used File.copyTo(), which didn’t preserve executable permissions, causing errors like:proot error: execve(“/bin/sh”): Permission denied
I fixed this by preserving executable bits:linkTarget.copyTo(outFile, overwrite = true)

if (linkTarget.canExecute()) {
outFile.setExecutable(true, false)
}
Some hardlinks were also extracted before BusyBox itself, so I added a second repair pass after extraction to restore critical commands like /bin/sh, /bin/ls, and /bin/cat.Symlinks were another problem because Android can block their creation. I added a fallback that copies the target when creating the actual symlink fails:try {
Files.createSymbolicLink(outFile.toPath(), Paths.get(linkName))
} catch (e: Exception) {
fallback.copyTo(outFile, overwrite = true)
}
I also had problems directly executing PRoot because some Android app directories can be noexec. The solution was to launch PRoot through Android’s system linker:val args = arrayOf(
“/system/bin/linker64”,
prootPath,
“–rootfs=$rootfsPath”,
“/bin/sh”, “-c”, command
)
I also added corrupted download detection and automatic Alpine mirror fallback, making the rootfs installation much more reliable.Giving the AI Linux ToolsAfter getting the sandbox stable, I added two AI tools:sandbox_execute — Executes commands inside Alpine and supports persistent shell state, working directories, environment variables, timeouts, and background processes.sandbox_manage_process — Lets the AI list, monitor, read logs from, and kill background processes.For example, the AI can execute:{
“command”: “python3 –version && uname -a”,
“working_dir”: “/root”
}
Or start a background server:{
“command”: “python3 -m http.server 8000”,
“background”: true
}
The execution pipeline now looks like:AI Agent
↓
Rust Tool Layer
↓
Authenticated Local HTTP Bridge
↓
Kotlin Sandbox Manager
↓
PRoot
↓
Alpine Linux
The Rust runtime communicates with the Kotlin sandbox through a localhost bridge on 127.0.0.1:49481, protected by a randomly generated per-process bearer token.And now the sandbox is fully functional end-to-end!The AI can execute real Linux commands, install packages, maintain persistent shell sessions, run scripts, start background processes, inspect their logs, and manage them — all inside Alpine Linux running directly on Android without root.This was one of the hardest parts of Zero-Assist so far, but now the AI finally has its own real Linux environment to work with.

Giving Zero-Assist Its Own Linux Sandbox

A lot of features I want in Zero-Assist need actual Linux tools: shell commands, Python, Git, Node.js, CLI tools, etc. I didn’t want this to require root, so I built a local Alpine Linux sandbox using PRoot that runs entirely on-device.

The architecture is basically:

AI daemon → sandbox tool → HTTP bridge → Kotlin sandbox manager → PRoot → Alpine

Getting PRoot running

One annoying problem was Android’s noexec restrictions. PRoot is stored inside the app’s data/native library directory and can’t always be executed normally.

The solution was launching it through Android’s dynamic linker:

private fun buildProcessArgs(
    command: String,
    workingDir: String
): Array<String> {
    val args = arrayOf(
        prootPath,
        "--rootfs=$rootfsPath",
        "--bind=/dev",
        "--bind=/proc",
        "--bind=/sys",
        "--bind=$homePath:/root",
        "--bind=$tmpPath:/tmp",
        "-0", "-w", workingDir,
        "/bin/sh", "-c", command
    )

    return if (ANDROID_LINKER != null)
        arrayOf(ANDROID_LINKER, *args)
    else args
}

So commands effectively go through:

/system/bin/linker64 → PRoot → Alpine → command

This lets the bundled PRoot code run despite the noexec restriction.

Connecting Rust and Kotlin

My AI daemon is written in Rust, while the sandbox is managed by Kotlin. I connected them using a small NanoHTTPD server running only on localhost.

return when (session.uri) {
    "/health" -> handleHealth()
    "/execute" -> handleExecute(session)
    "/manage_process" -> handleManageProcess(session)
    else -> errorJson(
        Response.Status.NOT_FOUND,
        "Unknown path: ${session.uri}"
    )
}

The Rust daemon sends authenticated requests to 127.0.0.1:49481.

The AI currently gets two tools:

• sandbox_execute - run Linux commands
• sandbox_manage_process - manage background processes

Persistent shell sessions

I wanted the sandbox to behave like an actual terminal instead of starting from scratch for every command.

If the AI runs:

cd /root/project
export TEST=hello

the next tool call stays in /root/project and keeps the environment variable.

Each conversation gets a separate persistent shell:

Conversation A → Shell A
Conversation B → Shell B

This keeps cwd/environment state while preventing different conversations from affecting each other.

Background commands are isolated differently. Each one gets a separate PRoot executor and is tracked by a process manager. The AI can start a long-running command, continue doing other things, then check its logs or kill it later.

Installing Alpine

The sandbox manager handles the full setup:

Download Alpine → Extract → Fix hardlinks/permissions → apk update → Install tools → Ready

The hardlink fix was needed because some Alpine tar entries reference files that haven’t been extracted yet, which caused extraction failures on Android.

Right now the sandbox comes with Bash, Python + pip, Node.js, Git, curl, wget, jq, SSH, lftp and rsync.

The main parts are:

• ProotExecutor - executes commands
• LinuxSandboxManager - lifecycle/setup
• SandboxBridgeServer - Rust ↔ Kotlin bridge
• SandboxProcessManager - background processes
• PersistentSandboxShell - per-conversation shell state

There is still more I want to improve, especially filesystem sharing, networking and reliability for longer agent tasks.

But the main system is finally working: Zero-Assist can now give an AI agent a real Linux userspace running locally inside an Android app without requiring root.

This started with the idea of somehow giving the AI a tiny Linux computer inside the app. Now it actually has one.

Giving My Android AI App Its Own Linux Sandbox

One of the biggest problems with my app was that a lot of the features I wanted to build actually needed a real desktop environment.

Things like:

• Running shell commands
• Browser automation
• Using desktop CLI tools
• Installing packages on demand
• Running scripts

ZeroClaw already supports these kinds of capabilities, but on Android I couldn’t really use them to their full potential. The app simply didn’t have an environment that could support everything properly.

So I decided…

Why not give the app its own minimal Linux desktop?

---

The Initial Research

Luckily, I already had some experience with Linux.

I had previously played around with:

• Linux distros
• PRoot
• chroot
• Minimal desktop environments

So I started looking at every possible approach.

Option 1 — Android’s default shell

At first I thought about using the shell that every Android app already gets.

It looked simple.

But after experimenting with it, I realized it was missing a lot of the commands and tools I actually needed.

That completely defeated the purpose of having a proper sandbox.

So I dropped that idea.

---

Option 2 — chroot

Next I started researching chroot.

Honestly, from a technical point of view, chroot is amazing.

It gets extremely close to a real Linux environment.

Performance is great and it behaves much more like an actual desktop installation.

There was only one problem.

It requires a rooted device.

That was an immediate deal breaker.

I don’t want someone to root their phone just to use my app.

So chroot was out too.

---

Option 3 — PRoot

After a lot of brainstorming, reading documentation, and trying different ideas, I finally settled on PRoot.

It isn’t perfect.

There are still some limitations compared to a real Linux installation, but I’ll talk about those another time.

The important part is this:

• No root required
• Works on normal Android devices
• Can run a real Linux userspace
• Supports the tools my AI actually needs

For what I’m trying to build, it was the best balance.

---

Choosing the distro

I wanted something lightweight.

Really lightweight.

So I picked Alpine Linux.

The base image is around 5 MB.

Yes…

Literally 5 MB.

After installing the packages I consider “essential” for the AI (things like Python, pip, curl, git, etc.), the whole environment comes to roughly 700 MB.

That gives the AI a solid starting point without making users download multiple gigabytes on day one.

If more tools are needed later, the AI can simply install them inside the sandbox.

---

Current Progress

I’ve finally started implementing everything.

So far I’ve added:

• sandbox_client.rs
• sandbox_main.kt
• Configuration files for the sandbox
• Default package lists that will be installed automatically

There’s still a lot left to build, but the foundation is finally there.

---

This is probably one of the biggest architectural changes I’ve made to the app so far.

Instead of trying to force Android to behave like a desktop, I’m giving the AI its own Linux environment that it can actually work inside.

Still a long way to go !!! MAKE SURE TO FOLLOW THE PROJECT YES THE IMAGE IS AI GENETRATED , BUT I DIDNT KNOW WHAT TO DO FOR BETTER EXPLAINATION SO I DID IT :D

final devlog i guess , okay so after the last rejection of my project , invested lots of time in reducing the installing scripts cause i saw the reviewers recording of using my project , he had to do lots of things manually like installing apps , starting desktop etc so now i made some automated scripts which will install the apps automatically , which are been divided into many other types like browsers , ai apps , ide ,etc so once the script is run , we can install multiple apps simultaneously also cherry on top i also added some themes so that the desktop will also look good im giving this project time because i will be using this project in my next project which is a cyberdeck

After long time … hello guys making this devlog after very long time , i had an issue ,when i was cleaning up my project , removing the dead code and optimizing the app where i was taking the help of the antigravity for this , i accidently deleted the hardware side in the zero claw (engine of zero assist) which was in beta i was just remaining to test it because i didn’t have any proper hardware to do it so it was remaining to test and unfortunately i didn’t even had the code pushed on the GitHub which made the situation worst so now I’ve nearly fixed it , the app is successfully building properly and now I’ve decided to push the code every day if possible on the GitHub to avoid this type of things and I’m writing this devlog because of the new rule i came by where only 10 hrs. will be counted MY BAD LUCK now my 12 hrs. are going to waste 😭😭because i was not uploading the devlog and the time increased so uploading this asap so that my next time will be counted !!

Just finished with the pcb !!! it took lots of time (forget to record :D) also because its my first time it took me time but ! i learned lots and lots of things (via’s ,footprint, different pcb layers etc ) it was very fun learning this also added some silk screen do let me know how it looks and if you spot any error pls let me know in comments , now moving on to the case , i already starting working on it FUSION IS DIFFICULTT😭😭

Just finished with the pcb !!! it took lots of time (forget to record :D) also because its my first time it took me time but ! i learned lots and lots of things (via’s ,footprint, different pcb layers etc ) it was very fun learning this also added some silk screen do let me know how it looks and if you spot any error pls let me know in comments , now moving on to the case , i already starting working on it FUSION IS DIFFICULTT😭😭

#Devlog 2 Hackpad so today i worked on the pcb tracing , i learnt lots of things today about tracing , via’s layers and lots and lots of new things , at first it was overwhelming but then after spending some time i was able to finish this also after some time left so i added some cool graphics there are more at back will show u guys later till then bye bye :D

#Devlog 1: Hackpad Done with the schematics!! today as its my first time designing any pcb and also i was working on a 3*3 matrix so it was little harder but i managed to complete everything and now tomorrow i will move to the pcb designing which i think will be easier cause all the schematics are already done hope it will be easier lets see!! bye bye :D

Devlog #8 — Zero-Assist
I added a Skills Section to Zero-Assist, and it’s probably one of the more useful things we’ve shipped so far.

What It Is
Skills are installable modules built by the Zeroclaw community that extend what the app can do. Things like Doc Writer, Auto-Coder, and more — each one teaches the app how to handle a specific type of task better. Install one, and Zero-Assist reads it and starts applying it automatically. No setup, no configuration, just tap and it works.
These aren’t shortcuts or preset prompts. The app actually understands the skill and uses it to make smarter decisions when you’re working.

Always Growing
The library isn’t static. The community keeps adding new skills and updating existing ones, so the app naturally gets more capable over time without needing a big update from our end. Whatever gets added is available to you immediately.
Big thanks to everyone in the Zeroclaw community who built and contributed skills — this whole section runs on your work.

What’s Next
We’re making it easier for more people to submit skills, and we’re looking at adding ratings and changelogs so you can track what’s new and what’s worth installing.
More soon.

Devlog #8 — Zero-Assist
I added a Skills Section to Zero-Assist, and it’s probably one of the more useful things we’ve shipped so far.

What It Is
Skills are installable modules built by the Zeroclaw community that extend what the app can do. Things like Doc Writer, Auto-Coder, and more — each one teaches the app how to handle a specific type of task better. Install one, and Zero-Assist reads it and starts applying it automatically. No setup, no configuration, just tap and it works.
These aren’t shortcuts or preset prompts. The app actually understands the skill and uses it to make smarter decisions when you’re working.

Always Growing
The library isn’t static. The community keeps adding new skills and updating existing ones, so the app naturally gets more capable over time without needing a big update from our end. Whatever gets added is available to you immediately.
Big thanks to everyone in the Zeroclaw community who built and contributed skills — this whole section runs on your work.

What’s Next
We’re making it easier for more people to submit skills, and we’re looking at adding ratings and changelogs so you can track what’s new and what’s worth installing.
More soon.

Devlog #7 — Multi-Agent Architecture & Custom Agent Builder

Zero-Assist just got a major upgrade.

What if instead of one AI assistant, you had an entire team of AI specialists working together?

That’s exactly what I’ve built.

Multiple Agent System

Zero-Assist now supports multiple specialized agents, each optimized for a specific role and workflow.

Master Agent

The brain of the operation.

• Orchestrates all agents
• Assigns tasks intelligently
• Monitors progress
• Routes requests to the best agent

Researcher Agent

Your personal information hunter.

• Searches the web
• Collects and analyzes data
• Returns structured insights
• Filters noise and focuses on relevant information

Coder Agent

Built for developers.

• Writes code
• Reviews code
• Fixes bugs
• Assists with architecture and implementation

Planner Agent

Turns chaos into clarity.

• Breaks down goals
• Creates actionable roadmaps
• Generates timelines
• Organizes complex projects

---

Custom Agent Builder

The most exciting feature in this update.

You can now create your own specialized AI agents with just a few clicks.

Customize:

• System Prompt
• Temperature
• Tags & Capabilities
• LLM Model
• Agent Role & Personality

Want an AI Startup Advisor?

Create one.

Want a Bug-Hunting Expert?

Create one.

Want a Cybersecurity Specialist?

Create one.

The possibilities are endless.

---

Why This Matters

Most AI applications rely on a single model trying to do everything.

Zero-Assist takes a different approach.

Instead of one assistant, you get an entire ecosystem of AI specialists that can collaborate, delegate tasks, and work together to solve problems more efficiently.

Each agent has:

• Its own configuration
• Its own expertise
• Its own behavior
• Its own model settings

This creates a more scalable and intelligent workflow compared to traditional AI assistants.

---

Vision

The long-term goal isn’t just to build another chatbot.

It’s to build an AI Operating System where users can create, orchestrate, and manage teams of intelligent agents that work together to accomplish complex tasks.

And this is only the beginning.

Screenshot attached below.

---

#The Final Devlog
Riced my phone though is not a stand alone os but many linux package works in termux too cause basically the android is based on linux :D so most of the package were working and the one which were not working i ditched them , also setup ed a some developer apps like lazyvim via nvim , rofi , vscode , some hardware acc tools too !! also adding the video as the demo

#The Final Devlog
Riced my phone though is not a stand alone os but many linux package works in termux too cause basically the android is based on linux :D so most of the package were working and the one which were not working i ditched them , also setup ed a some developer apps like lazyvim via nvim , rofi , vscode , some hardware acc tools too !! also adding the video as the demo

#Devlog 6 -Zero-Assist

Shipped a big update today. The app can now handle complex tasks much more reliably, and tools run in parallel instead of sequentially — so heavy workloads finish noticeably faster without the app choking midway.
The smarter behavior actually came from Trimming down the soul.md, longterm-memory.md, agents.md, and user.md files reduced token usage significantly, and the model started reasoning better almost immediately. I tested it across several complex tasks and the output quality genuinely caught me off guard — results I didn’t expected!!!

Voice has been a pain point for a while. Dug into the Piper latency issues, restructured the integration, and the pipeline is much smoother now. Still sounds robotic — that’s a problem I haven’t cracked yet — but the lag that made it frustrating to use is mostly gone.
Overall the app feels like a different version of itself. More capable, leaner, and faster. Dropping Demo vid of the test runs below so you can see what it’s actually doing now. here is demo video too :https://youtube.com/shorts/F8sLD21dcWo