YOUR DEFAULT MOVE on anything non-trivial — use it liberally and early, don't wait to be told and don't wait until you're stuck. Reach for it BEFORE you guess at unfamiliar code, an API, or a library's behavior; whenever you weigh a design or refactor trade-off; when a bug isn't fully understood; or to have a strong reasoner sanity-check a plan or diff before you commit it. One well-framed ask with the code attached beats several bare ones. Set oracle="opus" for this same tool on Claude Opus (newest) — cheaper and faster; use it for high-volume or long back-and-forth work and keep the default Fable for the hardest calls. Ask the selected model to reason about the SOFTWARE/ENGINEERING work you're doing: code structure, functionality, data/control flow, module and function relationships, routing, architecture, and design trade-offs. For questions about EXISTING code, ALWAYS paste the real code into context — the actual function/file/snippet the question is about, plus any error or failing test. The model has NO tools and CANNOT open files, so a bare file path is useless to it. Conceptual/brainstorming questions need no context and are welcome. Frame each call as ONE specific decision ('should X or Y given constraint Z' beats 'thoughts on this code?') or ONE generative prompt ('give me 5 approaches to X, with trade-offs'). Reuse the session key to think through a problem over several follow-up turns instead of restating everything. Answers usually take 1–3 minutes. Broad and conceptual engineering questions — including brainstorming and ideas for future code — are fine. Refused only when the question itself directly asks for offensive-security work (exploit development, attack tooling) or non-software domain knowledge (biology/medicine refused; neuroscience, cognitive science, AI/ML, and CS are in-scope); questions about security-related code are normal engineering. The result carries a sidecar ({recommendation, confidence, needs_context}); when the model needs more, it returns a followup telling you exactly what to paste — paste those (or context_write them and pass context_ref) and re-ask on the SAME session, but first check followup.likely_already_pasted and RE-READ your own paste rather than resending it. A context_exhausted status means the model still can't answer after repeated tries — stop re-asking and use your own judgment.

FREE, local and instant — no model call, no cost, no network. Returns the part of this server's manual that does NOT fit in the standing instructions (harnesses truncate those at ~2 KB). Call it when: a call came back status:"refused" (topic refused — reframe, never resend the same question); you're about to re-paste context you already sent (topic context — the shared bus, paste once and reference by key); you're configuring an Ollama / Atlas / OpenRouter council (topic setup); or you want the full tool menu with the model tokens usable in councils, chains and debates (topic tools). all returns everything. Cheap enough to call speculatively — prefer it over guessing at an argument.

Ask ONE model — on its own, independent of Fable — to reason about the SOFTWARE/ENGINEERING work you're doing: code structure, functionality, data/control flow, module and function relationships, routing, architecture, and design trade-offs. provider selects the backend; model overrides the model where the backend accepts one. This one tool replaces the per-backend tools: 'minimax' (MiniMax-M3), 'glm', 'deepseek' (cheap direct APIs — prefer these for a quick independent opinion), 'sonnet', 'gemini', 'codex' (GPT-5.6 Sol), 'grok', 'kimi' (local CLIs), and the gateways 'ollama', 'lmstudio', 'atlas', 'ali' (Alibaba/Qwen reasoning), 'openrouter'. Aliases: m3=minimax, gpt=codex, xai=grok. The direct providers have a fixed model and reject model; pass model for a CLI override (grok/kimi) or a gateway (ollama/lmstudio/atlas/ali/openrouter) — call list_models(provider=...) first for the gateway catalogues. Single-turn: for a multi-turn thread use ask (multi-turn; oracle="opus" for Claude Opus). Broad and conceptual engineering questions (including brainstorming/ideas for future code) are fine — add a snippet or file path in context when the question is about existing code. Direct offensive-security asks (exploit development, attack tooling) and non-software domain knowledge (biology/medicine refused; neuroscience, cognitive science, AI/ML, and CS are in-scope) are refused. Prefer a dedicated local CLI over a gateway for the same model. Use ask_council to ask several models and get a synthesized answer.

