Changelog

What changed in the Decision API, docs, proof, and rollout surface.

A plain public log of meaningful site and product-surface changes. Entries focus on what shipped, what became easier to evaluate, and what buyers or developers can now inspect.

Read docs Integration guides Status
API contract Developer docs Pricing Proof surfaces Reliability

Release index

Start here when reviewing whether a change affects integration work, buyer evaluation, or operational trust.

Protocol

Decision lifecycle is the stable story

Decision Record, execution receipt, Outcome Record, policy intelligence, Decision Packet, and verification are the core surfaces to track.

Buyer review

Trust surfaces are now grouped

Status, security, docs, pricing, live proof, and changelog pages are the fastest path for a procurement or implementation review.

SDK status

Publish claims stay verified

Public npm latest is 0.1.13 as of May 22, 2026. Local source package metadata is ahead at 0.1.14 until the next publish.

Change type What to inspect Impact rule
API contract API reference, OpenAPI, and machine docs. Breaking request/response changes should be explicitly labeled with migration guidance.
Verification and packets Verification docs, SDK verifier, and hosted verifier. Proof changes should preserve replayability or state the verification delta.
Decision Intelligence Intelligence docs, examples, and policy report endpoints. Outcome-derived reports should stay explainable and avoid unsupported ML claims.
Trust and operations Security, status, and production smoke checks. Operational claims should map to visible endpoints, exports, or documented process.

Release policy

This log should stay useful for technical evaluation. It should not invent momentum, customer proof, or compliance claims before they exist.

Included

Shipped product-surface changes

API docs, pricing, proof artifacts, public reliability views, and integration assets that a prospect can inspect.

Included

Evaluation improvements

Anything that makes the Decision API easier to understand, test, integrate, replay, or procure.

Excluded

Unverified claims

No customer logos, certification labels, production counts, or social proof unless the underlying proof exists.

Latest updates

Buyer sequencing examples added

The homepage and Trust page now make the first pricing-exception boundary easier to forward, explain, and review.

  • Added a plain-English 28% discount example that walks from action name to context, verdict, stored record, and RevOps route.
  • Expanded the homepage lifecycle visual to show Decision Record, Execution Receipt, Outcome Record, Policy Intelligence, and Decision Packet as staged proof.
  • Added a synthetic before/after operating example and a role-based Trust packet for CTO, RevOps, Security, and Procurement review.

Advanced trust escalation framed

Docs and proof pages now frame packets, signatures, verification, and audit chains as trust escalation after the first Decision Record.

  • Added explicit guidance to start with a Decision Record before adding portable packet export.
  • Clarified that receipt signatures, packet verification, and audit-chain checks are for production-critical boundaries.
  • Added static and smoke checks so advanced proof language stays staged instead of feeling required on day one.

Proof-surface status cues added

Homepage and proof review links now label what each proof surface is before the reader clicks through.

  • Added live sandbox, canonical artifact, production docs, and data-dependent report cues to the homepage proof grid.
  • Added artifact-status labels to the proof review packet for verifier, readiness, trust, and implementation links.
  • Added static UI and production smoke checks so proof surfaces keep clear trust status labels.

Homepage CTA paths tightened

The homepage now separates the evaluation route for implementers from the buyer-review route before production access.

  • Added a Developer path: docs, first-hour examples, verification, and SDK.
  • Added a Buyer path: pricing proof, pricing, security, and request access.
  • Added static and smoke checks to keep the CTA hierarchy explicit.

Homepage hero sentence simplified

The first screen now states the basic product motion before introducing lifecycle intelligence.

  • Updated hero copy to lead with context, guardrails, yes/no/review, evidence, IDs, and replay.
  • Reduced the hero proof strip to the first-layer API outputs: context, verdict, evidence, and replay.
  • Added static and smoke checks to keep the above-fold product sentence concrete.

API contract language clarified

Public navigation and docs now distinguish the Decision API contract from commercial contract terms.

  • Renamed the homepage nav anchor from standalone Contract to API contract.
  • Updated docs, pricing, platform, live proof, and pattern copy to say API contract, API-fit, or commercial contract where appropriate.
  • Added positioning and critical-interaction checks that block ambiguous contract labels from returning.

