Decision infrastructure for support teams

Stop losing refund disputes to inconsistent answers.

Support teams run thousands of policy decisions monthly. decide gives humans and AI agents the same deterministic refund, cancel, return, and trial verdict with linked request_id evidence.

Open live demo Start sprint intake
Verified daily policy monitoring Loading latest confirmed policy check...

Deploy without rip-and-replace. Works with Zendesk, Intercom, Salesforce Service Cloud, and internal workflows.

See integration path

See the workflow in 20 seconds

Use this quick walkthrough structure to show exactly how policy intake becomes deterministic action + evidence.

Quick decide demo (20s) Overview entry -> live demo run -> evidence panel -> sprint intake handoff

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.

  1. 0s-4s Enter through the pain-first hero Open live demo is clicked from the primary CTA row on Overview.
  2. 4s-10s Run a real policy request Preset and mode are selected, then Run request executes a deterministic refund check.
  3. 10s-15s Show output and linked evidence Latest response, request-linked fields, and audit trail/CSV view confirm traceability.
  4. 15s-20s Close on sprint intake handoff Sprint intake opens, form is completed, and Continue to payment unlocks for the buyer path.

Pilot scorecard in 30 days

Each pilot is scoped to one workflow and measured with a shared KPI table, rollout timeline, and audit evidence matrix.

Quick read for first-time visitors

Automate subscription policy decisions across humans and agents.

decide routes refund, cancel, and trial decisions through deterministic policy checks. The scorecard below measures whether that routing lowers avoidable escalations, tightens handling consistency, and improves dispute readiness in one scoped queue.

Metric units: escalation and dispute deltas are measured in percentage points; handle-time variance is measured as percentage change. Measurement window: 30-day baseline before rollout vs first 30 days after rollout, reviewed weekly.
Open live demo Start sprint intake

Reduce escalations and variance in the first 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

  1. Week 0
    Baseline + instrumentation freeze Lock queue scope, baseline formulas, and request-level capture before routing.
  2. Week 2
    Midpoint variance review Check escalation drift, handle-time spread, and exception patterns by intent class.
  3. Week 4
    30-day scorecard readout Publish outcome deltas, dispute-readiness evidence, and Core 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 this wedge wins first

Subscription support queues process policy tickets every day. 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 it works in 3 steps

One Core rollout path for humans and automations: /api/decide classifies action, notaries enforce 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

Route

Verdict determines next step: run the matching notary, collect more context, or escalate to a policy owner.

3

Execute + evidence

Notary output applies customer action and logs deterministic fields 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 Core flows stay in one place.

Open live demo

30-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.

MetricBase caseStretch 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.

Open live demo Start sprint intake

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 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.

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 humans and agents, not a full replacement of your support platform.

Last updated: February 12, 2026. Criteria-based snapshot, not a paid ranking.

Pricing for support teams

Free Evaluate is for testing. Paid Onboarding Sprint and Core plans are for rollout support, SLA/commercial terms, and ongoing operations.

Evaluate
$0 / evaluate
Core endpoints + live demo
Public notaries + audit trail
Lower rate + no SLA + non-production support
Open live demo
Onboarding Sprint (2 weeks)
From $1,500 / sprint
Policy mapping for one scoped queue
Integration checklist + KPI baseline/target
Backtest + rollout plan + weekly readout
Start sprint intake

Sprint credit: if you go live within 30 days, we apply the $1,500 sprint fee to your first Core month (manual invoice credit).

Core
From $2,000 / month
Core limits + commercial terms
SLA support + audit exports
Security + procurement support
Annual option: $20,000 / year (save $4,000)
Book Core call

Direct checkout: Monthly · Annual ($20,000)

What happens after payment

  1. Day 1
    Receipt + onboarding handoff Payment confirmation, intake recap, and scheduling link sent to your work email.
  2. Day 2-3
    Week 1: kickoff + baseline lock Lock queue scope, helpdesk stack, baseline formulas, and success criteria before rollout starts.
  3. Day 4-7
    Week 2: integration + live checks Connect routing + notary endpoints and validate request-level evidence in your target workflow.
  4. Week 2-4
    Week 3-4: controlled rollout window Run live traffic with weekly scorecard updates and exception review checkpoints.
  5. Day 30
    Go/no-go readout Final scorecard + Core rollout recommendation with evidence package for decision owners.

Sprint terms and cancellation policy: read terms.

