# Who does the thinking

A house separates **remembering** from **judging**. Remembering is deterministic code and
always available. Judging needs a language model, and the model is yours.

## Two kinds of work

| Kind | What it is | Needs |
|---|---|---|
| **Kernel** | storing, linking, versioning, full-text search, semantic search, structural queries, time and place, reading web captures into documents, backups | nothing |
| **Judgment** | a decision over material: which topic a document belongs to, whether two name forms are one person, how a raw text is really structured, a summary of a volume | a model |

Semantic search uses a small embedding model that ships inside every house. It is part of
the kernel and not something you supply.

## Borrowed mode: how every house runs today

You do the judging, on whatever model you already run. The house never calls a model and
needs no API key. This is how a house works today, at every size.

What that means in practice:

- Everything in the kernel works without you doing anything.
- Every judgment is an act of yours, made with the author and modeller skills: you read a
  document and assert its topic; you compare two identities with `describe` and decide to
  `merge_into` or to `assert_separate`; you write a digest as a document and attach it with
  `adopt_digest`.
- The house helps you see what there is to do: `list_conjectures` is the list of recorded
  open questions, `find_missing` lists things that lack something, `digest_coverage` lists
  documents without a valid digest, `coverage` tells how deep the files were read.

## Recipes: the prompts of the house, today

For four judgments you do not have to invent the way. A recipe gives you the route the
house software itself runs: the skills that fetch the context, the prompt (adapted from the one
that ran in production on a German corpus), the answer form, the checks, and the skills
that apply the verdict. There are recipes for assigning documents to topics, resolving names into
identities, merging name forms, and summarising a document. The house checks nothing while
you follow one; you run the checks. Start at `working-by-recipe`.

What borrowed mode does not give you:

- **Nothing is judged while you are away.** A document that arrives is stored, indexed and
  searchable at once, and stays unclassified until an agent visits.
- Large one-off jobs (thousands of judgments over a big corpus) run against the limits of
  your own plan and take correspondingly long.
- The quality of a judgment is the quality of your model.

If your environment has scheduled tasks, a scheduled visit gives a house a rhythm.

## What is planned

Two things, described in topics of their own, neither of them built:

- **Guided judging.** The house collects whatever needs a judgment on one list, hands you
  the next item with its context and the prompt, checks your verdict with guards of its
  own and applies it. It is what a recipe is, with the house doing the fetching, the
  checking and the applying. See `the-list-of-open-work` (planned).
- **A model for the house.** Your own local model, your own API key, or a model service
  operated by core.blue can be attached to a house, which then works through the same list
  by itself, immediately. See `plugging-in-a-model` (planned).

The second changes when a judgment happens, not whether a house can be used: every size of
house is meant to run in borrowed mode alone.

## What a house cannot do in any mode

- OCR, transcription and image description do not exist yet.
- Agents living inside the house (an assistant, topic stewards, a planner with a memory and
  a voice of their own) exist in Atlantis and are not offered by core.blue yet. The house's
  skills mention helpers and speakers; those belong to that part.

## Go deeper

- [working-by-recipe](working-by-recipe.md)
- [the-list-of-open-work](the-list-of-open-work.md)
- [plugging-in-a-model](plugging-in-a-model.md)
- [sizes-and-volumes](sizes-and-volumes.md)
- [what-does-not-exist-yet](what-does-not-exist-yet.md)