Pricing-exception boundary promoted

The homepage now introduces pricing exceptions as the first production boundary before the sandbox and broader proof surface tour.

  • Moved the first-boundary section directly after the hero so buyers see the commercial starting point earlier.
  • Updated hero copy to name CRM, billing, agents, queues, and pricing exceptions before moving into lifecycle proof.
  • Added static UI and smoke checks to keep the first boundary visible before the API playground.

API reference maturity labels added

The focused API reference now separates first-boundary endpoints from proof, lifecycle data, and reference utility surfaces.

  • Added an endpoint maturity legend for stable core, stable proof, data-dependent, and reference utility surfaces.
  • Added a Status column to the endpoint table so implementers can see which endpoints belong in the first production path.
  • Updated static UI and production smoke checks to guard the maturity labels on the focused API reference.

Homepage clarity and surface status added

The homepage and docs now answer the two buyer questions raised by deeper resource review: why not hard-code rules, and which surfaces are core versus supporting.

  • Added a homepage objection section explaining reusable boundaries, stored records, replay/diff, and execution/outcome proof.
  • Added a docs surface-status map for stable core, stable proof, data-dependent lifecycle, and reference utility surfaces.
  • Added a static vendor-directory review summary so text-only reviews see the utility status and catalog source before dynamic rows load.

Production interaction smoke deepened

The production smoke check now verifies the public interaction bundle behind the verifier, status page, pricing controls, API playground, and intake CTAs.

  • Verifier checks now cover upload handlers, stored-decision verification, fail-closed errors, and copy-result behavior in the published asset.
  • Status checks now cover refresh endpoints, readiness export download wiring, and export failure fallback copy.
  • Homepage checks now fetch the playground, proof-run, snippet, decision-runner, intake, deeplink, and action-router assets before passing.

Policy alert packet tightened

The Reference Source Alerts page now frames the compatibility feed as an operational review packet.

  • Added a packet for signal, source, quality, and response review before any reference application changes.
  • Added an alert response path for confirmed changes, continuity rows, pending signals, volatile indicators, fetch holds, and coverage gaps.
  • Added lifecycle context tying source alerts to Decision Records and Decision Packet v1 without treating the feed as the customer action record.

Pattern adoption packet tightened

The Pattern Catalog now explains how first-party templates move from starter payloads into verified lifecycle evidence.

  • Added a pattern adoption packet for choosing, binding, proving, and reviewing a template before production use.
  • Added a lifecycle contract that maps registry fields to Decision Records, Outcome Records, CRM sync receipts, and Decision Packet v1 exports.
  • Upgraded pattern copy buttons with the same fallback-safe behavior used by examples, integrations, and live proof pages.

Integration rollout packet tightened

The Integration Guides page now starts with a first-boundary rollout packet before connector-specific guidance.

  • Added a rollout packet for boundary choice, server-side key custody, lifecycle proof, and expansion rules.
  • Added lifecycle proof mapping from Decision Record to execution receipt, Outcome Record, and Decision Packet v1 export.
  • Added copyable integration snippets and a first-boundary launch checklist for owners, engineering, operations, and reviewers.

Platform control-plane packet tightened

The Platform page now explains production access as a concrete control-plane review packet.

  • Added a production control-plane packet for server-side keys, usage limits, Decision Packet v1 evidence, and readiness review.
  • Updated the production flow around Decision Records, Action Execution Receipts, Outcome Records, and packet export.
  • Added operational handoff steps for access, quotas, monitoring, evidence verification, and expansion.

Live proof artifact packet tightened

The Live Proof page now works as a reviewable artifact packet, not only a narrative demo.

  • Added artifact review links for proof narrative, first-hour examples, verification docs, hosted verifier, status, and trust packets.
  • Added copy controls for request, response, and replay JSON so implementers can lift the example directly.
  • Expanded production handoff with Decision Packet v1 export and verification before buyer or security forwarding.

Proof review packet added

