---
title: "Playbook for LLM agents building with Jev"
type: guide
tags: [playbook, agent, integration, checklist, decision-table]
created: 2026-09-17
updated: 2026-09-20
confidence: high
sources:
  - wiki/concepts/system-one.md
  - wiki/concepts/primitives.md
  - wiki/concepts/state.md
  - wiki/concepts/confidence.md
  - wiki/concepts/how-to-build.md
  - wiki/concepts/jaggedness-jev-1-13.md
  - wiki/concepts/use-case-map.md
  - wiki/concepts/workflow-evals.md
  - wiki/reference/http-api.md
  - wiki/reference/models-and-pricing.md
  - wiki/reference/rate-limits-and-errors.md
  - wiki/reference/python-sdk.md
  - wiki/reference/python-sdk-responses.md
  - wiki/reference/javascript-sdk.md
  - wiki/reference/environment-variables.md
  - wiki/reference/agent-skill.md
  - wiki/patterns/overview.md
  - wiki/patterns/fan-out.md
  - wiki/patterns/confidence-routing.md
  - wiki/patterns/composite-scoring.md
  - wiki/cookbooks/overview.md
  - wiki/cookbooks/parallel-questions.md
  - wiki/cookbooks/classification-using-confidence.md
  - wiki/guides/quickstart.md
  - wiki/guides/choosing-a-primitive.md
  - wiki/guides/writing-instructions-and-criteria.md
  - raw/docs/introduction__quickstart.md
  - raw/docs/agent-skill.md
jev_version: "jev-1.13.0"
sdk_python: "0.6.0"
sdk_js: "0.6.0"
summary: "Seven-step playbook for an agent told 'use Jev for X': decide, decompose, shape state, write questions, call, consume, handle errors, test."
---

# Playbook for LLM agents building with Jev

> **TL;DR** Jev answers narrow, typed questions about one `state` and returns `choice`/`score`/`noul` plus calibrated probabilities — it never generates text, does arithmetic, or picks its own next action. Decompose the user's job into atomic questions, filter the state down to what those questions need, ask them all in one `POST /v1/systemone`, and branch in code on the values and on `confidence`. Everything deterministic stays in your code.

## Step 0 — Is Jev the right tool?

Work backwards from the behavior the user wants: what will the application show, select, change, or hand off? ([[reference/agent-skill]]). Then place each decision in this table.

