# Quickstart

Join, connect your agent, ask it for your first Decision and put it to use.

## Create your account

Join at [TypeFuse](https://typefuse.dev/signup). You get a personal space named after your username (such as
`@dana`), where you can build and test Decisions straight away. Create an organisation when you want
to work with a team or ship to production; see
[Organisations and moving Decisions](https://typefuse.dev/guides/organisations).

## Connect your agent

Run this in a terminal. It installs the TypeFuse skill and adds the TypeFuse tools to Claude Code.
It writes only under `~/.claude` and `~/.codex`, and you can [read the script](https://typefuse.dev/install)
first:

```sh
curl -fsSL https://typefuse.dev/install | sh
```

Or paste this into any agent and let it set itself up:

```prompt
Install the TypeFuse skill and MCP server from https://typefuse.dev/agents.md, then ask me to sign in.
```

## Sign in

- **Claude Code**: run `/mcp`, choose **typefuse** and **Authenticate**.
- **Codex**: add the tools with `codex mcp add typefuse --url https://api.typefuse.dev/v1/mcp`, then run
  `codex mcp login typefuse`.
- **claude.ai**: in Settings → Connectors, add a custom connector with the URL `https://api.typefuse.dev/v1/mcp`, then
  sign in when asked.

Signing in opens TypeFuse in your browser, where you choose which organisation the agent may use
and how much it may do. Choose **Full** so it can create your first Decision. The
[Agents page](https://typefuse.dev/agents) has every step for each agent.

## Ask for your first Decision

Paste this into your agent, with the judgement you want in place of the brackets, such as "whether
a refund request should be approved, reviewed or declined":

```prompt
Use TypeFuse to build a Decision that judges <what you want decided>. Write three to five Examples, evaluate it, and tell me before you publish.
```

The agent writes the Definition, adds Examples, runs an Evaluation and stops before it publishes, so
you can read what it made. Open the Decision in TypeFuse to see its questions, try an input in the
Sandbox and change anything you like. [Decisions and Definitions](https://typefuse.dev/guides/decisions) explains what
you're looking at.

## Publish, deploy and call it

When the Decision answers the way you want, ask the agent to publish it, or publish it yourself.
Publishing freezes a version that never changes; see [Versions and releases](https://typefuse.dev/guides/versions).
Then deploy the release to an environment
([Deploying, environments and approvals](https://typefuse.dev/guides/deployments)) and call it from your own software:
[Calling a Decision](https://typefuse.dev/guides/calling) has what you need and the request to send.

## Let your agents use it

In the Decision's Settings, turn on **Offer to agents**. Any agent you connect can then find it by
the judgement it needs, read what it expects and call it for each item. Every call is recorded like
any other.

Add this to your `AGENTS.md` or `CLAUDE.md`, so your agent looks for a Decision before it judges by
itself:

```md
## Judgements

This organisation keeps its business judgements (eligibility checks, risk scores, routing choices) as TypeFuse Decisions in <your organisation>. Before making one yourself, search for a Decision with search_decisions and call it for each item. If none fits, say so rather than guessing.
```

### Where next

- [Examples, Test sets and the Sandbox](https://typefuse.dev/guides/examples-and-test-sets): the evidence that a
  Decision answers as you intend.
- [Test runs and Evaluations](https://typefuse.dev/guides/evaluations): run that evidence against a draft or a version.
- [The Decision log and audit](https://typefuse.dev/guides/decision-log): every answer, recorded.
- [Connecting an agent](https://typefuse.dev/guides/agents): what an agent can do, and what you allow.
