Skip to content

Call.

How agents and apps ask a Decision.

Agents call a Decision through MCP. Apps call it by name with the SDK or over HTTP. Either way the work happens on TypeFuse’s servers, against the release the caller accepts.

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_decision with 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

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
  • accepts keeps your app on the major it was written for
  • Plain HTTP if you’d rather not use the SDK

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

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

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

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("acme/refunds", …) with @typefuse/sdk
  • Or POST /v1/acme/refunds with an API key
  • Relay through …/prepare and …/complete

The CLI

  • typefuse call for 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.