DEV Community: Priya Negi

How I build my first automation as a non-coder

Priya Negi — Wed, 01 Apr 2026 06:33:07 +0000

I'll be honest, when I first heard about mobile automation, I pictured lines of incomprehensible code scrolling down a black terminal screen. As someone who barely remembers high school algebra, the thought of programming anything made me want to close my laptop and pretend I never heard the word automation. Okay that was exaggerated.

But here's the thing, I like listening to people talking about automating this and that. I also wanted to try something. So I looked for some options, and that's when I discovered Droidrun.

The Problem with Traditional Automation

Most automation tools expect you to write code or scripts, understand programming logic, learn technical syntax and then debug when things break. Basically configuring at every single step.
( I don’t know these many things, I just asked LLM the problems with traditional automation)

For someone like me, this felt like being handed a spaceship manual when I just wanted to ride a bike or maybe a scooter.

Mobilerun: Automation for non-coders

Mobilerun is the cloud infrastructure of Droidrun, an AI-powered mobile automation framework. But here's the thing, you don't need to know what a framework is to use it.

Instead of writing code, you just describe what you want in plain English. The AI figures out how to do it. Simple.

Think of it like this:

You : Send a WhatsApp message saying hello to John
Mobilerun: Sends a message to John.

You don’t need to think about what happens in the backend, you just get a task executed as simple as that.

My First Automation

Let me walk you through exactly how I set up my first automation without coding anything.

What You'll Need

Before we start, here's what you need:

An Android phone (sorry iOS users, not yet!)
About 15 minutes
A Mobilerun account (free to start)

That's it. No programming knowledge needed.

Step 1: Get the Droidrun Portal APK

The Droidrun Portal APK is like a bridge between your phone and Mobilerun's AI. It allows the AI to see what's on your screen and interact with your apps.

Here's the complete setup guide for this : https://docs.droidrun.ai/guides/device-setup

Important: You'll need to enable "Install from Unknown Sources" in your Android settings. Don't worry, the Portal app is open-source and safe. It's like giving your trusted friend the remote control to help you with tasks.

Step 2: Set Up Portal Permissions

Once Portal is installed, open it. It will ask for a few permissions:

Accessibility Service: This lets the AI see what's on your screen and interact with buttons and text fields
Display Over Other Apps: This allows Portal to work in the background while you use other apps

These permissions sound scary, but they're necessary for automation to work. It's like giving someone permission to use your keyboard and mouse on your behalf.

Step 3: Connect to Mobilerun Cloud

Now comes the easy part:

Go to cloud.mobilerun.ai
Sign up for a free account (just email and password).
You'll land on your dashboard
Look for "Connect Device" or "Add Device"
On your phone's Portal app, you'll see a "Connect to Cloud" option
Scan the QR code shown on the Mobilerun website (or enter the code manually)

And that's it! Your phone is now connected. You'll see it appear as "Online" on your Mobilerun dashboard.

Note: Make sure to use the same email address to login to mobilerun and portal apk. Otherwise, you won’t be able to see the device in the cloud.

Step 4: Your First Automation

Here's where it gets fun. Let's start with something simple automatically saving Instagram posts you like.

On the Mobilerun dashboard:

In the playground, write the task in plain english. Something like, Open Instagram, go to my saved posts, and unsave them all.
Select the agent
Under devices, you can already see the connected device
Under advanced setting, choose the other relevant settings
and finally click on Run to start the automation

That's it. Now your mobile will automatically perform tasks specified by you.

What Can You Automate?

Once you've got the basics down, the possibilities are pretty wild. You can automate anything you do on your phone.

What I Learned

Building my first automation taught me something important: technology should work for you, not the other way around.

For years, I thought automation was only for programmers. I was wrong. The real barrier wasn't knowledge, it was that tools were built by developers for developers.

Mobilerun changes that. It's built for people who just want their phone to do things without becoming a software engineer in the process.

Final Thoughts

If you're also someone who wants to run automation or at least try it once, Droidrun is the tool you can use.

You don't need to learn to code.
You don't need to understand how AI works.
You just need 15 minutes and a willingness to try something new.

Happy Learning.

How I automated LinkedIn with my old phone

Priya Negi — Sun, 29 Mar 2026 06:31:26 +0000

We all have at least one old phone that nobody uses anymore. A Galaxy something or other with a cracked screen protector. A phone that still works fine but hasn't been charged for so many months now. They just sit there, slowly becoming e-waste. Until you turned one into your personal LinkedIn automation agent.

That’s right. Just an old Android phone and an AI that does all the clicking, scrolling, posting, commenting stuff for me.

Let me explain. If you've ever tried to automate LinkedIn, you know the deal. Chrome extensions that inject scripts into the page. Cloud tools that log into your account from some random IP in Virginia. Dedicated SaaS platforms charging $99/month to send connection requests. and LinkedIn's crackdown has only gotten worse. People are getting accounts restricted left and right. The problem isn't the automation itself but how most tools do it. They're all browser-based hacks pretending to be you, and anti-bot software has gotten scary good at spotting them.

