Physical Phone Farm — Best Software for Stealth Automation?

• TikTok/Reels/Shorts compatible
• Minimal detection risk
• Centralized control (20+ devices)

xishuaionline said:

I’m running a different approach, mainly because I don’t want any software-level automation footprint on the target devices.
Instead of installing automation tools (Xiowei, GenFarmer, or other agent-based apps), I keep all phones 100% stock — no extra packages, no accessibility services, no resident automation software, and no modified ROMs.
The core idea is to move automation completely outside the phone.
A separate control system handles logic and scheduling
Cameras visually observe each phone’s screen (similar to human eyesight)
Robotic actuators physically tap, swipe, and interact with the devices
From the device and app perspective, it’s just real hardware with real touch input.
On top of basic computer vision, I’m experimenting with using an LLM (e.g. ChatGPT or similar) at the reasoning layer. The camera feed is combined with the LLM to better interpret what’s on the screen, understand UI context, and make more appropriate action decisions, rather than relying purely on fixed rules or templates.
The controlled phones can be any model — Android or iOS — with different OS versions and screen sizes. Since everything is driven by visual recognition and physical interaction, the same control logic works across all devices without writing separate automation scripts for each model or OS version.
Only the master device needs to be rooted or jailbroken. It acts as the “brain,” where all automation logic, decision-making, and learning live.
The master device observes the screens via cameras, decides what action to take, and sends commands to robotic actuators — very similar to how a human brain sends instructions to the hand to operate a touchscreen.
Because nothing runs on the controlled phones themselves, there’s no need to maintain different software stacks for Android vs iOS, or worry about OS updates breaking automation logic.
Just sharing my current thinking — happy to hear how others are approaching this.

View attachment 494481

Click to expand...

xishuaionline said:

I’m running a different approach, mainly because I don’t want any software-level automation footprint on the target devices.
Instead of installing automation tools (Xiowei, GenFarmer, or other agent-based apps), I keep all phones 100% stock — no extra packages, no accessibility services, no resident automation software, and no modified ROMs.
The core idea is to move automation completely outside the phone.
A separate control system handles logic and scheduling
Cameras visually observe each phone’s screen (similar to human eyesight)
Robotic actuators physically tap, swipe, and interact with the devices
From the device and app perspective, it’s just real hardware with real touch input.
On top of basic computer vision, I’m experimenting with using an LLM (e.g. ChatGPT or similar) at the reasoning layer. The camera feed is combined with the LLM to better interpret what’s on the screen, understand UI context, and make more appropriate action decisions, rather than relying purely on fixed rules or templates.
The controlled phones can be any model — Android or iOS — with different OS versions and screen sizes. Since everything is driven by visual recognition and physical interaction, the same control logic works across all devices without writing separate automation scripts for each model or OS version.
Only the master device needs to be rooted or jailbroken. It acts as the “brain,” where all automation logic, decision-making, and learning live.
The master device observes the screens via cameras, decides what action to take, and sends commands to robotic actuators — very similar to how a human brain sends instructions to the hand to operate a touchscreen.
Because nothing runs on the controlled phones themselves, there’s no need to maintain different software stacks for Android vs iOS, or worry about OS updates breaking automation logic.
Just sharing my current thinking — happy to hear how others are approaching this.

View attachment 494481

Click to expand...

• What's your latency like between screen observation → decision → physical tap?
• Are you using off-the-shelf robotic arms or a custom rig?
• At what scale are you running this currently?

saphiron said:

This is genuinely impressive — and probably the cleanest approach I've seen for avoiding detection.

Moving automation entirely outside the device is smart. No packages, no accessibility abuse, no fingerprint. From TikTok's perspective, it's just a human tapping a screen.

The LLM + camera vision layer is interesting too. I assume it handles edge cases better than hard-coded rules (pop-ups, UI changes, etc.)?

Quick questions:

• What's your latency like between screen observation → decision → physical tap?
• Are you using off-the-shelf robotic arms or a custom rig?
• At what scale are you running this currently?

I went the ADB route for simplicity, but your method is definitely more future-proof. Would love to see how this evolves.

Thanks for sharing!

Click to expand...

xishuaionline said:

I’m running a different approach, mainly because I don’t want any software-level automation footprint on the target devices.
Instead of installing automation tools (Xiowei, GenFarmer, or other agent-based apps), I keep all phones 100% stock — no extra packages, no accessibility services, no resident automation software, and no modified ROMs.
The core idea is to move automation completely outside the phone.
A separate control system handles logic and scheduling
Cameras visually observe each phone’s screen (similar to human eyesight)
Robotic actuators physically tap, swipe, and interact with the devices
From the device and app perspective, it’s just real hardware with real touch input.
On top of basic computer vision, I’m experimenting with using an LLM (e.g. ChatGPT or similar) at the reasoning layer. The camera feed is combined with the LLM to better interpret what’s on the screen, understand UI context, and make more appropriate action decisions, rather than relying purely on fixed rules or templates.
The controlled phones can be any model — Android or iOS — with different OS versions and screen sizes. Since everything is driven by visual recognition and physical interaction, the same control logic works across all devices without writing separate automation scripts for each model or OS version.
Only the master device needs to be rooted or jailbroken. It acts as the “brain,” where all automation logic, decision-making, and learning live.
The master device observes the screens via cameras, decides what action to take, and sends commands to robotic actuators — very similar to how a human brain sends instructions to the hand to operate a touchscreen.
Because nothing runs on the controlled phones themselves, there’s no need to maintain different software stacks for Android vs iOS, or worry about OS updates breaking automation logic.
Just sharing my current thinking — happy to hear how others are approaching this.

View attachment 494481

Click to expand...

xishuaionline said:

I’m running a different approach, mainly because I don’t want any software-level automation footprint on the target devices.
Instead of installing automation tools (Xiowei, GenFarmer, or other agent-based apps), I keep all phones 100% stock — no extra packages, no accessibility services, no resident automation software, and no modified ROMs.
The core idea is to move automation completely outside the phone.
A separate control system handles logic and scheduling
Cameras visually observe each phone’s screen (similar to human eyesight)
Robotic actuators physically tap, swipe, and interact with the devices
From the device and app perspective, it’s just real hardware with real touch input.
On top of basic computer vision, I’m experimenting with using an LLM (e.g. ChatGPT or similar) at the reasoning layer. The camera feed is combined with the LLM to better interpret what’s on the screen, understand UI context, and make more appropriate action decisions, rather than relying purely on fixed rules or templates.
The controlled phones can be any model — Android or iOS — with different OS versions and screen sizes. Since everything is driven by visual recognition and physical interaction, the same control logic works across all devices without writing separate automation scripts for each model or OS version.
Only the master device needs to be rooted or jailbroken. It acts as the “brain,” where all automation logic, decision-making, and learning live.
The master device observes the screens via cameras, decides what action to take, and sends commands to robotic actuators — very similar to how a human brain sends instructions to the hand to operate a touchscreen.
Because nothing runs on the controlled phones themselves, there’s no need to maintain different software stacks for Android vs iOS, or worry about OS updates breaking automation logic.
Just sharing my current thinking — happy to hear how others are approaching this.

View attachment 494481

Click to expand...

xishuaionline said:

I’m running a different approach, mainly because I don’t want any software-level automation footprint on the target devices.
Instead of installing automation tools (Xiowei, GenFarmer, or other agent-based apps), I keep all phones 100% stock — no extra packages, no accessibility services, no resident automation software, and no modified ROMs.
The core idea is to move automation completely outside the phone.
A separate control system handles logic and scheduling
Cameras visually observe each phone’s screen (similar to human eyesight)
Robotic actuators physically tap, swipe, and interact with the devices
From the device and app perspective, it’s just real hardware with real touch input.
On top of basic computer vision, I’m experimenting with using an LLM (e.g. ChatGPT or similar) at the reasoning layer. The camera feed is combined with the LLM to better interpret what’s on the screen, understand UI context, and make more appropriate action decisions, rather than relying purely on fixed rules or templates.
The controlled phones can be any model — Android or iOS — with different OS versions and screen sizes. Since everything is driven by visual recognition and physical interaction, the same control logic works across all devices without writing separate automation scripts for each model or OS version.
Only the master device needs to be rooted or jailbroken. It acts as the “brain,” where all automation logic, decision-making, and learning live.
The master device observes the screens via cameras, decides what action to take, and sends commands to robotic actuators — very similar to how a human brain sends instructions to the hand to operate a touchscreen.
Because nothing runs on the controlled phones themselves, there’s no need to maintain different software stacks for Android vs iOS, or worry about OS updates breaking automation logic.
Just sharing my current thinking — happy to hear how others are approaching this.

