Every caller reaches the same copy of the Decision. The input is checked, the release is chosen and its pinned model is asked, and the answers come back in TypeSafe’s own shape.
Nothing runs inside your app, so a new minor or patch release reaches your callers without a new build.
- Who
- Your agents, apps and scripts
- Where
- MCP, the SDK, the CLI or HTTP
- You end up with
- Native answers and a record of the call
From an agent.
An agent finds the Decision, reads what it needs and calls it with the facts of the case. The answers come back with the release that gave them.
call_decisionwith the Decision’s name and the facts- Answers and confidence in TypeSafe’s shape
- A refusal by name if it isn’t offered or deployed
search_decisions("refund eligibility") ←acme/refunds1.4.0 · 42/42 tested call_decision("acme/refunds", { days_since_delivery: 12, item_condition: "damaged", }) ← route: review · 0.88 · run_demo_1042
From your app.
Your app calls the Decision by name with the SDK, or posts to the runtime over HTTP with an API key. It says which versions it accepts.
- A thin client: the SDK holds no rules
acceptskeeps your app on the major it was written for- Plain HTTP if you’d rather not use the SDK
// Your app, with @typefuse/sdk
const result = await runtime.decide("acme/refunds", {
days_since_delivery: 12,
item_condition: "damaged",
}, { accepts: "^1.4.0" });
// route: review · 0.88 · 1.4.0# or over HTTP
POST https://run.typefuse.ai/v1/acme/refunds
Authorization: Bearer tf_live_…What happens on the server.
The runtime checks the input against the Definition, picks the newest release the caller accepts, asks the model and returns the answers. The call’s record follows within seconds.
- The same checks for every caller
- The pinned model of the release that answers
- Recorded before answering if your organisation turns that on
- Check the inputagainst
state_schema - Choose the releasethe newest the caller accepts
- Ask the modelthe release’s pinned jev-1.13.0
- Return the answersnative TypeSafe answers
- Record itwithin seconds
Whose key pays.
By default each call uses your own TypeSafe key: your app sends it with the call, or you store one for the environment, and nobody can read a stored key back. Relay keeps the key in your app entirely. Managed uses TypeFuse’s key.
- Your own key (BYOK), the default
- Relay: TypeFuse prepares the request and your app sends it
- Managed: usage billed, on Enterprise
The default. Your app sends its own TypeSafe key with each call, or you store one for the environment so it doesn't have to; nobody can read a stored key back.
SDK: createRuntime({ apiKey, typesafeKey }).For a key that must never leave your systems. TypeFuse prepares the request, your app sends it to TypeSafe and hands the response back. A little slower, no shadows, and the audit marks responses as reported by your app.
SDK: add route: "relay".TypeFuse's own key answers and the usage is billed; Enterprise, by contract.
Fast enough for a request.
Answers through TypeFuse come back lightning fast, close to calling the model directly. If TypeFuse can’t answer in time, your code gets a clear error and can use its own default.
- Lightning fast, close to calling the model directly
- The same answers as calling the model directly, in our tests
- A clear timeout your code can catch and act on
| When | Your code gets |
|---|---|
| Answered | the answers, their confidence and the release |
| Too slow or unavailable | a clear error, so your own default runs |
Where it happens.
Your agent, over MCP
search_decisions,describe_decision,call_decision- Signs in through the browser
- Calls only what you offer it
Your app
runtime.decide("withacme/refunds", …)@typefuse/sdk- Or
POST /v1/with an API keyacme/refunds - Relay through
…/prepareand…/complete
The CLI
typefuse callfor a one-off- The same release choice
- The same record
Private preview
Own your next decision.
Keep the judgement calls your agents and apps make under your control, with a record of every answer.
- Your criteriaThe people who own a decision set its rules, and change them when the business changes.The people who own a decision set its rules.
- Your evidenceEvery release is tested against real cases before your application ever sees it.Every release is tested on real cases first.
- Your recordEvery answer is traced and sealed, ready for an auditor or the customer who asks why.Every answer is traced and sealed.