So I asked myself what if the automation happened on an actual phone, doing actual taps, like an actual human?

Here's what I did. I grabbed my old Android device from the drawer, installed the Droidrun APK, and connected it to Mobilerun. That's it. That was the setup. Mobilerun is a platform that lets you automate real Android devices with plain English. You literally tell it what to do and it does it on a real phone, with real taps, real scrolls, real keystrokes.

I told it to open LinkedIn, go to my feed, and start engaging with posts. Liking. Commenting thoughtful responses (not those cliche Great post bots). Sending connection requests to people in my niche. Checking messages. And because it's happening on a real device with a real screen, LinkedIn sees exactly what it expects: someone using the app normally on their phone. Because that's literally what's happening. The AI is just the one holding the phone.

What I Actually Automated:

Here's my daily LinkedIn workflow that now runs without me touching anything:

Morning engagement round: The agent opens LinkedIn, scrolls through my feed, likes relevant posts, and leaves actual comments. Not generic ones contextual comments based on what the post is about.
Connection requests: Targeted outreach to people in my industry. The agent visits profiles, reads their bio, and sends personalized connection requests.
Message replies: It checks my LinkedIn inbox and drafts responses. I review the important ones, but for the, thanks for connecting messages it handles it all.
Content interaction: When I post something, the agent monitors engagement and responds to comments throughout the day.

All running on a phone that was of no use two weeks ago.

Watch it in action:

https://www.youtube.com/watch?v=LVx_jL8PT4o

Why This Approach is Different:

Most LinkedIn automation tools work at the API or browser level. They're essentially puppeteering a web session. LinkedIn knows(trust me, you are like this far from getting banned). They track browser fingerprints, unusual session patterns, and IP mismatches. But a real phone running the real LinkedIn app? That's just... a phone. The touch events are real. The screen renders are real. The network requests come from a normal mobile connection. There's nothing to detect because there's nothing fake. And here's the kicker if you don't even have an old phone lying around, Mobilerun offers cloud-hosted real Android devices. Same concept, but you skip the hardware entirely.

The Results:

After two weeks of running this:

Connection acceptance rate went up (personalized requests hit different)
My posts got more early engagement because the agent was actively engaging with others' content (LinkedIn's algorithm rewards that)
I reclaimed about 40 minutes per day I was spending on manual LinkedIn engagement
No account warning so far. Because it is an actual device working for me like a real person.

Should You Do This?

Look, I'm not telling you to go full bot-mode on LinkedIn. The platform has rules, and mass-spamming connection requests is still a terrible idea whether a human or an AI does it. But thoughtful, measured automation? Engaging with content you'd engage with anyway, just without spending an hour doing it manually? That's not gaming the system. That's just being efficient.

And if you've got an old phone sitting in a drawer doing nothing... well, now you know what to do with it.

I talk about AI agents and agentic AI.

Get in touch with me on LinkedIn.

Tasker Vs Droidrun: Rule based automation vs Agentic AI system

Priya Negi — Thu, 26 Mar 2026 06:02:51 +0000

Mobile automation has been around for quite some time with tools like Tasker and MacroDroid. But the landscape of Android automation has evolved dramatically over the past few years. In this blog, I will examine two distinct paradigms in mobile automation technology.

Tasker enables users to perform custom actions based on contexts such as time, location, application state, and events. The platform has continuously evolved to adapt with Android's changing ecosystem.

Droidrun, by contrast, launched in 2025 as an open-source mobile AI agent framework specifically designed to enable natural language control of Android and iOS devices. The framework represents a shift from programmed automation to agent-based control.

Tasker vs Droidrun: Approach

Tasker: Rule-Based Automation

Tasker works as a rule-based automation engine for Android. Users create profiles (trigger conditions) that activate tasks (sequences of actions). This model provides precise automation:

Profiles: Define when something should happen. It looks for contexts such as time-based triggers, location changes, application launches, system states, or custom events.

Tasks: Define what should happen when a profile is triggered for Eg. Modifying system settings, launching applications, manipulating files, sending network requests, or controlling hardware.

Apart from this Tasker supports variables, which makes it very flexible. It can also create custom interfaces like popups, buttons, menus etc.

This architecture grants users granular control over Android's operating system, without requiring root access for most operations. Users can also extend capabilities through JavaScript, shell scripts, and Java code execution.

Droidrun: Agent-Based Control

Droidrun uses large language models to understand and execute tasks written in natural language. Rather than pre-programmed rules, the system uses AI reasoning to complete objectives:

Natural Language Commands: Users describe what they want to achieve in natural language command.
UI Understanding: Vision models and accessibility tree parsing enable dynamic interface comprehension
Multi-Step Planning: LLMs decompose complex objectives into sequential actions
Cross-Application Workflows: Agents can navigate between applications to complete integrated tasks.

