What your agent sees.

sqlRun bounded SQLread-only

Run one bounded read-only SQL statement over registered relations: exactly one of `sql` (a literal LIMIT unless the statement is a bare aggregate or names rows by the relation's row key; every aggregate aliased) or `q` (one search-grammar line over one `relation`, never "*"; returns document rows plus compiled_sql; `limit` sets the compiled page, default 20). Start here: `schema` for columns, then a LIMIT 20 statement — queries are free while the system has slack (every response reports billing_mode and spend_nanodollars; the money arguments below are optional ceilings, not fees), so probe first and widen after reading the meter. Read coverage, completeness, deadline_partial, and truncated before interpreting rows — LIMIT bounds output, not scan cost. An Int64/UInt64 past 2^53 (every tweet_id) keeps every digit on the wire but rounds in a parser that reads numbers as doubles: such a client selects toString(x) (every cell type's transport: reference section EXPLAIN). Replies are bounded to max_chars (default 40000 characters of the JSON reply text, under the common tool-result pipes): past it the longest text cells are cut to one shared length, each ending in …[+N chars cut], and the reply reports truncated_cells and reply_chars — rows are never dropped; raise max_chars, tighten the SELECT, or substring the column to see more. Reference, grammar, helpers, and the money law: call guide with {"tool": "sql", "section": "MONEY"} (one of seven heads; omit section for the whole; the prompts/get method serves the same as query_guide). `recipe_versions` pins each scry_recipe('slug', …) operand to a version instead of its head.

schemaSchema and corpus contractread-only

Return the live relation catalog; call it before `sql`. Default (mode index): one line per relation — name, tier, time extent, freshness lag, purpose — plus helper signatures; then relation="<name>" for that relation's columns, indexed predicates, known holes, and value spaces. Schema discovery is also one SQL call: `scry.relations` and `scry.columns` are the same catalog served as relations you can filter and join, e.g. SELECT relation FROM scry.columns WHERE name = 'author_id' LIMIT 100.

guideRead the live manualread-only

Return the long reference for sql, datalog, or recipes: grammar, helpers, worked examples, bounds, and the money law. Served live, so it is current whatever the age of this tool list; the descriptions here stay short and point at it. Pass tool, and section for one head of that tool's reference (an unknown section answers with the heads it has); omit section for the whole.

semantic_joinJoin SQL cohorts by vector distanceread-only