The Proof page now gives buyers and implementers a compact review packet before the deeper proof narrative.

  • Added a proof review packet with inspect, run, verify, and review steps.
  • Added direct links to live proof, first-hour examples, verification docs, hosted verifier, status, trust, and security artifacts.
  • Updated the minimum evidence packet around Decision Packet v1, runtime exports, and verification samples.

Developer examples handoff packet added

The Developer Examples page now gives implementers a first-hour path before the full catalog of snippets.

  • Added install, proof-pack, verification, and fail-closed action-gate steps at the top of examples.
  • Added verified SDK artifact links, including npm package, registry metadata, published tarball, and access-controlled source note.
  • Production smoke and UI checks now guard the first-hour implementation packet and copy targets.

Legal review pages tightened

Public Terms and Privacy pages now match the buyer-review structure used by trust, security, and API access terms.

  • Terms now includes a review packet, legal review links, and clearer Decision lifecycle artifact limits.
  • Privacy now includes a data-review packet, Decision lifecycle data boundaries, and review/export request guidance.
  • Production smoke and UI checks now cover Terms and Privacy as part of the procurement packet.

API access terms packet tightened

The API access terms page now works as a procurement review artifact instead of only listing basic checkout terms.

  • Added a commercial review summary for scope, billing, data boundaries, and buyer-review artifacts.
  • Added a plan review matrix for Starter, Team, Enterprise, and guided implementation paths.
  • Added written-agreement precedence and procurement links for terms, privacy, security, status, trust, and verification docs.

Checkout handoff pages tightened

Payment success and cancel pages now behave like part of the buyer review path instead of simple Stripe return screens.

  • The success page now includes an access handoff checklist that routes buyers into API docs, verification docs, trust, status, and the hosted verifier.
  • The cancel page now includes a checkout recovery packet for retrying payment, choosing the API access path, or reviewing trust and security material first.
  • Production smoke checks now cover the checkout handoff and recovery markers so post-payment routing stays review-ready.

Trust procurement hub tightened

The Trust page now routes buyers through a concrete review sequence instead of acting only as a link directory.

  • Added a five-step buyer review sequence from product fit to launch decision.
  • Expanded the procurement packet into forwardable security, legal, engineering, and operations bundles.
  • Added quick answers for Decision Packet evidence, fail-closed behavior, and formal security review requests.

Docs overview packet anatomy added

The main docs overview now explains the portable Decision Packet without requiring readers to jump into the focused verification page first.

  • Added a Decision Packet anatomy diagram covering the core record, execution receipts, Outcome Records, policy intelligence, and audit-chain proof.
  • Added packet verification checks for packet hash, embedded record verification, lifecycle links, and review proof.
  • Production smoke and contract checks now guard the overview packet diagram.

Security review packet hardened

The security page now gives buyers a clearer first-pass packet for procurement, implementation, and security review.

  • Added a security review checklist that maps common buyer questions to public evidence links.
  • Added a shared responsibility matrix for API key custody, payload minimization, action-boundary placement, evidence retention, and incident response.
  • Clarified retention, deletion, service-provider, and browser-boundary notes without adding unsupported certification claims.

Docs navigation and trust packet polish added

The public evaluation surface now makes the decision lifecycle easier to scan and gives buyer reviewers a clearer status/security/change packet.

  • Docs pages now include sticky current-section sidebars and stronger overview diagrams for the lifecycle, protocol stack, implementation path, and verification routes.
  • Homepage and pricing now surface Decision Intelligence by tier: lifecycle capture, policy feedback loop, and proof governance.
  • Status and security pages now present buyer-review packets, readiness exports, data boundaries, verification scope, and incident paths without making unsupported certification claims.
  • SDK link rows now point to the verified npm registry artifact and mark GitHub source as access-controlled instead of linking buyers to unauthenticated 404 pages.
  • Production smoke checks now cover verifier upload/copy, status refresh/export, pricing controls, API playground wiring, and intake CTAs.

Focused docs paths added

