Structured process automation
NextDoer deploys a dedicated runner inside your business to actually perform recurring back-office work, not to assist someone else in doing it. Every runner is a structured execution system: a playbook engine, a verification layer, and a team of specialized agents, each responsible for a single step and accountable to machine-checkable criteria. You hire a dedicated agent for each job you want done: a one-time build, then you pay only for the work it puts in, a fraction of a single hire, working around the clock. No seats, no licences, nothing for your team to learn or operate.
How it works
There is no product to install and no dashboard your team has to live in. We map one process, write it down as an executable playbook, and deploy a runner that performs it.
01, Discovery
One session on a single recurring process: what triggers it, which systems it touches, where a judgement call is genuinely required, and what "done correctly" means in your words. We pick high-volume, money-adjacent work first.
02, Playbook
Your process is written as a versioned playbook: trigger, inputs, ordered steps, the tools each step may touch, machine-checkable success criteria, and an exceptions block for the long tail. You sign off on it before anything runs.
03, Runner
A runner is deployed for your business alone, its own container, database, encryption key and credential vault. It executes the playbook, verifies every result against the success criteria, and asks you before anything leaves the building.
The NextDoer app
Every running process, open task, and exception lives in a single window on your phone. The agent does the work and surfaces exactly what needs a decision, you approve, reject, or reply in one tap. Download it on iOS or Android and run everything from there.
Today
NEEDS YOUR DECISION
It's Thursday and Acme hasn't replied. I've drafted an escalation to their AR manager. Send it?
Rather stay where your team already works?
The same agent can also run over Telegram, WhatsApp, or any chat platform, the app just gives it one dedicated screen. Same approvals, same control.
Processes
High-volume, repetitive, money-adjacent back-office work that is too small to hire for and too costly to keep ignoring.
Overdue invoices are classified by notice level, a follow-up is drafted per invoice against your accounting record, and the outcome is written back to your CRM. Disputes are handed to a human immediately.
approve
Claims are assembled from your own records, checked against the payer's requirements before submission, tracked to a decision, and appealed with the reason a rejection actually gave.
approve
Recurring filings and renewals are prepared ahead of their deadline, submitted through the portal that owns them, and confirmed by an observable effect, not by assuming the click worked.
shadow
Requests, scheduling and chase-ups across tenants, contractors and suppliers, in your tone of voice, with every promise made on your behalf recorded against the task that made it.
approve
The same record re-keyed between systems that will never integrate, with an exact-match check against the source of truth before the write and an idempotency key so a retry can never duplicate it.
shadow
Incoming email, forms and calls are classified, routed to the process that owns them, and booked into the right calendar slot. Anything ambiguous is escalated rather than guessed at.
shadow
The chip on each card is the trust mode a process typically starts in. Nothing starts autonomous, a process reaches that rung only after it has earned it.
Built for your business
The work looks different in every industry. Pick yours to see the exact routines NextDoer would take over, in the language of your day, not ours.
14 rental panels across 7 channels, one window. Inquiries, listings, rent reconciliation and maintenance follow-up.
See the rollout →Every portal lead answered from one window, showings booked, follow-ups run, closing documents chased.
See the playbook →Refill intake, supplier follow-up, pickup reminders and insurance threads, one queue, gated by the pharmacist.
See the playbook →Appointment requests, reminders that cut no-shows, recall outreach and intake-form chasing, from one window.
See the playbook →Document collection chased to completion, deadline reminders, reconciliation against your ledger, status updates.
See the playbook →Intake answered and qualified, matter documents chased, invoices followed up, status updates drafted for the lawyer.
See the playbook →Every lead answered, income and ID documents chased to complete, closing deadlines tracked, lenders and clients followed up.
See the playbook →Renewals chased before they lapse, claims status kept current, documents and signatures collected, payments followed up.
See the playbook →The long document list chased to complete, submission and biometrics deadlines tracked, case status kept current for every client.
See the playbook →Every lead answered in seconds, jobs booked and reminded, quotes chased, invoices and deposits followed up, reviews requested.
See the playbook →The email-and-Excel coordination replaced: subcontractors chased, scheduling run, RFIs and submittals tracked, testing and inspection results routed.
See the playbook →The trust ladder
Autonomy is not a switch we flip on day one and hope for. It is a per-process setting with three rungs, and a process only climbs when its own record says it should.
Rung 01
The runner executes the whole process and produces the finished work, but nothing leaves your business. You compare its output against what your team actually did, on your own cases.
Rung 02
The runner prepares the work and holds the task in needs_approval. You approve, edit or reject from your phone. Every edit you make is logged and feeds back into the playbook.
Rung 03
The runner executes without waiting for you, with the verifier still standing in front of every external action and the audit log still recording all of it. The kill switch stays one click away, per process.
Promotion happens only on measured success rates. A playbook has to pass its golden set, real historical cases from your own business, before shadow mode ends, and it moves to autonomous only after a run of real cases at a measured human-correction rate. If the rate regresses, the process is demoted automatically. Individual steps can be pinned behind approval forever, whatever the process mode says.
The playbook
Every process we take on is documented as a playbook, a clear, versioned description of the trigger, the steps, the success criteria, and the exceptions. You read it and sign off on it. It is the same document the runner executes from.
The playbook is written in plain language and shared with you before the first task executes. If the description of a step is not something you would sign off on in words, it does not run.
There is no separate "what the machine actually does" version that only we can read. The playbook you approve is the exact specification the runner follows. Every step is named, every success criterion is stated.
Every edge case that surprises the system, every correction you send us, every new rule becomes a versioned update to the playbook. Changes are approved before they go live, the same way the first version was.
The audit log
The runner keeps an append-only log of every step and every external effect. It is your accountability record, not our internal telemetry, and it is the reason "the agent did something odd" is a question with an answer.
| ts | actor | task · step | state | authorization rule | effect / verification |
|---|---|---|---|---|---|
| 09:00:04 | orchestrator | task_8841 | created → queued | schedules.invoice_followup | — |
| 09:00:11 | executor | task_8841 · classify | running → needs_verification | role.executor · accounting.read | — |
| 09:00:19 | verifier | task_8841 · classify | needs_verification → verified | playbook.success_criteria | every invoice has exactly one classification |
| 09:00:41 | verifier | task_8841 · draft_messages | needs_verification → verified | playbook.success_criteria | amount and invoice number match accounting record |
| 09:00:42 | hitl_gateway | task_8841 · send | verified → needs_approval | step.gate = approval | approval request sent to owner |
| 09:14:02 | human · owner | task_8841 · send | needs_approval → approved | hitl.decision · edit_diff recorded | one sentence edited before approval |
| 09:14:03 | action_executor | task_8841 · send | approved → executing_actions | idempotency_key: tenant_a:invoice_followup:8841:send | adapter.email.send |
| 09:14:07 | action_executor | task_8841 · send | executing_actions → done | playbook.success_criteria · observable effect | message present in Sent folder |
| 09:14:09 | escalation_triager | task_8842 · classify | running → escalated | exception: invoice disputed in any correspondence | routed to owner, task held |
Every column is a real field of the log: the timestamp, the actor, a role or a named human, the task and step, the state transition, the rule that authorized the action, and what was observed afterwards. blocked and escalated are first-class states with an owner, not dead ends.
Security and data residency
The isolation model is structural, not a policy we ask you to trust. Here is the honest version, in the same words we use internally.
Your own container, your own database, your own encryption key. No business-data store is ever shared between customers.
Our control plane sees that a task ran, what it cost and how many actions it took. It never sees an invoice, an email body or a customer's name.
The runner initiates every connection it makes. A runner on your own server needs no inbound firewall holes at all.
Content goes to the model solely for processing, under a zero-retention, no-training agreement, through one gateway with a redaction filter in front of it.
If you want the runner on your own Linux server, it is the identical artifact we run in our cloud, not a stripped-down build with different behaviour.
Secrets are keyed to your business and one service, and handed to a connector by the execution context. They never appear in a playbook, a prompt, a log line or a model context.
Every write to an outside system carries a deterministic idempotency key, so a retry can never duplicate an action and a failure is never silently dropped.
Per business and per process, flippable by you or by us and honoured by the runner within seconds. Spend and send caps pause a process rather than crash it.
Onboarding
That is the target we design against, and it shortens as our connector and playbook libraries grow. The slow part is understanding your process properly, which is also the part worth not rushing.
We pick one process and map it with you end to end. You talk; we write. What comes out is the trigger, the systems involved, the judgement calls, and your definition of a correct outcome.
The process is written as a playbook you can read and sign off on, and we build only the connectors this one process needs. Systems without an API are reached through a browser recipe, at the lowest trust tier.
We build an evaluation set from your own historical cases and run the playbook against it. It has to clear the bar on your real work before it is allowed near anything live.
The runner performs the process in parallel with your team and produces nothing but output you can compare. This is where you decide whether it is actually good at your work.
Approve mode goes live on your phone: approve, edit or reject. Autonomy comes later and only per process, when the correction rate supports it. Every correction you make becomes a new evaluation case.
How we work with you
Most business software sells you a subscription and a dashboard. Whether the work actually gets done is your problem. Our model is different: we get paid because the work was done correctly, not because the billing cycle ended.
We don't go live and disappear. From the first process session through every run that follows, you have someone from our side who knows your setup and is accountable for it working correctly. You are never alone in this.
There is no subscription running whether or not anything happens. Price is agreed per processed case, or as a share of what comes back. If the work was not done correctly, there is nothing to invoice for.
Our monitoring runs continuously across every process, every open task, every external action. You don't need to check anything. If something drifts, we catch it before you see it.
Reply to any report or daily summary, "adjust the tone on the Acme follow-up", "add a hold step before the send", and it becomes a tracked change request immediately. You are notified the moment it goes live.
Pricing
Pricing works like taking on a teammate, not buying software. We build a dedicated agent for each job once, then every month you see how much work it did and pay for that work, nothing more. An agent that had a quiet month costs next to nothing.
Each distinct job, answering customers and booking, reconciling payments, filing requests, is its own agent. A new job later is a new agent, with its own one-time build. The same job across several inboxes or channels is still one agent, not many.
We design, connect and prove each agent once, for a one-time setup fee. After that there is no fixed monthly seat, you pay only for the work your agents actually put in, measured in a single unit we call Nex.
An agent is paid for the work it does, the same way a salaried teammate is, not a cut of results. Whether a task reaches a finish can depend on the customer or an outside system; the agent still does its part, and that work is what Nex measures.
Setup
$500 – $5,000 one-time, per agent
We map the process, connect your systems and prove the agent runs correctly. The fee depends on how involved the job is and how many systems it touches. Each new agent has its own one-time setup.
Monthly
Pay per Nex from 1¢ each, billed after the month
Every agent's work is metered in Nex. The first 20,000 Nex each month are 1¢ each, and as your monthly volume grows the rate steps down band by band, to as little as ½¢. At month-end you get the report and pay for the combined work of your whole team of agents, in one bill. No fixed seat, no minimum, no per-seat licence. Want it cheaper up front? Prepaid Nex packs are available at a discount from your billing panel.
Nex is how we measure the work your agents do, the unit an agent spends to get something handled. The first 20,000 Nex each month cost a cent each, and the rate then steps down band by band as your usage grows, down to around half a cent, so the busier your agents get, the less each unit of work costs you.
A single task, a customer conversation, a payment follow-up, a support reply, usually runs somewhere between 50 and 200 Nex, and it varies with how involved the task is and how many systems it has to reach into. Treat that as a rough guide to set expectations, not a fixed price.
The real figure becomes clear once your agent's flow is built and running: after about a month it settles, and unless you change how the agent works it stays steady. So your monthly bill is predictable, it simply tracks how much work came in.
An example. Say an agent handles around 300 tasks in a month at roughly 80 Nex each, about 24,000 Nex. With the first 20,000 at 1¢ and the rest already into the next band, that comes to close to $235 for the month, and less once higher volume brings the rate down further. An illustration only, not a quoted price, your real usage is whatever work actually comes through.
Compare it to hiring. A part-time coordinator runs well past $1,500 a month; a full one, $3,500 and up, whether the phone rings or not. An agent is a one-time build plus the work it puts in, typically a fraction of that, working 24/7 with a full audit trail and no subscription running when nothing is happening.
Book a process review
One hour on one recurring process. You get back a scoped playbook draft, the trigger, the steps, the success criteria, and what it would take to run it in shadow mode against your own cases. We reply with that draft, not a sales sequence.
Canada first. Four questions, no demo required.
Process review
One hour on one recurring process. Four questions, the answers are enough for us to draft the playbook before we ever meet.
It is on the founder's desk, not in a queue. Here is exactly what happens next.
