Skip to content
Automated decisioning platform

Risk policy your team can change — without waiting on engineering.

Build your credit, fraud, and onboarding logic as a visual flow, run it in milliseconds, and keep an auditable trace behind every approval, referral, and decline. No deploy, no engineering ticket.

Already have decision flows elsewhere? Migrate them in minutes.

Built for credit unions, lenders, and fintech risk teams
Credit underwriting
Fraud & KYC screening
Affordability & limits
Onboarding decisions
The problem

Risk logic shouldn’t live in a spreadsheet — or a codebase only two people understand.

Buried in code

Rules live in a service only two engineers understand. Every change is a ticket and a deploy.

Impossible to trace

When a regulator or a customer asks why, no one can reconstruct the exact decision.

Scary to change

You can’t tell what a policy tweak does until it’s already live and affecting real applicants.

The platform

One canvas from first rule to live traffic.

Everything a decision needs lives in the same place — the logic, the data it reads, the model that scores it, and the trace it leaves behind.

Visual builder

Draw the decision, don’t bury it in code.

Compose rules, decision tables, splits, and sandboxed Python into one auto-laid-out graph. Every branch is explicit and reviewable.

Decision states

A verdict, not a black box.

Every call resolves to a state your team already speaks.

Approvepass200
Refermanual→
Declinefail422
Decision tables

Change policy without a deploy.

Edit conditions and results in a grid your analysts already use — no engineer in the loop.

AI agents

Add judgment where rules fall short.

Drop an LLM agent into a flow for document review, adjudication, or triage.

Test & traffic

Roll out without holding your breath.

Replay a version against real cases, then route a slice of live traffic before you commit.

Case management

Hand the work to a person, not the decision.

Open a case mid-flow and keep going. Queues, tasks, and actions run on a blueprint you version.

Audit trail

Prove every decision to a regulator.

Each call stores the exact path it took and the value every node produced — reproduced byte-for-byte for audits, disputes, and adverse-action notices.

Data & connections

Bring your own data, or use ours.

Connect to your own database, or model entities and events right here. Either way, flows pull live data mid-decision — no batch jobs, no stale copies.

Migration

Switching platforms? Bring everything with you.

Import your existing flows, versions, and subflows in minutes — then keep building where you left off.

Built with ArboRule

One flow, every lending product.

This is the product canvas, not a diagram made for the landing page. Watch one application route through rules, a decision table, an AI agent, and human review before it returns a single decision.

Requestapplication.received
Active routewaiting for input
Outcomeready
Personal loanAuto loanMortgageCredit card
Underwriter decision/Initial15 nodes · 4 branches
AI agents

Create agents for the judgment rules can’t express.

Give an agent a focused role, the tools it may use, and the exact fields it must return. Publish it as a versioned building block, then place it in any decision flow like another node.

Standing brief

Define the task, hard rules, and examples in a reusable system prompt.

Controlled reach

Add calculators, files, web access, published flows, or other agents as tools.

Bounded result

Require a structured output schema the next node can use immediately.

Agent run / sandbox

Verified credit income

Initial·gpt-5.4-nano·Agent Tool

Successful
Iterations
3
Tokens in / out
22,082 / 1,122
Cost
$0.0388
Duration
12.6s
Execution ribbonSegment width follows step latency
12,498 ms traced
01Model requested calculator7,023 tok · 2,275 ms
02Tool result · calculator0 ms
03Model response7,949 tok · 7,069 ms
04Output failed schema validationretry
05Model response8,232 tok · 3,154 ms
06Finished · successfulfinal
Structured output
verified_income3708.64
confidenceHIGH_CONFIDENCE
Case management

Some decisions don’t end in milliseconds.

A flow can open a case mid-decision and carry on returning its answer — nothing waits on a person. 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.

KYB reviewv3 · publishedcase #482 · KYB queue · live

Complete 1 required task to unlock actions.

Tasks

Verify documentsverdict · textRequired
Confirm beneficial ownersconfirmed · booleanComplete

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.verify.form.verdict.data
The reviewer’s own answer, grouped by the status they gave it at, ready for the next flow to read.
A look inside

The whole decision, in plain sight.

Follow every call through the exact version that served it, with outcomes and latency on one timeline.

Decision history in ArboRule, showing successful and failed calls on a chronological execution spine.
Decision historyTrace outcomes, versions, and latency together.
How it works

From draft to production without leaving the tool.

01

Model

Lay out the flow — rules, tables, splits, and Python — on an auto-arranged canvas.

02

Simulate

Replay it against saved datasets and testcases until every case lands where it should.

03

Publish

Cut a version, request review, and route a slice of live traffic to it.

04

Monitor

Watch decision history and performance, and replay any single call end to end.

For developers

Call it like any other endpoint.

Send an asynchronous decision. If it needs a person, the API returns a pending decision and review case immediately, then resumes the same execution when review is complete.

POST{{baseUrl}}/run/api/v1/flows/{{flowSlug}}/sandbox/decide
  # header  X-Api-Key: sk_…
{
  "data": {
    "first_name": "Ada",
    "last_name": "Lovelace"
  },
  "metadata": {
    "grouping_id": "user-123456"
  },
  "control": {
    "async": true
  }
}
  1. 01
    Request acceptedPending returns immediately
  2. 02
    Human reviewThe case carries the waiting task
  3. 03
    Decision resumesExecution continues from the same node
200 OK · responseManual review
{
  "data": {},
  "status": "pending",
  "metadata": {
    "environment": "sandbox",
    "flow_slug": "webhook",
    "version": "v1.3",
    "grouping_id": "user-123456",
    "timestamp": "2026-07-25T02:11:07Z",
    "decision_id": "fcb3b695-…",
    "decision_url":
      "{{baseUrl}}/versions/:versionId/history/:decisionId",
    "waiting_for": {
      "type": "manual_review",
      "node": "Manual Review",
      "case_id": 6,
      "case_url":
        "{{baseUrl}}/flows/:flowId/review-queue/6"
    }
  }
}
For other teams

Automating something that isn’t a risk decision?

The same engine runs ordinary operational automations — lead routing, invoice reminders, support triage, order sync. Same canvas, same versions, same trace behind every run, priced for that job and free to start.

See ArboRule Engine
Start with one decision

Bring one real decision. Leave with an endpoint you can explain.

Model the policy, replay it against real cases, and publish only when every outcome has a trace.

VersionedTestableReview-ready