View attachment 494481

Click to expand...

xishuaionline said:

I’m running a different approach, mainly because I don’t want any software-level automation footprint on the target devices.
Instead of installing automation tools (Xiowei, GenFarmer, or other agent-based apps), I keep all phones 100% stock — no extra packages, no accessibility services, no resident automation software, and no modified ROMs.
The core idea is to move automation completely outside the phone.
A separate control system handles logic and scheduling
Cameras visually observe each phone’s screen (similar to human eyesight)
Robotic actuators physically tap, swipe, and interact with the devices
From the device and app perspective, it’s just real hardware with real touch input.
On top of basic computer vision, I’m experimenting with using an LLM (e.g. ChatGPT or similar) at the reasoning layer. The camera feed is combined with the LLM to better interpret what’s on the screen, understand UI context, and make more appropriate action decisions, rather than relying purely on fixed rules or templates.
The controlled phones can be any model — Android or iOS — with different OS versions and screen sizes. Since everything is driven by visual recognition and physical interaction, the same control logic works across all devices without writing separate automation scripts for each model or OS version.
Only the master device needs to be rooted or jailbroken. It acts as the “brain,” where all automation logic, decision-making, and learning live.
The master device observes the screens via cameras, decides what action to take, and sends commands to robotic actuators — very similar to how a human brain sends instructions to the hand to operate a touchscreen.
Because nothing runs on the controlled phones themselves, there’s no need to maintain different software stacks for Android vs iOS, or worry about OS updates breaking automation logic.
Just sharing my current thinking — happy to hear how others are approaching this.

View attachment 494481

Click to expand...

FatBlackCat said:

I'm sorry but i really want to bunp this thread. Where are you guys now with this?

Click to expand...

NomixGuy said:

up to 24 accs per iPhone

Click to expand...

NomixGuy said:

iPhones 12, decentralized automation with clickers, ig clones built from own Apple Developer account. That’s our current recipe to register & run automatically up to 24 accs per iPhone

Click to expand...

iFreelancer said:

You haven't faced any issue so far? (hope not)

Click to expand...

FatBlackCat said:

Are there any tools to automate 20 iphones? or how does it work?

Click to expand...

xishuaionline said:

I’m running a different approach, mainly because I don’t want any software-level automation footprint on the target devices.
Instead of installing automation tools (Xiowei, GenFarmer, or other agent-based apps), I keep all phones 100% stock — no extra packages, no accessibility services, no resident automation software, and no modified ROMs.
The core idea is to move automation completely outside the phone.
A separate control system handles logic and scheduling
Cameras visually observe each phone’s screen (similar to human eyesight)
Robotic actuators physically tap, swipe, and interact with the devices
From the device and app perspective, it’s just real hardware with real touch input.
On top of basic computer vision, I’m experimenting with using an LLM (e.g. ChatGPT or similar) at the reasoning layer. The camera feed is combined with the LLM to better interpret what’s on the screen, understand UI context, and make more appropriate action decisions, rather than relying purely on fixed rules or templates.
The controlled phones can be any model — Android or iOS — with different OS versions and screen sizes. Since everything is driven by visual recognition and physical interaction, the same control logic works across all devices without writing separate automation scripts for each model or OS version.
Only the master device needs to be rooted or jailbroken. It acts as the “brain,” where all automation logic, decision-making, and learning live.
The master device observes the screens via cameras, decides what action to take, and sends commands to robotic actuators — very similar to how a human brain sends instructions to the hand to operate a touchscreen.
Because nothing runs on the controlled phones themselves, there’s no need to maintain different software stacks for Android vs iOS, or worry about OS updates breaking automation logic.
Just sharing my current thinking — happy to hear how others are approaching this.

View attachment 494481

Click to expand...