Exact nearest-vector matches per left id between two SQL-selected cohorts, each one statement over one relation with a real embedding_voyage4 column — the joinable relations are exactly embeddings.crawl_pages (cohort column url), embeddings.openalex_works (cohort column work_id), embeddings.tweets (cohort column canonical_uri); every other embeddings.* relation is refused: embeddings.coverage_cells, embeddings.chunks, embeddings.academic_paper_chunks score in sql with scry_cosine_similarity over their readable embedding column, and a Lance-only lane's vectors are reachable through sql's scry_vector_topk_distance projection, not this join (LIMIT <= 10000, first column a column of that relation). Select the named cohort column first — the join filters each side by it, and that column prunes by the primary key while an `id` cohort scans the whole table (379 M rows for openalex_works) — e.g. SELECT work_id FROM embeddings.openalex_works WHERE work_id IN ('W2772307444', 'W4389326242') LIMIT 20. Returns left_id/right_id/distance/left_chunk_index/right_chunk_index rows (the chunk pair that produced the distance, its witness; hydrate both passages from the relation by id and chunk_index), diagnostics (left_rows, right_rows, left_with_vectors, right_with_vectors, pairs_scored, left_truncated), per-statement metering (statements[].elapsed is each cohort statement's engine seconds), wall_ms (this call end to end) and engine_ms (the statements' engine time summed — the difference is the join's own pair scan and its waits); a side whose selected rows all have embedding_dim = 0 (chunk skeletons — the vector is in the Lance lane, not in embedding_voyage4) is refused with that count before the join spends; same-relation joins exclude equal ids, and a cold physical scan takes 10-30s per statement.

datalogRun a datalog programread-only

Run bounded recursive graph walks as a JSON program of named id sets — each frontier step is one metered `sql` statement under your key — for graph expansion, in-walk pruning, set subtraction, and ranking a walked set, not tabular analysis. Reference: guide with {"tool": "datalog"} ("section": "EDGES" for one head — PROGRAM | ATOMS | EDGES | FILTERS | SQL ATOMS AND SPLICES | BOUND BODIES | RANK, COUNTS, PATHS | RESPONSE | BOUNDS | TEMPLATES; omit section for the whole reference with the input schema). Minimal program (a body whose rel names its own relation is the recursion): {"relations": {"seed": {"bodies": [[{"ids": ["44000000"]}]]}, "thread": {"bodies": [[{"rel": "seed"}], [{"rel": "thread"}, {"edge": "hackernews.children"}]]}}, "out": ["thread"], "depth": 3}. Atoms: ids, sql (a string: alone it seeds, after a rel it hydrates), rel, edge, filter, ann {handle, k}, in, not_in, not; edges span OpenAlex citations (resident in memory — references and cited_by hops answer inline; cited_by walks the newest 50 citers per work) and authorship, Twitter reply/quote/follow graphs, Hacker News and forum threads, GitHub, Bluesky, YouTube, TikTok, Instagram, and the crawl — an unknown edge name returns the catalog with each edge's measured cost; no edge bridges identities across corpora (a Hacker News handle is not a GitHub login or a Bluesky DID — a typed row of the wrong kind is refused, not joined; an untyped literal takes the consuming edge's namespace and walks it there, so an OpenAlex author id seeded bare into github.repos_of is an empty hop, not a refusal). Rows return as {id, kind, parent, depth}; counts are included for every relation and out: [] is a counts-only census; depth absent walks to the fixpoint, 50000 rows per relation; truncations[] lists every fired bound; max_seconds and budget_nanodollars are arguments beside program, never fields inside it.

whoamiInspect this connectionread-only

Return this connection's account, owner settings, and memory head — workspace state, not corpus reads. Wallet balances are net of wallet.reserved_nanodollars, the estimated cost held by queries still running and returned at settlement; spend_today_usd counts settled queries only. Open every session with {"roster": "3cc8f29c"} — the fingerprint of the tool list this description belongs to; the reply's roster.synced says whether that fingerprint is the served roster's.

memoryRead account memoryread-only

Read the account's cross-platform agent memory document, one retained version, or its change log.

memory_writeWrite account memory

Replace the account memory document with compare-and-swap version control.

recipesRead lexical recipesread-only

List shared lexical recipes — measured keyword instruments (sentiment lexicons, epistemic stance, registers, concept surface-form sets) usable as one `sql` operand — or read one recipe's terms, measurements, and history; check this shelf before hand-writing a keyword list. The listing is compact (slug, kind, stance, n_terms, has_measurements); slug=<slug> returns everything. Usage: guide with {"tool": "recipes"}.

recipe_writeWrite a lexical recipe

Publish a complete shared lexical recipe version with compare-and-swap control. Read guide with {"tool": "recipes"} first: it contains the kinds, the term forms, and the measurement contract. Minimal first write: {"slug": "my_hedging", "if_version": 0, "kind": "stance", "stance": "hedged assertion", "license": "CC0-1.0", "terms": [{"t": "perhaps"}, {"t": "it seems", "form": "phrase"}], "options": {}, "provenance": "hand-picked from 40 LessWrong comments", "measurements": {}} — if_version is the global head (0 for a first write; recipes reports it), and a stale head answers a conflict that gives the current one.

recipe_deriveDerive recipe candidatesread-only

Derive bounded lexical recipe candidates from one registered relation — corpus-grounded vocabulary expansion with document-frequency denominators instead of guessed terms — to inspect or publish with recipe_write.

coverage_estimateEstimate embedding coverageread-only

