Production smoke checks passing
Route, API, and decision contract checks run continuously before release.
View statusDecision API for support systems and agents
Deterministic decisions for support operations.
Run refund, cancellation, return, and trial decisions through one runtime, with MCP notaries, request-linked audit evidence, and production trust controls.
Model: Decision API runtime + policy rulebooks + trust layer.
Primary wedge: policy operations for B2C SaaS support queues, marketplaces, and commerce operations.
Last confirmed policy change
See policy alerts
Vendor coverage
See all 100 vendors →
Decision API runtime
Policy wedge: 100 vendors
request_id audit trail
Proof from live operations
Every claim below links to a live endpoint or public check.
Policy updates tracked daily
Semantic policy changes are tracked in a public alert feed with run-by-run history.
View policy alertsRequest-linked audit trail
Decision IDs, replay paths, and evidence fields are documented for QA and disputes.
View API docsQueue impact modeled before rollout
Escalation, handle-time, and reopen-rate planning ranges are published up front.
Open proofDeploy without rip-and-replace. Works with Zendesk, Intercom, Salesforce Service Cloud, and internal workflows.
See integration pathSee the workflow in 20 seconds
Use this quick walkthrough structure to show exactly how policy intake becomes deterministic action + evidence.
This is the same path a first-time buyer follows before checkout handoff.
What this walkthrough proves
In 20 seconds, the viewer sees intake-to-evidence-to-commercial handoff without narration.
- 0s-4s Enter through the pain-first hero Open live demo is clicked from the primary CTA row on Overview.
- 4s-10s Run a real policy request Preset and mode are selected, then Run request executes a deterministic refund check.
- 10s-15s Show output and linked evidence Latest response, request-linked fields, and audit trail/CSV view confirm traceability.
- 15s-20s Close on sprint intake handoff Sprint intake opens, form is completed, and Continue to payment unlocks for the buyer path.
Policy is the first production wedge
decide.fyi is the Decision API. Policy operations are where it proves itself first, with one scoped queue, one shared KPI table, and one audit-ready rollout path.
Why policy first
Decision API first. Policy proof first.
decide routes deterministic decisions across systems and agents. Support policy is the flagship wedge because it has clear owners, repeatable queue volume, and audit-heavy outcomes. The scorecard below shows how the first production wedge is measured in 30 days.
Measure the first policy wedge in 30 days
Baseline and target are frozen at kickoff. Weekly readouts track whether deterministic policy routing lowers L2 handoffs, stabilizes handle-time spread, and reduces dispute reopen pressure.
| Metric | Baseline | Target (30d) | Outcome (30d) |
|---|---|---|---|
| Escalation rate | Queue-specific baseline | -4 to -6 percentage points | -4 to -8 percentage points (modeled estimate) |
| Handle-time variance | Current p90-p50 spread | -12% to -18% | -12% to -30% (modeled estimate) |
| Dispute reopen rate | Current reopen ratio | -2 to -4 percentage points | -2 to -5 percentage points (modeled estimate) |
Modeled estimate: At ~5,000 policy decisions/month, base-case labor impact is typically $6k-$9k/month before dispute-loss reduction.
Model assumptions
- 12%-18% handle-time reduction on comparable policy intents.
- $25-$30 loaded hourly support cost.
- One scoped queue with stable ticket mix over the 30-day post-rollout window.
Example queue: a support queue starting at 18% escalation to L2 is modeled to reach 11%-13% in the first 30 days with deterministic routing plus weekly exception review.
Rollout timeline
-
Week 0
Baseline + instrumentation freeze Lock queue scope, baseline formulas, and request-level capture before routing.
-
Week 2
Midpoint variance review Check escalation drift, handle-time spread, and exception patterns by intent class.
-
Week 4
30-day scorecard readout Publish outcome deltas, dispute-readiness evidence, and production rollout recommendation.
Evidence matrix
| Input signal | Verdict output | Audit artifact |
|---|---|---|
| Ticket context + policy intent | /api/decide yes/no/tie + request_id |
Request hash + mode + actor type |
| Vendor policy parameters | Notary verdict + code + rationale | Response hash + latency + run status |
| Applied customer action | Allowed / denied / escalated branch | Ticket note with request_id linkage |
Why policy wins first
Support policy queues process high-frequency decisions with clear owners, visible failure cost, and strong audit requirements. decide removes interpretation drift across agents, automations, and escalation paths.
Frequent pain, clear owner
Buyer is Support/CX Ops. User is frontline agents plus automation teams. One policy layer removes per-agent drift.
Measured ROI per queue
Track escalation rate, handle-time variance, and dispute outcomes with deterministic verdicts tied to request_id.
Repeatable distribution
Drop outputs into Zendesk/Intercom playbooks, AI copilots, and workflow routers without backend rework.
Expansion path
Start with refund/cancel/trial. Extend into returns, disputes, SLA exceptions, and goodwill-credit policies.
How a decision run works
One request in. One deterministic path out: /api/decide classifies action, notaries verify policy, and every run stays linked by request_id.
1
Classify
Ticket macro or agent workflow sends policy context to /api/decide and gets yes/no/tie + request_id.
2
Verify
The matching notary returns the policy verdict, code, and rationale needed for the next action.
3
Execute + audit
Apply the customer action and keep deterministic fields attached for replay, QA, and dispute response.
End-to-end example: Zendesk refund queue
One realistic flow from ticket intake to final action using /api/decide, refund notaries, and request-level evidence.
| Flow phase | Primary action | System output | Audit artifact |
|---|---|---|---|
| Queue intake | Agent receives a cancellation ticket asking for a refund on an annual plan. | Ticket payload normalized for routing. | Ticket id, queue id, timestamp. |
| Classify | Workflow sends policy context to /api/decide. |
Deterministic verdict plus linked request_id. |
Decision payload + verdict snapshot. |
| Policy verification | Refund notary endpoint receives vendor and purchase-age arguments. | ALLOWED, DENIED, or UNKNOWN with policy code. |
Policy code, rationale, request/response hashes. |
| Execute action | Agent macro or automation applies refund, partial credit, or escalation path. | Customer-visible action result. | Final action type + operator/workflow id. |
| Audit close-out | Run history is indexed for QA and dispute response. | Replay-ready case record tied to request_id. |
Exportable evidence packet by request id. |
Sample call + response chain
Single case flow with shared request_id across classification and policy execution.
POST /api/decide {"question":"Refund this Adobe annual plan bought 5 days ago?","mode":"single"} 200 {"c":"yes","v":"yes","request_id":"req_9f3c"} POST /api/v1/refund/eligibility {"vendor":"adobe","days_since_purchase":5,"region":"US","plan":"individual","request_id":"req_9f3c"} 200 {"verdict":"ALLOWED","code":"WITHIN_WINDOW","message":"Within vendor refund window.","request_id":"req_9f3c"}
Swipe horizontally to view full payload and response.
Interactive test surface
Overview stays static. Run issue -> workflow -> action testing only in Agents / Live demo so sprint and production flows stay in one place.
Open test surface30-day KPI ranges (modeled pilot estimate)
Research-informed planning ranges
Pilot scorecard compares a 30-day baseline vs first 30 days post-rollout on one scoped queue. Escalation and reopen deltas are percentage points.
| Metric | Base case | Stretch case |
|---|---|---|
| Escalation rate | -4 to -6 percentage points | -8 percentage points |
| Avg handle time | -12% to -18% | -25% to -30% |
| Dispute reopen rate | -2 to -4 percentage points | -5 percentage points |
Modeled estimate: At ~5,000 policy decisions/month, base-case labor impact is typically $6k-$9k/month before dispute-loss reduction.
Assumptions: 12%-18% handle-time reduction, $25-$30 loaded hourly support cost, and a stable refund/cancel/trial queue mix.
Example queue: 18% escalation to L2 modeled to 11%-13% within 30 days.
Concrete workflow proof blocks
Modeled pilot estimates by queue type so teams can scope outcomes before rollout; each figure is tied to explicit queue and cost assumptions.
Refund eligibility queue
Subscription support queue (US + EU mix)
Volume: 3,000-5,000 policy decisions / month
Measured range: escalation rate down 4-8 percentage points in 30 days
Measured range: average handle time down 12-25%
Modeled estimate: At ~5,000 decisions/month, $6k-$9k monthly labor effect before dispute-loss reduction (assumes 12%-18% handle-time reduction and $25-$30 loaded hourly cost).
Cancellation exception queue
Renewal + goodwill-credit edge cases
Volume: 1,800-3,200 policy decisions / month
Measured range: exception drift down 25-40%
Measured range: supervisor escalations down 3-6 percentage points
Modeled estimate: Stronger consistency for manual exception handling, lower preventable dispute loss from exception drift, and cleaner audit evidence.
Returns + dispute prep queue
Returns, chargeback prep, and policy replay
Volume: 1,200-2,400 policy decisions / month
Measured range: dispute reopen rate down 2-5 percentage points
Measured range: QA replay time down 20-35%
Modeled estimate: Fewer evidence gaps when responding to disputes and QA audits.
Ranges are planning baselines from scoped pilot modeling and operator research, not guaranteed outcomes for every queue.
Interface example (Decision API runtime): Krafthaus
How decide compares by approach
Criteria-based comparison for support policy execution and dispute-readiness.
| Criteria | Manual SOP + spreadsheets | General AI support platform | decide policy layer |
|---|---|---|---|
| Deterministic output | No | No | Yes |
| Request-linked audit trail | No | No | Yes |
| API-first integration | No | No | Yes |
| Accuracy quality | Agent-dependent and shift-dependent consistency. | Model-probability output; quality varies by context. | Rule and policy-version driven output with repeatable verdicts. |
| Integration effort | Fast to start, but manual drift and QA overhead grows. | Requires platform workflow design and migration effort. | Layered API + MCP notaries into existing helpdesk flow. |
| Total cost at scale | Low tooling cost, high rework and escalation cost. | Higher platform spend with workflow lock-in risk. | Predictable policy ops spend with lower inconsistency waste. |
| Best fit | Small volume and low process complexity. | Teams optimizing for full-platform automation speed. | Teams prioritizing policy consistency and dispute evidence. |
Manual SOP + spreadsheets
- Deterministic output: No
- Request-linked audit trail: No
- API-first integration: No
- Accuracy quality: agent-dependent and shift-dependent consistency.
- Integration effort: fast to start, but manual drift and QA overhead grows.
- Total cost at scale: low tooling cost, high rework and escalation cost.
- Best fit: small volume and low process complexity.
General AI support platform
- Deterministic output: No
- Request-linked audit trail: No
- API-first integration: No
- Accuracy quality: model-probability output; quality varies by context.
- Integration effort: requires platform workflow design and migration effort.
- Total cost at scale: higher platform spend with workflow lock-in risk.
- Best fit: teams optimizing for full-platform automation speed.
decide policy layer
- Deterministic output: Yes
- Request-linked audit trail: Yes
- API-first integration: Yes
- Accuracy quality: rule and policy-version driven output with repeatable verdicts.
- Integration effort: layered API + MCP notaries into existing helpdesk flow.
- Total cost at scale: predictable policy ops spend with lower inconsistency waste.
- Best fit: teams prioritizing policy consistency and dispute evidence.
Use decide when you need reproducible policy outcomes and evidence across systems and agents, not a full replacement of your support platform. This is where dispute-loss prevention comes from: same policy input, same verdict, with traceable request_id evidence.
Snapshot basis: Criteria-based comparison and product evidence, not a paid ranking.
Pricing for support teams
Simple model: run Evaluate for free validation, then buy a Production API tier by monthly decision volume (10k -> 50k -> 200k). Annual billing saves 20%, and burst packs handle temporary spikes.
Evaluate (free)
Validate payloads before production purchase
Use live demo + docs to test deterministic outputs and request-linked evidence fields.
Live demo and sandbox payload testing
No production API key issuance
Docs-first integration validation path
Production API tiers
Pick by monthly decision volume
Choose by monthly decision volume. API Starter and Team can run as checkout plans. Enterprise stays contract-led when governance and procurement controls are strict.
API Starter
From $299 / month
Up to 10,000 decisions/month
Self-serve production Decision API.
20 req/min default per API key
Deterministic contract + evidence fields
Self-serve production runtime
Email support for integration questions
API Team
From $1,199 / month
Up to 50,000 decisions/month
Growth tier for heavier production traffic and faster launch support.
Higher throughput envelope than Starter
Expanded support/SLA package
Implementation support included
Single contract for runtime + rollout
API Enterprise
From $3,999 / month
Up to 200,000 decisions/month
For multi-team governance, procurement review, and strict enterprise controls.
Custom throughput/SLA envelope
Procurement/security package
Implementation support included
Multi-team governance and rollout planning
Plan contract snapshot
Compare decision scope, delivery model, rate-limit envelope, and expansion path before you submit intake. Default delivery is remote integration handoff (not on-site services).
| Plan | Price | Delivery model | Monthly decision scope | Rate-limit envelope | Overage / expansion | Support + SLA |
|---|---|---|---|---|---|---|
| Evaluate ($0) | $0 | Sandbox + live demo validation only. | No production usage. | Shared demo limits; non-SLA. | Move to API Starter, API Team, or API Enterprise for production. | No production SLA. |
| API Starter (from $299/mo) | From $299/mo | Standalone keyed /api/decide access. |
Up to 10,000 decisions/month (single team). | Default Starter envelope: 20 req/min per API key (returned in x-ratelimit-*). |
Use burst packs (+10k/+25k/+50k) or upgrade to API Team. | Self-serve runtime with email support for implementation questions. |
| API Team (from $1,199/mo) | From $1,199/mo | Quote-based API runtime with included implementation support. | Up to 50,000 decisions/month. | Higher contract-defined envelope than Starter. | Use burst packs or move to Enterprise for stricter governance and larger envelopes. | Expanded support package + contract SLA terms + implementation support included. |
| API Enterprise (from $3,999/mo) | From $3,999/mo | Enterprise runtime with included rollout/governance support. | Up to 200,000 decisions/month and/or strict multi-team controls. | Custom throughput/SLA envelope by contract. | Further custom tiers above 200k/month as volume and controls expand. | Full procurement/security package and enterprise support model with implementation support included. |
Need procurement or fit review? Book optional fit call.
FAQ
Can we start without a full platform rollout?
Yes. Choose API Starter for direct API runtime access, add burst packs for temporary spikes, or move to Team/Enterprise for larger envelopes and controls.
What happens right after payment?
You land on /payment/success with handoff steps, and receive kickoff confirmation by email. If missing after 10 minutes, check spam/promotions and contact [email protected].
Is Evaluate production-ready?
No. Evaluate is for runtime testing and payload validation only. Production usage starts with API Starter (or higher API tiers).
When does pricing move to custom scope?
Usually when monthly volume approaches or exceeds 200,000 decisions, when multi-team governance is required, or when procurement/compliance controls need custom contract terms.
Modeled estimate: Typical payback targets assume one queue with 3,000-5,000 policy decisions/month. Base-case labor impact is often $6k-$9k/month before dispute-loss reduction. Production runtime starts on API Starter, API Team, or API Enterprise.
Queue ROI calculator
Use assumption-based queue math before commercial commit so upside and spend stay explicit.
Queue ROI calculator
Estimate monthly labor effect for one policy queue and compare it against your selected plan cost.
Reference scenario (assumption-based): 4 agents × 50 tickets/day × 22 days/month × 3% inconsistent outcomes × $40 dispute impact ≈ $5,280/month avoidable leakage before labor savings.
Formula: hours saved = (decisions/month × avg handle minutes ÷ 60) × reduction%; labor savings = hours saved × loaded hourly cost; net impact = labor savings - plan cost.
Hours saved / month
0 h
Labor savings / month
$0
Plan cost in model
$0
Net impact / month
$0
Payback estimate appears after input values are applied.
Modeled estimate only. Use your pilot baseline and measured scorecard deltas for procurement decisions.
