Skip to content

Build.

How a judgement becomes a Decision your team can read.

A Decision is one short file: the facts it needs, the rules it follows and the questions it answers. Write it yourself, or describe it to your agent and review what it drafts.

Most teams start with rules spread across prompts and policy documents. Building a Decision puts them in one place, in a form a person can read and a machine can check.

The result is a draft. It can be tested and changed as often as you like, and nothing calls it until it is published.

Who
The person who owns the rules, with or without an agent
Where
The editor in the app, your agent over MCP, or the CLI
You end up with
A checked draft, ready to test

Write it in plain YAML.

Every Decision has the same parts: the model it uses, the facts each caller sends, the rules that stay the same and the questions it answers. YAML is the main format and JSON works too. TypeFuse keeps exactly what you wrote.

  • state_schema checks the facts on every call
  • context holds your rules and reference material
  • questions use TypeSafe’s own types: noul, choice and score

Describe it to your agent.

With the TypeFuse skill installed, your agent can draft a Decision from a description, add Worked Examples and run the tests. You read the draft and say when it’s ready to publish.

  • Claude Code and Codex through the skill, and any MCP client
  • Drafts stay drafts until you say they’re ready
  • The same checks run on what your agent writes

Checked as you type.

The editor checks the draft on every change and points at the exact field that needs work. Publishing refuses an object or a list that doesn’t say what it holds, so the draft stays editable until it does.

  • The exact path, such as state_schema.properties.items
  • A fix you can apply for the mechanical ones
  • No model runs these checks: they are TypeFuse’s own rules

Ask the assistant.

“Review my Definition” reads the draft and suggests improvements, such as two criteria that overlap. “Ask the assistant” takes what you want in your own words and proposes a change. Each suggestion is a change to the draft that you accept or leave.

  • Shown as a change to the YAML, with what it does
  • Your call each time. Nothing is applied until you accept it
  • Never published by the assistant

One question, many items.

When a request carries a list, such as the items in an order, a question can be asked once per item in the same call with each: input.items. The answers come back in the same order as the items.

  • Up to 100 items in a list
  • Asked together with the rest of the request
  • Each item’s answer stays next to the item it belongs to

Where it happens.

In the app

  • The Definition editor, with Review as you type
  • Review my Definition and Ask the assistant
  • Worked Examples beside the draft

Your agent, over MCP

  • Drafts and edits through the TypeFuse skill
  • review_draft runs the same checks, and apply_fix applies a fix
  • Publishes only with full access, once you say the draft is ready

Your code

  • The source kept in your repository, sent with typefuse draft push
  • typefuse compile checks it and gives advice
  • typefuse review --strict in CI

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.