Real Android phones in the cloud.
Describe a task once — it becomes an automation that learns, improves, and repairs itself.
One sentence is enough to start. The AI works the task out on a real device, remembers the path, and every run after that takes seconds — with no scripts to write and nothing to maintain.
“Open the composer, post this image with this caption.”
while you watch
0.0s
same resultone sentence · no scripts · no selectors
A real phone doing a real thing. Nothing is spoofed.
Browser automation has to pretend: fake fingerprints, patched drivers, headless flags to hide. Emulators have to pretend too — and apps notice.
We don't pretend. It's a physical Android device with a real screen, real sensors and a real app installed from the store, doing what a person's thumb would do. There is nothing to detect, because there is nothing being faked.
A phone on a shelf, plugged in, running the same build of Android as the one in your pocket.
You log in yourself, on your own device, exactly as you would by hand. Nothing is shared, nothing is pooled.
A social login lives in the app's storage on one specific device. We keep it there — an automation for that account always runs on that phone, never somewhere else.
Residential bandwidth is included for the work that needs it. Datacenter routing is free and unmetered for everything else. Or connect your own proxy — mobile ones included.
on this one phoneour rack · our network · mains power
your scheduler
runs at 06:00
a person you pay
Half your platforms have an API. The other half have a person with a phone.
One piece of content has to land everywhere. Where there's an API, a scheduler handles it. Where there isn't, someone you're paying opens an app and does it by hand — every post, every reply, every DM.
That doesn't scale, it doesn't run at 6am, and it costs a salary per set of accounts.
Or skip the building entirely.
Common workflows — posting, replying, checking a feed, handling DMs — come ready in the library. Pick one, point it at your account, and run it. They're built and verified by us, and they're included.
Everything in the library is a starting point, not a cage: open any of them, change what you need, and it becomes your own.
Read the notifications inbox
Post an image with a caption
Reply to every new comment
Forward a post to five channels
Publish a thread from a draft
Check a channel for new comments
Answer unread DMs from a script
Share a post to a company page
Pick one from the library
Point it at your account
Put it on a schedule
Describe it → It learns → It just runs
“Open the composer, post this image with this caption.”
plain words · any language
on the real device
0.0s
no AI · not metered · identical
Write what you want in plain words. No selectors, no scripts, no flowchart.
The AI does the task on a real device while you watch, maps the app, and turns the path that worked into a program.
The next run replays that program directly on the device: seconds, not minutes, and the same result every time.
When the app changes, only the broken step costs anything.
Recorded scripts break the day an app ships a redesign. Ours don't stop — they notice that one step no longer fits, bring the AI back for that step alone, and carry on. The rest of the automation keeps running the way it always did.
open app
go to composer
attach image
type caption
tap publish
open app
go to composer
attach image
type caption
tap publish
overnight
for this step only
open app
go to composer
attach image · relearned
type caption
tap publish
Five steps, replayed on the device. No AI in the loop.
An update moves a control. The automation notices — it doesn't blindly carry on.
The AI works out the new path for it, the automation absorbs the change and goes back to running on its own.
We tried doing it with an agent. It didn't hold up.
On paper it's the right idea: describe the task, let the model drive the phone. In practice it came apart on simple work. The agent solved the same task a different way every time — succeeded once, failed twice, took five minutes to do something a person does in twenty seconds. Whatever it remembered between runs barely helped the next one.
And even if it had worked perfectly, the arithmetic didn't. Paying a model to re-decide every tap is fine at five tasks a day and impossible at five hundred.
So we built what we actually needed: the AI does the discovery once, and after that the phone runs on what it learned.
three routes,
three pricesA learned automation, every runone route.
free.
The AI builds it. The phone runs it. Neither does the other's job.
An AI agent solves the same task from scratch every single time. It re-reads the screen, re-decides every tap, and re-discovers the route it already found yesterday. That's why agent-driven automation is slow, unpredictable, and expensive at exactly the moment it starts to matter — when you're running hundreds of tasks a day instead of five.
The old alternative was hand-written scripts: fast and repeatable, but weeks of engineering to build, and a permanent maintenance bill, because the first redesign breaks them.
We took the useful half of each. The AI builds the automation, so there's nothing to write. The finished automation runs without it, so it's fast and identical every time. And when something changes, the AI comes back for that one step — instead of the whole thing collapsing, and instead of billing you for a rebuild.
| Person with a phone | API tools | Browser automation | Real-time AI agents | Never Manual | |
|---|---|---|---|---|---|
| Covers apps without an API | Yes | No | Partly | Yes | Yes |
| Runs on real device | Yes | — | No | Varies | Yes |
| Speed per task | Minutes | Instant | Fast | Slow | Seconds |
| Same result every time | No | Yes | Yes | No | Yes |
| Setup effort | Hiring | Low | Engineering | Low | One sentence |
| Survives app updates | Yes | Yes | No | Yes | Yes |
| Billed per run | Salary | No | No | Yes | No |
their screen
nm.cloud/s/8fk2…
screen only · no account
Take the wheel whenever you want.
Every device streams live to your browser at 30 fps with about 68 ms round trip — measured on the production tunnel, not estimated. Tap, type and swipe with your mouse as if the phone were on your desk.
See an automation run in real time and know exactly where it went, instead of reading a log afterwards.
Some things aren't worth automating. Take the device, do them by hand, hand it back.
Send a contractor one link that opens the device screen. No account, no VPN, nothing to install.
Anyone on your team can build automations.
No engineer required. An operator writes what they want, watches it happen on the phone, and corrects it in a conversation with the agent — “close the popup first,” “don't use the shortcut here, go through the app.” The agent remembers and applies it from then on.
Roles decide who runs automations, who can take a device, and who can only watch. And two people can never fight over the same phone: one person holds it, everyone else sees the screen.
0 9 * * 1-5
or a specific time · or on demand
Set it and forget it.
Run any automation on a schedule — a cron expression, a specific time, or on demand. Every run leaves a report: what it did, what it saw, what it changed. Devices are held only while a run needs them and released automatically.
Fits into the pipeline you already have.
Trigger any automation with a single HTTP call, or schedule it from n8n, Make, Zapier or Notion.
Send the same reference twice and the schedule updates instead of duplicating — so your workflow can retry as often as it likes without creating a mess.
curl -X POST https://nevermanual.cloud/engine/presets/<preset>/run \
-H "X-Api-Key: nmk_..." -H "Content-Type: application/json" \
-d '{"inputs":{"caption":"new drop is live"}}'One price per device. Everything else is included.
Runs are never metered. The allowance covers the AI, and the AI only works while something is new — while it's learning your app, or fixing a step an update broke. Replaying what it already knows costs nothing and is never counted. That's the difference: the nearest comparable real-device plan is $80 a month and bills roughly a cent for every step the agent takes on top of it. Ten thousand steps there is a hundred dollars. Here it's included, and the steps you don't need to take are free.
A physical phone, racked and connected, with everything below included. Includes 10,000 AI executions and 2 GB of residential bandwidth per month. Top either up when you need more, or connect your own proxy.
No card to start. Build the automations you need and watch them run on screen. When the trial ends your account stays, and so does everything you built.
Early-access pricing, limited to the first 50 accounts and locked for as long as you stay subscribed.
Fleet, 10+ devices — talk to us.
The questions we get asked first.
Is this an emulator?
Both exist, and you choose. A virtual device is a cloud Android environment — fine for learning the product and for work where the hardware doesn't matter. A real device is a physical Android phone, racked and connected. Where the app cares what it's running on, you want a real one.
What happens when the free trial ends?
The device stops. Your account, your automations and everything they learned stay exactly where they are. Add a device whenever you want and they pick up where they left off.
Is there a plan fee on top of the device?
No. The price of a device is the whole price. Every feature is included with every device, virtual or real.
What counts against the 10,000 AI executions?
Only work the AI actually does: learning an app for the first time, or working out a new path after an update changed one. Running an automation the AI already knows costs nothing and isn't counted, however often you run it.
What if I run out?
Top up, or wait for the next month — automations that have already been learned keep running either way.
Whose accounts are used?
Yours. You sign in on your device exactly as you would by hand. We don't supply, share or rotate accounts.
What happens when an app updates?
The automation notices that a step no longer fits, the AI works out the new path for that part, and the automation continues on its own from there. You don't rebuild anything.
How long does an automation take to learn?
It depends on the app and the task — some are learned almost immediately, others take a few runs. You watch it happen on screen either way, so you always know where it stands.
Do I need a developer?
No. Automations are written in plain language and refined by talking to the agent. The API exists for teams that want to trigger runs from their own systems.
Can I use the phone manually?
Yes. Take control from the browser at any time and use it like a phone on your desk.
Do I get a proxy?
Yes. Datacenter routing is free and unmetered on every device. Every plan also includes a monthly residential bandwidth allowance for work that needs a residential IP — top it up any time, or connect your own proxy, mobile ones included.
Where are the phones?
On our own racks, on our own network, maintained by us. You rent the device — not a slot on someone else's shared machine.
Stop paying someone to tap a screen.
Real Android phones, automations that write themselves, and a browser tab that shows you exactly what's happening on the device.