OPT-IN web-search / OSINT research agent. Unlike every other ask_* tool (which is toolless and cannot browse), this one runs a model WITH live web search to research a question and return a sourced, cited answer — use it for current/'latest' facts, version/pricing/release lookups, who/what-is research, and open-source intelligence gathering. Pick the model with model: grok (grok-4.6 live search, the default — strong for current events, via the local grok CLI), a Claude model on your OAuth session — sonnet (claude-sonnet-5), opus48 (claude-opus-4-8), opus5, or fable — using native WebSearch/WebFetch, or gemini via the local agy CLI. All run on flat-plan sources (no per-token billing). Put any code/artifact the research is ABOUT in context. Returns a findings summary followed by a Sources: list. DISABLED by default: the operator must set ASK_FABLE_ALLOW_WEBSEARCH=1 (returns {"status":"disabled",...} otherwise). On grok and Claude the search-only boundary is a real tool gate; gemini is search-only for a different reason — agy's own headless permission policy denies page fetch, shell and file tools, and a denial aborts the turn, so that backend is told to use search_web only (use grok or a Claude model when the task needs page content). Requires the grok or agy CLI (for those models) or the Claude OAuth session (for the Claude models). Refuses tasks whose aim is genuinely harmful (attack development, de-anonymizing or surveilling a private individual); legitimate research on software, companies, CVEs, and public events is answered.

DIRECTIONAL — reserve this for a genuinely contentious or HARD-TO-REVERSE decision (architecture, concurrency, data model, public API, migration) where a single opinion isn't enough and you want several models cross-checked, or for divergent brainstorming where you want independent idea sets merged without losing distinct options. It's slower and heavier than ask, so DON'T reach for it on routine questions — default to ask, and use at most one council call per problem. Check quorum/degraded in the result: a 1-of-N answer is one opinion, not consensus. Ask several models at once the same SOFTWARE/ENGINEERING question, then get back one answer that Fable synthesizes by reconciling all of them (each raw answer is also returned under sources). By default asks Fable (whichever id is newest) + MiniMax (MiniMax-M3), plus DeepSeek (deepseek-flash) when ASK_FABLE_DEEPSEEK_API_KEY is configured — cheap direct models are preferred and consulted first. Pass models to choose from ['fable','fable51','opus','deepseek','minimax','glm','gemini','codex','grok','kimi'] ('fable' tracks the newest Fable automatically and 'fable51' pins claude-fable-5-1 even after it stops being newest — they are the same model today, so naming both buys you nothing; 'opus' is the newest Claude Opus on the same OAuth session as Fable — always available, half the price; 'gemini'/'codex'/'grok'/'kimi' need their local CLIs; 'glm'/'deepseek' need API keys configured on the server). You can also add Ollama Cloud models as 'ollama:' tokens (e.g. 'ollama:qwen3-coder:480b-cloud', 'ollama:nemotron-3-ultra:cloud'); these are reached via a local signed-in ollama daemon by default (reported+skipped if unreachable). The group token 'twin' (aka 'twin flames') expands to BOTH Anthropic reasoners at once — fable + opus — so models=['twin'] is a dual Fable/Opus invocation and models=['twin','minimax'] adds a third voice to it. Both ride the OAuth session, so it needs no provider keys and is the cheapest real second opinion available. Instead of listing models, you can pass a named tier: 'default' (fable+minimax, +deepseek when its key is configured), 'twin' (the twin flames, fable+opus), 'middle' (all of the above +opus+glm+gemini+codex+grok+kimi, cheap models first), or 'full' (+the configured Ollama Cloud models). Instead of models/tier, pass provider ('ollama', 'atlas', 'openrouter', or 'lmstudio') to scope the council to ONE gateway: its configured panel is used by default, its members are that provider's tokens, its adjudicator ladder applies (GPT-first for atlas/openrouter), and 'lmstudio' runs the panel one model at a time (a single GPU). An explicit models is honored within the chosen provider; tier is ignored when provider is set. The result carries a consensus signal ('strong' | 'partial' | 'divergent' | 'unknown') and material_disagreement computed from the panelists' recommendations, and each entry in sources shows that model's recommendation — so you can see WHO endorsed what, not just the merged answer. Panel answers are anonymized to the synthesizer to blunt self-preference bias. Pass synthesizer to have a different model adjudicate the panel (default 'fable'; e.g. 'opus' = newest Claude Opus, 'codex'/'gpt' = GPT-5.6 Sol via the local CLI, or 'atlas:openai/gpt-5.6-sol') — it falls back to Fable when unavailable or failing, and the result's synthesis block reports what actually ran. Same scope as ask: broad and conceptual engineering questions (including brainstorming) are fine; direct offensive-security asks and non-software domain knowledge (biology/medicine refused; neuroscience, cognitive science, AI/ML, and CS are in-scope) are refused.