Onboarding Sprint risk reversal

  • Sprint credit: the $1,500 sprint fee is credited to your first Core month if you go live within 30 days.
  • Scoped delivery: one queue, one workflow, one measurable scorecard before kickoff.
  • Clear go/no-go decision: you get a Core rollout recommendation with evidence before expanding usage.

Best Fit

  • Support teams with daily refund/cancel/return/trial tickets.
  • Queues already running in Zendesk, Intercom, or internal agent tooling.
  • Teams that need deterministic outputs and dispute-ready audit evidence.

Not a Fit

  • One-off personal decision tools or generic chat use cases.
  • Workflows without measurable policy outcomes to improve.
  • Teams not ready to run a scoped pilot with KPI tracking.

Modeled estimate: Typical payback target assumes one queue with 3,000-5,000 policy decisions/month. Base-case labor impact is roughly $6k-$9k/month before dispute-loss reduction. Evaluate is for testing; Sprint/Core plans are for operational rollout.

Queue ROI calculator

Model expected queue impact separately from pricing so commercial terms and operational upside stay clear.

Queue ROI calculator

Estimate monthly labor effect for one policy queue and compare it against your selected 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.

Support Policy Ops Console

Run intake-to-rollout operations from one place: commercial readiness checks, runtime telemetry, and launch actions.

Loading
Loading control-plane status…

Control Plane Readiness

These checks confirm intake delivery, checkout links, booking path, and confirmation channel for production rollout.

Ops access token not set. Configure only if Ops lock is enabled.

Commercial Actions

Launch paths wired directly to your configured links.

Pilot payment Core monthly Core annual Book Core call
  • Intake accepted: submission id and confirmation email are logged.
  • Checkout handoff: payment opens with prefilled email and linked reference id.
  • Readout cadence: weekly snapshot uses runtime metrics + export bundle.

Runtime Telemetry

Use your x-metrics-token to load 24h runtime metrics and export the pilot scorecard snapshot.

No metrics loaded yet.
Load metrics to calculate delivery health.
Pilot Intakes (24h)—
Pilot Delivery Success (24h)—
Pilot Delivery Failures (24h)—
Pilot Delivery Rate (24h)—
Decision API Signals (24h)—
MCP Signals (24h)—
Events (1h)—
Events (24h)—
Events (7d)—
Last Updated—
Top event (24h) Count
Load metrics to view top events.

Executive Pilot Scorecard

Build a concise rollout brief from current readiness checks and telemetry. Use this for customer updates and weekly pilot readouts.

Generate report to produce an executive-ready scorecard.
No report generated yet.
Decision API

Clear verdicts.

Run the same deterministic decision API your automations use. One question in, one verdict out, with request-level traceability.

Workflow mode adds queue context and returns deterministic verdict + policy evidence.
High-risk categories are blocked (finance / legal / medical). See Terms & Safety.
Input → single verdict Tie when equivalent Deterministic rationale Sentiment optional (off by default) 
{
  \"endpoint\": \"/api/decide\",
  \"request\": { \"question\": \"ship this launch today?\", \"mode\": \"single\" },
  \"response\": { \"c\": \"yes\", \"v\": \"yes\", \"request_id\": \"abc123\" },
  \"field_map\": { \"c\": \"decision_class\", \"v\": \"decision\" }
}
Deterministic outputsTie detectionStateless decisionsSafety filtersDeterministic outputsTie detectionStateless decisionsSafety filters

Why support teams trust it

Built for high-volume policy choices where consistency and traceability matter.

Deterministic Verdict

The same input returns the same verdict: yes, no, or tie.

Tie Detection

If options are equivalent, decide returns tie instead of forcing a false winner.

Stateless Input

Each call is scoped to current context, so old chat drift does not leak into policy decisions.

Workflow-Ready Output

Response fields are compact and easy to route into macros, automations, and MCP tools.

Safety Filters

Finance, legal, and medical prompts are blocked by policy.

Decision run matrix

One deterministic flow for humans and automations, expressed as concrete inputs, outputs, and evidence.

Phase Input Deterministic output Operator action Audit artifact
Classify Question or policy context payload Yes / no / tie + request_id Proceed, gather more context, or stop Request hash + timestamp
Verify policy Vendor + timing + region + plan fields Allowed / denied / unknown + policy code Apply macro branch or escalate exception Response hash + notary latency
Execute + record Agent or automation action payload Customer-facing action completed Reply, refund, cancel, or route to owner Ticket note linked by request_id

Ready to standardize one support queue?

Start with one workflow, one scorecard, and one deterministic policy layer.

Open live demo Start sprint intake
Support automation stack

