Skip to main content
Glama

Sitting

sitting

Reads a topic from your knowledge base in publication order, revealing how thinking evolved, what claims the material supports, and what contradicts or is missing.

Instructions

Read one topic of the user's knowledge base end to end, in publication order — as standing research queries, a briefing, a trajectory, or a search for what contradicts or is missing from it.

Reach for this when the user wants to know what their saved material actually SAYS about a subject over time — "what have I been collecting on agentic payments", "how has the thinking on X moved", "read everything I've saved about Y", "what's in my blind spots". It is the opposite of the search tool: search finds the few best-matching items, this assembles EVERY item on a topic and reads the whole set in date order. Search answers "where is it"; this answers "what happened".

Do not reach for it to look something up, to answer a factual question, or to find a specific post — that is the knowledge-base search tool, and it is free and instant. This assembles a large context and, on read, makes a model call (the other actions do not).

The five actions:

preview (FREE, the default) — name a topic and find out what is actually there. It grows the region and reports its size, the stretch of time it covers, how many people wrote it, a few of the items by name, and anything about its shape that would make a read disappointing. It calls no model. Costs one metered embedding for a typed phrase (a fraction of a cent) and nothing else. This is not a permission step. It is here because a phrase can resolve to four items or to two hundred and the user cannot tell which in advance — the size is a property of what they have saved, not of the words they typed. Skip it whenever the user has already said to go ahead. A preview alone queues nothing — consumption subscribes a region, construction does not. Nothing reads it, and nothing spends, until read or lens actually consumes it.

read (SPENDS) — reads the assembled region with a model. A topic too big for one sitting is read in PARTS, oldest stretch first; each read carries forward the claims every earlier part established and is asked to confirm, revise or refute them. Two lenses, pick with lens: - queries (default) — emits standing research queries from the material. Those then run on a schedule against papers, repos and datasets, catching what gets published NEXT in that thread. - claims — extracts 8-15 falsifiable claims the material actually makes, each one naming specifics (systems, numbers, dates), citing every atom that supports it, and stating what observation would prove it WRONG. Use this when the user wants to know what their saved material actually establishes, not what to watch next. Pass a sitting_id from a preview, or pass query to build and read in one step. The two lenses spend and read INDEPENDENTLY — reading a region for claims does not use up or block its queries read, and the reverse holds too.

render (FREE) — hand back a region that was already built, as the document a reader would see. Nothing is re-grown and nothing is re-read.

watchlist (FREE) — the standing questions currently being watched on the user's behalf, with how often each runs, how many times it has come up, and whether the user typed it or a read of their material proposed it. Pass a sitting_id or query to see one region's; pass neither for everything. SHOW THIS ONLY WHEN ASKED — "what am I watching", "show my watchlist", "did anything change". Never volunteer it at the start of a session or alongside unrelated work. add puts questions the user names onto the list; those never decay and are removed only by drop. drop retires a question EVERYWHERE — a question two regions both watch is retired for both, because the list is one list of questions, not a copy per region. Say so before dropping something the user did not name precisely.

lens (SPENDS only on material never lensed before) — hand back an instruction plus a document, and read them YOURSELF, right here in this conversation, to answer the user directly. This is how you answer a question ABOUT the material rather than generating queries against it. The document is NOT the region's raw text. A topic read across several sittings is summarised one stretch at a time, and what comes back is those summaries labelled with the dates they cover — so you are joining stretches, not re-reading everything. Each stretch is summarised once ever, so asking the same lens again is free, and asking a DIFFERENT question of the same lens is free too. Only material that has never been lensed this way costs anything. Pass lens to pick which reading: - briefing — what this material actually says, as knowledge, not a table of contents. - trajectory — how the thinking on this topic MOVED over time: what changed, reversed, or got abandoned. - disconfirmation — what in this material would UNDERMINE a belief. Pass claim with the belief being tested; without one, it red-teams the material's own apparent thesis. - gaps — answer a question using only this material, and if nothing here answers it, the CLOSEST it comes and why that falls short (never a bare "nothing here"). Pass claim as the question. - sprouts — everything no sitting has ever read: true orphans, unread regions, fracture leftovers. This is what "what's in my blind spots" means. Needs no sitting_id, query, or atom_ids — it is not about one topic. Like read, pass a sitting_id from a preview or a query/atom_ids to build one in the same call (sprouts needs neither). The answer YOU give is never written anywhere — no queries, no table, no record of it — because it is about the topic as it stands today and would be wrong the moment anything is added. This is a conversation, not a rail.

What comes back from a read, lens queries: a consensus — how the conversation moved, what reversed, what is unresolved — plus the queries it emitted. Show the user the consensus. It is the part written for a human.

What comes back from a read, lens claims: a claims list, each one {claim, falsified_by, atom_ids}. Show the user the claims themselves — falsified_by is what lets them decide whether to believe one, so surface it alongside the claim rather than dropping it.