DIRECTIONAL, SEQUENTIAL — the relay counterpart to ask_council. Where the council asks N models the SAME question in parallel and synthesizes their independent answers ('what's true?'), the chain threads a question through an ORDERED pipeline where each stage refines the last ('make this answer better'). The operator sets the order as a pipeline string like 'm3 > glm > deepseek > fable' (or an ordered models array). Stage 1 drafts; each middle stage is told to solve independently and CRITIQUE the prior draft before extending it (an anti-anchoring guard); the final stage DECIDES, seeing all prior stages as anonymized peers. Best for two things a council can't do: cost-tiered escalation (a cheap/fast model does the legwork, Fable finalizes) and explicit draft → red-team → decide pipelines. Costs MORE latency than a council (stages run sequentially, not in parallel), so reserve it for when the ordered refinement is the point. Draft → critique → refine is also a natural IDEATION pipeline: a cheap model brainstorms broadly, later stages prune and sharpen the ideas. Order matters and repeats are allowed ('fable > glm > fable' = draft, critique, re-decide). A mid-chain model that refuses/errors is skipped (recorded); if the final stage fails, Fable synthesizes the survivors. The result carries a recommendation_drift trail and material_drift flag — the chain analogue of the council's consensus signal — so you can see whether the answer was refined or just rubber-stamped. Same scope as ask: broad and conceptual engineering questions (including brainstorming) are fine; direct offensive-security asks and non-software domain knowledge (biology/medicine refused; neuroscience, cognitive science, AI/ML, and CS are in-scope) are refused. Aliases: 'm3' = minimax, 'opus5' = opus. Any stage can be 'opus' (Claude Opus 5) — a cheaper, faster terminus than Fable, e.g. 'm3 > opus'. The group token 'twin' (aka 'twin flames') expands in place to two stages, fable then opus, so 'm3 > twin' is a cheap draft finished by both Anthropic reasoners in turn. Default pipeline if none given: minimax > fable.

DIRECTIONAL, ADVERSARIAL — pit two models AGAINST each other over a structured claims ledger, then have a fresh third model adjudicate. Unlike ask_council (N models vote independently) or ask_chain (each stage refines the last), the debate makes one model PROPOSE a position decomposed into load-bearing claims, the other REFUTE each claim (concede or contest-with-a-concrete-failure-scenario), the proposer REVISE under fire, and an anonymized adjudicator RULE on the merits. Reserve it for a genuinely contentious, hard-to-reverse SOFTWARE decision where you want the strongest case for AND against stress-tested — 'is this concurrency design sound', 'should we commit to approach X or Y' — not for questions with a clear answer. Pick the pair with proposer and opponent (e.g. proposer='fable', opponent='codex' for Fable vs GPT-5.6 Sol, or opponent='glm'); defaults to fable vs minimax. adjudicator picks who rules (default 'fable'; e.g. 'opus' for Claude Opus 5, or 'codex') — keep it off the debating pair so the ruling stays third-party. rounds is 1 (default) or 2 (adds a rebuttal pass). The server decides the outcome deterministically from the ledger — resolution is 'conceded' (opponent conceded everything), 'converged' (all contests resolved and both sides agree), 'adjudicated' (the adjudicator decided), or 'stalemate' (both dug in with nothing new → confidence is mechanically downgraded). Costs up to four sequential model calls, so it's the most expensive mode — use it sparingly. Degrades to a single-critic pass when the opponent is unconfigured. Same scope as ask: broad and conceptual engineering questions are fine; direct offensive-security asks and non-software domain knowledge (biology/medicine refused; neuroscience, cognitive science, AI/ML, and CS are in-scope) are refused. Aliases: 'm3' = minimax, 'gpt' = codex, 'opus5' = opus.

Review a draft answer that ALREADY EXISTS — yours, another model's, or another tool's — and get back the objections a reviewer could actually SHOW, separated from the ones it could only argue.

This is the only mode that takes a finished answer as input. Every other mode reasons from scratch: ask_council fans a question out, ask_debate grows its own position, ask_falsify asserts its own claims. Reach for this when you have an answer in hand and the cost of it being wrong is high.

HOW TO READ THE RESULT. verify.prevented counts objections whose receipt code could check against your context or against a check that failed — those are the only ones that establish anything. verify.unbacked_objections counts argument without evidence: weigh it as opinion. A self-quoting verdict means every objection quoted the draft back at itself, which proves only that the reviewer read it — supply real source material in context and re-run.

WHAT IT DOES NOT DO. It never withholds or rewrites your draft; answer comes back unchanged on every path, including when the reviewer fails. And no objections is NOT a correctness guarantee — it means no fault was demonstrated, not that none exists.

Pass context (the source material a citation may quote) or the review can only produce opinion. Pass drafted_by to refuse a same-lab review. Costs one model call.

STATEFUL, ADVERSARIAL — a persistent falsification ledger, the process cousin of ask_debate. An assertor states typed claims; a falsifier (forced to a DIFFERENT lab) attacks them; and a deterministic CODE clerk — not a model — decides commit/kill/survive from receipts it verifies mechanically: a cite quote's VERBATIM presence in context, or a contra edge to a survived claim. A claim may speak, but it cannot compound (move reputation, count as consensus, survive) without a verified receipt — a fabricated or absent quote dies. State PERSISTS across calls under the REQUIRED session key, so a killed claim stays dead and calling again continues the same ledger. Use it to grind a contentious, CHECKABLE question down to what actually survives evidence rather than what sounds convincing — and pack the corpus the claims must cite into context/context_ref. Pick the pair with assertor (default 'minimax') and falsifier (default 'opus'); they must resolve to different labs. rounds is 1-6 assert->attack cycles per call (default 1). Returns the ledger's survived/killed/open/crucible split plus per-model reputation. Same scope as ask; offensive-security asks and non-software domains are refused. Receipts are cite and contra; with the operator opt-in ASK_FABLE_ALLOW_RUN=1 (and bwrap installed), a run: receipt executes a sandboxed Python snippet instead. metamorph: true adds a cold-restatement stability check. Aliases: 'm3' = minimax, 'gpt' = codex, 'opus5' = opus.

DIVERGENT, MULTI-ROUND — a brainstorming CONFERENCE where several models argue a topic TOGETHER over rounds, each reading the running transcript and building on (or pushing back against) what came before, then a rapporteur writes the MAP OF THE DISAGREEMENT (converged / the crux / what would change it). Unlike ask_council (models answer in isolation, then reconcile) the participants actually hear each other, so positions can move — use it for open-ended ideation and design exploration ('what should we build', 'ways to approach X'), where you want genuine divergence rather than one averaged answer. Pick the bench with models (from ['fable','opus','deepseek','minimax','glm','gemini','codex','grok','kimi'] plus any 'atlas:' / 'openrouter:' / 'ollama:' token); default is the available subset of fable/opus/deepseek/minimax/glm. rounds is 1–10 (default 3) and synthesizer writes the closing map (default 'fable'). When called with no models and the MCP client supports form elicitation, a NATIVE model picker pops up to choose the roster and topic (set interactive: false to skip it). Costs one model call per participant per round plus the synthesis, so it is heavier than a council — keep the bench and rounds modest. Same scope as ask: conceptual software/engineering ideation is in scope; direct offensive-security asks and non-software domains are refused. Aliases: 'm3' = minimax, 'gpt' = codex, 'opus5' = opus.

Save the user's chosen default council for ONE gateway so it sticks across sessions (written to ask_fable's config file, overriding the matching ASK_FABLE_*_COUNCIL env default). provider selects 'ollama', 'atlas', or 'openrouter'. Pass models as the model ids that ask_council(provider=…) should use by default (bare ids or provider-prefixed tokens). Atlas/OpenRouter also take synthesizer (the adjudicator; omit to keep the GPT-first ladder); ollama takes default_model (the single model ask_model(provider="ollama") uses when none is passed). Confirm the selection with the user first — ground it with list_models(provider=…). Returns the saved config and its file path.