Estimate the bounded work and maximum charge for an embedding-coverage request over rows selected from `sql` relations; estimated_* fields are worst-case ceilings (bytes counted as tokens), and paid runs settle to actual tokenizer usage. storage_admission is the verdict coverage_request would give this estimate right now (admits, admissible_bytes, smaller_request_can_help) against the GLOBAL storage reserve — not an account quota. selected.covered counts the selected rows that already have this model's PAID coverage cells and nothing else; the corpus's native semantic lane is a different store, reported beside it as selected.native_lane: a 2,000-record sample of the selection probed in that lane, searchable / sampled being the fraction already findable through `relation` and the semantic operators. A low covered beside a high native_lane.searchable means the selection is searchable today and needs no request; only sources without a native lane (github) omit it.

coverage_requestRequest embedding coverage

Start an idempotent embedding-coverage run whose completed cells are queryable through `sql`; call coverage_estimate first. With selector.source "twitter" and kinds ["following"] or ["followers"] (operator-class keys only) it is instead a capture request: the named accounts (numeric ids) are queued on the priority follow lane and coverage_status reports each list's freshness from twitter.follow_coverage (a list the profile row declares empty is fresh at once); omit model and max_chunks.

coverage_statusCheck embedding coverageread-only

Return one embedding-coverage run's status, staged cells, spend, and failure detail; selector_fully_covered: false means the chunk cap excluded matching chunks. For a twitter capture request: the accounts, the queue seeding, and per-list freshness (fresh once observed on or after the request date).

shareSave a share

