# ThinkThen

> ThinkThen: code that knows what you mean. Simple functions that give your software the judgment to handle whatever comes its way. Ten functions, in your scripts, your programs, and your queries.

Every page on this site has a Markdown twin at the same address with .md added. https://thinkthen.dev/llms-full.txt holds every twin in one file.

## Pages

- [About — ThinkThen](https://thinkthen.dev/about.md): Ian Maurer makes ThinkThen. He is the CTO of [GenomOncology](https://www.genomoncology.com/).
- [Code that knows what you mean — ThinkThen](https://thinkthen.dev/blog/code-that-understands.md): Code sees strings, not meaning. `grep` finds the word “refund”. It can’t tell whether “I want to send this back” asks for money or for an exchange. Search match
- [Blog — ThinkThen](https://thinkthen.dev/blog.md): Articles about software that answers questions about text. These articles are drafted with AI agents against a voice guide, reviewed and edited by Ian.
- [annotate — ThinkThen](https://thinkthen.dev/functions/annotate.md): *form.json, a file the examples read*
- [choose — ThinkThen](https://thinkthen.dev/functions/choose.md): *Each of the first three messages names one team: billing, shipping, and account. The fourth names a parcel and a login. No team reaches 0.9, and it comes back 
- [decide — ThinkThen](https://thinkthen.dev/functions/decide.md): *The refund request answers true and the thank-you note false. "I want to send this back." could mean an exchange or money back. It lands inside the band 0.2:0.
- [filter — ThinkThen](https://thinkthen.dev/functions/filter.md): *filter keeps the two complaints: the broken zipper and the snapped strap.*
- [find — ThinkThen](https://thinkthen.dev/functions/find.md): *find prints the line with the 30 day refund deadline.*
- [Functions — ThinkThen](https://thinkthen.dev/functions.md): Each function reads text and answers a question about it. Each does a job you already write in code: an if, a switch, a grep, a sort.
- [@question — ThinkThen](https://thinkthen.dev/functions/question-file.md): *refund.json, a file the examples read*
- [rank — ThinkThen](https://thinkthen.dev/functions/rank.md): *The outage comes first and the quote due today second. The bill due in a month comes third, and the newsletter that needs no reply comes last.*
- [recognize — ThinkThen](https://thinkthen.dev/functions/recognize.md): *names.json, a file the examples read*
- [relate — ThinkThen](https://thinkthen.dev/functions/relate.md): *Paul McCartney sings Yesterday, and Ringo Starr sings Octopus's Garden. The two wrong pairs do not reach the default threshold.*
- [score — ThinkThen](https://thinkthen.dev/functions/score.md): *The outage scores 2.0, and 2 is Immediate on this scale.*
- [tag — ThinkThen](https://thinkthen.dev/functions/tag.md): *The message praises the dashboard, reports a crash, and names a double charge. It gets praise, bug, and billing.*
- [Guard a coding agent tool call — ThinkThen](https://thinkthen.dev/how-tos/bash/agent-tool-guard.md): This Claude Code `PreToolUse` hook reads a proposed Bash command as text. It runs none of the proposals. A yes gives `allow`, a no gives `deny`, and not sure gi
- [Ask many files at once — ThinkThen](https://thinkthen.dev/how-tos/bash/batches.md): A function asks one question of one file. `xargs -P 4` runs it on four files at a time.
- [Route with case — ThinkThen](https://thinkthen.dev/how-tos/bash/case.md): `choose --raw` prints the bare label. `case` sends each label to its own queue.
- [Fail a build — ThinkThen](https://thinkthen.dev/how-tos/bash/ci-gate.md): `filter` finds the lines that hedge. The script exits 1 when it finds any, and the build fails.
- [Fill a form by selection — ThinkThen](https://thinkthen.dev/how-tos/bash/fill-a-form-by-selection.md): Every field is a pick from a list you wrote, or true or false. No character in the form comes from a model.
- [Branch with if — ThinkThen](https://thinkthen.dev/how-tos/bash/if.md): `decide --quiet` prints nothing. Its exit code is the answer. The function `asks_for_refund` names what that code means, and `if` reads it directly.
- [Bash techniques — ThinkThen](https://thinkthen.dev/how-tos/bash.md): A ThinkThen function is a shell command. It reads standard input, prints an answer, and sets an exit code. Each page here teaches one shell form with one real r
- [Judge one paragraph at a time — ThinkThen](https://thinkthen.dev/how-tos/bash/judge-paragraphs.md): `awk -v RS=` splits on blank lines. `jq` gives each paragraph a `text` field, and `filter --field /text` sends only that text. Use a sentence splitter for sente
- [Label a JSON file and keep its ids — ThinkThen](https://thinkthen.dev/how-tos/bash/label-a-json-file.md): Label every ticket in a JSON array by kind and urgency. `--field /body` sends only the body. The id and the date stay in each record. Run it again, and the answ
- [Lint prose for hedging — ThinkThen](https://thinkthen.dev/how-tos/bash/lint-prose-for-hedging.md): `jq` numbers the lines. `filter` keeps the lines that hedge, and each comes back as it went in, line number and all.
- [Keep one process for a step loop — ThinkThen](https://thinkthen.dev/how-tos/bash/long-lived-loop.md): `coproc` holds one `choose` process open. `--batch 1` prints each answer while the input stays open. The example replays a recording. It needs no key and no net
- [Handle not sure — ThinkThen](https://thinkthen.dev/how-tos/bash/not-sure.md): `refund_code=$?` names the exit code of `decide`. `case` reads its three values: 0 for yes, 1 for no, and 3 for not sure.
- [Chain questions with pipes — ThinkThen](https://thinkthen.dev/how-tos/bash/pipeline.md): Two filters in a row keep the records that pass both questions.
- [Review a diff by what it does — ThinkThen](https://thinkthen.dev/how-tos/bash/review-a-diff-by-what-it-does.md): `jq` cuts a unified diff into hunks. `decide` asks of each hunk whether it changes what the code does. The file name and the hunk header stay in each record.
- [Set bad records aside first — ThinkThen](https://thinkthen.dev/how-tos/bash/set-aside-bad-records.md): `jq` reads each raw line and keeps only JSON objects with a string `body`. It writes every other line to an aside file before `decide` sees the good records. A 
- [Set a cut or a band — ThinkThen](https://thinkthen.dev/how-tos/bash/threshold-band.md): One number is a cut. Two numbers are a band. An answer inside the band is not sure, and it prints null.
- [Loop over lines — ThinkThen](https://thinkthen.dev/how-tos/bash/while-read.md): `while read` hands each line to `decide` on its own. The loop acts on each answer.
- [Check an expense against the policy — ThinkThen](https://thinkthen.dev/how-tos/check-an-expense-against-the-policy.md): Check an expense against your policy. `find` pulls the rule. `decide` says whether the expense fits.
- [Sort survey answers by mood and problem — ThinkThen](https://thinkthen.dev/how-tos/code-open-ended-survey-answers.md): Place every answer between unhappy and happy, then name what went wrong. `score` places them. `tag` names the problem.
- [Group alerts into incidents — ThinkThen](https://thinkthen.dev/how-tos/group-alerts-into-incidents.md): Tell whether a new alert belongs to an open incident. `find` picks the incident, or none. `decide` confirms the match.
- [How-tos — ThinkThen](https://thinkthen.dev/how-tos.md): Pick your job. Each page shows the commands and what came out.
- [Join two tables by meaning — ThinkThen](https://thinkthen.dev/how-tos/join-two-tables-by-meaning.md): Match each ticket to the incident it describes, even when the words differ. The loop pairs every ticket with every incident. `filter` keeps the pairs that match
- [Rank the inbound leads — ThinkThen](https://thinkthen.dev/how-tos/rank-the-inbound-leads.md): Drop the noise, put the buyer ready to pay first, and send each to the right sales team. `filter`, `rank`, and `choose` do it in one pipeline.
- [Screen a post before it goes up — ThinkThen](https://thinkthen.dev/how-tos/screen-a-post-before-it-goes-up.md): Judge a post against each rule on its own. `decide` asks one narrow question per rule.
- [Screen studies for a review — ThinkThen](https://thinkthen.dev/how-tos/screen-studies-for-a-review.md): Sort the clear studies in or out, and hand a person the ones that give too little to judge. `decide` with a band does both.
- [Split a scanned packet into documents — ThinkThen](https://thinkthen.dev/how-tos/split-a-scanned-packet-into-documents.md): Split a stack of scanned pages into documents. `choose` says what kind each page is. `decide` marks where a new document starts.
- [Triage a support inbox — ThinkThen](https://thinkthen.dev/how-tos/triage-a-support-inbox.md): Keep the messages that need a reply, and label each by kind and urgency. `filter` keeps them. `annotate` labels them.
- [ThinkThen: code that knows what you mean](https://thinkthen.dev/index.md): Simple functions that give your software judgment. Hand one a message, ask "Is this a complaint?", and get back yes, no, or not sure.
- [Jev and System One API from Ada — ThinkThen](https://thinkthen.dev/install/ada.md): A `Thinkthen` package over the C library, for GNAT. Each call is a procedure with out parameters.
- [Backends — ThinkThen](https://thinkthen.dev/install/backends.md): A backend is an address and a model. ThinkThen speaks one wire shape, System One, and any server that speaks it can answer.
- [Liquid d1 — ThinkThen](https://thinkthen.dev/install/backends/liquid.md): d1 is Liquid's decision model. Its server speaks System One, so ThinkThen asks it with no change but the backend name.
- [Ollama — ThinkThen](https://thinkthen.dev/install/backends/ollama.md): Ollama 0.35 and later serve System One on your own machine. ThinkThen asks them with `--backend ollama`, with no key and no hosted service.
- [OpenAI Decisions API — ThinkThen](https://thinkthen.dev/install/backends/openai.md): OpenAI announced the Decisions API at DevDay on 2026-09-29. OpenAI has not released it.
- [Servers without System One — ThinkThen](https://thinkthen.dev/install/backends/other-servers.md): ThinkThen speaks one wire shape, System One. A server with another shape needs a small server in front of it that speaks System One.
- [Any System One server — ThinkThen](https://thinkthen.dev/install/backends/system-one.md): ThinkThen posts every question to `BASE/systemone`. Any server that answers there in the System One shape can be a backend.
- [TypeSafe Jev — ThinkThen](https://thinkthen.dev/install/backends/typesafe.md): Jev is a System One model from TypeSafe. ThinkThen asks it when you name no backend.
- [Jev and System One API from C — ThinkThen](https://thinkthen.dev/install/c.md): One header over a shared or a static library. Bind ThinkThen to any language that can call C.
- [Jev and System One API from COBOL — ThinkThen](https://thinkthen.dev/install/cobol.md): A copybook and called programs over the C library, for GnuCOBOL.
- [Configuration — ThinkThen](https://thinkthen.dev/install/configuration.md): ThinkThen reads flags, environment variables, question files and one configuration file. It never writes the configuration file.
- [Jev and System One API from C++ — ThinkThen](https://thinkthen.dev/install/cpp.md): One C++17 header over the C library. Calls return `CallResult` values. The engine frees itself when it goes out of scope.
- [Jev and System One API from C# — ThinkThen](https://thinkthen.dev/install/csharp.md): An `Engine` over the C library, for.NET 8. Each call returns its answer and its run facts.
- [Jev and System One API from Dart — ThinkThen](https://thinkthen.dev/install/dart.md): One `Door` class over the C library, through Dart FFI. Each call returns its answer and its run facts.
- [DuckDB — ThinkThen](https://thinkthen.dev/install/duckdb.md): Ask a question in WHERE, SELECT, or ORDER BY.
- [Jev and System One API from Go — ThinkThen](https://thinkthen.dev/install/go.md): A cgo package over the C library. Each call that sends takes a `context.Context` and returns a `Result` and an `error`.
- [Install — ThinkThen](https://thinkthen.dev/install.md): ThinkThen runs from the command line, from your language, and from your database.
- [Jev and System One API from Java — ThinkThen](https://thinkthen.dev/install/java.md): One `Door` class over the C library, for Java 21. Each call returns its answer and its run facts.
- [Jev and System One API from Kotlin — ThinkThen](https://thinkthen.dev/install/kotlin.md): A `KotlinFacade` over the Java door. Its calls take strings.
- [Jev and System One API from Objective-C — ThinkThen](https://thinkthen.dev/install/objective-c.md): A `TTClient` over the C library, for GNU Objective-C with no Foundation.
- [pandas — ThinkThen](https://thinkthen.dev/install/pandas.md): A pandas Series goes in, and a Series with the same index comes back in `Call.value`.
- [Jev and System One API from PHP — ThinkThen](https://thinkthen.dev/install/php.md): One `ThinkThen` class over the C library, through PHP 8.3 FFI. Each call returns its answer and its run facts.
- [Polars — ThinkThen](https://thinkthen.dev/install/polars.md): A Polars frame goes in. Read the frame with its new columns from `Call.value`.
- [PostgreSQL — ThinkThen](https://thinkthen.dev/install/postgresql.md): One extension. Ask questions in any query.
- [Jev and System One API from Python — ThinkThen](https://thinkthen.dev/install/python.md): Pass a string or a list. Read the answer from `Call.value`.
- [Jev and System One API from R — ThinkThen](https://thinkthen.dev/install/r.md): The ten functions work inside dplyr pipelines. Read the answer from `$value`.
- [Jev and System One API from Ruby — ThinkThen](https://thinkthen.dev/install/ruby.md): Any Enumerable goes in. Read the answer from `Call#value`.
- [Jev and System One API from Rust — ThinkThen](https://thinkthen.dev/install/rust.md): Call the engine directly. The compiler makes you handle not sure.
- [Jev and System One API from Scala — ThinkThen](https://thinkthen.dev/install/scala.md): A `ScalaFacade` over the Java door, for Scala 3. Its calls take strings.
- [Settings — ThinkThen](https://thinkthen.dev/install/settings.md): This page lists every setting ThinkThen takes, with its default, the values it allows, and how to set it on each surface.
- [Jev and System One API from Bash — ThinkThen](https://thinkthen.dev/install/shell.md): Pipe text in, read the answer out, and branch on the exit code.
- [SQLite — ThinkThen](https://thinkthen.dev/install/sqlite.md): Judge a whole table in one call, then join the answers back by key.
- [Jev and System One API from Swift — ThinkThen](https://thinkthen.dev/install/swift.md): A SwiftPM package over the C library, for Swift 6. Each call returns its answer and its run facts.
- [Jev and System One API from TypeScript — ThinkThen](https://thinkthen.dev/install/typescript.md): Pass the question and the text. Await the call, then read its `.value`.
- [Jev and System One API from Zig — ThinkThen](https://thinkthen.dev/install/zig.md): A Zig 0.15.2 module over the C library. Each call returns `.ok` or `.failed`.
- [annotate answers a question set — ThinkThen](https://thinkthen.dev/learn/beatles-bench/annotate.md): `annotate` answers many questions at once. The question set holds four questions you have already seen. choose asks who sings the lead vocal. tag asks which lab
- [audit grades a run — ThinkThen](https://thinkthen.dev/learn/beatles-bench/audit.md): You already know the right answer for some of your records. `audit` grades saved answers against those answers at any bar. It sends no request.
- [Bring your own backend — ThinkThen](https://thinkthen.dev/learn/beatles-bench/backends.md): Any server with [the same interface as Jev](/install/backends/system-one/) can answer. Name it with `--url`.
- [Bash runs on judgment — ThinkThen](https://thinkthen.dev/learn/beatles-bench/bash.md): The script reads one song per line on standard input and asks whether a Beatle wrote each one. It passes the question and its flags on the command line. `--true
- [Run the Beatles Bench — ThinkThen](https://thinkthen.dev/learn/beatles-bench/bench-run.md): The bench is open source. The repository holds the songs, the questions and their right answers, and a saved recording of every answer. Each function has its ow
- [Jev has blind spots — ThinkThen](https://thinkthen.dev/learn/beatles-bench/blind-spots.md): Jev's memory fades on obscure facts. It gets 73% of the questions about the most viewed quarter of songs on Wikipedia right, and 49% about the least viewed. Tri
- [choose selects one option — ThinkThen](https://thinkthen.dev/learn/beatles-bench/choose.md): `choose` is a switch statement that reads. You list the options, and Jev puts a probability on each. The top option is the pick.
- [Database tables and data frames — ThinkThen](https://thinkthen.dev/learn/beatles-bench/data.md): One SQL query adds an answer column to a table of songs. It asks one `decide` question of each title and names the column `on_abbey`. The question and the band 
- [decide answers yes, no, or not sure — ThinkThen](https://thinkthen.dev/learn/beatles-bench/decide.md): `decide` is an if statement that reads. Ask one yes or no question about a text. Jev returns the probability of yes. Your threshold turns it into yes, no, or no
- [diff shows what changed — ThinkThen](https://thinkthen.dev/learn/beatles-bench/diff.md): Ask the same question twice, and `diff` prints only the answers that changed. A summary comes last. With an answer key, each change says whether it fixed a mist
- [filter keeps what clears your bar — ThinkThen](https://thinkthen.dev/learn/beatles-bench/filter.md): `filter` is a grep that reads. It keeps each record where the answer is yes and passes it through unchanged.
- [find picks one from many — ThinkThen](https://thinkthen.dev/learn/beatles-bench/find.md): `find` reads every line together and picks the one that answers the question. Each line sees the others. An answer can depend on the whole set.
- [Beatles Bench — ThinkThen](https://thinkthen.dev/learn/beatles-bench.md): These pages follow the talk "Jev, ThinkThen, and Beatles Bench", one slide at a time.
- [Jev set the standard — ThinkThen](https://thinkthen.dev/learn/beatles-bench/jev.md): Jev is the model behind ThinkThen. TypeSafe makes it. It reads a text and a question and returns a probability for every answer. It writes no text, and you trai
- [Scripting and systems languages — ThinkThen](https://thinkthen.dev/learn/beatles-bench/languages.md): On the slide, Python and C ask Jev the same `decide` question: does Ringo Starr sing the lead vocal on Octopus's Garden? Each stores the answer in `is_ringo` an
- [Store and reuse questions — ThinkThen](https://thinkthen.dev/learn/beatles-bench/question-file.md): A [question file](/functions/question-file/) is a small recipe. `decide` holds the question. `true` and `false` say what yes and no mean. `threshold` sets the b
- [Retrieval-augmented decisions (RAD) — ThinkThen](https://thinkthen.dev/learn/beatles-bench/rad.md): Giving Jev context improves accuracy. Look up the record, put it in front of the question, and ask. We call it retrieval-augmented decisions. ThinkThen sends th
- [rank sorts by your criteria — ThinkThen](https://thinkthen.dev/learn/beatles-bench/rank.md): `rank` is a sort that reads. It asks one yes or no question of each record and sorts the records by the probability of yes.
- [recognize labels things it finds — ThinkThen](https://thinkthen.dev/learn/beatles-bench/recognize.md): `recognize` finds every name in a text and gives each one a kind from your list. It works in three steps.
- [relate asks what Jev knows about the names — ThinkThen](https://thinkthen.dev/learn/beatles-bench/relate.md): `relate` gets a list of names and their kinds, and no text. Jev answers from what it knows. `recognize --relation` links names by what a text states.
- [Four ways to retrieve — ThinkThen](https://thinkthen.dev/learn/beatles-bench/retrieval.md): Keyword search matches shared words. TF-IDF and BM25 work this way. Semantic search matches similar meaning. Embeddings work this way. Each text becomes a list 
- [10 functions, 1 CLI, 24 bindings — ThinkThen](https://thinkthen.dev/learn/beatles-bench/runs-in.md): ThinkThen is one command-line tool, `thinkthen`. It runs from the command line in [Bash](/install/shell/). It has ten functions, such as `decide`, `filter`, and
- [score can rate on a non-linear scale you define — ThinkThen](https://thinkthen.dev/learn/beatles-bench/score-bands.md): The steps of a scale need not be even. Here `score` places Beatles songs on five levels of length, from very short to very long. Each level carries its name and
- [score can rate on a linear scale you define — ThinkThen](https://thinkthen.dev/learn/beatles-bench/score.md): `score` places a text on a scale you name, lowest level first. It returns a number along that scale. Here the scale runs from about 0 minutes to about 9 minutes
- [Code sees strings, not meaning — ThinkThen](https://thinkthen.dev/learn/beatles-bench/strings.md): To code, "Octopus's Garden" is a string of letters. You know it is a Ringo song on Abbey Road. `grep` matches letters, and none of these titles holds the words 
- [tag applies labels to data — ThinkThen](https://thinkthen.dev/learn/beatles-bench/tag.md): `tag` names every label that fits. Each label gets its own probability. A label counts when it clears the bar, and the default bar is 0.5.
- [Jev for agents — ThinkThen](https://thinkthen.dev/learn/beatles-bench/use-cases.md): These are ideas for Jev inside a coding agent. Most come from [a post by Diogo Almeida](https://x.com/completeskeptic/status/2101894250401271876). Diogo works a
- [Caching and replay — ThinkThen](https://thinkthen.dev/learn/caching.md): ThinkThen saves each answer under its question. Ask the same question again, and it reads the saved answer. Nothing is sent, and nothing is charged.
- [Functional patterns — ThinkThen](https://thinkthen.dev/learn/functional.md): A ThinkThen question works like a function. Bind the question once. Then apply it to text, a list, a column or a stream.
- [Learn — ThinkThen](https://thinkthen.dev/learn.md): Start with the tutorial. Then watch ThinkThen answer questions about Beatles songs.
- [Tutorial — ThinkThen](https://thinkthen.dev/learn/tutorial.md): From one question and its exit code to a saved question and a stream of messages.
- [annotate's edge cases — ThinkThen](https://thinkthen.dev/reference/annotate.md): `annotate` answers a saved set of questions for every record. Where each answer lands depends on the record. This page uses one question set throughout.
- [How answers work — ThinkThen](https://thinkthen.dev/reference/answers.md): The model gives a probability for each choice. ThinkThen turns those probabilities into the answer it prints. Each function does this its own way.
- [audit — ThinkThen](https://thinkthen.dev/reference/audit.md): `thinkthen audit RESULTS KEY` grades saved answers against answers you already know. It sends no request and reads no API key.
- [check — ThinkThen](https://thinkthen.dev/reference/check.md): `thinkthen check` tests whether a server works with ThinkThen. It sends four fixed requests, one after another. Every request is real. A hosted server may charg
- [diff — ThinkThen](https://thinkthen.dev/reference/diff.md): `thinkthen diff A B` prints only the saved answers that changed between two runs. It sends no request.
- [annotate options — ThinkThen](https://thinkthen.dev/reference/functions/annotate.md): The command takes `FILE`. The file is a saved question set. [Start with its value and exit code](/functions/annotate/).
- [choose options — ThinkThen](https://thinkthen.dev/reference/functions/choose.md): The command takes `QUESTION` or `@FILE`, then `OPTION...`. [Start with its value and exit code](/functions/choose/).
- [decide options — ThinkThen](https://thinkthen.dev/reference/functions/decide.md): The command takes `QUESTION` or `@FILE`. [Start with its value and exit code](/functions/decide/).
- [filter options — ThinkThen](https://thinkthen.dev/reference/functions/filter.md): The command takes `QUESTION` or `@FILE`. It reads one record per line. A pointer from `--field` or a question file makes it read JSON Lines. [Start with its val
- [find options — ThinkThen](https://thinkthen.dev/reference/functions/find.md): The command takes `QUESTION`. [Start with its value and exit code](/functions/find/).
- [question-file options — ThinkThen](https://thinkthen.dev/reference/functions/question-file.md): The command takes `@FILE`. It takes the place of the question words on decide, choose, tag, score, filter, and rank. [Start with its value and exit code](/funct
- [rank options — ThinkThen](https://thinkthen.dev/reference/functions/rank.md): The command takes `QUESTION` or `@FILE`. It reads one record per line. A pointer from `--field` or a question file makes it read JSON Lines. [Start with its val
- [recognize options — ThinkThen](https://thinkthen.dev/reference/functions/recognize.md): The command takes `KIND...` or `@FILE`. The file is a question file. [Start with its value and exit code](/functions/recognize/).
- [relate options — ThinkThen](https://thinkthen.dev/reference/functions/relate.md): The command takes `RELATION...` or `@FILE`. Each relation is `NAME=SOURCE_KIND:TARGET_KIND` or a bare `NAME`. [Start with its value and exit code](/functions/re
- [score options — ThinkThen](https://thinkthen.dev/reference/functions/score.md): The command takes `QUESTION` or `@FILE`, then `LEVEL...`. [Start with its value and exit code](/functions/score/).
- [tag options — ThinkThen](https://thinkthen.dev/reference/functions/tag.md): The command takes `QUESTION` or `@FILE`, then `LABEL...`. [Start with its value and exit code](/functions/tag/).
- [Reference — ThinkThen](https://thinkthen.dev/reference.md): Everything the `thinkthen` command takes and prints. Read this page before you write a pipeline, and hand it to an agent. [How answers work](/reference/answers/
- [Question sets — ThinkThen](https://thinkthen.dev/reference/question-sets.md): A question set is one JSON file that holds every question `annotate` asks of each record.
- [Recording and the answer cache — ThinkThen](https://thinkthen.dev/reference/recording.md): ThinkThen saves every good answer, one per question. Ask the same question again and it reads the saved answer instead of sending a request. [Caching and replay
- [transform — ThinkThen](https://thinkthen.dev/reference/transform.md): ThinkThen ships ten `jq` programs that read saved runs. `thinkthen transform` prints them. It never runs one. `jq` does.
- [What it will not do — ThinkThen](https://thinkthen.dev/refusals.md): ThinkThen sends text to a model and returns one of the answers you allowed. Turn a screen, image, or audio recording into text before asking it a question.
- [Trust — ThinkThen](https://thinkthen.dev/trust.md): Every answer comes with the model's probability. You set the bar, and you count the misses on your own records.