---
title: Quickstart
description: From a Google Doc to a released Decision Pack and your first decision, in about 15 minutes.
sidebar:
  order: 3
---

In about 15 minutes you will turn a policy in a Google Doc into a released Decision Pack, then ask Felspar for a decision the way an agent would.

**You need:**

- a Felspar account (see step 1);
- a Google Doc that states one decision: which team a support ticket goes to, whether an NDA can be signed without a lawyer, which applicants advance, which prospects qualify. Short and specific is best. The steps below use the fictional [Fernwood Payments policy](/concepts/fernwood-example#the-full-policy), a sales-qualification policy; copy it into a new Doc to follow along exactly, or use your own and swap in its job and question keys;
- ChatGPT or Claude;
- a terminal with `curl`, for the last step.

## 1. Sign in

Go to [app.felspar.ai](https://app.felspar.ai) and sign in. Felspar is invitation-only for now: if your account has no workspace yet, the sign-in page offers a short request-access form, and someone on your team (or at Felspar) invites you by email.

The first person in a workspace is its **owner**. Owners can approve and release packs. If someone else invited you, you are a **member** until the owner makes you an **approver**. See [Roles and permissions](/guides/roles-and-permissions).

You stay signed in for up to 30 days on the same browser.

## 2. Connect your Google Doc

1. Open **Sources** in the web app.
2. Under **Google Drive**, connect your own Google account. Felspar asks only for access to files you pick.
3. Click **Open Google Drive**, choose your Doc, then **Add**.

Felspar reads the exact current version of the Doc and keeps it as a source. From now on it watches the Doc for edits. See [Connect Google Docs](/guides/connect-google-docs).

## 3. Connect Felspar to your assistant

- **ChatGPT:** your ChatGPT workspace admin installs the Felspar plugin. See [ChatGPT](/integrations/chatgpt).
- **Claude:** add a custom connector with the URL `https://mcp.felspar.ai/mcp`, or install the Felspar plugin in Claude Code. See [Claude](/integrations/claude).

The first time a Felspar tool runs, you sign in with your Felspar login. Your assistant then acts as you, with your permissions, and can never approve or release anything.

## 4. Draft the pack

Ask your assistant, in your own words:

> Draft a Felspar pack from my "Fernwood ICP policy" doc. The job is `classify-prospect`.

With the plugin installed, the assistant follows the `drafting-decision-packs` skill. It will:

1. call `get_pack_guide` to learn the pack format;
2. call `list_sources` and `read_source` to read your Doc exactly;
3. write the job's purpose, its subject (here a company, identified by its web domain), the questions, answers, rules, next steps, escalations and test cases, quoting your Doc;
4. call `check_pack` until every quote is found, every rule compiles and every test passes;
5. ask you about gaps the Doc leaves open, one at a time;
6. call `propose_pack`, and give you a **review link**.

If the Doc doesn't define something the pack needs, the assistant proposes a sentence for you to add to the Doc. Add it, and the assistant re-reads the Doc. Meaning always comes from the document, never from the chat.

## 5. Approve and release

Open the review link. You need to be the owner or an approver.

1. Read **Do these rules match your document?** Each rule and definition sits next to the passage it quotes.
2. Read **Would it give the expected answers?** These are the test cases and their actual results.
3. Tick the two review boxes, add a short note, and click **Approve this exact proposal**.
4. On the next page, click **Release this approved Pack**.

The pack is now released. It can be replaced by a newer release, never edited. See [Approve and release](/guides/approve-and-release).

## 6. Register an agent

Agents don't use your login. Each one gets its own key.

1. Open **Workspace** in the web app and find **Company agents**.
2. Name the agent, for example `Quickstart test`.
3. For your job, choose **Latest (follows each approved release)**.
4. Click **Register agent**. Copy the key now: it is shown once. Keep it in a secret manager or an environment variable, never in chat or Git.

```sh
export FELSPAR_AGENT_KEY="paste-the-key-here"
```

See [Register an agent](/guides/register-an-agent).

## 7. Get your first decision

List the jobs your agent may run, then ask what one needs:

```sh
curl -s https://api.felspar.ai/v0/jobs \
  -H "Authorization: Bearer $FELSPAR_AGENT_KEY"

curl -s https://api.felspar.ai/v0/jobs/classify-prospect/brief \
  -H "Authorization: Bearer $FELSPAR_AGENT_KEY"
```

The brief leads with the job's purpose and its subject: what each case is about, and in `subject.send`, exactly which ID to send (here the company's web domain). Then it lists each question by its `key`, what each answer means, where to look and the request format. Now send evidence for each question: the exact words a source says, and where they came from. With the Fernwood pack, the question keys are `page_kind`, `offering`, `main_user`, `money_role` and `payout_pattern`; with your own policy, use the keys in your brief. This first request sends only two questions, so expect an undecided result that names what is missing.

```sh
curl -s https://api.felspar.ai/v0/jobs/classify-prospect/decisions \
  -H "Authorization: Bearer $FELSPAR_AGENT_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "mode": "facts",
    "executionId": "quickstart-0001",
    "jobId": "classify-prospect",
    "entityId": "tidewell.example",
    "facts": {
      "page_kind": {
        "text": "Tidewell: card issuing for any platform, live in days.",
        "source": {
          "class": "company-site",
          "id": "https://tidewell.example",
          "locator": "https://tidewell.example/#hero",
          "observedAt": "2026-10-21T09:00:00Z"
        }
      },
      "offering": {
        "text": "Tidewell: card issuing for any platform, live in days. Read the API docs.",
        "source": {
          "class": "company-site",
          "id": "https://tidewell.example",
          "locator": "https://tidewell.example/#hero",
          "observedAt": "2026-10-21T09:00:00Z"
        }
      }
    }
  }'
```

The response has:

- `status` and `reason`: `ready` when a rule decided; otherwise why nothing was decided yet, such as `gap` when a question the decision needs has no evidence (here, `main_user` and `money_role`);
- `result.outcome`: the outcome, such as `platform_builder`, or `null`;
- `result.explanation`: why, with the deciding rule quoted from your Doc, and what is still missing;
- `result.retry` and `result.attempts`: when undecided, which questions to work on and whether to retry or escalate;
- `result.subject`: the case as Felspar keyed it, with the ID normalized by the subject's match rule (`Tidewell.example` and `tidewell.example` are one case);
- `result.escalation`: when the pack names a hand-off for this result, its `id`, `trigger` and the policy's `why`. Your own code decides what each escalation does;
- `result.receipt` and `result.executionObjectId`: the receipt and the ID you verify it with.

If the request has a mistake, Felspar refuses it and lists every problem with its path and a fix. See [Refusal codes](/reference/refusal-codes).

## 8. Verify the receipt

```sh
curl -s https://api.felspar.ai/v0/executions/EXECUTION_OBJECT_ID/verify \
  -H "Authorization: Bearer $FELSPAR_AGENT_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "receipt": RECEIPT_JSON, "expectedReceiptDigest": "RECEIPT_DIGEST" }'
```

Felspar replays the decision from what it recorded and answers `reproduced` or `mismatch`, with the job, entity, release, outcome, subject and escalation it reproduced. This is what a [pre-action gate](/guides/pre-action-gate) does before a tool acts.

## Next

- Wire a real agent. In Eve it's two lines with `@felspar/sdk`:

  ```ts
  import { defineMcpClientConnection } from "eve/connections";
  import { felsparConnection } from "@felspar/sdk/eve";
  export default defineMcpClientConnection(felsparConnection());
  ```

  Then `npx @felspar/sdk skill` installs the Felspar method. See [Eve](/integrations/eve), [Claude Agent SDK](/integrations/claude-agent-sdk), [OpenAI Agents SDK](/integrations/openai-agents-sdk) or [REST and n8n](/integrations/rest-and-n8n).
- Change the policy safely: [Source changes](/guides/source-changes) and [Review and backtest](/guides/review-and-backtest).
- Understand the parts: [Core concepts](/concepts/decision-packs), and [Subjects and escalations](/concepts/subjects-and-escalations) for jobs about tickets, contracts or candidates.