Deterministic policy tools for agents.

Deploy refund, cancel, return, and trial notaries over MCP or REST. Every call returns deterministic, auditable policy output.

Open live demo Start sprint intake

Refund Notary

refund.decide.fyi
Last policy sync (UTC): loading…
Live

Deterministic refund eligibility checker for US consumer subscriptions. Returns ALLOWED, DENIED, or UNKNOWN based on each vendor's official refund policy window.

100 vendors Stateless Updated daily Free / No auth
Visit GitHub

Cancel Notary

cancel.decide.fyi
Last policy sync (UTC): loading…
Live

Cancellation penalty checker for US consumer subscriptions. Returns FREE_CANCEL, PENALTY, or LOCKED based on each vendor's cancellation terms.

100 vendors Stateless ETF detection Free / No auth
Visit GitHub

Return Notary

return.decide.fyi
Last policy sync (UTC): loading…
Live

Return eligibility checker for US consumer subscriptions. Returns RETURNABLE, EXPIRED, or NON_RETURNABLE with return type (full refund, prorated, credit) and method.

100 vendors Stateless Return method Free / No auth
Visit GitHub

Trial Notary

trial.decide.fyi
Last policy sync (UTC): loading…
Live

Free trial availability and terms checker for US consumer subscriptions. Returns TRIAL_AVAILABLE or NO_TRIAL with trial length, card requirement, and auto-conversion status.

100 vendors Stateless Card & auto-convert Free / No auth
Visit GitHub
Missing a vendor? Request a vendor

Live demo + audit trail

Trust Suite: not run

Run real policy calls, inspect deterministic responses, and keep a scoped audit trail for QA and incident review.

Run Request
Run request to update output below.
Advanced tools
No monitors yet.
Vendor requests (network)
    Missing a vendor? Request a vendor
    Share redaction:
    Audit scope: loading…
    Assertions
    Latest response
    Run a request to see output.
    Diff vs previous response
    Run twice to compare output changes.
    Audit Trail
    Showing 0 of 0 runs.
    Time (UTC) Notary Mode Status Assert Latency Req hash Actions
    No runs yet. Run your first request.

    Connect your agent

    Add decide notaries to any MCP-compatible client in seconds.

    Add to Cursor Add to VS Code Add to Claude Add to ChatGPT Add to Codex Add to Gemini
    Claude Desktop / Cursor / Windsurf
    {
  "mcpServers": {
    "refund-decide": {
      "url": "https://refund.decide.fyi/api/mcp"
    },
    "cancel-decide": {
      "url": "https://cancel.decide.fyi/api/mcp"
    },
    "return-decide": {
      "url": "https://return.decide.fyi/api/mcp"
    },
    "trial-decide": {
      "url": "https://trial.decide.fyi/api/mcp"
    }
  }
}
    JSON-RPC — tools/call
    curl -X POST https://refund.decide.fyi/api/mcp \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tools/call",
    "params": {
      "name": "refund_eligibility",
      "arguments": {
        "vendor": "adobe",
        "days_since_purchase": 12,
        "region": "US",
        "plan": "individual"
      }
    }
  }'
    REST API
    curl -X POST https://refund.decide.fyi/api/v1/refund/eligibility \
  -H "Content-Type: application/json" \
  -d '{"vendor":"spotify","days_since_purchase":5,"region":"US","plan":"individual"}'
    Commercial handoff

    Need rollout and commercial terms?

    Starts at $1,500 onboarding sprint and $2,000/month Core. Review full pricing, ROI model, and terms in one place.

    Onboarding Sprint: from $1,500 Core: from $2,000/mo Annual option: $20,000
    View pricing Start onboarding sprint

    Built for support automations

    Deterministic outputs, no hidden state, and clean integration paths.

    Deterministic

    Same input, same output. Every time. Fully auditable decisions your agent can cite.

    Stateless

    No sessions, no tokens, no stored data. Pure function over HTTP.

    MCP Native

    JSON-RPC 2.0 over HTTP POST. Works with Claude Desktop, Cursor, and any MCP client.

    100 Vendors

    Adobe, Netflix, Spotify, Microsoft 365, and 96 more. Updated daily via automated checks.

    Zero Config

    No API keys needed for Evaluate. Core access is managed with paid plan controls and support.

    Open Source

    Full rules, policy sources, and server code on GitHub. Verify everything.

    Roll out policy decisions with confidence.

    Integrate once, route every support workflow through deterministic verdicts.

    Open live demo Start sprint intake