This removes the need to write code, letting you automate things just by texting. But it can sometimes behave unpredictably because it relies on AI-generated responses.

Feature Comparison

Dimension	Tasker	Droidrun
Core Approach	Rule-based (IF → THEN)	AI-driven (intent → execution)
Triggers	Built-in (time, app, events, system)	No native triggers (manual / external)
Actions	Predefined (400+ actions)	Decided dynamically by AI
UI Automation	Limited (via plugins)	Strong (native, vision-based)
Ease of Use	Hard to learn	Easy to use (after setup)
Setup	Simple	Complex (Python, ADB, APIs)
Execution	Deterministic (predictable)	Non-deterministic (can vary)
Speed	Fast (milliseconds)	Slower (seconds)
Adaptability	Low (breaks on UI change)	High (adapts to UI changes)
Platform	Android only	Android + iOS (limited)
Internet Needed	No	Yes (usually)
Privacy	Fully local	Cloud-dependent
Best For	System automation, routines	UI automation, complex workflows

Tasker and Droidrun address fundamentally different automation paradigms, making direct comparison challenging.

Criteria	Choose Tasker if you…	Choose Droidrun if you…
Automation Type	Need deterministic, repeatable automation	Need flexible, adaptive automation
Operation Mode	Prefer fully offline operation	Are okay with internet/API dependency
Control Level	Need precise system-level control	Need UI-level control across apps
Ease of Use	Can learn structured logic	Prefer natural language commands
Use Case	Automate device settings, routines	Automate app workflows, UI tasks
App Dependency	Work with system features/APIs	Work with apps without APIs
Adaptability	Can manually fix broken automations	Need automation that adapts automatically
Cost Preference	Want one-time cost	Okay with ongoing API costs
Platform	Only need Android	Need Android + iOS support

For many users, the tools are complementary rather than competitive. Tasker excels at system automation and trigger-based actions, while Droidrun addresses UI navigation and adaptive workflows. The optimal approach may involve both: Tasker for predictable system control, Droidrun for intelligent application interaction.

The broader question is rather more philosophical: Should mobile automation require users to program specific behaviors, or should AI agents interpret human intent? Tasker represents the former; Droidrun explores the latter. Both approaches have merit, and the mobile automation landscape is richer for their coexistence.

I talk about mobile app automation. Follow me on Linkedin.

Best Mobile AI Agents in 2026

Priya Negi — Mon, 16 Mar 2026 09:08:32 +0000

Stop me if you've heard this one: "AI agents are going to revolutionize how you use your phone!"

Yeah, I've been hearing that since 2024. And for two years, most of it was vaporware slick demos that fell apart the second you tried to do something real.

But 2026 is different. I'll give it that.

I've spent the last few weeks installing, configuring, cursing at, and occasionally being impressed by every mobile AI agent I could get my hands on. Some of these are legitimately game-changing. Others are polished marketing wrapped around mediocre tech. And a few surprised me in ways I didn't expect.

This isn't another top 10 best tools listicle.

This is what I actually found when I put these things to work. Lets dive into the Best Mobile AI Agents in 2026.

What are we even talking about?

A mobile AI agent is software that can:

Look at your phone screen
Understand what's happening
Take actions such as tapping, scrolling, typing

Just like you would.

The big leap in 2026 is that these agents don't just work inside one app anymore.

They work across apps, controlling the entire device.

THE ONES THAT ACTUALLY IMPRESSED ME

Droidrun: The Open-Source Framework That Punches Way Above Its Weight

I almost skipped Droidrun because open-source mobile agent framework sounds like something that'll eat my entire weekend just getting it to run.

I was wrong.

Droidrun is the foundation that serious developers are building on.

MIT-licensed
LLM-agnostic (plug in GPT-4, Claude, Gemini, whatever)
Handles device communication
Screen understanding
Action execution

While your model does the thinking.

What I love

You own the entire stack.

No vendor lock-in
No surprise pricing
Android support today
iOS planned for the future

I had a custom agent controlling my test device within an afternoon and this is why I have placed Droidrun at top in the Best Mobile AI Agents list.

The catch

A few months ago it required a bit more setup.

But when I checked again recently, they launched their cloud as well.

And honestly — even if you know nothing about coding, you can still set up automation in under 10 minutes.

Mobilerun — Droidrun's Cloud-Powered Big Sibling

If Droidrun is the engine, Mobilerun is the fully assembled car.

It gives you cloud-hosted real Android devices that you can automate using simple English instructions.

Let's be real — managing physical devices is a nightmare at scale:

Charging issues
OS updates breaking things
Devices going offline at 2 AM

Mobilerun tries to eliminate all of that.

The tech is still evolving, but it's clear where this is going.

My test

I connected my old Android device using the Droidrun APK and asked the agent to order a blueberry cheesecake on a food delivery app.

The interesting part:

This was done on a real device, not an emulator.

The platform is still young and evolving, but for teams building mobile automation at scale, this approach feels like the future.