The docs now give buyers and implementers shorter paths into the same canonical contract instead of requiring every reader to scan the full reference page first.

  • API reference summarizes endpoints, auth, response views, rate limits, idempotency, and fields to store.
  • Verification docs explains hosted, API, CLI, packet, key-registry, and conformance checks.
  • Decision Intelligence docs explains Decision Record to execution receipt to Outcome Record to policy intelligence.

Decision Packet v1 exports added

Decide can now export a portable proof bundle for support, audits, and buyer reviews without requiring the reviewer to trust the hosted ledger.

  • GET /api/decision/:id/packet returns decision_packet_v1 with the Decision Record, optional input, execution receipts, Outcome Records, policy intelligence, audit-chain metadata, verification hints, and packet_hash.
  • POST /api/decision/packet/verify verifies exported packets, including embedded record verification and linked proof hashes.
  • SDK source package metadata adds decisionPacket() and decide verify-packet; public npm latest remains 0.1.13 until the next package publish.

Lifecycle proof pack added

Decide now has a single packaged example and public proof path that shows how one proposed action becomes a Decision Record, execution receipt, Outcome Record, and policy intelligence readout.

  • sdk/examples/lifecycle-proof-pack.js runs the end-to-end proof sequence for technical buyers.
  • Developer Examples, Live Proof, and Proof now expose the lifecycle proof path directly.
  • @decide-fyi/sdk@0.1.13 documents the packaged proof pack without changing the core Decision API contract.

Action execution receipts added

Decide now records a target-system neutral receipt for whether the action authorized by a Decision Record was actually attempted, closing the gap between authorization and final outcome.

  • POST /api/decision/:id/execution writes a decision_execution_v1 receipt with execution status, target system/object, mutation, execution id, state hashes, action_binding_hash, and execution_hash.
  • GET /api/decision/:id/execution lists execution receipts for a decision in the caller API-key scope.
  • @decide-fyi/sdk now exposes recordExecution() and listExecutions(), plus sdk/examples/action-execution-receipt.js.

Counterfactual analysis added

Decide can now evaluate simulation-only what-if scenarios against a stored Decision Record, making policy tuning and rollout review a first-class API surface.

  • POST /api/decision/:id/counterfactuals returns decision_counterfactuals_v1 with baseline-to-scenario verdict, action, policy version, and hash diffs.
  • Scenario inputs are labeled and capped, and every scenario is marked simulation_only so it is not treated as downstream action authorization.
  • @decide-fyi/sdk now exposes counterfactuals(), plus sdk/examples/counterfactual-analysis.js.

Policy pattern catalog added

Decide now has a public first-party catalog for Decision API pattern templates, turning the registry into a browsable onboarding surface without claiming a community marketplace before one exists.

  • /resources/patterns lists pricing exception, refund review, agent action gate, and CRM write-back patterns.
  • Each detail view links back to /api/decision/policy-patterns and the packaged policyPatterns() SDK path.
  • Machine-readable docs now expose the catalog URL alongside the registry endpoint.

Policy pattern registry added

Decide now exposes first-party templates for common state-changing workflows so teams can start from a versioned request shape instead of inventing their first payload from scratch.

  • GET /api/decision/policy-patterns returns decision_pattern_registry_v1 with request, outcome, CRM sync, and SDK example hints.
  • ?pattern_id=pricing_exception resolves one decision_pattern_v1; ?tag=crm filters the registry by workflow tag.
  • @decide-fyi/sdk now exposes policyPatterns(), plus sdk/examples/policy-patterns.js.

CRM write-back receipts added

Decide now has a CRM sync receipt primitive so teams can prove a Decision Record was written back to Salesforce, HubSpot, or another source system without storing CRM credentials in Decide.

  • POST /api/decision/:id/crm-sync writes a decision_crm_sync_v1 record with CRM object references, mapped Decision Record fields, idempotency, and sync_hash.
  • GET /api/decision/:id/crm-sync lists CRM sync receipts for a decision in the caller API-key scope.
  • @decide-fyi/sdk now exposes recordCrmSync() and listCrmSyncs(), plus sdk/examples/crm-writeback.js.

Anonymized policy benchmarks added

