1
Describe the policy
Write the rule the way you'd explain it to a colleague. SmartDecision's local LLM converts it into a structured decision table with inputs, outputs, and rules you can inspect and edit by hand.
Business rules as decision tables.
Written in plain English, resolved over an API.
SmartDecision converts written policies into structured decision tables you can edit, test, and call from any application. It runs on your own hardware as a single binary, with a local LLM. Nothing leaves your network.
Early access is rolling out in small batches. No spam, one email when it's your turn.
- Self-hosted
- Single binary
- Local LLM
- No third-party APIs
01 · Policy
“A loan is approved if credit score is 700 or higher, age is between 21 and 65, and income is at least €10,000. Scores from 650 to 699 go to manual review.”
02 · Decision table
| credit_score | age | income | decision |
|---|---|---|---|
| >= 700 | 21...65 | >= 10000 | approved |
| 650...699 | 21...65 | >= 10000 | review |
| * | * | * | rejected |
03 · Resolve API
POST /api/resolve/214
credit_score = 712
age = 34
income = 18000{ "decision": "approved" }01 · The problem
Business logic becomes chaos faster than you think
Every growing application accumulates hundreds of hidden decisions: pricing rules, eligibility checks, fraud
thresholds, approval workflows. They start as simple if statements and end as deeply nested
logic nobody wants to touch: hard to test, risky to change, impossible for non-engineers to read.
SmartDecision pulls those decisions out of the codebase and into decision tables: a format business teams can read, engineers can test, and applications can call.
02 · How it works
2
Test every scenario
Pin expected outcomes as decision tests. Run them against the table before anything ships, so a rule change never silently breaks an edge case.
3
Resolve over the API
Applications send inputs to one REST endpoint, authenticated with an API key, and get the evaluated result back in milliseconds. Evaluation is deterministic rule-matching; the LLM only drafts tables, it never sits in the request path.
03 · Under the hood
Plain infrastructure, on purpose
- Deployment
- One self-contained binary with the web console embedded. Docker image available. No cluster, no sidecar services.
- Storage
- SQLite. Your rules are rows in a file you own and can back up with
cp. - Rule generation
- Local LLM. No third-party AI APIs, no per-token bills, no prompts leaving your machine.
- Rule evaluation
- A deterministic comparator engine: equality, ranges, wildcards, numbers, strings, booleans, dates. Same inputs, same answer, every time.
- Integration
- REST.
POST /api/resolve/:idwith an API key. Works from any language that can make an HTTP request. - Accountability
- Built-in audit log of changes, plus decision tests that document expected behavior next to the rules.
04 · Where it fits
Anywhere policy changes faster than code ships
Pricing logic
Discounts, promotions, regional pricing, tier thresholds. Adjusted by the people who own the policy.
Eligibility checks
Who can access a feature, upgrade a plan, or apply for a service. Defined once, resolved everywhere.
Fraud & risk rules
Thresholds and transaction policies evaluated locally, without exposing sensitive data to anyone.
Feature rollouts
Gate features by user attributes, regions, or experiments without redeploying the application.
05 · Data boundary
Air-gapped by design
Everything runs inside your infrastructure: the rule engine, the web console, and the LLM. Credit scores, transaction amounts, eligibility inputs: none of it ever crosses your network boundary, at authoring time or at resolution time. If your compliance team's first question is “where does the data go?”, the answer is nowhere.
Get early access
SmartDecision is rolling out to a small group of early users. Leave your email and we'll reserve your spot.
Early access is rolling out in small batches. No spam, one email when it's your turn.