THE BIG TECH HEAVYWEIGHTS

Google Gemini

Google replaced Assistant with Gemini, and the screen automation is impressive when it works.

I watched it complete a multi-step food order.

Then the next day it got confused by a slightly different menu layout.

That's Gemini in a nutshell:

Incredibly high ceiling
Frustratingly low floor

Still beta for a reason but still deserves a place in the list of Best Mobile AI Agents.

Apple Intelligence & Siri

Apple took the philosophical opposite approach.

It's privacy-first, and Private Cloud Compute is genuinely impressive engineering.

But as an autonomous agent, it's less capable.

Apple treats AI more like a background assistant than a fully autonomous actor.

If you want your phone to execute complex tasks on its own, Gemini is further along.

But a real agent ecosystem on iOS is still a work in progress.

Samsung Galaxy AI

The Galaxy S26 ships with Gemini integrated deeper than stock Android.

Some features are surprisingly good:

Live Translate during calls
Circle to Search

But there’s a catch:

Samsung hardware only
Feature fragmentation across models

So What Should You Actually Use?

If you are building mobile AI agents or automation

Droidrun → open-source, full control
Mobilerun → cloud devices, less infrastructure headache

If you want a smarter phone

Gemini → Android
Apple Intelligence → iPhone
Samsung Galaxy AI → Samsung devices

These technologies are genuinely changing how we interact with our phones.

And honestly, it's about time.

The future of headless apps is not very far.

I talk about Mobile AI Agents and Browser AI Agents.

If you're building in this space, feel free to connect with me on LinkedIn.

How to Turn Old Android Phones into AI Agents (Complete Guide)

Priya Negi — Mon, 09 Mar 2026 10:58:16 +0000

What if that old device in your drawer could be transformed into a functional AI agent — capable of executing tasks autonomously? Thanks to emerging open-source tools like OpenClaw, Droidrun, and cloud services like Mobilerun.ai, this idea is now real. You can turn a forgotten Android phone into an intelligent automation node that executes workflows, interacts with apps, scrapes data, and acts as a personal AI assistant.

What It Means to Turn a Phone into an AI Agent

An AI agent, in this context is an LLM powered system that can understand natural language commands, interact with a real mobile device and complete a multi-step task autonomously on its own.

The traditional automation scripts rely on brittle selectors or hard-coded input sequences. Modern AI agents on the other hand can see the device screen, reason about the UI, and decide on the next action based on intent and context.

We planned to automate the old mobile phones because they are inexpensive, have decent CPUs, and run Android versions that support remote control interfaces.

Instead of collecting dust, these phones can become always-on assistants, running tasks around the clock.

Skip the API and use the screen

Most automation tools assume the app you want to automate has an API. Most apps don't.

For example, your Uber app? No public API. WhatsApp? The business API costs money, requires approval, and can't do half of what the actual app does. Your regional food delivery service? Your banking app? Your transit app? Nothing got an API.

But here's the catch, every single one of these apps has a screen and buttons that you can tap, text that you can read, fields you can type into. And it is a universal interface, and it's the exact same interface a human uses.

Our idea is simple: At Droidrun, instead of calling an API, we let the Droidrun agent look at the screen and decide what to do, how to scroll, and where to tap, exactly like you would.

Sounds interesting right? But making it actually work is where it gets interesting.

How it works: accessibility trees + LLMs

Android has a built-in accessibility system designed to help screen readers describe what's on the screen. This accessibility tree contains every UI element (like buttons, text fields, labels, checkboxes) in a structured format.

Droidrun agent reads this tree, sends it to an LLM (GPT, Claude, or Gemini), and asks: "here's what's on the screen. what should I do next?" the LLM responds with a thought process and an action (An example):

think: i'm on the home screen. launching youtube.
action: launch (842ms)

--- step 2/30 ---
think: youtube is open. tapping the search icon.
action: tap (623ms)

--- step 3/30 ---
think: search field focused.
action: type "lofi hip hop" (501ms)

Our agent does not work on a brittle script that breaks when an app updates its layout. The agent is capable of reasoning about what it sees in real time. If a button moved, if a modal bottom sheet popped up, the agent adapts because it's reading the current state, not relying on hardcoded script.

When the accessibility tree is empty (Games, webviews, screens with custom views), the agent falls back to the vision.

Why old phones are perfect for this

First, because they are old and will not cost you extra bucks. Second, they are not being used by anyone, so we can run agents on them 24*7.

Plug it into a charger, connect to Wi-Fi, and you've got an always-on device running automated tasks 24/7.

The complete setup guide

Option 1: Droidrun Framework (open-source, self-hosted)

If you are a developer and can connect your mobile to the framework, you can try the Droidrun framework for automation. Droidrun is an open-source mobile AI agent framework with 7.8K + GitHub stars, specifically built for developers who want full control.

Detailed Process for getting started with Droidrun Framework

