Connect your apps.Add real logic.Keep the receipt.
Build the automations your business runs on — across your apps, your database and your own APIs — with branching, tables, Python, AI and a person in the loop where you need one. Test every version before it ships. Open any run months later.
Write what you want decided in a sentence and an agent builds it on the same canvas you would have used. It asks when a choice is genuinely yours to make, it tests what it wrote, and it leaves you a draft — never a live version.
Say what you want decided, what it may look at, and the rules that matter. Attach a real payload if you have one — a JSON body, a spreadsheet, a screenshot of the form — and the agent reads that too.
Stop 01 of 06, Describe the decision. The walkthrough highlights Send.
✦Build with AIDecision flow workshop
✦What decision should this flow make?
Give the agent the outcome, the information it can use, and any rules that matter.
When a support ticket arrives, summarise it, tag the area, and open a case for the urgent ones.
Connect ChatGPT, Claude, Cursor, or any MCP client.
Give an agent one remote server and the permissions you choose. It can call published flows, read the workspace context, and build and test drafts without being allowed to publish or touch live traffic.
A step is not only "call this app". It can be a branch, a table your operations team edits, a query against your own database, a model, or a person.
Starts with
An HTTP call
POST to the flow's own endpoint and read the result in the response.
An inbound webhook
Give a service a URL. The Inbound Webhook node receives the payload and starts the run.
A schedule
A job reads rows from a database, S3 or an uploaded file and runs the flow over each one, on the schedule you set.
Then any of these
Rule
Branch on conditions, written as conditions.
Decision Table
A grid of cases and results anyone on the team can edit.
Code
Sandboxed Python for the part that is genuinely code.
Loop
Run a child flow once per item in a list.
Connection
Call a packaged provider, or any HTTPS or JSON API you have credentials for.
PostgreSQL
Read and write your own database mid-run — Postgres, MySQL, Snowflake, BigQuery, Redshift or MongoDB.
AI and Agent
An LLM step with a required output shape, or an agent with tools and a standing brief.
Create Case
Hand a run to a person without stopping it, and pick it back up when they answer.
A Custom Connection speaks any HTTPS or JSON API you have credentials for, so the list below is a convenience and never the ceiling. Fifty-five providers are packaged with their operations already described, and six databases connect directly.
SlackHubSpotSendGridTwilioTelegramOpenAIAnthropicPlaidGoogle MapsTavilyExperianMiddeskSocureSumsubSee the packaged ones →
AI steps and agents
Put a model in the middle, and still know what it did.
An AI step reads free text — a ticket, an email, a PDF — and returns the exact fields you asked for, so the next step can branch on them. An agent goes further: a standing brief, a set of tools it may use, and a required output shape.
Standing brief
Define the task, the hard rules and the examples once, in a reusable prompt.
Controlled reach
Give it a calculator, web access, your files, a published flow, or another agent.
Bounded result
Require a structured output schema. A response that does not match is retried, not passed on.
Every iteration, every tool call and every retry is recorded with its tokens, its latency and its cost — so an agent is a step you can audit rather than a black box you hope about.
Some steps need a person. That is not the same as stopping.
A flow can open a case mid-run and carry on to its last step — nothing waits. The case takes the human work from there, under a blueprint your team versions and publishes, and it stays pinned to the version it was opened under for its whole life.
Refund review/v3 · publishedcase #482 · Billing queue · live
Complete 1 required task to unlock actions.
Tasks
Check the order and the chargeverdict · textRequired
✓Note what the customer was toldcontext · textComplete
Actions
→EscalateMoves the case to escalatedLocked
→Close caseMoves the case to closedLocked
Flow handoff
data.case
Where every preparation and action flow receives the case it is working on.
data.case.tasks.open.check.form.verdict.data
The reviewer’s own answer, grouped by the status they gave it at, ready for the next flow to read.
When something breaks
An endpoint that goes dark should not cost you the run.
A timeout, a 429, or any 5xx from the service you are calling is retried on a widening gap that spans a little over 24 hours. That is long enough to survive a maintenance window without hammering a service that is already struggling.
When the last attempt fails, your workspace admins get an email naming the endpoint, the event and the response code — once per endpoint per day, so a dead URL on a busy flow does not turn into a thousand messages.
Retries are free. A run that took six attempts to deliver is still one run.
01immediately
025 seconds later
0330 seconds later
045 minutes later
051 hour later
0623 hours later
✕Still failing — your admins are emailed
Why it stays working
Your automations are software. Ship them like software.
Most automation tools give you one live copy that everyone edits. That is fine until the automation matters — and then a Tuesday afternoon change is the reason Friday's orders never reached the warehouse.
Test it before anyone depends on it
Run the automation in Sandbox against payloads you keep, and read what every step produced before a version goes anywhere near live traffic.
Publish a version, not an edit
Live traffic runs a published version. Editing the draft changes nothing that is running, so a half-finished change cannot leak into production.
Move traffic a slice at a time
Send a percentage of runs to the new version and the rest to the old one, or mirror live traffic onto a candidate in shadow mode and compare before you switch.
Open any run, months later
Every run keeps the version that served it, the path it took, and the value each step produced. Open run #8,412 from March and see exactly what happened.
Run history, in the appEvery run on one time spine, with its outcome, its version and its latency.
Your credentials
You are about to hand us keys. Here is what happens to them.
Credentials are encrypted at rest
Connection settings — API keys, database passwords, webhook secrets — are encrypted in the database with keys held outside it. They are decrypted to make the call your flow asked for and for nothing else.
Your API keys are never stored
A new key is shown to you once. What the database keeps is a SHA-256 digest and the first eleven characters, which is enough to name the key in a log and not enough to use it.
Sandbox and Live are separate
A draft cannot touch live traffic, and live traffic only ever runs a published version. Testing an automation and running it are two different environments, not two intentions.
Single sign-on and directory sync
Bring your identity provider and let it own who has access. Available with granular workspace permissions on the decisioning plans.
Pricing
One run is one run, whether it has three steps or thirty.
Tools that bill per step, per task or per operation make you pay for how you built the automation. A run here is one execution of a published version, start to finish. Splitting a step in two does not change your bill.
trigger7 steps2 branchesoutbound webhook
1 run counted
Take that automation, run 2,000 times in a month.
Billed by run
2,000 billable units
Every step, branch and retry included. That is the Pro plan, US$ 49.
Billed by step, task or operation
14,000 billable units
Same automation, same result. Add a step and the number moves again.
Split a step in two here and nothing changes. That is the whole difference, and it is why the plans below are quoted in runs.
FREE
US$ 0forever
150 runs / month
Unlimited testing in Sandbox on top of the allowance. No card to start.
Every step type and every provider
Versions and run history
Community support
STARTER
US$ 19per month
1,000 runs / month
For the first automations a team actually depends on.
Everything in Free
Scheduled jobs and outbound webhooks
Email support
PROMOST CHOSEN
US$ 49per month
4,000 runs / month
For a workspace running its operations on these.
Everything in Starter
Traffic split and shadow mode
12 months of run history
SCALE
US$ 149per month
15,000 runs / month
For automations carrying real volume across several teams.
Everything in Pro
Priority support
Onboarding with our team
Above your allowance, runs keep going at US$ 10 per 1,000 runs — nothing pauses, nothing queues, and no automation stops mid-month.
Bring one automation. The one that keeps breaking.
There is no importer for another vendor's file format, and we are not going to pretend otherwise — you rebuild the automation here. That takes an afternoon for most of them, and it is the only honest way to end up with something you can test and version.
If you already have ArboRule flows somewhere, those import directly, versions and subflows included.
Start with the noisy one. Rebuild the automation you already get pinged about, and watch its run tape for a week.
Run both for a while. Nothing forces a cutover date. Point a copy of the traffic here and compare the runs.
Move the rest when you want to. Your allowance covers runs, not automations, so a half-migrated workspace costs nothing extra.
Before you start
The questions we get asked first.
What counts as one run?
One run is one execution of a published flow version, from the trigger to the last step. A flow with three steps and a flow with thirty each count as one run, a branch that is not taken costs nothing, and a delivery that needed six retries is still one run. Sandbox runs and live runs draw from the same monthly allowance, so there is one number to watch. This is why an allowance quoted in runs is not comparable to one quoted in steps, tasks or operations: a seven-step automation is one unit here and seven there.
Do I pay per user?
No. ArboRule is priced on runs, not seats. Everyone who touches the automation — whoever built it, whoever operates it, whoever gets paged when it fails — works in the same workspace without changing what you pay.
What can start an automation?
Three things. An HTTP call to the flow's own endpoint, which returns the result in the response. An Inbound Webhook node, which gives you a URL to hand to another service. Or a scheduled job, which reads rows from a database, an S3 bucket or an uploaded file and runs the flow over each one on the schedule you set.
What happens when a step calls a service that is down?
Outbound deliveries are retried six times on a widening gap — immediately, then after 5 seconds, 30 seconds, 5 minutes, 1 hour and 23 hours — which spans a little over a day in total. If the last attempt still fails, your workspace admins are emailed with the endpoint, the event and the response code, throttled to one message per endpoint per day.
Can I connect to a tool that is not on your list?
Yes. There are 55 packaged providers, and a Custom Connection speaks any HTTPS or JSON API you have credentials for. Six databases connect directly: Postgres, MySQL, Snowflake, BigQuery, Redshift and MongoDB.
Can I test an automation before it goes live?
Yes, and that is the point of the product. Build and run it in Sandbox as many times as you like, read what every step produced, then publish a version when it is right. Live traffic only ever runs a published version, so editing a draft cannot change what is already running.
How is this different from the automation tool I already use?
Most of the category gives you one live copy of an automation that everyone edits, a linear list of steps, and a run log that answers whether it succeeded. ArboRule gives you a branching canvas, versions you publish, a sandbox you test in, traffic you can move a slice at a time, and a stored trace for every run showing the exact path and the value each step produced. If your automations are small and rarely change, that machinery is overhead you do not need.
Can an automation include a step a person has to do?
Yes, in two shapes. A Create Case node opens a case in a queue and the run carries on to its last step, so nothing waits on a person. A Manual Review node pauses the run instead and resumes it from the same node once the reviewer answers. Both record what the person did on the same trace as the rest of the run.
Start with one
Rebuild one automation. Watch its runs for a week.
Create a workspace, wire up the automation you already worry about, and let the run tape tell you whether it is behaving.