Decide can now compare caller-scoped policy outcomes to opt-in anonymized cohorts after minimum privacy thresholds are met, turning Outcome Records into a safer data-moat primitive.

  • GET /api/decision/policies/:policy_id/benchmarks returns decision_benchmark_v1 with caller metrics, cohort percentiles, comparison deltas, privacy thresholds, and benchmark_hash.
  • Benchmark collection is explicitly opt-in through DECIDE_BENCHMARKS_ENABLED; raw records are not returned and the caller is excluded from its comparison cohort.
  • @decide-fyi/sdk now exposes policyBenchmarks(), plus sdk/examples/policy-benchmarks.js.

Predictive decision confidence added

New Decision Records now carry a hashed confidence signal derived from caller-scoped Outcome Records, so integrations can distinguish routine verdicts from decisions that deserve closer review.

  • decision_confidence_v1 includes score, level, similar decision count, policy stability, recommendation, reasons, and confidence_hash.
  • GET /api/decision/policies/:policy_id/confidence returns a confidence baseline for a candidate verdict/action.
  • @decide-fyi/sdk now exposes policyConfidence(), plus sdk/examples/policy-confidence.js.

Cryptographic audit chains added

Decision Records now link into a caller-scoped audit chain so a stored decision can be placed in a tamper-evident sequence without changing the stable Decision Record hash.

  • audit_chain binds decision_id, record_hash, and receipt_hash into a rolling Merkle root.
  • GET /api/decision/chains/:chain_id returns decision_chain_v1 head metadata, retained links, and verification checks.
  • @decide-fyi/sdk now exposes decisionChain(), plus sdk/examples/decision-chain.js.

Policy anomaly reports added

Decide now turns reported Outcome Records into explainable anomaly reports for unusual policy results, without claiming model prediction before enough customer data exists.

  • GET /api/decision/policies/:policy_id/anomalies returns decision_anomaly_report_v1 from latest Outcome Records per decision.
  • Reports include baselines, anomaly score, severity, reason codes, observed metrics, recommendation, and anomaly_hash.
  • @decide-fyi/sdk now exposes policyAnomalies(), plus sdk/examples/policy-anomalies.js.

Policy effectiveness scoring added

Decide now turns reported Outcome Records into scoped policy effectiveness metrics, giving teams a way to see whether a policy is producing reliable operational results.

  • GET /api/decision/policies/:policy_id/effectiveness returns policy_effectiveness_v1 metrics from latest Outcome Records per decision.
  • Scores include success, failure, review, terminal coverage, confidence, recommendation, and explicitly labeled proxy-quality rates.
  • @decide-fyi/sdk now exposes policyEffectiveness(), plus sdk/examples/policy-effectiveness.js.

Decision Outcome tracking added

The Decision API can now record what happened after a Decision Record authorized or routed an action, creating the first data-moat primitive for policy effectiveness and future anomaly analysis.

  • POST /api/decision/:id/outcome writes a decision_outcome_v1 record with outcome_hash, idempotency, execution references, observed metrics, and Decision Record hash links.
  • GET /api/decision/:id/outcome lists stored outcomes for a decision.
  • @decide-fyi/sdk now exposes recordOutcome() and listOutcomes(), plus sdk/examples/outcome-tracking.js.

Decision Record conformance fixtures added

The SDK now ships a public conformance pack with a valid Decision Record, original input, tampered record, and replay/diff example so integrators can test verification behavior without live API access.

  • sdk/fixtures/valid-decision-record.json verifies with the public conformance HMAC secret.
  • sdk/fixtures/tampered-record.json fails record, receipt, and signature checks.
  • sdk/fixtures/replay-diff-example.json documents the shape of a current-policy drift packet.

SDK published with packaged action-gate examples

The public npm package now includes first-party examples for billing discount gates, webhook and queue workers, agent action authorization, and CI Decision Record verification.

  • @decide-fyi/sdk is published on npm for server-side Decision API integrations.
  • sdk/examples/billing-discount-gate.js shows a billing mutation gated by a stored Decision Record.
  • sdk/examples/webhook-queue-gate.js shows fail-closed queue and webhook side-effect routing.
  • sdk/examples/agent-action-gate.js shows agent execution authorization before the proposed action runs.