Check link (https://droidrun.ai/)

Option 2: [Mobilerun Cloud (managed, no ADB needed)]

No terminal required. Works with your personal phone.

Create account at cloud.mobilerun.ai
Install Portal APK on your phone (droidrun.ai/portal)
Enable Accessibility permission and notifications
Get API key from cloud.mobilerun.ai/api-keys (starts with dr_sk_)
Long-press "Connect to Mobilerun" in Portal, paste key
Run tasks from the Playground or API:

Watch full setup video: Watch Here

Option 3: Mobilerun + OpenClaw (AI agent with skills)

The most powerful setup, chain phone control with web search, calendars, messaging. Here’s how to set it up.

Install Mobilerun skills in OpenClaw

Get Your Mobilerun API Key

Go to https://cloud.mobilerun.ai/api-keys

Click New Key, name it, and copy it — keys start with dr_sk_

Configure the API Key in the OpenClaw config file or in your terminal config file

Connect your Android Device

Run the OpenClaw with the task to do some automation on your device.

Watch full setup video: Niels video link here

Now you can say: "open Instagram and like the latest post from @natgeo" or "check my WhatsApp messages and summarize them"

Getting started today

Get started with OpenClaw and Mobilerun by following the simple steps below.

Find your old phone (check that drawer)

Charge it up, connect to Wi-Fi

Pick your approach:

Developer → Droidrun (free, open-source)

Managed → Mobilerun Cloud (Portal app, no ADB)

AI assistant → Openclaw + Mobilerun skill

Start simple: "open Settings and tell me the Android version"

Build up: chain tasks, schedule automations, go wild

That phone in your drawer has been waiting. Give it something to do.

Giving Openclaw access to Mobile

Priya Negi — Fri, 20 Feb 2026 12:22:24 +0000

Your AI assistant can write code, search the web, manage files, and hold a conversation. But ask it to open an app on your phone, check a notification, or test a mobile workflow and it hits a wall.

That wall just came down.

With the Mobilerun skill on ClawHub, OpenClaw can now control real Android devices in the cloud. Not emulators. Not screenshots you paste into chat. Actual phones, running actual apps, responding to actual taps and swipes — all driven by your AI assistant.

Here's how it works, why it matters, and how to set it up in under a minute.

https://www.youtube.com/watch?v=HTUJhAVNb7k&t=4s

The stack: from prompt to pixel

You / AI Assistant
→ OpenClaw + Mobilerun Skill
→ Mobilerun Cloud API
→ Real Android Device
→ droidrun Agent Framework
→ Vision Model + Accessibility Tree
→ Screen Understanding → Action Execution

At the foundation is droidrun, an open-source mobile AI agent framework with 7.7k GitHub stars and a 91.4% score on the Android World benchmark. It's the engine that makes phone automation actually reliable.

Droidrun combines two approaches to understand what's on screen:

Vision models — a multimodal LLM looks at the device screenshot and interprets the UI visually
Accessibility tree — the structured representation of every UI element with properties and coordinates By fusing both signals, the agent knows what it's looking at and where to interact. It executes actions through Android's standard interfaces: tap, swipe, type, scroll, back, home.

Mobilerun wraps this into a cloud platform. No USB cable or Android SDK, no local device. Real phones in the cloud, exposed via API.

why this matters for OpenClaw users

OpenClaw is already one of the most capable AI assistant platforms. But desktop and web automation only covers half the story. Mobile is where people spend their time — and where most apps live exclusively.

The Mobilerun skill unlocks:

• QA testing — "test the signup flow on our Android app and report any issues"
• Social media management — "post this to Instagram, check engagement on my last tweet"
• Personal assistant workflows — "order me an Uber to the airport"
• Competitor monitoring — "screenshot competitor's pricing page, compare with last week"
• Cross-app automation — "copy the confirmation code from SMS and paste it into the auth screen"

Real devices. Real apps. Real state. Your assistant sees the screen, reads the UI, and takes action.

setup: 60 seconds to mobile access

Install the skill — ClawHub → search "Mobilerun" → install. Done.
Log in to Mobilerun Cloud — first invoke prompts authentication at mobilerun.ai
Claim free access to Mobilerun
Start using it:

what makes this different

Feature	Traditional Automation	droidrun + mobilerun
Setup	SDK, drivers, device farm	API key
Scripting	xpath selectors, brittle	natural language
UI changes	scripts break	agent adapts
Cross-app	painful	native
Cloud devices	separate service needed	built in
Intelligence	none — pure execution	vision + reasoning

get started with it

The Mobilerun skill takes 10 seconds to install and gives your OpenClaw assistant something it's never had before: hands.

Real hands, on a real phone, in the cloud.

→ clawhub.com — https://openclaw.ai/
→ mobilerun.ai — https://mobilerun.ai/
→ github.com/droidrun — https://github.com/droidrun/droidrun

Appium Vs Droidrun - Pros and Cons

Priya Negi — Fri, 26 Dec 2025 05:59:27 +0000

Mobile applications are a critical part of how we communicate, transact, work, and stay informed.

However, with the increasing complexity of mobile ecosystems across numerous device types, operating system versions, screen sizes, and user interactions, ensuring consistent performance and functionality has become a significant challenge.

To address this, various mobile app automation and testing frameworks have emerged. One of the most widely used among them is Appium which is an open source framework to automate mobile apps.

But with the introduction of AI, the mobile automation landscape is evolving rapidly. New frameworks that support AI integration are changing how developers approach automation. Droidrun is one of the early frameworks in this space.

It is important to note that Appium and Droidrun are not meant to be compared on every parameter. Appium focuses solely on mobile app testing automation, while testing is only one part of what Droidrun enables. Droidrun extends beyond testing into broader mobile and cross-app automation.

In this blog, we discuss the pros and cons of Appium and Droidrun within their respective scopes.

Appium: Pros and Cons

Appium is a popular test automation framework that is used to automate mobile apps. It allows you to execute your tests on real iOS and Android devices as well as on emulators. It is open-source and allows you to use multiple programmin
g languages that it supports like Java, Javascript, Python, etc. Let us look at some of the advantages offered by Appium.

Pros:

Cost-efficiency: Its open-source nature makes it cost-efficient for both small and large development teams.

Vast community: Since it’s an open-source tool, Appium has a thriving community that fosters continuous updates, bug fixes, and the development of plugins and extensions.

Simplified Testing: With its support for multiple programming languages, Appium simplifies the testing process and allows teams to leverage their existing coding skills.

Cons:

Script Writing: Appium requires you to write the script for each automation, and one needs to deeply dive into how the app functions.

Device Compatibility: Appium's is not always compatible with certain Android devices and iOS versions. Some advanced device-specific features may not be easily accessible with the Appium script.

Limited Support for Non-Mobile Apps: Appium is primarily designed for mobile apps, so automating interactions with non-mobile apps, like web apps, can be more complex.

No Natural language command: Appium requires you to write scripts for each automation. No automation can work on natural language command.

Learning Curve: As the automation is not driven by natural language, the learning curve is very steep for early-level developers.

Adapting to UI Changes: Mobile applications change frequently, and even small UI shifts can break traditional scripts, which means every time a change occurs, the script has to be rewritten.

Appium is a valuable asset for anyone involved in mobile application development and testing. Its open-source nature, cross-platform compatibility, and support for multiple programming languages make it a popular choice for ensuring the quality and functionality of mobile applications. Whether you're a developer, a quality assurance professional, or a part of a mobile development team, Appium is a tool that can streamline your testing process and help deliver reliable, high-quality mobile applications to end-users.

Droidrun: Pros and Cons

Droidrun enables automation of mobile applications using natural language commands. It supports automation across Android and iOS apps and is not limited to mobile apps alone, extending to web-based applications as well.

Unlike traditional testing frameworks, Droidrun focuses on task-based automation, where testing is only one part of the overall capability.

Pros

Natural Language Commands: While Appium requires manual script writing, Droidrun allows automation through natural language commands.

Learning Curve: Because automation is driven by natural language, it is easier to learn, especially for beginner developers. In comparison, Appium has a steeper learning curve for early-level developers.

Adapting to UI Changes: Mobile applications change frequently, and even small UI shifts can break traditional scripts. Droidrun uses LLMs as a decision-making layer, allowing automation to continue functioning despite UI changes.

Cross-App Workflow: Droidrun can complete tasks across multiple apps. For example, it can open Gmail to fetch an OTP and then enter that OTP into another application.

Cons

Cost: Running LLM-based agents can be more expensive than running simple scripted automation in Appium.

Speed: For complex tasks, AI-based automation may take more time to reason and execute actions.

Appium and Droidrun serve different purposes within the mobile automation ecosystem. Appium is focused on deterministic, script-based mobile testing, while Droidrun enables broader, AI-driven automation across apps and platforms, with testing being just one component.

Choosing between them depends on whether the goal is structured test automation or flexible, task-oriented automation that adapts to real-world app behavior.

5 Must watch videos on Mobile app automation

Priya Negi — Tue, 23 Dec 2025 07:12:46 +0000

Mobile apps run the world but automating them has always been fragile, expensive, and really slow. Droidrun is changing this by introducing AI agents that can understand and operate real Android apps through intent.

If you are a developer, founder, QA engineer, or simply curious about mobile AI agents, these videos are the best place to start. Each video showcases a different capability and, together, they explain why mobile automation is entering a new era.

1. Mobile app testing

Just launched a new app and want it tested the way a real user would use it?

With Droidrun, you can test your app using simple natural language commands—no complex scripts required. It’s easier, faster, and far more cost-effective.

Watch the video to see how mobile testing can be automated end to end.

Automating Mobile app testing with Droidrun

2. Automating real apps

Now its possible to do everything without downloading the app on your phone. Watch how this user ordered ferrero Rocher using Mobilerun (Droidrun's cloud)

I ordered Ferrero Rocher using Mobilerun

3. Developing new apps

Droidrun isn’t just for testing apps—it can also be used during development.

Watch how you can build a simple app and automatically test it using Droidrun’s framework.

Automating mobile app development and testing

4. Automating Tinder ;)

Yes, you read that right. Using Droidrun, someone automated Tinder swiping and even sending the first message which is arguably the most important part.

Watch the video to see it in action.

I automated Tinder using Droidrun

5. Linkedin automation

Finding jobs, posting new stuff, liking something or just commening valuable comments - all can be automated using droidrun's automation.

I automated linkedin for job hunting

Check out more videos related to the automation.

Droidrun on Youtube

Check Github

Keep Building❤️

Agentic AI - Simple to complex

Priya Negi — Sun, 21 Dec 2025 12:40:47 +0000

Agentic AI - Simple to complex

AI agents are everywhere today, but not all of them are similar. Some AI agents can only answer simple questions but others can perform multiple tasks, coordinate with other systems, or act with minimum human input. In this blog, I will take you through different AI models, from simple to complex.

Rule-Based Automation: The Simplest “AI”

Rule based automations are the systems that follow simple logic like ‘If this then that’ logic. There is no real thinking or learning involved, they just do what they’re told in the predefined conditions. Like FAQ chatbots with prefilled answers,or automated email responses. Most of the agents previously used to be on this level.

These types of agents are cheap and predictable but not intelligent. They are useful for simple automation but are not capable of decision making.

Co-Pilots and Routers: Smart Helpers

These types of agents operate on machine learning systems. They can classify, route or recommend things based on the previous data patterns, but they still can’t act independently. You are supposed to direct the workflow in order to make them work properly. For eg. Email auto-sorting, or support model that can redirect the request to the correct department ( eg - telecom or banking service agents).

With these types of agents, you can decide what the next step would be, but you are still the one with your hands on the steering wheel. They are helpful but are not autonomous.

Tool-Using Agents

This is where things get interesting. These types of agents can break tasks into steps, call external APIs, and maintain context throughout a workflow. This is where real agentic AI lives in the current scenario. For eg, an agent that searches a database, summarizes the findings and updates a website/blog automatically. At this level, we can give Large Language Models (LLMs) more context by connecting them to external knowledge bases, allowing them to retrieve up-to-date, factual information before generating answers, making outputs more accurate, specific, and trustworthy, without needing costly retraining.

Multi-Agent Systems

In a multi agent system, instead of one agent doing everything,multiple agents act simultaneously. Multiple specialized agents work together, review each other's outputs, and improve over time. One agent gathers data while another analyzes it, and a third reviews the results for quality control. This is quite powerful but needs a lot of experiments and sophisticated design principles. For eg. Agents like Droidrun, Browser use etc.

Fully Autonomous AGI

This is the most advanced AI system which is still theoretical. It is believed to set its own goals, adapts across any domain, and operates without human oversight. True AGI would think and plan like a human expert. The technology is not there yet. Most of the AI systems currently are either tool using agents or multi agent systems.

Real-World Applications

Agentic AI is already creeping into our daily lives through:

Smart Homes: Systems that coordinate temperature and security.
Self-Driving Software: Multiple models working together to navigate roads safely.
Virtual Assistants: Scheduling meetings and managing calendars across different apps.

The Era of Mobile AI Agents is Already Here

Priya Negi — Fri, 12 Dec 2025 10:17:21 +0000

Everyone is obsessed with one question- If AI is really that good, can it pick my phone and do stuff automatically.

In my opinion, why not…AI is absolutely capable of it and it’s not a future tech fantasy anymore. It’s happening right now, right in front of us.

AI can already order food for you just by asking.

It can book a ride when you’re running late and still getting ready (that’s me most of the times)

It can handle sales, customer service, billing, customer journeys, and almost anything you want to automate.

This is exactly what Droidrun is doing.

Bottleneck to Breakthrough: Droidrun’s journey

We at Droidrun started working on this project around 7–8 months ago. The technology came a long way- from making the agent do random clicks to making it do everything precisely (even if the app UI changes).

Earlier, the agent struggled with text tasks, unstable UI interpretation, and limited app understanding. We addressed this by creating a dedicated text-manipulation agent that programmatically constructs and replaces text using structured accessibility data. We then strengthened contextual awareness by stabilizing screen-state detection, filtering visual noise, tracking screen changes, and extracting app-specific knowledge for more accurate system understanding.

To make the framework predictable, we added transparent action reporting and expanded the action space with long-press, targeted typing, system buttons, swipe gestures, and app launching. We reinforced memory across the prompt flow and refined the system through extensive testing, turning it into a reliable and capable mobile automation framework.

Earlier, the agent occasionally got things right; now it can decide when to run, when to click, where to click, and what the user is asking for. To enable natural-language execution, we built a complete framework that abstracts core actions like clicking, scrolling, typing, screenshots, and UI understanding. Then, we taught the agent to interpret commands and the mobile environment like a real user.

Repo-https://github.com/droidrun/droidrun

Moving to the cloud — Mobilerun

After testing and refining the framework, now we are taking the next step towards building the cloud. Mobilerun is like having a virtual phone that runs fully in the cloud. It keeps all your sensitive data encrypted and safe, and it allows you to replay, pause, and audit every action. Everything happens with transparency and control.

Why did we keep it open-source?

The tech behind Mobile AI agents is continuously evolving. The primary intent of open-sourcing Droidrun was to turn this AI capability into a public foundation that the entire industry can build on, improve together, and innovate freely.

As a developer, you can treat it as a building block. You can extend it, modify the code, or transform it into something entirely new.

Check out our Github repo here- https://github.com/droidrun/droidrun

How are we ensuring privacy and security

Users can use proxy. It makes it possible to connect to the app from different geographical areas.
Credentials of the users are not sent to LLM. They are saved into the file as key-value pairs and the agent (droidrun) fetches them by using a script. LLM does not see these credentials. So, no leaks will happen.
Users don’t use their real phone. So apps cannot understand the real identity of the user if users won’t use their private emails and nicknames.

What’s Next?

We are continuously working on the cloud, making it more reliable, more stable and more stealth. And this is only the beginning. We would love to see what users can build with our framework and later on the cloud. Start building, experiment, and explore. If you get stuck, reach out to us on Discord.

Moving forward, we will keep building together toward the kind of agent we all imagine. The era of Mobile AI Agents is here, and we want everyone to see it, experience it, and use it for themselves.

Keep Building

We built the first native mobile AI agent and open-sourced it🤯

Priya Negi — Tue, 18 Nov 2025 08:39:29 +0000

Hi Everyone,

We have built Droidrun, the first native mobile AI agent that can automate mobile devices and its completely open-source 😌

New things happening lately:

Product of the day on Product Hunt.
Reached 6k stars on github!

Here is the link to the repo:
https://github.com/droidrun/droidrun
Can you help me with a star? 😁

Check out the use cases and setup tutorial:
https://youtu.be/u9ebQ_wOBnw?si=oCWCRSBNapFFZ-Ny

The future of Mobile Apps in the era of Agentic AI

Priya Negi — Thu, 13 Nov 2025 04:57:18 +0000

Imagine a future where you never have to open an app again, your phone just gets things done.

What Are AI Agents?

AI agents are software systems that use artificial intelligence to pursue goals and complete tasks on behalf of users. They can operate autonomously deciding what to do end-to-end, breaking tasks into steps, and using APIs or apps to get the job done.

These agents don’t just assist; they act. Whether it’s managing emails, booking appointments, or controlling applications, AI agents are designed to take initiative and deliver outcomes without constant human input.

What Is Agentic AI?

Agentic AI, on the other hand, is a broader system or framework that uses AI agents to perform tasks autonomously on behalf of a user or another system. It’s the architecture that supports, manages, and regulates the behavior of multiple AI-powered agents working within a generative AI environment.

Think of Agentic AI as the ecosystem, a layer of intelligence that allows different agents to coordinate, collaborate, and function together effectively.

Types of AI Agents

Types of Agentic architectures:

Agentic architecture refers to the structure and design of agentic artificial intelligence (AI) frameworks. An agentic architecture is one that shapes the virtual space and workflow structure to automate AI models within an agentic AI system. These are different types of agentic architectures:

Single-Agent : task specific assistant
Multi-agent: agent coordinates and collaborate

Agentic AI in mobile application:

Agentic AI in mobile applications marks a major shift in how we interact with technology. We’re no longer in the era where AI simply assists us, we have entered the age where AI acts, an age of smart autonomous agents quietly revolutionizing the world of mobile app development. One such agent is Droidrun, whose framework enables large language models (LLMs) to control Android and iOS devices.

How agentic AI will change the mobile app development landscape:

When agents can perform tasks across multiple apps, the need to manually open apps fades. You might never open your food, cab, or calendar app, your AI agent will coordinate all of them silently in the background by controlling Graphical User Interface or using MCPs.

This will create a wave of headless apps, basically software that runs purely as services for agents, not humans.

Agents also will be able to operate within different apps, without you actually having them on your mobile. Agentic AI turns every app into a building block for automation. Instead of switching apps, you’ll express an intent, and your AI agent will orchestrate the workflow across multiple apps: For example, you say “order the best denim jacket in “M” size under budget $50”. The phone will automatically find the best deals available out of all the shopping apps and show you the final suggestion.

Mobile UX is entering a new era, one where we don’t navigate software, we collaborate with it. Instead of menus and structured workflows, mobile AI apps will include prompt interfaces and personalized data visualizations. AI will forecast what the end-user needs to know based on their current job, and prompt interfaces will simplify both querying for information and providing job updates.

As Agentic AI continues to evolve, the way we think about apps, automation, and user experience will never be the same.