Create a shareable scry.io artifact: a rerunnable query (kind=query: a parameterized `sql` statement, a datalog `program`, or a `semantic_join` — the same three envelopes `sql`, `datalog` and `semantic_join` take), a write-up, or a standing research question (kind=question: someone's research desire quoted verbatim as payload.prompt, plus an optional brief on how to attack it). Contribute to a question by setting `answers` to its slug — the question's page and JSON list every public contribution; the open index of questions is scry.io/s. A query share may include the inquiry behind it: payload.question (the ask in the asker's words, verbatim) and payload.approach (the technical question it became: what is measured, over which relations, with what denominators and cutoffs); `board: true` enters it on the query board, and when a result is worth keeping, offer the person that entry. Entered inquiries are judged pairwise by a model on four public criteria and ranked in tiers at scry.io/board; the entry queues that round on the entrant's wallet. The response includes permalink — the share's scry.io/s/{slug} page — cite that URL, never a guessed one.

share_runRun a shared queryread-only

Run a saved query share by slug through the same metered path its grammar takes: its sql with supplied parameters (as `sql`), its program (as `datalog`, each statement metered), or its semantic join. A program or semantic_join share takes a key; params are for sql shares only. The execution envelope is sql's, argument for argument — deadline, budget, exposure, staleness, idempotency, admission — because saving a query changes how it is referenced, never which safeguards you can state.

share_updateRevise a share

Revise one of your shares in place by slug — title, summary, payload, or visibility — keeping its slug and link. Owner only; no call deletes a share, `is_public: false` withdraws it from every public index while its link keeps resolving for you. A revised payload is re-admitted under the share's kind (sql, program, semantic_join, question) exactly as share does; a query share keeps the recipe versions it froze at create, and a recipe the revised statement newly names pins at its current head.

share_listList sharesread-only

Your own shares newest first (kind omitted; needs your key or session) — each with share_slug, permalink, kind, title, summary, is_public and created_at, so a returning session finds its saved queries without knowing their slugs — narrowed to one kind with kind=query (or chat, rerank, markdown, insight), or with kind=question the open index of standing research questions (public, no key). No call deletes a share: share_update with is_public: false withdraws it from every public index while its link keeps resolving.

share_getRead a shareread-only

One share by slug — kind, title, summary, payload (a query share's sql/program/semantic_join and declared params), permalink, and a question's contributions. Public shares read without a key; a private share reads for its owner.

feedbackSend feedback

Send a bug report, suggestion, or note to Scry's operators.

index_requestIndex a source

Ask Scry to index a URL into its corpora. A supported host becomes a sovereign acquisition campaign — best-effort, nothing guaranteed — whose progress is queryable through `sql` with the returned query; an unsupported host answers `unsupported` and writes nothing. Today: YouTube — a watch, @handle, or channel URL indexes the whole channel (catalog, metadata, captions) into the youtube.* relations; a playlist URL indexes that playlist's videos.

wishMake a wish

Submit a wish of any sort to Scry's operators.

painReport pain

Tell Scry's operators about an experience of pain, product or otherwise.

batchRun a tool batchread-only

Run 1–16 tool calls in one round trip, each result in its own envelope; suited to independent calls whose only shared cost is the round trip. The response includes results (one entry per call, in order), calls, failed (isError entries plus programs whose outcome is failed), partial (programs halted on a bound and statements cut by their deadline), not_started (calls a batch cap refused), complete (true only when failed and partial are 0 and not_started and timed_out are empty), burden_nanodollars (every returned meter summed, a killed statement's included), burden_settled (false when timed_out is non-empty: a discarded call's meter is not in the sum, so read that call's own query row for its charge), and elapsed_s. timed_out lists calls still running when max_seconds plus approximately one second of grace elapsed; their results are discarded and complete is false, while completed results return within that bound.

creativityGenerate a covered idea fieldread-only

Run a bounded server-side creativity campaign over one brief and return candidates plus a distilled nugget. Paid: this runs third-party inference, which draws on the account's cash or promo balance — free signup credit funds Scry queries, not inference — so a free account gets insufficient_credits until funds are added under Dashboard → Billing. shots.failures gives the cause of every shot that did not enter the field and whether a re-run helps.

chatConsult an OpenRouter modelread-only

Send one chat completion to an OpenRouter model. Paid: third-party inference draws on the account's cash or promo balance — free signup credit funds Scry queries, not inference, so a free account gets insufficient_credits until funds are added under Dashboard → Billing — or on your own OpenRouter key on the x-provider-key header of this connection (used per call, never stored). An unknown model id is refused as unknown_model before any funding check. Routing is restricted to zero-data-retention endpoints (provider zdr, data_collection deny): every preset lane has one; a full model id without one is refused by the provider rather than served with retention.

rerankRerank supplied documentsread-only

Rerank 2–1000 caller-supplied documents against a query and optional instruction. Local tiers score a document as every 3,500-character window of it (stride 3,000, so windows overlap) and keep the best window's score: every result has document_chars and best_window, the [start, end) the score came from, and usage.windows_scored counts the inputs — a call past 1,024 windows is refused with the count (send fewer or shorter documents, or tier hosted, which scores each document whole). Supply passages with stable ids.

qrandomQuantum random floatsread-only

Draw floats in [0,1) from live quantum-entropy sources (qrandom.io, ANU), each block XOR-whitened with the host CSPRNG and listed in the result's sources by source and fetch time (entropy: quantum-xor-os). When no quantum block is ready within 1.5 s the draw is served from the host CSPRNG alone and says so (entropy: os-csprng, with a note); strict: true refuses instead (503 quantum_entropy_unavailable, retry-after) — a seeded pseudorandom generator is never used either way.

attestAttest a phrase or quoteread-only

Per-corpus verbatim attestation of an exact phrase: verbatim vs distinctive-word near-miss counts, plus the earliest match on two clocks (claimed authorship vs estate observation) with its document. Both counts are computed within the door's population: documents containing each of the phrase's distinctive words (its longest alphanumeric runs of 3+ characters, at most six) as a whole word on the words index. A phrase whose first or last word is a fragment of a longer word in the corpus (KubernetesReall inside KubernetesReally) is outside that population; it belongs to sql with position(search_text_lc, '<phrase>') > 0, and verdict absent means absent from the population, never from the corpus's substrings. Thirteen lanes run in parallel under fixed budgets (10–45 s), so a phrase whose rarest word is common finishes on the small lanes only: read complete and lanes_timed_out first; a lane declined before running (predicted_over_budget) still returns token_hits, the count of documents containing the words, when the words index answers within 2 s — when partial, headline_scope lists the lanes the counts cover and deadline_note gives the call that fits. Rare phrases (a name, a coined term) answer in seconds.

sampleSeeded uniform sample of a phrase stratumread-only

Draw a reproducible uniform random sample of documents containing an exact phrase, with per-lane stratum sizes as the denominator; one row per document with uri/title provenance where the catalog resolves it. The stratum is the door's population: documents containing each of the phrase's distinctive words (its longest alphanumeric runs of 3+ characters, at most six) as a whole word on the words index. A phrase whose first or last word is a fragment of a longer word in the corpus (KubernetesReall inside KubernetesReally) is outside that population; it belongs to sql with position(search_text_lc, '<phrase>') > 0, and an empty stratum means empty within the population, never in the corpus's substrings. Twelve lanes run in parallel under fixed budgets (10–45 s): read complete and lanes_timed_out first — the draw is uniform over the completed lanes, and when partial, headline_scope and deadline_note give the lanes and the call that fits.

embedCreate a vector handle

Create a stored vector handle from exactly one of text, an expression over existing @handles, or sql selecting ids from one relation with stored embedding_voyage4 vectors (the cohort is averaged and normalized in the engine; diagnostics report cohort_rows, vectors_found, and coverage). Example: {"sql": "SELECT id FROM embeddings.openalex_works WHERE work_id = 'W2772307444' LIMIT 5000", "name": "work_centroid"}.

vectorsList vector handlesread-only

List the caller's stored vector handles available to `sql`, newest first, paged.

vector_deleteDelete a vector handle

Delete one stored vector handle by name; deleting an absent handle succeeds.

market_statusLive admission market statusread-only

The query market's live posted state in one free read: base fee, the congestion multiplier c that `sql`'s max_multiplier is compared against (total_multiplier = 1 + c), whether congestion pricing is active, pin state, the door census (door and load pressure, queue depth, predicted wait) and, when footprint preemption is active, what one fair slot is (market_status.admission.footprint), lane health (lanes.vector for ANN over embeddings.*, lanes.attest, lanes.sample, lanes.embed: ok, last success and failure ages, failure class, the lanes down — the engine's state for every caller, not whether this key's scopes reach the lane: whoami lists your scopes), reservation availability, and charge_law. Poll this instead of probing with queries; law: schema mode="contract" § admission.

No arguments.

reservationsList capacity reservationsread-only

List booked slot windows and market terms; booking runs over REST POST /v1/scry/reservations (law: schema mode="contract" § admission).

No arguments.

fetchFetch one recordread-only

Hydrate one record — full text, title, uri, author, timestamp, provenance — by its record_ref (`source:id`) exactly as a `sql` q row returned it. q rows over the fifteen text relations have record_ref; a q row over any other relation has that relation's own key column (quora.answers: aid) — hydrate those with `sql` on that key. A query record_id (the UUID a `sql` response minted) reads back that run from your query log: the statement as text, its row_count, bytes, and error. `offset`/`limit` window a long text by character.

page_as_ofA URL as of a dateread-only

Point-in-time lookup of one URL in the crawl corpus (every fetch is a retained version): the newest capture at or before `as_of` on the second clock — capture instant (capture_at, from observed_at; capture_ts is its day), title, full text, HTTP status — plus counts of the usable versions before and after (captures with an accepted text extraction; a capture whose extraction was noindex or failed stays in crawl.pages with that reason in `extraction` and counts here as none, so 0/0 is a corpus miss or an unusable page) and the nearest later capture; on a corpus miss the `archive` block contains the Internet Archive's nearest capture at or before the ask (capture_ts, replay_url, text body), fetched server-side under bounded budgets so an archive outage degrades the block, never the tool (archive.found: true = a capture, false = the index answered and has none in range, null = the index did not answer and the same call may be retried). Scheme, www., and trailing-slash variants match; the executed SQL returns verbatim for deeper archaeology via `sql` over crawl.pages.