The AI Tool Landscape: A Living Catalog

The AI-Augmented Analyst · independent branch · Node AI0.02 of 7 · ~10 focused hours · rubric gate ≥85%

New AI products launch, rename themselves, merge, and reprice faster than any other tool category you will ever study in this program. A chat assistant you evaluated in January can ship a new tier by March; a "coding copilot" and a "research agent" can blur into the same product by the next release; a name that meant one thing eighteen months ago can mean something else entirely today. A learner who responds to that churn by memorizing a list of current best tools is guaranteed to be wrong within a year, often within a quarter. This node teaches you something that does not go stale: a small set of durable categories every AI tool falls into regardless of its brand name, and a five-question rubric you can point at any tool, including one that does not exist yet, and get a usable, checkable answer in about two minutes.

AI0.01 gave you the mechanism: every one of these tools, however it is branded, is built on the same engine that predicts the next plausible token from a corpus with a cutoff, and optimizes for plausible, not true. That single fact is why the categories in this catalog share failure modes across brand lines, and why the rubric's fourth question (how do you verify its output) is never optional, no matter how polished the interface. This module turns that shared mechanism into a working map: seven categories that cover essentially everything on the market, and one rubric that evaluates every tool in every one of them the same way.

The duality, stated once (R10). This module carries two objectives at once, like every node in this branch. The understanding objective (running the five-question rubric on an unfamiliar tool from its own documentation, unaided) is what the mastery gate rewards; a tool can never buy you a pass on it. The productivity objective (a working map of the seven categories plus a dated snapshot of current examples) is the payoff you keep day to day. Categories and the rubric are durable; brand names, prices, and version numbers are perishable and are quarantined below in a clearly dated section. Learn the map, not the label.

One promise for the hours ahead: hand you a tool you have genuinely never seen before (one that ships next month, with a name invented for marketing) and by the end of this node you will place it in a category, run the five questions against its own website and documentation, and decide whether and how to use it on real analyst work, in about two minutes, without needing anyone's opinion about whether it is "good."

Learning objectives

By the end you can:

1. State the seven durable tool categories (chat assistant, coding copilot, research/agentic, data-analysis, document/PDF, spreadsheet, presentation/design) and place any described AI product into the correct one, arguing why, even when its marketing blurs the line.
2. Run the five-question tool-evaluation rubric, what is it? what's it good and bad at? where does your data go? how do you verify its output? what's its cost/offline profile?, on an unfamiliar tool using only its own documentation or website, inside a couple of minutes.
3. For each of the seven categories, name its single most common failure mode and the Guardrail check (Trace · Match · Recompute · Date-check · Cite) that catches it.
4. Distinguish durable information about a tool (its category, its mechanism, its typical failure shape) from perishable information (its name, price, version, or exact feature list), and explain why that split protects your judgment from marketing churn and dated tutorials.
5. Read a tool's own data-usage or privacy documentation and correctly answer whether a given input (a paste, an upload, a query) is used to train future models, retained, or processed and discarded.
6. Given a real analyst task, choose the right tool category (not brand) for it and justify the choice against at least one plausible alternative category.
7. Explain why "free" and "offline" are two independent facts about a tool, not two words for the same thing, and why both matter when the input is sensitive company data.
8. Apply the rubric, as a standing habit, to a tool that did not exist when this module was written, this is the productivity skill the module exists to install, not a one-time exercise.
9. State this module's dated catalog is a snapshot as of a specific date, correctly locate a live source to verify any name or price in it, and describe the standing refresh ritual for keeping a personal tool catalog current.

The duality, stated once (R10). Objectives 2, 3, 5, and 7 are the understanding objective (the rubric skill, run by hand against a tool's own documentation) and this is what the mastery gate rewards; no subscription and no tool ever buys a pass on it. Objectives 1, 6, 8, and 9 are the productivity objective, the category map, the habit of re-running the rubric on anything new, and the dated snapshot of current examples you keep for day-to-day use. Awareness of what exists makes you fast; the rubric, applied by hand, makes you an analyst who cannot be fooled by a landing page.

Prerequisites & connections

Builds on. AI0.01's mechanism is the reason this catalog holds together at all: every category below (however differently it is branded, priced, or marketed) is built on the same next-token-prediction engine that optimizes for plausible, not true. That is why a chat assistant, a coding copilot, and a presentation-design tool share overlapping failure shapes (a confident wrong answer, an invented citation, a narrative that fits your data without being true to it) even though they look nothing alike on screen. If AI0.01 is not fresh, its one-sentence payoff is worth re-reading before you start: the model optimizes for plausible, not true. Nothing below requires code, a paid subscription, or prior tool experience, only that sentence, held firmly.

Feeds forward. AI0.03 (prompt engineering) assumes you can already place a tool in one of these seven categories and picks up from there, teaching you what to actually type into it. AI0.04 (retrieval and RAG) is the mechanism running underneath most of the document/PDF category and a growing share of the research/agentic one, you will recognize "chat with this filing" as a specific, grounded instance of the document/PDF category you meet here. AI0.05 (agents) reuses these same seven categories directly when it asks you to name, step by step, which category of tool a workflow needs at each stage, categories, never vendors, so a workflow design survives tool churn. AI0.06, the branch's crown, needs you to already know where a given tool's data goes and what its typical failure shape is, so that detecting a planted error is about the failure mode, not a first encounter with the tool. AI0.07's capstone applies the rubric across your whole analyst workflow (research, modeling, memo, deck, code, data) and adds the ethics, disclosure, and data-privacy layer this module only opens the door to. Like every node in this branch, AI0.02 gates nothing in the eleven-phase Finance sequence, and nothing outside AI0.01 gates entry here.

Core teaching content

Why a catalog by category, not by brand

Picture two ways of studying "what AI tools exist." The first is a list: this product, at this price, with these features, is currently the best in its space. The second is a map: here are the handful of jobs an AI tool can be built to do, here is what each job structurally implies about strengths, blind spots, and where your data ends up, and here is a rubric that works on any specific product doing that job. The first approach is more exciting to read and is wrong by the time you finish reading it, a "current best" list is a snapshot of a market that reprices monthly and rebrands yearly. The second approach is less exciting and stays true for years, because the job a research/agentic tool does, search, read, synthesize, cite, does not change even when every named product doing it changes completely.

This module teaches the second approach on purpose. The durable content is the seven categories below and the five-question rubric: learn these once, and you can evaluate a tool that launches after this program ships. The perishable content is every specific tool name, price, and version, quarantined in its own clearly dated section further down, reviewed on a standing cadence, and never to be treated as current without a fresh check. Confusing the two is the single most common way a learner's AI judgment goes stale without them noticing: they keep the rubric current in their head but let a two-year-old brand impression stand in for it.

The tool-evaluation rubric: five questions, every time

Run these five questions, in this order, on any AI tool, a household name, a tool a colleague just mentioned, or a product that launches next month. They work identically on all of them, which is the entire point.

1. What is it? In one sentence, what job does this tool actually do, which of the seven categories below does it belong to, and what is the underlying mechanism (a chat interface over a model, a retrieval system grounded in documents you provide, an agent that plans and executes multi-step actions)? Marketing copy answers this question with adjectives ("powerful," "intelligent"); you answer it with a mechanism.
2. What's it good and bad at? Every category has a structural strength and a structural blind spot that follow from what it is, not from how well it was built, a chat assistant is good at drafting and explaining and bad at being a live database; a coding copilot is good at boilerplate and bad at silently wrong business logic that still runs. Name both, specifically, not generically.
3. Where does your data go? Whatever you paste, upload, or connect leaves your machine and goes somewhere, a provider's servers, a specific cloud tenancy, a training pipeline. Read the tool's own data-usage or privacy documentation for the specific tier you would actually use (a free consumer tier and a paid business tier from the same company routinely have different answers here) before you paste anything non-public into it.
4. How do you verify its output? Every category needs a different concrete check, running independent tests for code, re-deriving a number by hand for a spreadsheet or data-analysis answer, tracing a citation to the actual page it claims for research or document tools. "It sounds right" is never a verification method; naming the specific, mechanical check is the whole answer to this question.
5. What's its cost/offline profile? Price (free, per-seat, metered) and offline capability (cloud-only versus a genuinely local option) are two separate facts about a tool, not one. A free tier and an offline tool are not the same claim, and neither tells you anything about the other three questions above.

Two questions in this rubric map directly onto the Primary-Source Guardrail you first met in AI0.01 and will drill to reflexive mastery in AI0.06 (the full five checks (Trace, Match, Recompute, Date-check, Cite) live in guides/ai-primary-source-guardrail.md, the standing reference every AI-Augment callout in this program points back to): question 3 ("where does data go") is a before-you-use-it governance question, and question 4 ("how do you verify") is an after-you-get-an-answer discipline question that always resolves to one or more of those five checks. Keep them mentally distinct, a tool can have an excellent data-governance answer and a terrible verification story, or the reverse, and you need both answered, not just one.

Category 1: Chat assistant

What it is. A general-purpose conversational interface to a large language model: you type a natural-language request and receive a natural-language (increasingly also image, table, or code) response, often with add-on "modes" (extended reasoning, voice, web-connected research) layered on top of the same base conversation.

Good at. Drafting and rewriting text, explaining an unfamiliar concept at whatever depth you ask for, brainstorming a structure before you commit to one, a first-pass summary of something you paste in directly, acting as a patient Socratic tutor for a concept you are still learning.

Bad at. Being a live database, it has no standing connection to today's filings, prices, or news unless a tool or plugin explicitly fetches one for it (AI0.01's cutoff, restated); being reliably right on multi-step arithmetic without you re-deriving the answer; being the source of a fact it "remembers" from training rather than something it looked up just now; staying fully consistent across a very long session as earlier context competes for the model's limited attention (AI0.01's context window).