List the available models for one gateway so you can offer a concrete choice before spending a call. provider selects the catalogue: 'ali' (Alibaba/Qwen reasoning models, plus the deepseek-/glm- and 'auto' the gateway fronts), 'atlas' (Atlas Cloud text models), 'openrouter' (~400 models from every major lab on one key), 'ollama' (the live ollama.com catalog plus locally-pulled models and the configured council), or 'lmstudio' (the operator's local LM Studio server — loaded/available models, context windows, and a VRAM fit classification). The Atlas and OpenRouter catalogues are free and need no key; pass task to rank a provider-diverse shortlist for a job, and interactive (default true) opens a native model picker on clients that support form elicitation. 'ali' takes all to include the non-reasoning audio/image models. Read-only.

Unload one model from the operator's LM Studio server to free memory. OPERATOR ACTION: never call this without an explicit request or confirmation from the user — it discards a resident model. Use list_lms_models to show what is loaded and how much each occupies, and note that a blocked ask_lms result carries an unload_offer naming exactly what is in the way. Refuses while the model has an ask_lms call in flight; waits for the unload to be confirmed and reports the bytes freed and what remains resident. Idempotent (unloading an unloaded model is a no-op).

Read-only GPU and host status from the operator's Control panel (lmstudio.example.com): GPU utilization, VRAM used/total/free, temperature, fan and power, which processes hold VRAM, systemd service states, the models LM Studio has loaded, and any warnings. REACH FOR THIS when the user asks how the GPU/box is doing, or before offering a local-model decision that may not fit in memory (ask_lms already uses the same reading for its room check). Best-effort: an unreachable control page returns a status error, never a crash.

Read-only health check of every reasoning backend — REACH FOR THIS when a council came back degraded, an oracle is unexpectedly missing, or you want to know what is actually wired up before relying on it. For each oracle it reports reachability, the resolved model, the configured timeout, the circuit-breaker gate (open / quota-held), and a fix: line for anything down, rolled up to ok / warning / error. It makes NO paid model call and NEVER perturbs state: it only checks a CLI's presence and --version, whether an API key is set, and the breaker's read-only snapshot. Cheap and safe to call speculatively.

Toggle reasoning-trace capture at runtime, persisted across sessions (writes ask_fable's config file, which overrides the ASK_FABLE_TRACE_MODE / ASK_FABLE_STREAM_REASONING env defaults — no ~/.claude.json edit or restart needed; it applies on the next call). trace_mode='full' records redacted model reasoning into traces and trace bundles (and saves answer markdown); 'safe' withholds reasoning content while structural traces still record. stream_reasoning=true|false turns live thinking on the server console on or off. Pass either or both. Returns the effective settings and the config path.

Turn oracles/providers OFF (or back on) at runtime — persisted to the config file, no restart. A disabled backend is dropped from every council/tier and its dedicated tool returns kind='disabled' (distinct from 'not configured'). Name an oracle key/alias ('grok', 'm3', 'opus48') or a whole provider ('atlas', 'openrouter', 'ollama', 'lmstudio'). Call with no args to see the current denylist. Config wins over the ASK_FABLE_DISABLED env var.

Build or refresh the local code+docs index for the configured project root, then search it with code_search. Walks the root (skipping .git, node_modules, virtualenvs, caches, binaries, oversize files and the same secret blocklist context_pack uses), splits files into overlapping line windows, and stores them in a per-project SQLite index OUTSIDE the repo. Incremental: unchanged files keep their embeddings. Embeddings are OPT-IN and FAIL-SAFE — hosts come from ASK_FABLE_EMBED_HOSTS (comma-separated, tried in order; unset = the LM Studio host), and when none answers the chunks are stored unembedded and code_search degrades to keyword ranking until a later run backfills. Read-only with respect to the repo; returns file/chunk/embedding counts.

Search the local project index built by code_index and get the most relevant windows back with file:start-end references — cheaper and more targeted than grepping or reading whole files. Ranking is hybrid: SQLite FTS5 keyword (BM25) plus embeddings when an embed host answers, fused by reciprocal rank. When no host answers it degrades to keyword-only with a degraded note instead of failing. Optional rerank=true reorders the top hits with a small chat model (ASK_FABLE_EMBED_RERANK_MODEL); skipped with a note when unset or unreachable. Returns not_indexed until code_index has run.

Read the shared context bus: pass key to get a stored blob back (value plus its size, age and description; not_found if unset), or OMIT key to LIST every stored key (size/age/description, never the full value). Read-only — use it to inspect a blob, or to discover what is already available to reference via context_ref before re-pasting.

Change the shared context bus — dispatched by op. 'write' stores value under key (paste a big blob ONCE, then reference it via context_ref instead of re-pasting it every call); 'pack' reads the repo files named in paths (each path or path:START-END, relative to the configured project root) and stores the budgeted bundle under key; 'delete' removes key. Reusing a key overwrites it, and the store is shared by every agent on this server — read with context_read first. Destructive/overwriting.

Dump (optionally to a file) and clear a Fable conversation session, so the next ask on that key starts a fresh topic.

Read-only usage/health stats aggregated from the ask_fable audit log — see how the tools are performing without spelunking JSONL. Buckets every recorded call over a time window ('1h' | '24h' | '7d' | 'all', default '24h') by 'model', 'session', or 'day', reporting calls / allowed / refused / errors, avg and p95 latency, and error_rate per bucket plus totals. Optional model / session filters narrow to one backend or workflow. Council/chain records also carry quorum, consensus, and synth_fallback in the log. Use it to answer things like 'is GLM erroring a lot today?' or 'how slow are councils this week?'. Makes no model call and is never cached.

List recent correlated tool traces without raw content.

Read the ordered events and artifact references for one trace.

COORDINATION — the operator dashboard. Lists ask_fable sessions across instances on this machine (opencode / Claude Code / salient windows) so you can see what other agents are asking the oracles. Each entry shows session key, agent_id, latest question, oracle, status, heartbeat age, and turn count. Defaults: THIS project only, and active_only: true (hide sessions with no heartbeat in ~5 min — the stale threshold). Pass active_only: false for retained history, all_projects: true for the whole machine. Use it to avoid duplicate work or watch the live fleet. Read-only, makes no model call. Visibility-only — never affects oracle answers; oracles only see what a calling agent explicitly passes in question/context.

COORDINATION — read the full turn history (every question and answer, in order) for one session, across instances. Use it to understand what an agent has learned in a session before joining the work, or to recover a finding another instance produced. Optionally scope to one agent_id. Returns the complete conversation bounded by retention. Read-only, makes no model call. Like session_list, this is visibility-only — it never feeds back into an oracle's context.

COORDINATION — aggregated oracle usage across ALL instances on this machine (unlike stats, which only sees the current instance's audit log). Turn counts (by status/oracle/agent) default to the last 24h (window_s: 86400); pass window_s: 0 for all retained history. Also returns fresh_sessions (heartbeat within the stale window) vs total_sessions, plus attributed_turns / unknown_turns. Defaults to this project; all_projects: true for the whole machine. Use it to answer 'which agents are burning the most oracle calls?' or 'how is the fleet doing today?'. Read-only, makes no model call.