Skip to content

Release.

How a Decision changes without breaking its callers.

Publishing freezes a Definition into a numbered release. TypeFuse reads what changed and picks the version number, and each caller moves when its code is ready.

Rules change. Callers shouldn’t break when they do. A release is a frozen copy of the Decision with a number that says what kind of change it is.

Callers name the versions they accept, so a breaking change waits until each one is ready for it.

Who
The Decision’s owner, with approval where you require it
Where
Versions and Environments in the app, or the CLI
You end up with
A release serving in Test, then Production

Publish a frozen release.

Publishing compiles the Definition into a plan, checks it and freezes both. A release answers the same way for as long as it lives, and keeps the exact source it was published from.

  • A revision number for exact replay and debugging
  • The source and its format kept as written
  • Its Evaluations kept beside it

The number says what changed.

TypeFuse compares the new Definition with the last release. A change that breaks the contract is a new major version, a change in behaviour is minor and a change to wording or documentation is a patch.

  • Major: a new required input, or an answer removed or changed
  • Minor: new rules or instructions, an optional input or an added answer
  • Patch: clearer descriptions, nothing else

Test, then Production.

Deploy a release to Test, check it with real calls, then promote it to Production. Each environment shows which releases it serves.

  • The promotion path is the same for every Decision
  • Each environment has its own keys
  • A passing Test set is needed for Production, unless you turn that off
  • Roll back by deploying the previous release

Callers move when ready.

Each caller says which versions it accepts, such as ^1.4.0. When 2.0.0 reaches Production, callers on ^1.4.0 keep getting the newest 1.x until their code moves to 2.

  • No surprise breaks for callers that name a range
  • Exact versions for replaying a call
  • Old majors keep answering after a new one is deployed

A person approves.

A deployment to Production that an agent asks for waits until a person approves it. An organisation can also require approval for every deployment, and from a second person. Agents can ask for one; only a person can approve it.

  • Who asked and who approved, on the record
  • Through which token or connected app the request came
  • In the change history, and in the evidence pack for the period on paid plans

Where it happens.

In the app

  • Versions with what changed in each
  • Environments, the promotion path and what each serves
  • Approvals for Production

Your agent, over MCP

  • Publishes and deploys to Test
  • Asks for a Production deployment
  • Never approves

Your code

  • typefuse publish and typefuse deploy in CI
  • accepts ranges in the SDK
  • Exact versions for replay

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.