Where data goes. Whatever you paste is sent to the provider's servers for processing. Free and lower consumer tiers commonly default to using your conversations to improve future models unless you find and use an explicit opt-out; paid business/enterprise tiers typically carry a contractual guarantee that your conversations are excluded from training. This makes "chat assistant" the single riskiest category in this whole catalog for pasting an unpublished filing, a client's data, or anything under an NDA, check the specific tier's policy, every time, before you paste something non-public.

Verify. Never treat a remembered fact, a quoted number, or a cited source as true because it was stated fluently, trace it to a named primary source before it enters any real work (Guardrail #1, Trace).

Cost/offline. Almost always cloud-hosted; no meaningful offline mode exists for a flagship chat assistant as of this writing. Free tiers exist with usage caps and often a less capable underlying model; paid tiers scale with usage, context length, and feature access, never with "more truth." Worked Examples 3 and 6 below both live in this category.

Category 2: Coding copilot

What it is. An AI integrated into or alongside a code editor, IDE, or terminal that suggests, writes, explains, or executes code, ranging from inline autocomplete of a single line to an autonomous, multi-file "agentic" session that can run its own terminal commands and iterate.

Good at. Boilerplate you would otherwise type by hand, syntax in a language you do not have memorized, turning a plainly described piece of logic into a first-draft function, explaining an unfamiliar codebase quickly, scaffolding test structure.

Bad at. Silently getting business logic subtly wrong in a way that still runs cleanly, an off-by-one row range in a financial calculation, a plausible-looking library function that does not actually exist, a "fix" that quietly deletes or weakens the failing test instead of fixing the underlying bug.

Where data goes. Your source code, which for an analyst can mean a proprietary model's logic, a client's data schema, or a script with real embedded figures, is sent to the provider unless you are specifically on a private, local, or on-prem configuration. Some tiers default to using your code to improve future models; others carry a contractual exclusion. This is a per-tier fact, not a per-brand one, check it.

Verify. "It ran without an error" is never proof of correctness, run the actual independent or hidden test suite and compare against a value you can defend, the same discipline this program teaches for a spreadsheet formula (Guardrail #3, Recompute). This category is deliberately taught shallow here; the deep, code-verified version of "trust AI-written code only after it passes a real test harness" belongs to the Quant & Data galaxy's coding track, which this catalog only places, not teaches.

Cost/offline. Free tiers with limited monthly completions are common; paid per-seat tiers unlock more capable models and materially higher usage. A small number of tools offer a genuinely local model option (no code leaves the machine) usually at a real capability cost, making this category the sharpest illustration in the whole catalog of the offline-versus-capability trade-off. Worked Example 2 below walks a real, cited pricing structure in this category.

Category 3: Research/agentic

What it is. Tools that go beyond a single conversational turn: a "deep research" mode that searches the web (or a bounded document set), reads multiple pages, and synthesizes a cited report; more broadly, "agents" that plan a multi-step task and use tools (browsing, running code, calculating) with only periodic human checkpoints (the full mechanics of agent loops are AI0.05's territory; this catalog only places the category).

Good at. Surveying "what's out there" on a topic fast, cutting hours of manual tab-opening down to a first-pass draft you then check, producing a structured starting point for a market scan or a literature review.

Bad at. Distinguishing an authoritative source from an SEO-optimized page merely restating a rumor in confident language; silently substituting something adjacent-but-wrong for a source's actual claim while "synthesizing" across many pages; treating a paywalled or JavaScript-heavy page it could not really read as though it had read it fully.

Where data goes. Your query or research prompt is visible to the provider; if the tool browses live pages, the sites it visits see traffic originating from the tool's own infrastructure rather than attributable to you individually, but the content of what you asked for is still visible upstream to the provider running the tool.

Verify. This category needs Guardrail #1 (Trace) and #5 (Cite) harder than almost any other: for every fact in a synthesized research report, open the actual source it names and confirm the source really says that, on the page or section claimed. A fabricated or misread citation reads exactly as confident as a real one, the polish of a "deep research" report is not evidence of its accuracy.

Cost/offline. Usually gated as a premium mode layered on top of an existing chat-assistant subscription (a handful of free uses, then a paid unlock), reflecting the extra compute of multi-step browsing. No offline mode is possible by definition, since the category requires live access to external sources. Worked Example 3 below is set in this category and is worth reading closely: it is about verifying the tool's own claim of currency, which turns out to be exactly this module's central discipline turned back on itself.

Applying AI to this skill: keeping your own tool catalog current.

{ "skill": "Keeping a personal AI-tool catalog current", "use": "Use a research/agentic tool for a fast first-pass survey of what currently exists in one category of this catalog before you commit to a specific product -- a map, never a verdict.", "tools": ["Research/agentic -- a chat assistant's deep-research mode, or a dedicated web-research agent (as of July 2026)"], "prompt": "Give me a first-pass survey of AI tools in the <CATEGORY, e.g. document/PDF> category as of <MONTH YEAR>. For each one you find, list: name, one-line description, its pricing-tier structure in general terms (not exact figures), and a link to its own official pricing or docs page. Do not rank them or tell me which is 'best' -- just the map and the links, so I can check each one myself.", "verify": "Open every linked official page yourself and re-confirm the tool's category fit and current tier structure directly on the page (Guardrail #1 Trace) -- and note whether the page shows any independent sign of recency (a dated changelog entry, a recent press release), because a URL loading successfully is not proof its content is current (Guardrail #4 Date-check). Never repeat a tool's claimed price in your own notes without having seen it on the live page in the same sitting.", "diy": "Know the seven durable categories and the five-question rubric cold, unaided, before you ever let a tool suggest a tool -- otherwise you have no way to tell a thorough survey from a shallow one that just repeats marketing copy." }

Category 4: Data-analysis

What it is. An AI layer over a data or analysis environment: upload a dataset, ask a question in plain English, and get a chart, table, or statistic back, often by having the AI actually write and run code behind the scenes (a sandboxed interpreter) rather than merely describing what the answer might be.

Good at. Fast first-pass exploration of a dataset you already trust (a distribution, a quick pivot, a first look at whether two variables move together) and writing the boilerplate cleaning code so you review it rather than typing it from scratch.

Bad at. Silently choosing the wrong aggregation for your actual question (mean instead of median on a skewed dataset) and presenting a confident chart with no warning that one outlier moved the headline number; being trusted with statistical judgment, a correlation it highlights is not evidence of causation, and it will not reliably flag that distinction unless asked; handling a dataset larger than what it can actually hold in view without silently truncating rows.

Where data goes. The uploaded dataset itself (not just a described question about it) typically leaves your machine for the provider's compute environment to be processed. This is the sharpest version of the "where does data go" question in the whole catalog, because the input here is very often your organization's raw numbers, not a paraphrase of them.

Verify. Confirm the unit, scale, and period of what it actually computed matches what you asked for (Guardrail #2, Match), and re-derive the headline number yourself, by hand or with your own formula, at least once before trusting the tool's version on anything that matters (Guardrail #3, Recompute). Worked Example 4 below walks exactly this failure, with real arithmetic.

Cost/offline. Sometimes bundled free into an existing spreadsheet or BI subscription; standalone tools often meter by dataset size or query volume. A fully local, fully offline version of this category is rare as of this writing, because the code-execution sandbox underneath it typically needs real server-side compute. The deep, code-verified version of this category (validating a pipeline against hidden tests rather than trusting a chat answer) belongs to the Quant & Data galaxy's data-analysis track.

Category 5: Document/PDF

What it is. "Chat with this document": you upload one or more files (a filing, a contract, an annual report, a research note) and ask questions grounded specifically in that content, usually with the tool citing a page or passage for every answer. The retrieval mechanism underneath this category (chunking a document, finding the relevant piece, generating a grounded answer) is taught in full in AI0.04.

Good at. Finding a needle in a long filing fast (what does the related-party-transactions note actually say), producing a first-pass summary of a document you intend to read in full anyway, comparing a stated figure across two uploaded documents side by side.

Bad at. Reading a scanned, image-only PDF without proper OCR (silently missing content, or worse, inventing plausible text over an image it never actually parsed); correctly handling a table that spans a page break; catching its own misreading of a number in a dense table, a ₹ crore column read as a ₹ mn column looks identical to the tool, and it will report the wrong scale with the same confidence as the right one.

Where data goes. The document you upload, very often the single most sensitive file in the whole exercise, an unpublished draft or a data-room document under NDA: is sent to the provider. Some tools process a document transiently and discard it after the session; others index and retain it for later re-querying by design. Read the specific retention policy before uploading anything you are not permitted to disclose.

Verify. Guardrail #1 (Trace) and #2 (Match) apply to every single figure the tool hands you: click through to the exact page or note it cites and confirm the number, its scale, and its period genuinely appear there. Worked Example 5 below walks a page-break scale error in this category with full arithmetic.

Cost/offline. Many chat-assistant products bundle a basic version of this category free, with upload-size or upload-count limits; dedicated document-AI products often price by page count or number of stored documents. A generous free tier in this category is common partly because the provider values the signal of which sources you find useful, one more reason to read the privacy policy for this category specifically, not just assume it matches whatever policy you already read for a chat assistant.

Applying AI to this skill: a first-pass digest of a long filing.

{ "skill": "First-pass digest of a long filing with a document AI tool", "use": "Use a document/PDF AI tool to get a fast first-pass digest of a long filing or annual report before your own close read -- a map of where things are, never a replacement for reading them.", "tools": ["Document/PDF AI -- a 'chat with this document' tool, or a notebook-style grounded-Q&A tool (as of July 2026)"], "prompt": "Using ONLY the document I uploaded, list every place it discusses <TOPIC, e.g. related-party transactions>. For each, give the exact page or note number and quote the sentence itself, not a paraphrase.", "verify": "Open the filing yourself to the exact page or note cited and confirm the quoted sentence is really there, in that scale and period (Guardrail #1 Trace, #2 Match, #5 Cite) -- a document tool that misreads a ₹ crore column as ₹ mn will still hand you a page number with total confidence.", "diy": "You must already know how to navigate the filing's own table of contents or index and read the note unaided -- the tool only speeds up the search; it never substitutes for knowing what a related-party note is supposed to say." }

Category 6: Spreadsheet AI

What it is. An AI assistant embedded directly inside a spreadsheet application: describe what you want in a cell or a chat pane and it writes the formula, builds the pivot, or drafts a first-pass model, and, in more advanced 2026-era tools, orchestrates documented, reusable multi-step "skills" against live connected data sources.

Good at. Turning a described intent ("summarize this by region and quarter") into a first-draft formula or pivot instantly, suggesting a function you did not know existed, and (where offered) running a saved, reusable workflow against connected data instead of you rebuilding it from scratch every reporting cycle.

Bad at. Silently building a formula that references the wrong range the moment your data reshapes, the exact class of failure EX0.01 through EX7.02 teach you to prevent by hand, just now authored by AI instead of by you; being trusted with a figure pulled from a "connected" market-data source without you checking which vendor and as-of date the connector actually used; preserving a genuine audit trail of what changed unless the specific tool explicitly surfaces one.

Where data goes. Usually processed within the same cloud tenancy as your existing productivity-suite subscription, under your organization's existing data-handling agreement, rather than sent to an unrelated third party, a materially different risk profile from pasting the same numbers into a general consumer chat assistant. Do not assume which of the two is actually safer for your organization; check your specific agreement rather than guessing from the feeling of familiarity.

Verify. Guardrail #3 (Recompute) is non-negotiable here: every AI-authored formula gets exactly the same treatment as a colleague's formula, click into the cell, read what it actually references (not what you asked for), and rebuild at least one non-trivial formula by hand to confirm a match before you extend the pattern across the rest of the workbook. A "show changes" or attribution feature, where offered, tells you what changed, never whether it is correct; that judgment stays yours. Worked Example 1 below walks this category with real, cited India pricing.

Cost/offline. Typically bundled as an add-on tier of the same per-seat subscription as the spreadsheet application itself, rather than sold as a separate product. A fully offline spreadsheet AI is essentially nonexistent as of this writing, because the assistant itself is cloud-served even when your workbook lives entirely on a local disk.

Applying AI to this skill: a first-pass model scaffold.

{ "skill": "First-pass model scaffolding with a spreadsheet AI copilot", "use": "Use a spreadsheet AI copilot to draft the first-pass structure of a repetitive build -- a standard revenue-build tab, a variance-analysis layout -- from a plain-English description, so you start from a scaffold instead of a blank grid.", "tools": ["Spreadsheet AI -- a copilot embedded in your spreadsheet application (as of July 2026)"], "prompt": "Build a <TAB NAME> tab with rows for <LIST OF LINE ITEMS> and columns for <PERIODS>. Use structured Table references, not hard-coded ranges. Do not connect or pull in any external data source -- leave the input cells blank for me to fill from the source I already trust.", "verify": "Click into every formula it wrote and read exactly what it references, not what you asked for (Guardrail #3 Recompute) -- then rebuild at least one non-trivial formula from scratch by hand and confirm the two match before you extend the pattern across the rest of the tab.", "diy": "You must already be able to build the same tab, by hand, from a blank sheet at ordinary Excel-track competence -- the copilot only removes the typing; it never removes your responsibility for what each formula actually says." }

Category 7: Presentation/design

What it is. An AI layer that goes from a rough outline, a pasted document, or a one-line prompt to a formatted set of slides, or a restyled version of slides you already have, generating layout, imagery, and often a narrative structure all at once.

Good at. Collapsing the blank-page problem into a fast first draft of structure and layout you then edit, proposing a chart type or layout you had not considered, restyling an inconsistent deck onto a coherent visual system quickly.

Bad at. Knowing whether the story it imposed on your content is the true one, it will confidently invent a narrative arc ("three key drivers") that fits your bullet points whether or not that is actually your argument; sourcing any number it displays on a slide, which needs exactly the sourcing discipline of a memo figure, not less because it is "just a visual"; respecting a specific firm's brand or compliance template beyond a generic approximation of it.

Where data goes. Whatever outline, document, or dataset you feed it to generate the deck is sent to the provider, the same as any other category, and a deck for a live deal or an unannounced result is exactly the content this category tempts you to paste in, on the reasoning that "it's just formatting."

Verify. Guardrail #1 (Trace) and #2 (Match) apply to every number printed on a generated slide, exactly as in a memo, and beyond the numbers, read the argument the deck now implies and confirm it is still the one your data actually supports, not the one that produced the prettiest layout.

Cost/offline. Free tiers commonly cap the number of AI-generated decks or editable exports per month. A presentation-suite-embedded version (bundled into an existing office subscription) and a standalone generator (its own separate subscription) are priced on completely different bases, settle which one you are evaluating before you compare two numbers that are not actually comparable. The deep chart-grammar and storytelling skill behind this category belongs to the Presentation galaxy; this catalog only places the category.

When a tool blurs categories

Plenty of real products do not sit neatly in one box, a spreadsheet plug-in that also drafts slide summaries from your model, a chat assistant with a document-upload mode that shades into the document/PDF category, a coding copilot with a data-analysis mode bolted on. Do not force a single label. Instead, run the five-question rubric separately for each category the tool touches, its spreadsheet behavior can have a completely different data-destination answer than its presentation behavior, even inside the same product, and a single "what is it?" answer will hide that. A tool that blurs categories is not a reason to abandon the categories; it is a reason to apply the rubric twice.

The dated catalog: as of 2026-07-22, verify before you cite this

This catalog was reviewed against each tool's own pricing and documentation pages on 2026-07-22, and that date is the whole warranty on it: every name, tier and figure below is perishable and must be verified against the provider's live page before you use it. Everything in this section is a snapshot, not a fact you can cite in a memo without re-checking it yourself. Categories and the rubric above are durable; every name, tier structure, and figure below is exactly the kind of perishable detail this module has been warning you about, it is included so you have a concrete, dated starting point, not so you can quote it as current next quarter.

A few of the entries above are backed by a real, checkable primary source rather than general impression, worth knowing precisely because they show what "checking before you cite" looks like in practice:

• Chat assistant, pricing pattern. OpenAI's own announcement of its lower-cost "Go" tier states it launched first in India in August 2025 and reached full worldwide availability on 16 January 2026, priced at $8/month in the United States (openai.com/index/introducing-chatgpt-go/, checked 2026-07-22). Note what the announcement does not give you: the source consulted here did not state the India-specific rupee price, which is exactly the kind of gap you resolve by opening the provider's own regional pricing page yourself rather than repeating a secondhand figure. Worked Example 1 shows why a second-hand number is worth distrusting even when it looks precise.
• Coding copilot, tier structure. GitHub's own Copilot plans page lists a Free tier (2,000 completions per month, limited model access), Pro at $10 per user per month (unlimited completions, cloud agent access, code review), Pro+ at $39 per user per month (premium-model access, audit logs, higher usage), and Max at $100 per user per month (priority access, the highest usage tier): (github.com/features/copilot/plans, checked 2026-07-22). Worked Example 2 below uses this exact structure.
• Spreadsheet AI, capability and India pricing. Microsoft's own announcement of Copilot in Excel (microsoft.com/en-us/microsoft-365/blog, dated 2026-06-25) describes "skill" files savable to OneDrive for repeatable workflows (with pre-built skills for tasks including DCF modeling, book closing, and variance analysis), direct data connectors to named market-data providers (CB Insights, Daloopa, FactSet, Morningstar, PitchBook, and S&P Global), a "Plan with Copilot" step that previews changes before they are made, and attribution tracking inside "Show Changes." Microsoft's own India business-plans pricing page (microsoft.com/en-in/microsoft-365/business/microsoft-365-plans-and-pricing, checked 2026-07-22) lists Business Standard with Copilot at ₹1,955 per user per month and Business Premium with Copilot at ₹2,660 per user per month, both billed annually plus GST. Worked Example 1 below builds directly on these two cited figures.
• Research/agentic, capability. Perplexity's own product page for its Pro tier describes "access to the latest AI models, extended deep research, increased file uploads and deeper sourcing" (perplexity.ai/pro, checked 2026-07-22) without a price quoted in the excerpt consulted, another reminder to open the live page rather than repeat a number from memory.
• Document/PDF, capability. Google's own description of NotebookLM calls it "an AI research tool and thinking partner that can analyze your sources, turn complexity into clarity" (notebooklm.google, checked 2026-07-22).

The standing refresh ritual

A dated catalog is only useful if you actually redate it. Adopt a simple, recurring habit rather than trusting this list, or any list, indefinitely: at least once a quarter (and any time you are about to make a real purchasing decision), pick the row of your personal tool catalog you rely on most, open that tool's own official pricing or docs page directly, confirm the category fit and the rubric's five answers still hold, and update your own "last verified" date next to it. This is the same discipline as re-checking a filing before you rely on a number from it, a source does not stay verified forever just because you verified it once (Guardrail #4, Date-check, applied to your own notes about tools rather than to a company's filing). The Applied mini-project below has you build the one-page artifact this ritual runs against.

Common mistakes & how experts think differently

1. Memorizing brand names instead of categories. The beginner's mental model of the AI landscape is a list of product names ranked by hype; the expert's is a list of seven jobs a tool can do, with brand names as disposable labels temporarily attached to one of them. When a name gets deprecated or rebranded, the beginner's map is gone; the expert's map has not moved at all, because it was never built out of names.
2. Treating "free" as a synonym for "safe for sensitive data." The beginner pastes an unpublished number into a free consumer chat tool because it is convenient and costs nothing, without checking that tier's specific data-usage policy. The expert checks the policy of the exact tier they are about to use before pasting anything non-public, regardless of price, a free tier and a paid tier from the identical brand routinely have different training-data defaults, and price tells you nothing about the answer.
3. Trusting "it ran / rendered / compiled without an error" as proof of correctness. This mistake recurs across coding, spreadsheet, and data-analysis tools alike: a formula, a script, or a chart can execute cleanly while quietly encoding the wrong logic, the wrong range, or the wrong aggregation. The expert never accepts the absence of an error message as evidence of anything beyond "the syntax was valid". Guardrail #3, Recompute, applies every time, on every category that produces a number.
4. Asking "which tool is best" as if there is one eternal answer. The beginner shops for a permanent champion; the expert asks "what category does my task actually need, and does this specific tool, on this specific tier, answer the five rubric questions well enough for this specific use", a question re-asked per task, not settled once per brand loyalty.
5. Confusing a marketing claim with a verified behavior. A landing page that promises "zero hallucinations" or "100% accurate" is making an advertising claim, not reporting the result of a test you ran. The expert treats any claim of perfect reliability as itself a fact requiring verification, and, per Worked Example 6, treats a tool that claims it needs no verification as a warning sign rather than a selling point, because nothing about the mechanism taught in AI0.01 supports that claim for any tool in this catalog.

The thread through all five: the expert's confidence in an AI tool never rests on the tool's own claim about itself, a brand's reputation, a landing page's promise, or the absence of a visible error. It rests on having actually run the rubric, and on the concrete Guardrail check that category's specific failure mode demands. That habit, applied identically across seven very differently branded categories, is what this node is actually teaching.

Worked examples

Worked example 1: Spreadsheet AI for a Mumbai buy-side team: choosing a Microsoft 365 Copilot tier (India, ₹)

A six-person research team at a Mumbai-based asset manager currently runs Microsoft 365 Business Standard without Copilot and is deciding whether to upgrade to a Copilot-enabled tier to speed up building variance-analysis tabs each quarter.

Solution: run the five-question rubric. (1) What is it? Per Microsoft's own announcement (microsoft.com/en-us/microsoft-365/blog, dated 2026-06-25), Copilot in Excel is an in-application AI assistant that can execute documented, reusable "skill" files saved to OneDrive (including pre-built skills for DCF modeling, book closing, and variance analysis) and connects directly to named market-data providers (CB Insights, Daloopa, FactSet, Morningstar, PitchBook, and S&P Global) pulling their data straight into a workbook, with a "Plan with Copilot" step that previews a change before it executes and an attribution trail inside "Show Changes." (2) Good/bad at? Good at turning "build me a variance-analysis tab for Q2" into a first-draft structure in seconds, and at running the same documented skill every quarter instead of rebuilding it from scratch. Bad at guaranteeing that a figure pulled in through a data connector is the exact vintage and source the team would cite in a client note, the team must still check which provider and as-of date supplied any specific pulled number. (3) Where does data go? Processed inside the firm's existing Microsoft 365 tenancy, under the data-handling agreement the firm already has with Microsoft for its email and files, not sent to an unrelated third party, a materially different risk profile from pasting the same model into a public consumer chat tool. (4) How do you verify? Guardrail #3, Recompute: before trusting the tool's version of any tab, the team rebuilds one full tab by hand first and compares. (5) Cost/offline? Microsoft's own India business-plans pricing page (microsoft.com/en-in/microsoft-365/business/microsoft-365-plans-and-pricing, checked 2026-07-22) lists Business Standard with Copilot at ₹1,955 per user per month and Business Premium with Copilot at ₹2,660 per user per month, both billed annually plus GST.

The arithmetic. For six seats, annualizing each tier: Standard-with-Copilot = ₹1,955 × 12 × 6 = ₹1,40,760/year. Premium-with-Copilot = ₹2,660 × 12 × 6 = ₹1,91,520/year. The difference is ₹1,91,520 − ₹1,40,760 = ₹50,760/year for whatever additional features (security and device-management features beyond Excel's AI capabilities, per Microsoft's own plan comparison) Premium adds over Standard.

Read it. The rubric does not tell the team which tier to buy, it tells them exactly which question to answer before paying the ₹50,760/year difference: do we actually need Premium's extra security/device features, or does Standard-with-Copilot alone cover the Excel AI capability we actually want? That is a real, answerable question once the five-question rubric has separated "what does Copilot do" from "what does the higher tier add beyond Copilot", a distinction a glossy feature comparison page is not built to make obvious.

Worked example 2: Coding copilot for a small US data team: choosing a GitHub Copilot tier (US, $)

A four-person analytics team at a small US-based research shop writes light Python for data pulls and wants to know whether GitHub Copilot's higher tiers are worth the extra spend.

Solution: run the five-question rubric. (1) What is it? An AI pair-programmer embedded in the code editor and terminal. GitHub's own plans page (github.com/features/copilot/plans, checked 2026-07-22) lists Free (2,000 completions/month, limited model access), Pro at $10/user/month (unlimited completions, cloud agent access, code review), Pro+ at $39/user/month (premium-model access including a top-tier model, audit logs, higher usage), and Max at $100/user/month (priority access, the highest usage tier). (2) Good/bad at? Good at writing the boilerplate data-loading and cleaning script fast, and at explaining an unfamiliar function already in the codebase. Bad at silently getting a financial formula's row range subtly wrong in a way that still runs without erroring. (3) Where does data go? The team's proprietary Python scripts, which embed real position and model logic, are sent to the provider; higher-tier/business terms typically carry a stronger contractual guarantee against training on your code than the base individual tier, so the team must check the exact tier's data-usage terms rather than trusting the brand's general reputation. (4) How do you verify? Guardrail #3, Recompute, run the team's actual independent test suite; "no error thrown" is never accepted as proof. (5) Cost/offline? No offline mode at any tier; cost scales per seat as listed above.

The arithmetic. For four seats on Pro: $10 × 12 × 4 = $480/year. Upgrading all four seats to Pro+: $39 × 12 × 4 = $1,872/year, a jump of $1,872 − $480 = $1,392/year.

Read it. Whether that $1,392/year is worth it depends entirely on rubric question 2, answered honestly for this specific team: do they actually hit Pro+'s premium-model or audit-log features often enough to matter? The rubric forces that question to be answered before the upgrade, using the team's real usage pattern, not decided by which tier sounds more impressive on the pricing page.

Worked example 3: Verifying a "current" price with a research/agentic tool: the stale-cache trap (US, $, Guardrail #4)

An analyst asks a research/agentic tool to confirm the current monthly price of a competitor's newly launched "budget" chat-assistant subscription before it goes into a competitive-landscape slide. The tool returns a confident, well-formatted answer, citing a fetched page from the provider's own site. This is not a hypothetical drawn from nowhere: a mid-2026 fetch of a major AI provider's own public pricing page, made while researching this very catalog, returned plan names and model references that had clearly been superseded roughly two to three years earlier, solid evidence the page had been served from a stale cache somewhere in the delivery chain, despite the URL loading successfully and looking entirely "live."

Solution. The analyst does not accept the first answer on the strength of it citing a real-looking URL. Instead, they cross-check against a second, independent, dateable source: OpenAI's own announcement of its "Go" tier (openai.com/index/introducing-chatgpt-go/, checked 2026-07-22) states plainly that the plan reached full worldwide availability on 16 January 2026 at $8/month in the United States, having first launched in India in August 2025. That announcement carries its own explicit date within the last several months. The first tool's answer, by contrast, referenced branding and a flagship-model name that had already been retired long before that date, a mismatch the analyst catches only by asking, explicitly, "does this source's content actually postdate what I'm using it to claim?"

Guardrail applied. #4, Date-check, is the headline check here, a source (or a "live" fetched page) must post-date the claim it is being used to support; the fact that a URL loads is not evidence that its content is current. #1, Trace, and #5, Cite, apply alongside it: the analyst opens the actual cited page rather than trusting the tool's paraphrase, and records exactly which page and its own visible recency signal (a dated changelog entry, a dated press release) for a reviewer.

Read it. "Verify current" is not a one-time click; it means actively hunting for an independent signal of recency (a dated announcement, a changelog entry, an in-product billing page) rather than accepting that a URL resolved. This is precisely the discipline behind the dated catalog's own review line of 2026-07-22: a date attached to a claim is a promise to re-check it, not a guarantee it is still true today.

Worked example 4: Data-analysis AI and the mean-versus-median trap (India, synthetic data)

An FP&A analyst at a Bengaluru-based SaaS company uploads a spreadsheet of monthly customer-churn rates across twelve regional teams to a data-analysis AI tool and asks, "what's the average monthly churn rate?" (Figures below are synthetic, constructed for this illustration.) Eleven teams cluster tightly: 1.8%, 1.9%, 2.0%, 2.0%, 2.1%, 2.2%, 2.2%, 2.3%, 2.4%, 2.5%, 2.6%. The twelfth team, mid-migration to a new billing system that month, reports 14.0%. The tool returns the arithmetic mean of all twelve values as "the churn rate," with no flag on the outlier.

Solution: recompute by hand (Guardrail #3). Sum of the eleven clustered values: 1.8+1.9+2.0+2.0+2.1+2.2+2.2+2.3+2.4+2.5+2.6 = 24.0. Adding the outlier: 24.0 + 14.0 = 38.0 across 12 teams. Mean = 38.0 ÷ 12 = 3.17% (to two decimal places). Now the median: sorted, the twelve values are 1.8, 1.9, 2.0, 2.0, 2.1, 2.2, 2.2, 2.3, 2.4, 2.5, 2.6, 14.0, with an even count, the median is the average of the 6th and 7th values, both 2.2%, so the median is 2.2%.

Match (Guardrail #2). Does "average churn rate" mean the literal arithmetic mean, or a typical team's actual experience? The tool answered the first question; the analyst's actual question was the second. The single migration-affected outlier pulled the mean to 3.17%, roughly 44% higher than the median of 2.2%, which sits squarely inside where eleven of the twelve teams actually are.

Read it. Nothing about the tool's answer was a lie: 3.17% genuinely is the mean of those twelve numbers. It was, however, the wrong statistic for the question actually being asked, presented with no warning that one data point was doing most of the work. The fix is never "trust the number the tool picked"; it is "recompute both the mean and the median yourself, and pick the one that answers your real question", a two-minute check that would have caught this before it reached a board slide.

Worked example 5: Document AI and a page-break scale error (US, synthetic filing excerpt, Guardrail #2)

(The filing excerpt below is synthetic, constructed for illustration, no real company's filing is being quoted.) An analyst uses a document-AI tool on a US 10-K-style filing to answer "what is total debt?" The relevant table spans a page break: page one shows a header "(in millions)" with a line "Long-term debt ......... 4,250," and the continuation on page two restates its own header, "(in thousands)," with a line "Current portion of long-term debt ......... 125,000", a common real-filing formatting quirk when a table crosses a page and re-declares its unit on each page. The tool sums both lines as though they shared one scale and reports "$129,250 million total debt."

Solution, Match, then Recompute (Guardrails #2 and #3). The two lines are not on the same scale: 4,250 is stated in millions, so it equals $4,250 million; 125,000 is stated in thousands, so it equals $125,000 thousand = $125 million, not $125,000 million. The correct total is $4,250 million + $125 million = $4,375 million, not the tool's $129,250 million, an error of roughly 30×, produced entirely by treating two different scales as one.

Trace (Guardrail #1). The only way to catch this is to open the actual pages, not trust the tool's summed figure: confirm which unit header governs each line before adding anything across a page boundary.

Read it. This is the US-dollar-flavored twin of the ₹ crore-versus-₹ mn error this program returns to repeatedly, because it is one of the most common, and most dangerous, because the resulting number still looks perfectly plausible, failures a document-AI tool can produce. A tool that reads every character on a page can still silently ignore which scale header governs which line, especially across a page break, and it will state the wrong total with exactly the same confident tone as the right one.

Worked example 6: Cold rubric on a brand-new tool: "FilingScope" (synthetic, capstone)

(No real product named "FilingScope" exists; this is a constructed, hypothetical example built to prove the rubric works on a tool you have never seen.) Imagine a tool called "FilingScope" launches tomorrow with landing-page copy reading: "The AI research analyst that reads any filing and never gets it wrong."

Solution, run the rubric cold, from the landing page and documentation alone. (1) What is it? Marketing language ("AI research analyst") is not a mechanism; digging into the actual documentation, suppose it turns out to be a document/PDF tool, you upload a filing and it answers grounded questions with citations, the same mechanism as Category 5 above. (2) Good/bad at? Whatever the documentation says, the structural strengths and blind spots of the document/PDF category still apply regardless of the brand's confidence: good at finding a specific note fast, bad at catching its own scale misreads or page-break errors. (3) Where does data go? Read its actual privacy page for the tier you would use, the landing page's confidence about accuracy tells you nothing about this question, which has its own separate, checkable answer. (4) How do you verify? Exactly as in Worked Example 5, trace every cited figure to the actual page, regardless of what the marketing promises.

The catch. Question 4 is where "FilingScope" actually fails the rubric, not passes it: a tool whose own marketing claims "never gets it wrong" is making a claim that AI0.01's mechanism gives you no reason to believe of any tool built this way, a large language model, however wrapped, still optimizes for plausible, not true, and "never wrong" is not a property that mechanism can deliver. A claim of zero necessary verification is not evidence of quality; treat it as a red flag.

Read it. Nothing about this example required "FilingScope" to be a real product, and that is exactly the point: you placed a brand-new, never-seen tool into a category and ran all five rubric questions on it, from its own claims alone, in about two minutes, and the rubric's own logic, not any prior experience with the brand, is what caught the one claim worth distrusting.

Practice set

Work each problem before reading its solution. Figures are illustrative or explicitly cited; treat any uncited number as synthetic.

P1 (guided). Categorize and justify. A product's description reads: "Point it at your messy sales export, ask a question in English, and get a chart back, it writes and runs the analysis code for you behind the scenes." Which of the seven categories does this belong to, and what one phrase in the description is the strongest evidence for your answer?

Solution. Data-analysis. The phrase "writes and runs the analysis code for you behind the scenes" is the tell, this is the defining mechanism of the data-analysis category (an AI layer that executes real code against your uploaded data), distinct from a chat assistant that would only describe an answer in prose without actually computing it.

P2 (guided). Run the rubric skeleton. A described tool: "An AI assistant living inside your presentation software; describe your report and it drafts a full deck." Give a one-line answer to each of the five rubric questions using only general category knowledge (no specific brand needed).

Solution. What is it? A presentation/design tool, generating layout and structure from a description. Good/bad at? Good at collapsing the blank-page problem into a fast first draft; bad at knowing whether the narrative it imposes on your content is actually the true one. Where does data go? Whatever report/outline you feed it is sent to the provider, check whether that's the same tenancy as your existing office subscription or an unrelated third party. How do you verify? Trace every number printed on a slide to its source, and confirm the deck's implied argument matches what your data actually supports (Guardrails #1, #2). Cost/offline? Likely bundled into an existing office subscription or sold as its own separate product, confirm which before comparing its price to anything else.

P3 (guided). Sort durable from perishable. From this sentence ("ChatGPT Go costs $8/month in the US as of January 2026, and is a chat-assistant tool") identify which parts are durable (will still be true in five years) and which are perishable (need re-checking soon).

Solution. Durable: "is a chat-assistant tool", the category and its structural implications do not expire. Perishable: the specific brand name "ChatGPT Go," the exact price "$8/month," and the date-stamped claim "as of January 2026", all three need re-verification before being repeated as current at any later date.

P4. Data-destination reasoning. The same chat-assistant brand offers a free consumer tier and a paid enterprise tier. An analyst wants to paste an unpublished internal projection into whichever is safer. Which tier is more likely to be safer, and what single document should the analyst actually read before deciding, rather than guessing from price alone?

Solution. Enterprise/business tiers typically carry a contractual guarantee excluding your data from model training, while free consumer tiers commonly default to using conversations for training unless you find and use an opt-out, but "typically" and "commonly" are not "always." The analyst should read that specific tier's own current data-usage or privacy documentation before pasting anything non-public, rather than assuming from price or brand reputation alone.

P5. Cost/offline independence. Give one real-shaped example of a tool that is free but not offline, and one example of a tool that is paid but still not offline. Then explain why "fully offline" AI tools are rare across most of this catalog's seven categories.

Solution. Free-but-not-offline: a chat assistant's free tier (Category 1), no cost, but every query still leaves your machine for the provider's servers. Paid-but-not-offline: GitHub Copilot's Pro tier at $10/user/month (Category 2), a real price, but the completions still require a live connection to the provider's models. Fully offline AI tools are rare because most categories in this catalog rely on models and/or compute (a code-execution sandbox, a live web index) too large or too dynamic to run entirely on a single device, the handful of exceptions are local-model coding assistants, which trade some capability for keeping code on the machine.

P6. Numeric: coding copilot cost. A seven-person team upgrades from GitHub Copilot's Free tier to Pro+ at $39/user/month. What is the team's annual cost on Pro+?

Solution. $39 × 12 × 7 = $3,276/year.

P7. Numeric: spreadsheet AI cost, India. A ten-person team is deciding between Microsoft 365 Business Standard with Copilot (₹1,955/user/month) and Business Premium with Copilot (₹2,660/user/month), both billed annually. What is the annual cost of each, and what is the difference?

Solution. Standard-with-Copilot: ₹1,955 × 12 × 10 = ₹2,34,600/year. Premium-with-Copilot: ₹2,660 × 12 × 10 = ₹3,19,200/year. Difference: ₹3,19,200 − ₹2,34,600 = ₹84,600/year.

P8. Category-blur diagnosis. A tool is described as: "a spreadsheet add-in that also lets you generate a slide summary of your model with one click." Which two categories does this draw from, and why should you run the rubric on it twice rather than once?

Solution. It draws from spreadsheet (the modeling side) and presentation/design (the one-click slide generation). Run the rubric twice because the two behaviors can have completely different answers even inside one product, the spreadsheet side may process data inside your existing productivity-suite tenancy while the slide-generation side may route your model's summary through a different backend entirely; a single "where does data go" answer for "the tool" would hide that difference.

P9. Guardrail-matching. Match each failure to the Guardrail check that catches it: (i) a research tool's citation that does not actually say what it's credited with saying; (ii) a chat assistant confidently stating today's policy rate; (iii) a spreadsheet AI's formula that references the wrong range after the data reshaped; (iv) an analyst wants to record exactly where a verified figure came from for a future reviewer.

Solution. (i) #1 Trace (and #5 Cite), open the actual source and confirm it says what's claimed. (ii) #4 Date-check, the model's training cutoff means "today's" anything is a hypothesis, never a fact, from the model alone. (iii) #3 Recompute, rebuild the formula by hand and compare. (iv) #5 Cite, record the exact location so the verification can be redone without repeating the research.

P10. Red-team: fabricated citation. A research/agentic tool's report states: "Per the company's Q1 filing, page 14, revenue grew 22% year over year." You open the actual filing and page 14 discusses executive compensation, with no revenue figure anywhere on it. What went wrong, and what is the correct next step?

Solution. This is a fabricated citation: a page number and a claim that do not correspond to what the source actually contains, which is exactly as fluent and confident as a correctly-cited claim would have been. The correct next step is not to ask the tool to "double-check itself" (that only asks the same plausibility engine to grade its own work), it is to search the actual filing yourself for the real revenue figure and its real page/note location, and discard the fabricated citation entirely rather than editing it.

P11. Mean-versus-median recompute. A team's six weekly numbers are 40, 42, 41, 43, 300, and 44 (the 300 reflects a one-off data-entry event, not a typical week). A data-analysis tool reports "the average is 85." Compute the mean and the median by hand, and say which better describes a typical week.

Solution. Mean: (40+42+41+43+300+44) ÷ 6 = 510 ÷ 6 = 85, matching the tool's answer exactly, and exactly why it is a poor description of a typical week, since one value did almost all the work. Sorted, the six values are 40, 41, 42, 43, 44, 300; the median is the average of the 3rd and 4th values, (42+43) ÷ 2 = 42.5, which sits right where five of the six weeks actually are. The median describes a typical week; the mean describes a number that no actual week come close to except the outlier one.

P12. Presentation-AI slide-narrative mismatch. A presentation tool builds a slide from your one-pager stating "Segment A drove 60% of the growth," but your underlying one-pager actually shows Segment A drove growth in only one of the three quarters analyzed, with Segment B leading in the other two. What is wrong, and which Guardrail check catches it?

Solution. The slide's narrative does not match what the source data actually supports across the full period analyzed, a classic invented-narrative failure of the presentation/design category (Common Mistake pattern, and the same failure shape as Worked Example 6's "never wrong" claim, just applied to a storyline instead of a factual claim). Guardrail #2, Match, the claim's scope (all three quarters vs. the one quarter it's actually true for) must agree with the source, not just the headline number.

P13. Cold-rubric drill, second tool. A newly launched tool markets itself as "an AI that turns your meeting notes into a fully cited research memo automatically." Run the five-question rubric on it using only that description.

Solution. What is it? Most likely blends chat-assistant drafting with research/agentic-style citation-fetching, a description alone should make you ask which mechanism actually produces the "citations," not assume the word implies verified accuracy. Good/bad at? Likely good at producing a fluent, well-organized first draft fast; likely bad at guaranteeing every "citation" traces to a real, correctly-quoted source, exactly as in Worked Example 6 and P10. Where does data go? Your meeting notes, which may contain confidential discussion, are sent to the provider; check the specific tier's data-usage policy before feeding it anything sensitive. How do you verify? Trace and Cite, open every cited source and confirm it says what's claimed, before the memo goes anywhere. Cost/offline? Unknown from the description alone, check the tool's own pricing page, and note that "automatically" in the marketing says nothing about whether it is free or offline.

P14. Reading a privacy-policy excerpt. (Illustrative wording modeled on real provider policies, not a quotation of any specific one.) A tool's data-usage page states: "By default, content you submit may be used to improve our models. You can opt out in your account's privacy settings; opting out does not affect existing responses already generated." Does this tool train on your inputs by default, and how would a user opt out?

Solution. Yes, it trains on submitted content by default, the opt-out is not automatic. The user opts out by locating and toggling the specific control in the account's own privacy settings before submitting sensitive content; toggling it afterward does not retroactively un-train anything already used, which is why this check belongs before pasting anything non-public, not after.

P15. Offline/local trade-off. A coding-copilot vendor offers both a cloud-hosted model (highest capability, code sent to the provider) and a smaller local/on-device model (code never leaves the machine, noticeably less capable on complex tasks). Under what circumstance should an analyst prefer the local option, even at a capability cost?

Solution. When the code being written directly embeds genuinely sensitive material (proprietary model logic, unpublished figures, client-identifying data) that the analyst's organization is not permitted to send to a third-party server regardless of that provider's contractual promises. The capability trade-off is real and should not be minimized, but for that specific class of task, "where does data go" (rubric question 3) can outweigh "how good is it" (rubric question 2) entirely.

P16. Design your own refresh ritual. In three bullet points, describe how you would keep your own personal tool catalog current, using this module's standing refresh ritual as the model.

Solution. (1) Maintain a one-page table, one row per category, columns for current tool, good/bad-at notes, data-destination answer, verification method, cost/offline notes, and a last-verified date. (2) At least quarterly, and always before any real purchasing decision, reopen the tool's own official pricing/docs page for whichever row you rely on most, re-answer all five rubric questions from that live page, and update the last-verified date. (3) Treat any row whose last-verified date is more than a few months old as unconfirmed for a real decision, exactly as you would treat a filing figure you have not re-checked against the source in a while.

Applied mini-project

Build your own tool catalog, and cold-evaluate one tool you have never used.

Part 1, your personal catalog. Build a one-page table with one row per category (chat assistant, coding copilot, research/agentic, data-analysis, document/PDF, spreadsheet, presentation/design). For each row, fill in: the specific tool you currently use (or "none yet"), a category-specific good-at and bad-at note (not a generic one), the tool's data-destination answer in your own words drawn from its own policy page, the verification method you would use on its output (naming a specific Guardrail check), its cost/offline profile, and today's date as "last verified."

Part 2: cold-evaluate something new. Pick one tool you have genuinely never used, from any category. Run the full five-question rubric on it using only its own official website and documentation, citing the specific page you got each answer from. Identify which Guardrail check matters most for that tool's category, and write two to three sentences on exactly how you would apply that check the first time you used it for real analyst work.

Deliverable and self-check. Score yourself honestly, 0–2 points per item: (a) All seven categories are present with a real, category-specific good-at/bad-at distinction, not a generic one that could apply to any tool. (b) Every row's data-destination answer is specific (not "somewhere in the cloud"), and the new tool's answer is cited to the actual policy page consulted. (c) The verification method named for every row correctly maps to a real Guardrail check (Trace, Match, Recompute, Date-check, or Cite). (d) The cost/offline row treats price and offline capability as two independent facts, never one. (e) Every entry carries a last-verified date, and the new tool's rubric answers each cite the specific page consulted.

Pass at 8/10 with no zero on any item. Keep this catalog, it is the artifact the standing refresh ritual runs against, and AI0.05 will ask you to name tool categories (not vendors) per workflow step using exactly this habit.

Lab: log your completed catalog and the new-tool cold evaluation in this node's Practice tab so later modules, and AI0.06's red-team drills, can reference what you already verified here.

Reading & resources

This branch's standing references (start here):

• guides/ai-primary-source-guardrail.md, the full five-check Guardrail (Trace, Match, Recompute, Date-check, Cite) this module's verify answers all resolve to; the standing reference every AI-Augment callout in this program points back to. [Free] [Beginner]
• guides/ai-resource-list.md, the durable reading list spanning all seven AI-Augmented modules, including this one's own entry describing the category-plus-rubric split as the durable content. [Free] [Beginner]

Primary sources behind this module's dated catalog (check the current before citing any of these further):

• OpenAI, "Introducing ChatGPT Go" (official announcement, openai.com/index/introducing-chatgpt-go/), the chat-assistant pricing anchor used in Worked Examples 1 and 3. [Free] [Beginner]
• GitHub, Copilot plans page (github.com/features/copilot/plans), the coding-copilot tier structure used in Worked Example 2 and Practice P6. [Free] [Beginner]
• Microsoft 365 Blog, "Copilot in Excel: Built for the era of Frontier Finance" (2026-06-25) and Microsoft's India business-plans pricing page (microsoft.com/en-in/microsoft-365/business/microsoft-365-plans-and-pricing), the spreadsheet-AI category and Worked Example 1's India figures. [Free] [Beginner-Intermediate]
• Perplexity's own Pro product page (perplexity.ai/pro), the research/agentic category. [Free] [Beginner]
• Google's own NotebookLM product page (notebooklm.google), the document/PDF category. [Free] [Beginner]

Frameworks and policy (durable; full treatment in AI0.07):

• NIST AI Risk Management Framework (AI RMF 1.0), a public, sector-neutral vocabulary for exactly this module's good/bad-at, data-destination, and verification questions; skim the Map/Measure/Manage functions. [Free] [Intermediate-Advanced]
• India's Digital Personal Data Protection Act, 2023 (DPDP Act), the legal backbone for "where does your data go" whenever the data in question is personal information; this module only opens the door, AI0.07 gives it full treatment. [Free] [Intermediate]
• Whichever specific chat assistant, coding copilot, and document tool you personally use, read that provider's own current data-usage/training policy directly, not a summary of it written by someone else. The habit of reading your own provider's current page is the actual resource here, more than any single page's content today. [Free] [Beginner]

Practice and habit-building:

• Maintain your own one-page tool catalog (category → current tool → last-verified date) using this module's rubric as the column headers, per the Applied mini-project; revisit it on the standing refresh ritual described in Core teaching content. [Free] [Beginner]
• Cross-reference: AI0.01 (the mechanism behind every category here), AI0.04 (the retrieval mechanics underneath the document/PDF category), AI0.05 (agent mechanics underneath the research/agentic category's autonomous end), AI0.06 (the full Guardrail drilled to a crown-level gate), AI0.07 (applying this rubric across your whole workflow, plus ethics, disclosure, and data-privacy in depth).

Teach it back & journal

Feynman prompt. Explain to a smart colleague who has only ever compared AI tools by reading "best of" articles why this module refuses to name one best tool per category. Use the seven categories and the five-question rubric to show them how you would evaluate a tool that launches next month (one neither of you has seen) in under two minutes, using only its own website. If your colleague can then apply the same five questions, unprompted, to a tool of their own choosing and land on a specific, checkable answer for each, you have actually taught the durable half of this module, not just its dated snapshot.

Journal prompt. List every AI tool you currently use for any part of your analyst work, across as many of the seven categories as apply. For each, write down (honestly, without looking anything up first) your best guess at its answer to "where does your data go?" Then actually open that tool's own current privacy or data-usage page and check. Note every case where your guess was wrong, and write a paragraph on what that gap tells you about how much of your day-to-day AI use has been running on assumption rather than verification. Which single tool, if its actual data-destination answer surprised you, changes what you will or will not paste into it starting today?