What comes back from a lens: instruction and document. Read document following instruction and write the answer yourself — there is no second call to make, and nothing here reads the document for you.

Read the warnings in a preview back to the user. They say when a region is a poor fit for the question — a region spanning three days has no arc to find, a region that is 85% one author generates queries pointing back at that author's own work. Pass the lens you intend to use to preview and the warnings are specific to it (a short span breaks trajectory and barely touches briefing). They are advisory: nothing here refuses to read, because whether the region is right depends on what the user is asking and only they know that.

A region is read once per lens (by read). A second read of the same sitting_id with the SAME lens is refused as already read — it would be the same input for the same money. The two read lenses do not share this guard: a region read for queries can still be read for claims, and the reverse. A region is re-read (same lens) when it has GAINED enough new material to be worth redoing, and the rail decides that on its own; to force it, preview the same phrase again, which grows a fresh region over the corpus as it is NOW. lens (the action) has no such limit — each stretch is summarised once and reused after that, so reading the same region's briefing twice costs nothing the second time.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
addNofor `watchlist` only — questions to start watching, in the user's own words.
dropNofor `watchlist` only — questions to stop watching, matched on their text. Retires them for every region, not just this one.
lensNofor `preview`, which lens's warnings to compute (default "queries"). For action `read`, which API lens to spend on: "queries" (default) | "claims". For action `lens`, which reading to return: "briefing" | "trajectory" | "disconfirmation" | "gaps" | "sprouts".
claimNothe belief or question being tested, for `lens="disconfirmation"` or `lens="gaps"` only. Optional on both.
floorNohow tightly related an item must be to join the region, 0-1. Leave unset. Higher is narrower, and a value below the corpus' measured noise ceiling is raised to it — down there an admission is not distinguishable from unrelated text. Two builds of one topic at different floors are two different regions with separate read histories.
queryNothe topic, in the user's own words. It does NOT have to be wording that appears in their saved material — the match is by meaning, so "prediction markets" finds a thread nobody in the corpus ever called that. If nothing in the corpus is close enough, it says so rather than assembling something plausible out of near-misses.
actionNo"preview" (default, free) | "read" (spends) | "render" (free) | "lens" (spends only on never-lensed material) | "watchlist" (free).preview
atom_idsNoseed from specific items instead of a phrase — the region around THESE. Free (no embedding). Use when the user points at something they just saw.
sitting_idNoan id from an earlier preview. Required for `render`; on `read`/`lens` it is the alternative to `query` (not needed for `lens="sprouts"`).
budget_tokensNocap on how much is read in one sitting. Leave unset.

Output Schema

TableJSON Schema
NameRequiredDescriptionDefault

No arguments

Install Server

TDQS

A4.8/5.0
Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It does this exhaustively: it marks each action as FREE or SPENDS, warns about model calls, explains that preview queues nothing but consumption does, describes the read-once-per-lens guard, clarifies that lens summarization is cached and re-using it is free, and states that lens answers are never persisted. It also openly acknowledges that region size depends on the user's saved material, not the typed phrase.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is long but structured with clear action-by-action bullets and explicit cost labels, and it front-loads the core purpose and the contrast with search. While some information is repeated (e.g., the sitting_id/query alternation appears several times), the overall organization makes complex information scannable. For a tool with 5 actions and 10 parameters, the length is justified; there is little waste.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity and the absence of annotations, the description covers virtually everything an agent needs to call it correctly: each action's behavior, cost implications, parameter combinations, return payloads (including consensus, claims, instruction/document), and warnings. It also explains the read-once guard and when re-reading is allowed. The presence of an output schema reduces the need to describe return shapes, but the description still does so extensively. No critical context is missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema already provides 100% coverage with rich descriptions, so the baseline is 3. The description meaningfully adds to this by clarifying the relationship between parameters (e.g., 'sitting_id' versus 'query' as alternatives), explaining that 'query' matches by meaning and need not appear verbatim in saved material, and contextualizing 'lens' differently across actions (preview, read, lens). This goes beyond the schema and aids correct parameter selection, justifying a 4.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description opens with a specific verb and resource: 'Read one topic of the user's knowledge base end to end, in publication order'. It then differentiates itself from the sibling 'search' tool by contrasting 'where is it' vs 'what happened', and explicitly names the opposite of the search tool. This is far beyond a generic 'read' or 'sitting' label; the agent understands exactly what this tool accomplishes.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives explicit when-to-use guidance: 'Reach for this when the user wants to know what their saved material actually SAYS...' and equally explicit when-not-to: 'Do not reach for it to look something up... that is the knowledge-base search tool, and it is free and instant.' It further details when to choose each of the five actions and even which lens to pick based on the user's intent.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Other Tools

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/maimond123/Opyt'

If you have feedback or need assistance with the MCP directory API, please join our Discord server