| Task shape | Verdict | Why |
|---|---|---|
| Classify into a known set of categories | **Jev** ([[concepts/choice]]) | The answer space is known in advance and the consumer is code ([[concepts/system-one]]). |
| Detect whether a property holds | **Jev** ([[concepts/noul]]) | The probability itself is the signal. |
| Rate on a rubric you can describe level by level | **Jev** ([[concepts/score]]) | Ordered, thresholdable, comparable across items. |
| Route a request to a handler, queue, or model | **Jev** + code | [[patterns/intent-routing]], [[patterns/confidence-routing]]. |
| Rank or shortlist on several dimensions | **Jev** + code | [[patterns/composite-scoring]]; weights live in your code, not a prompt. |
| Verify another model's output, citations, or tool calls | **Jev** | "Universal Verification" in [[concepts/use-case-map]]; [[cookbooks/citation-check]]. |
| Select a value that already exists in the text | **Jev**, as a Choice over candidates | Extraction becomes selection ([[cookbooks/pre-parsed-value-extraction]]). |
| Score millions of records cheaply | **Jev** | $0.042/Mtok input, output free ([[reference/models-and-pricing]]). |
| Write a reply, summary, explanation, or code | **An LLM** | "`jev-1.13` is not trained to generate text" ([[concepts/jaggedness-jev-1-13]] #9). |
| Decide its own next action in a loop | **An LLM agent** | System One "does not generate code or choose its own next action" ([[concepts/how-to-build]]). |
| Multi-hop reasoning over several inferred facts | **An LLM**, or decompose | Indirection costs accuracy ([[concepts/jaggedness-jev-1-13]] #4). |
| Arithmetic, sums, counting, percentages | **Keep it in code** | "Jev is not a calculator" ([[concepts/jaggedness-jev-1-13]] #2). |
| Date ordering, durations, windows, weekdays | **Keep it in code** | Jev reads dates as text ([[concepts/jaggedness-jev-1-13]] #3); extract parts, compare in code ([[cookbooks/date-extraction]]). |
| Exact lookups, regex matches, status checks, thresholds | **Keep it in code** | "Use code when you can" ([[concepts/how-to-build]] step 1). |
| Images, audio, video | **Pre-process to text** | Jev is text-only ([[concepts/state]]). |

**Do NOT use Jev for:** generating text or code; math, counting, or reconstructing an exact number by interpolating between Score levels; date and time comparison; questions requiring several hops of indirection or double negatives; a huge `state` full of material the question does not need; anything a regular expression, parser, or `if` already answers exactly. Most of these are documented failure modes in [[concepts/jaggedness-jev-1-13]] (nine in total); the last one — what a regular expression, parser, or `if` already answers — is not on that list but follows the how-to-build rule "Use code when you can" ([[concepts/how-to-build]] step 1).

One more thing to check before you write code: Jev's primary training language is English, and other languages including CJK are accepted but less accurate ([[reference/models-and-pricing]]).

## Step 1 — Decompose the job into questions

The docs call this "probably the most important concept" ([[concepts/how-to-build]] step 4).

1. **List the decisions the workflow actually makes.** Each one is either a code rule or a judgment. Keep control flow, deterministic rules, and side effects in code.
2. **Split every judgment until each question tests exactly one property.** If you cannot name the single property a question tests, it is not atomic yet. "Rate this startup pitch" becomes market size, technical feasibility, differentiation — weighted in code ([[concepts/primitives]]).
3. **Pick a primitive per question** using [[guides/choosing-a-primitive]]: unordered options → Choice; a described spectrum → Score; a clean yes/no → Noul; a count → none, one Noul per item plus `sum()` in code; free text → none, propose candidates in code and let a Choice pick one.
4. **Ask each decision one way.** Structural invariants are not guaranteed: a Noul and a yes/no Choice on the same text returned `0.22` vs `probabilities["yes"] = 0.01`, and a question plus its negation summed to `1.19` ([[concepts/jaggedness-jev-1-13]] #8). Do not implement "not X" by subtracting X, and do not carry a threshold tuned on a Noul over to a Choice. Enforce identities, totals, and mutual exclusion in code.
5. **Add the speculative questions too.** Questions run in parallel and adding them barely changes latency ([[patterns/fan-out]]) — but state each speculative premise explicitly, and ignore the answers on branches you did not take.

## Step 2 — Shape the state

`state` is the single input every question in the request sees ([[concepts/state]]).

- **Shapes:** a string, a JSON object, or an array of text values. Nothing else. Prefer an object with descriptive field names so questions can point at paths.
- **Budgets:** 64k tokens for `state` plus **all** questions; 32k tokens for `state` plus the **single longest** question. Staying under 64k does not guarantee you are under 32k ([[reference/models-and-pricing]]).
- **Filter first.** Accuracy falls as the state grows with irrelevant detail, and a big state makes a wrong answer hard to localize ([[concepts/jaggedness-jev-1-13]] #5). Retrieve and filter in code; where you cannot, use a Noul as a relevance filter ([[cookbooks/classifying-rag-passages]]).
- **Pre-parse numbers and dates.** Compute the number or the named bucket in code and put *that* in the state; Jev does better on semantic representations than numeric ones ([[guides/writing-instructions-and-criteria]]).
- **Point at fields with backticked dot-and-index paths**, backticks included: `` `ticket.messages[0].text` ``.
- **Asymmetry to remember:** extra questions are cheap, extra state is not.

## Step 3 — Write instructions and criteria

Full guide: [[guides/writing-instructions-and-criteria]]. The rules that matter most:

- **Literal reading.** Jev answers the question you wrote, not the one you meant. When a wrong answer makes you say "but I meant…", that sentence belongs in `instructions` or in the criteria as a boundary case.
- **Question ids are never sent to the model** — write the complete question even when the id looks self-explanatory ([[reference/http-api]]).
- **Choice:** give the full option list (up to **255** options per the launch blog; one cookbook reports ~240 as the practical working limit — [[cookbooks/classification-using-confidence]]). Add an `other`/`none of the above` option whenever the list might not cover an input. For confusable options, escalate the description from a string to an object with `what` / `not_for` / `examples`.
- **Score:** `criteria` is an **ordered array** from low to high, at least 2 and **up to 10** levels, each describing a concrete situation rather than a degree ([[concepts/score]]). `["0","1","2"]` with "rate 0 to 2" in the instructions scored 0.57 at confidence 0.35 where described levels scored 0.0 at 1.0. One dimension per Score.
- **Noul:** keep `true` meaning yes. A Noul whose `true` maps to "no" performs worse ([[concepts/jaggedness-jev-1-13]] #7). Avoid double negatives — rewrite them positively.
- **Align criteria with the instruction.** Contradiction between the two is its own failure mode.

## Step 4 — Call it

Get a key from the console: the quickstart points at `https://console.typesafe.ai/settings/keys`, the agent-skill page at `https://console.typesafe.ai/keys` — the sources disagree on the path, both are under `console.typesafe.ai` ([[entities/typesafe-console]]).

Environment variables read by **both** SDKs ([[reference/environment-variables]]):

| Variable | Default | Effect |
|---|---|---|
| `TYPESAFE_API_KEY` | none — required | Sent as `Authorization: Bearer <key>`. |
| `TYPESAFE_BASE_URL` | `https://api.typesafe.ai` | API root. |
| `TYPESAFE_DEFAULT_MODEL` | `jev-latest` | Model used when a call omits `model`. |
| `TYPESAFE_LOG_LEVEL` | JS: `warn`; Python: unset | Logger level. `debug` prints request and response **bodies**, which are not redacted. |

Model ids: `jev-latest` and `jev-preview` both currently resolve to `jev-1.13.0`. Pin `jev-1.13.0` if you have tuned thresholds; the response's `model` field reports which version answered ([[reference/models-and-pricing]]).

### curl

```bash
export TYPESAFE_API_KEY="..."   # from console.typesafe.ai

curl -X POST https://api.typesafe.ai/v1/systemone \
  -H "Authorization: Bearer $TYPESAFE_API_KEY" \
  -H "Content-Type: application/json" \
  -d @- <<'EOF'
{
  "state": {
    "ticket_message": "I was charged twice for order A-104. Please refund the duplicate.",
    "refund_policy": "Duplicate charges are eligible for a refund."
  },
  "model": "jev-latest",
  "questions": {
    "refund_requested": {
      "type": "noul",
      "instructions": "Does `ticket_message` request a refund?"
    },
    "department": {
      "type": "choice",
      "instructions": "Which team should handle `ticket_message`?",
      "criteria": {
        "billing": "Charges, invoices, refunds, subscriptions",
        "technical": "Bugs, outages, integrations",
        "other": "Anything else"
      }
    },
    "frustration": {
      "type": "score",
      "instructions": "How frustrated does the customer appear in `ticket_message`?",
      "criteria": [
        "Calm, just stating facts",
        "Frustrated but civil",
        "Very angry, strong language"
      ]
    }
  }
}
EOF
```

### Python — `typesafe-sdk` 0.6.0, sync

```python
# pip install typesafe-sdk    (import name: typesafe_sdk; requires Python >= 3.10)
from typesafe_sdk import Choice, Noul, Score, TypeSafeClient

STATE = {
    "ticket_message": "I was charged twice for order A-104. Please refund the duplicate.",
    "refund_policy": "Duplicate charges are eligible for a refund.",
}

QUESTIONS = {
    "refund_requested": Noul(instructions="Does `ticket_message` request a refund?"),
    "department": Choice(
        instructions="Which team should handle `ticket_message`?",
        criteria={
            "billing": "Charges, invoices, refunds, subscriptions",
            "technical": "Bugs, outages, integrations",
            "other": "Anything else",
        },
    ),
    "frustration": Score(
        instructions="How frustrated does the customer appear in `ticket_message`?",
        criteria=[
            "Calm, just stating facts",
            "Frustrated but civil",
            "Very angry, strong language",
        ],
    ),
}

with TypeSafeClient() as client:  # reads TYPESAFE_API_KEY; defaults to jev-latest
    response = client.system_one(state=STATE, questions=QUESTIONS, model="jev-1.13.0")

print(response.model, response.usage.input_tokens)
print(response.answers["refund_requested"].noul)
print(response.answers["department"].choice, response.answers["department"].confidence)
print(response.answers["frustration"].score, response.answers["frustration"].legend)
```

### Python — async

```python
import asyncio

from typesafe_sdk import AsyncTypeSafeClient, Noul


async def main() -> None:
    async with AsyncTypeSafeClient() as client:  # await client.aclose() if not using `async with`
        response = await client.system_one(
            state="Help! My payouts have been failing for 3 days.",
            questions={"is_urgent": Noul(instructions="Does this convey urgency?")},
        )
        print(response.answers["is_urgent"].noul)


asyncio.run(main())
```

Build one client per process and reuse it — do not construct a client per request ([[reference/python-sdk]]).

### TypeScript — `@typesafe-ai/sdk` 0.6.0

```ts
// npm install @typesafe-ai/sdk   (Node >= 20; server-side only unless you opt into
// dangerouslyAllowBrowser, which exposes your key)
import { APIError, choice, noul, score, TypeSafeClient } from "@typesafe-ai/sdk";

const client = new TypeSafeClient(); // reads TYPESAFE_API_KEY, TYPESAFE_BASE_URL, TYPESAFE_DEFAULT_MODEL

try {
  const { answers, usage, model } = await client.systemOne({
    state: {
      ticketMessage: "I was charged twice for order A-104. Please refund the duplicate.",
      refundPolicy: "Duplicate charges are eligible for a refund.",
    },
    model: "jev-1.13.0",
    questions: {
      refundRequested: noul("Does `ticketMessage` request a refund?"),
      department: choice("Which team should handle `ticketMessage`?", {
        billing: "Charges, invoices, refunds, subscriptions",
        technical: "Bugs, outages, integrations",
        other: "Anything else",
      }),
      frustration: score("How frustrated does the customer appear in `ticketMessage`?", [
        "Calm, just stating facts",
        "Frustrated but civil",
        "Very angry, strong language",
      ]),
    },
  });

  console.log(model, usage.input_tokens);
  console.log(answers.refundRequested.noul);
  console.log(answers.department.choice, answers.department.confidence);
  console.log(answers.frustration.score, answers.frustration.legend);
} catch (err) {
  if (err instanceof APIError) {
    console.error(`API error ${err.status} (request ${err.requestId ?? "unknown"}):`, err.body);
  } else {
    throw err;
  }
}
```

Answer types are inferred from the questions you passed, so `answers.department.choice` narrows to `"billing" | "technical" | "other"` ([[reference/javascript-sdk]]).

## Step 5 — Use the answers

| Type | Read | Notes |
|---|---|---|
| Choice | `choice`, `probabilities`, `confidence` | `probabilities` maps every option to 0–1, summing to ~1. |
| Score | `score`, `legend`, `probabilities`, `confidence` | `score` may fall between levels; normalize with `score / (len(criteria) - 1)` before combining or comparing rubrics of different lengths. |
| Noul | `noul` | Probability of yes. **No `confidence` field.** `0.5` means yes and no are equally likely, not "medium". |

In Python, `response.answers[...]` is the mixed map and `response.nouls` / `response.choices` / `response.scores` are per-type views ([[reference/python-sdk-responses]]).

**Confidence-gated routing.** Check the floor *before* branching on the answer, then give each action its own threshold sized to the cost of being wrong ([[patterns/confidence-routing]]):

| Threshold | Context in the sources |
|---|---|
| `confidence < 0.5` | Route to a human, any action ([[concepts/confidence]]). |
| `confidence < 0.6` | Floor in the voice-banking example ([[patterns/confidence-routing]]). |
| `confidence >= 0.7` | Trust a Score before acting on its value ([[concepts/confidence]]). |
| `confidence < 0.75` / `< 0.8` | Route a topic Choice to human review ([[concepts/how-to-build]]). |
| `confidence > 0.85` / `> 0.9` | Act automatically on a high-stakes, destructive action. |
| `confidence >= 0.9` | Report the fine label, else fall back to the coarser one ([[cookbooks/classification-using-confidence]]). |

These are examples from the sources, not defaults. Tune them on your own labelled data ([[guides/testing-and-evaluation]]), and keep every question and threshold in one file so a human can review them ([[reference/agent-skill]]).

**Fan-out.** Put every question the decision tree could need in one request; batching 13 questions about a 54k-character document was 12.2x cheaper and 10.0x faster than 13 single-question calls, with unchanged answers ([[cookbooks/parallel-questions]], [[patterns/fan-out]]).

**Composite scoring.** Normalize each Score to 0–1, weight in code, and re-rank by changing a coefficient rather than re-running inference. Weighted sums are for compensating preferences; an "any serious violation" rule needs separate conditions ([[patterns/composite-scoring]]).

```python
answers = response.answers
spam_risk = (
    0.45 * answers["requests_credentials"].noul
    + 0.30 * answers["sender_identity_mismatch"].noul
    + 0.25 * answers["unexpected_reward"].noul
)
```

## Step 6 — Handle errors and limits

| Status | Retry? | Action |
|---|---|---|
| `400`, `403`, `404` | No | Fix the request, the key's access, or `TYPESAFE_BASE_URL`. |
| `401` | No | Check `TYPESAFE_API_KEY` and the `Bearer` prefix. |
| `422` | No | Body is `{"detail": [{loc, msg, type, ...}]}` — read `loc` and fix the field. |
| `408`, `429`, `5xx` (incl. `529 Overloaded`) | **Yes** | Exponential backoff; honor `retry-after-ms`, then `retry-after`. |
| Connection error / timeout | **Yes** | Retry; raise the client timeout if it recurs. |

Both SDKs retry by default: 2 retries after the initial attempt, 500 ms initial backoff doubling to a 5,000 ms cap, 25% jitter, retryable statuses `{408, 429, 500–599}`; the JS SDK caps an honored server delay at 60,000 ms. Per-attempt HTTP timeout is 10 s (Python `DEFAULT_TIMEOUT = 10.0`, JS `DEFAULT_TIMEOUT_MS = 10_000`) ([[reference/rate-limits-and-errors]]). Log the `x-typesafe-request-id` (`response.request_id` / `err.requestId`) on every failure.

Limits and cost ([[reference/models-and-pricing]]): **250,000 tokens/second** and **1,200 requests/minute**, either breach returning `429`; TypeSafe warns these "can change without notice," so treat `429` as normal rather than exceptional instead of hardcoding a client-side budget. Price is **$42 per Btok / $0.042 per Mtok on input tokens only — output tokens are free**. There is no uptime SLA ([[reference/legal-and-data]]).

## Step 7 — Test before shipping

Do not ship on the strength of a few hand-checked examples.

- **Consistency.** Jev is not deterministic: 15 repeats of one claim moved a Noul from `0.43` to `0.53`, across a 0.5 threshold ([[cookbooks/consistency-noul]]), and 2 of 8 Choice questions changed their top label ([[cookbooks/consistency-choice]]).
- **Held-out cases.** Tune wording and thresholds on one set, validate on another ([[guides/writing-instructions-and-criteria]]).
- **Jaggedness edge cases.** Regression-test literal reading, negation, numbers, dates, and adversarial content ([[concepts/jaggedness-jev-1-13]]).
- Full method, harness, and legal caveat: **[[guides/testing-and-evaluation]]**.

## Copy-paste checklist

- [ ] Every deterministic rule, sum, date comparison, and exact lookup is in code, not a question.
- [ ] Each question tests exactly one named property.
- [ ] Each decision is asked **one** way; invariants and totals are enforced in code.
- [ ] `state` is an object with descriptive keys, filtered to what the questions need, under 64k / 32k tokens.
- [ ] Questions point at state with backticked paths (`` `ticket.messages[0].text` ``).
- [ ] Choice has a `none`/`other` option; Score levels describe situations, 2–10 of them, one dimension; Noul `true` means yes.
- [ ] All questions for one state go in **one** request; a second request only when an answer is needed to build it.
- [ ] `TYPESAFE_API_KEY` set; key never shipped to a browser.
- [ ] `model` pinned to `jev-1.13.0` if thresholds are tuned; `response.model` logged.
- [ ] `confidence` checked before branching on `choice`/`score`; Noul thresholded on `noul` itself.
- [ ] Questions and thresholds live in one reviewable file.
- [ ] `429`/`529` retried with backoff; `401`/`422` never retried; `x-typesafe-request-id` logged.
- [ ] `usage.input_tokens` metered against $0.042/Mtok.
- [ ] Repeatability, held-out accuracy, and adversarial inputs tested before rollout.
- [ ] `TYPESAFE_LOG_LEVEL=debug` is off in production (bodies are not redacted).

## Common mistakes

| Mistake | Symptom | Fix |
|---|---|---|
| One broad question hiding several judgments | A single confident number that is wrong for a reason you cannot see | Decompose; the tool-call example isolates the unit mismatch only when split into nine questions ([[concepts/how-to-build]]) |
| Acting on `choice` without `confidence` | A 0.60/0.38 split and a 1.00/0.00 split behave identically | Gate on `confidence` first ([[patterns/confidence-routing]]) |
| Reading `.confidence` on a Noul | Attribute error / undefined | Noul has no `confidence`; threshold `noul` ([[concepts/confidence]]) |
| Treating `noul = 0.5` as "medium" | Mid-range answers routed as moderate intensity | 0.5 means yes/no equally likely; use a Score for magnitude ([[guides/choosing-a-primitive]]) |
| Asking for a count, a sum, or a date comparison | Errors that grow with the size of the thing counted | One Noul per item plus `sum()`; extract date parts as Choices and compare in code ([[concepts/jaggedness-jev-1-13]]) |
| Numeric Score levels (`"0"`, `"1"`, `"2"`) | Low confidence, scores drifting toward the middle | Describe a concrete situation per level ([[guides/writing-instructions-and-criteria]]) |
| No `other` option on a Choice | Probability mass lands on the least-wrong listed option | Add a catch-all ([[guides/choosing-a-primitive]]) |
| Dumping the whole record into `state` | Accuracy drops; wrong answers are hard to localize | Filter in code first ([[concepts/state]]) |
| Asking X and `1 - not_X` and expecting agreement | Probabilities that sum to 1.19 | Ask the one question you want ([[concepts/jaggedness-jev-1-13]] #8) |
| Serial calls, one question each | ~12x the cost and ~10x the latency | Batch into one request ([[cookbooks/parallel-questions]]) |
| Thresholds tuned against `jev-latest` | Behavior shifts silently when the alias moves | Pin `jev-1.13.0`, log `response.model` ([[reference/models-and-pricing]]) |
| Retrying `401` or `422` | Repeated failures, wasted quota | Retry only `408`/`429`/`5xx` ([[reference/rate-limits-and-errors]]) |
| Expecting `Score.criteria` to be an int-keyed dict | `TypeSafeError` at build or validation time | 0.6.0 takes an ordered sequence ([[reference/python-sdk]], [[reference/javascript-sdk]]) |
| Trusting a demo threshold from a cookbook | False positives or negatives in your domain | "Treat cookbook thresholds and demo results as examples to evaluate" ([[reference/agent-skill]]) |

## Where to look next

| Question | Page |
|---|---|
| What is this model, exactly? | [[concepts/system-one]], [[entities/jev]] |
| Which question type do I want? | [[guides/choosing-a-primitive]], [[concepts/primitives]] |
| How do I phrase it? | [[guides/writing-instructions-and-criteria]], [[concepts/advanced-structure]] |
| What can go in `state`? | [[concepts/state]] |
| What does `confidence` mean? | [[concepts/confidence]] |
| What exactly goes on the wire? | [[reference/http-api]], [[reference/openapi-schemas]] |
| SDK signatures | [[reference/python-sdk]], [[reference/python-sdk-questions]], [[reference/python-sdk-responses]], [[reference/javascript-sdk]], [[reference/javascript-sdk-types]] |
| Errors, retries, limits | [[reference/rate-limits-and-errors]], [[reference/python-sdk-retries-errors]], [[reference/javascript-sdk-errors]] |
| Price, aliases, context window | [[reference/models-and-pricing]] |
| Upgrading an old integration | [[reference/migrating-to-v1]] |
| Can I publish my measurements? | [[reference/legal-and-data]] |
| First call, end to end | [[guides/quickstart]] |
| How do I evaluate it? | [[guides/testing-and-evaluation]] |
| Common questions, terminology, history | [[syntheses/faq]], [[syntheses/glossary]], [[syntheses/version-timeline]] |
| Jev vs an LLM in JSON mode | [[syntheses/jev-vs-llm-structured-outputs]] |

Closest recipe by task type:

| Task | Start here |
|---|---|
| Routing / intent | [[patterns/intent-routing]], [[cookbooks/consistency-choice]] |
| Extraction | [[cookbooks/pre-parsed-value-extraction]], [[cookbooks/date-extraction]], [[cookbooks/sde-cascade]] |
| Ranking / reranking | [[cookbooks/rerank]], [[patterns/composite-scoring]] |
| Guardrails | [[cookbooks/llm-guardrails]], [[cookbooks/classifying-rag-passages]] |
| Dedup / record matching | [[cookbooks/entity-alignment]] |
| Classification with confidence | [[cookbooks/classification-using-confidence]], [[cookbooks/hierarchical-classification]] |
| Function calling / tool use | [[cookbooks/function-calling]] |
| Search inside a document | [[cookbooks/semantic-find]] |
| Verifying an LLM's claims | [[cookbooks/citation-check]] |
| Agent context management | [[cookbooks/skill-suggestion]] |
| Document structure | [[cookbooks/autoformat]] |
| Features for a classical ML model | [[cookbooks/autoresearch-feature-discovery]] |
| Cost and batching evidence | [[cookbooks/parallel-questions]] |
| Everything else | [[cookbooks/overview]], [[concepts/use-case-map]] |

## Related

- [[ideas/consult]] — not sure Jev fits the project at all? Run the consult procedure first (community tier)
- [[concepts/how-to-build]] — the seven-step design workflow this playbook operationalizes
- [[patterns/overview]] — the four architectural patterns
- [[reference/agent-skill]] — TypeSafe's own instructions to coding agents
- [[concepts/workflow-evals]] — evidence that the workflow shape beats a single prompt
- [[concepts/machine-learning-primer]] — why the probabilities are calibrated
- [[guides/smart-home-demo]] — fan-out plus an LLM fallback in a running app

## Sources

- wiki/concepts/system-one.md, wiki/concepts/primitives.md, wiki/concepts/state.md, wiki/concepts/confidence.md, wiki/concepts/how-to-build.md, wiki/concepts/jaggedness-jev-1-13.md, wiki/concepts/use-case-map.md, wiki/concepts/workflow-evals.md
- wiki/reference/http-api.md, wiki/reference/models-and-pricing.md, wiki/reference/rate-limits-and-errors.md, wiki/reference/python-sdk.md, wiki/reference/python-sdk-responses.md, wiki/reference/javascript-sdk.md, wiki/reference/environment-variables.md, wiki/reference/agent-skill.md, wiki/reference/legal-and-data.md
- wiki/patterns/overview.md, wiki/patterns/fan-out.md, wiki/patterns/confidence-routing.md, wiki/patterns/composite-scoring.md
- wiki/cookbooks/overview.md, wiki/cookbooks/parallel-questions.md, wiki/cookbooks/classification-using-confidence.md, wiki/cookbooks/consistency-choice.md, wiki/cookbooks/consistency-noul.md
- wiki/guides/quickstart.md, wiki/guides/choosing-a-primitive.md, wiki/guides/writing-instructions-and-criteria.md
- raw/docs/introduction__quickstart.md (https://docs.typesafe.ai/introduction/quickstart) — console key URL
- raw/docs/agent-skill.md (https://docs.typesafe.ai/agent-skill) — alternate console key URL