Decision Record trust envelope added

Decision Record v1 now carries stronger verification fields for production integrations: action binding, policy bundle attestation, true idempotent retries, evidence manifests, receipt hashes, optional signed receipts, an offline verifier, and a verify endpoint.

  • /api/decide returns receipt_hash, verify_url, policy_bundle_hash, action_binding, evidence_manifest, and integrity metadata.
  • response_view now supports minimal, standard, and full projections over the same canonical record.
  • Receipt signing can add HMAC or Ed25519 receipt_signature fields, plus receipt_public_key_fingerprint for portable public checks.
  • /api/decision/receipt-keys publishes active Ed25519 public receipt keys when portable public signing is configured.
  • scripts/decision-offline-verify.js verifies exported records by recomputing hashes and checking Ed25519 or HMAC signatures.
  • x-idempotency-key now replays the original record for matching payloads and returns 409 for payload conflicts.
  • /api/decision/:id/verify recomputes record, receipt, and policy bundle hashes for stored or supplied records.
  • The docs replay lab now verifies the receipt before running replay drift checks.

Integration assets added for customer conversations

Added public integration guides, developer examples, and this changelog so a prospect can evaluate how Decide fits into existing CRM, billing, automation, webhook, queue, and agent boundaries.

  • Integration guides now describe shared rollout patterns and system-specific handoff rules.
  • Developer examples now provide copyable cURL, JavaScript, Python, webhook, replay, and routing snippets.
  • Changelog now gives a lightweight public product-velocity surface.

Homepage conversion flow sharpened around the Decision API

Promoted the playground as the lowest-friction hero action, clarified the expansion path from one boundary to broader software-action gates, and added an integration handoff panel with cURL, JavaScript, and Python snippets.

  • Hero action order now leads with playground, then API access, then docs.
  • Proof surfaces are framed as inspection paths for one API contract.
  • Pricing badges now describe real rollout scope instead of fake popularity signals.

Public uptime monitor defaults restricted to Decide

The public uptime endpoint default allowlist now stays Decide-only so the status surface does not leak unrelated product domains when environment configuration is missing.

  • Static guardrails now check the default monitor allowlist.
  • Reliability and smoke workflows passed after the change.

Docs tightened around production onboarding and replay

The docs were reorganized around the actual production path: quickstart, auth, rate-limit behavior, request fields, storage fields, outcome handling, error API contract, replay, and cutover checklist.

  • Added explicit x-api-key, x-idempotency-key, and rate-header guidance.
  • Added deterministic replay self-check tooling on the docs page.
  • Clarified reference applications as proof assets, not the core API product.

Pricing reframed around Decision API records and action boundaries

The pricing story moved away from old workflow-specific language and toward production API tiers by monthly decision records, live action boundaries, and implementation support level.

  • Evaluate remains free for sandbox and docs validation.
  • Starter, Team, and Enterprise now describe production API scope.
  • The ROI calculator models one bounded decision workflow without claiming guaranteed savings.

Decide ownership bridge clarified

Public compatibility routes for older reference-app paths remain live, but the current product surface is the Decision API. Reference applications are now positioned as source-backed proof surfaces built on the same recorded-decision pattern.

  • Legacy routes were kept lightweight and noindexed where appropriate.
  • Navigation no longer exposes old product-mode labels.
  • Machine-readable discovery still preserves stable remote endpoints for existing integrations.

What to watch next

The highest-signal future entries will come from real customer questions: connector-specific guides, production proof artifacts, security-review updates, and measured rollout learnings.

Customer proof

Only after it exists

Testimonials, logos, production counts, and case studies should appear only when they can be backed by permission and evidence.

Integration depth

Guides should follow objections

Add deeper connector pages when prospects repeatedly ask how Decide fits a specific system or workflow.

Reliability

Status should stay inspectable

Operational readiness, monitor coverage, and incident language should remain explicit and modest.