48  R5 · tafagent manual

What it is. The manual for tafagent, the in-browser diagnostic tool that accompanies this book. Here are its modes, what metrics it computes, the recipes, and how to read its verdicts. The key point up front, no misunderstandings: tafagent does NOT draw attention maps —it is a diagnostic that PREDICTS metrics from the model’s config—. To see maps, use BertViz or Transformer Explainer; to measure/predict γ, horizon, regime, and KV, use tafagent.

48.1 What it is and what it isn’t

• It is: a tool in the browser (zero install, zero GPU, no telemetry) that estimates aspects of viability of an LLM before you spend GPU/€: proposed context limits, quantization degradation, chat template, config errors.
• It isn’t: an attention-map viewer, nor a service that runs the model. What you see are deterministic predictions (computed with Pyodide) plus a natural-language layer.
• Input: an HF model id or a config.json (it reads θ, T_train, heads…); you set T_eval (the target length) and whether the model uses a sliding window (SWA).

48.2 From a question to the right tool

The selector prepares a route: concept → tool → explanation. TAF’s Understand this result links bring the selected metric, value and its origin (estimate or imported measurement) into the guide. This is a snapshot; the guide does not run the model or verify the result. Open explanations in a new tab to keep your diagnosis, or use Return to TAF to prepare the same mode.

Find a model: click the optional field to see popular Hugging Face models, or type part of a name. Use arrow keys and Enter to select, or enter the full ID yourself. Queries go to HF and results are cached in this tab for five minutes. Results are ordered by downloads, not release date; appearing in the list does not guarantee TAF compatibility. No weights are downloaded and no analysis starts.

Without JavaScript: profile, measure attention, compare measurements.

Optional demo: “Try an example” prepares an attention probe using Pythia-70m; it downloads no weights and runs no inference. TAF also offers a guided reading demo.

Entropy measurement: Diagnose CLI can generate --entropy-only or --measure-entropy. Inference runs with Python/PyTorch on your computer, not in this selector. Entropy does not determine γ and no automatic entropy correction is applied. The phase diagram reads the atlas; it does not perform a new measurement.

48.3 Solve my problem: from uncertainty to a check

Think of a diagnostic desk: you arrive with “it does not work” and receive the questions needed to narrow down the problem. You do not need to know each module’s name beforehand. Solve my problem provides this journey automatically in the browser, without an operator or a chat service.

The window starts with what is going wrong, not a module name. Choose memory, responses, adapters, access/loading, long context, evaluation or performance. One follow-up question narrows the case: for example, whether memory runs out while loading, generating or training. There are seven families and twenty situations. Distributed training receives an explicit boundary and guide reading, not an inference-memory estimate.

If you already know what to check, nine direct routes are available:

• Memory: the model does not fit or fails while generating.

• Chat template: inspect the conversation format.

• Compatibility: understand the architecture and its limits.

• JSON: review reasoning and answer field order.

• PEFT / QLoRA: inspect code without executing it.

• Prompts: compare the common text prefix.

• Evaluations: review differences and settings.

• Attention: inspect a measurement and its protocol.

• Adapter: check metadata and the base model.

Links only open the form. Every route has Try an offline example, so you can explore the responses before entering your model. The memory example recalculates with fewer tokens or compares a weight format; it changes the estimate without running or modifying the model.

The six new checks analyze pasted data locally without downloading weights. Reordered JSON is a proposal to review and check again; it does not validate the whole schema or guarantee quality. Prompt comparison predicts neither prices nor cache hits. An evaluation gap does not prove a bug and imported gamma is not a new inference run. Reports omit pasted code, prompts, files and JSON proposals.

Find a tool for another problem connects all 31 modes, explaining required inputs, outputs and limits. Each entry links to its specialized form, optional demo and guide reading. Some tools require Pyodide, network files, local Python or WebGPU; opening them does not mean a diagnosis has run. The questions draw on a public discussion sample, not a statistical ranking or automatic monitoring.

Review this result. After each direct check, expand a review of its evidence: what supports the result, what remains unverified and how to check it, with a link to this guide’s explanation. The panel distinguishes configuration estimates, static inspections, heuristic comparisons and imported measurements. It runs no additional model and assigns no probability of failure. Attention reports retain missing-protocol counts and comparison notices.

For example, a memory budget that fits does not prove your workload will fit: TAF does not measure loading peaks, buffers or runtime concurrency; reported peaks remain unverified. The next check suggests trying a short request and observing free memory at the failing stage. Saved or synthetic examples stay labelled as demos, not diagnoses of your model. The guided demo opens this panel; the downloaded report includes it without adding pasted source text.

Return to the same problem. When you reach the guide from a case summary or review, Return to this problem’s form preserves the route, TAF language and original host (GitHub or Hugging Face). It prepares the form without running a check or restoring pasted inputs. Keep the original tab for the complete result. Examples do not transmit a model ID as if it were yours.

From a notice to the next check. In Solve my problem → Attention, paste one or two reports containing γ and open Show protocol details. The panel lists 19 known conditions in four groups: model/data, sampling, execution and aggregation/fit. It identifies missing documentation and differences from the reference. Custom fields count, but their names and values are not exported.

What to check first prioritizes context conflicts or limitations, then protocol differences and missing documentation. If all checked conditions are documented and match, it proposes inspecting the curve and repeating the run. Recover settings from the actual experiment; never invent them to make reports match. A documented field does not establish accuracy or validate the theory. The optional route demo uses synthetic uniform attention to illustrate missing conditions; no model is run. The guide lets you return to the same form.

Ordered checks across eight routes. See the verification steps shows three instructions: what to inspect first, what to observe in your environment, and how to interpret or redirect the case. One of 41 priorities is selected from the result. Attention retains its own protocol checklist: all nine routes guide the next check. Recalculation updates the summary, review and “It still fails”.

Explore another example offers 33 situations: five memory, three template, three adapter, five cache, five evaluation, three architecture, three JSON and six PEFT-code cases. Changing examples resets the comparison and retains the illustrative label. Alternate architecture examples remove the previous ID, revision and sources to avoid attributing a synthetic config to the real model.

Reports retain the plan with executed: false. TAF has not executed these checks or certified a fix. The narrated memory demo shows the steps. Read more about architecture, PEFT code, JSON, cache and latency and evaluation differences. Chapters 20 and 28 also explain memory budgets and adapters. Returning opens the same form on the original host and in the original language without transmitting code, prompts or private results.

48.3.1 Continuing after a check: optional tracking

Track my checks records what you could review while retaining the current result. It is available on all nine routes. Each step can be pending, reviewed without a discrepancy, discrepant, or blocked. These are user declarations, not tests executed or verified by TAF.

The next step is selected automatically: first the first discrepancy, then the first blocked check, then the first pending step. Go to the next check focuses its control. “It still fails” uses this follow-up alongside the plan based on the original data. The guide link still explains the case; marks do not alter results or protocol metadata. Marking all three steps reviewed does not certify a fix: test the original task and retain counterexamples if it still fails.

Optional demo: in a saved example, Simulate a blocked check marks one step reviewed, one blocked and one pending. The narrated demo shows this in step five. These marks are illustrative, not an execution record. The simulation button does not appear in a case using your own inputs.

Without saving a private case, marks stay only in the original tab when closing the panel or changing language. Changed inputs, recalculation, another example or route clear them; reloading also loses unsaved changes. Reduced reports include tracking as unverified declarations, without free-text notes, prompts or pasted code. They cannot restore the session. Guide return links open a fresh form: keep the original tab open to retain your case and marks, or save a private case to continue later.

48.3.2 Continue from what you observed

After trying a check, open What happened when you checked?, select the step and report the observed outcome. It still fails opens this panel. The nine routes offer 27 concrete observations plus an option for unavailable evidence.

For example, if a short request works but a long one fails, TAF suggests fixing model, precision and concurrency, gradually increasing tokens and recording peak VRAM. Failure before generation instead leads to loading-memory and actual weight-format checks. JSON distinguishes invalid syntax, schema violations and incorrect answers with valid structure. The next instruction uses your report; the original analysis remains visible and does not become a verified repair.

The last twelve observations for the result are kept in order. Language changes and closing the panel retain them; changed inputs, recalculation, another case/example and reload clear them. Clear observations leaves analysis and progress marks intact. Reports include them as declarations without free text and cannot restore a session. Suggested tools open their catalog entry; their results do not return automatically to the case.

The interactive demo simulates an observation in step five. The recorded video shows the earlier progress-mark flow; use the interactive demo for observations. The standalone Fit Check demo uses a saved Qwen3-8B configuration and computes a budget without HF requests: 24 GiB, BF16 weights and FP16 KV. It illustrates an estimate, not your GPU usage.

A concrete case: weights can fit on a GPU while generation exceeds its memory after adding the KV cache. The route asks for available memory, total tokens, weight format and whether failure occurs during loading or generation. It reuses Fit Check to separate those components. This is an estimate for one GPU and one sequence, not a measurement of your hardware or a guaranteed diagnosis.

In the other routes, finding a template does not prove that the runtime applies it correctly, and recognizing an architecture does not certify quality or support in every engine. TAF shows the inspected files and revision, explains limitations and proposes the next check.

You can select I tried it and it worked or It still fails, open the detailed tool, read the relevant chapter and download the report. Pasted questions and errors stay in this tab; model queries go to HF. A shareable link carries only the route, model ID and language, with no error, hardware or result data. Responses are not posted automatically to HF. The technical note describes the scope and how to add routes using other TAF modules.

48.3.3 It fits the estimate but fails: phases and peaks

A steady memory budget and a phase peak are different quantities. The memory route lets you select loading, prefill (prompt processing), decode (subsequent tokens) or unknown phase. One generate() call may contain both prefill and decode: its maximum does not separate them. Keep the unknown phase when you cannot identify the boundary.

Phase	Baseline and next check
Loading	Resident weights, without claiming they predict the peak. Check temporary copies, conversion and free memory before loading.
Prefill	Budget at the prompt token count. Isolate that processing; inspect temporary attention/logit buffers and the backend actually used. Shorten only the prompt when repeating.
Decode	Budget at the actual cached token count: prompt plus generated tokens. Reset counters after prefill; check KV growth, retained outputs and concurrency. Keep the prompt fixed while varying generated length.

Observed memory peak is optional. Enter the value, its unit (GiB, decimal GB or MiB) and metric: PyTorch tensor allocations, allocator reserved memory, sampled device usage or unknown. The allocation requested in an OOM message is not an observed peak. Do not enter zero to replace a missing value.

A numerical difference requires a tensor-allocation peak, a known phase, a measurement isolated to that phase and a matching workload: model, weight format, tokens, one GPU, one sequence, resident weights and FP16 KV cache. Supported geometry is also required. Loading is compared with resident weights; prefill/decode with the steady estimate. These are baselines, not predictions of the real maximum. Reserved memory and device usage remain context, without subtracting them from an estimate that counts different quantities.

The difference does not measure fragmentation, prove a cause or certify a fix. A peak below budget does not rule out OOM: a failed allocation does not become successfully allocated memory. TAF does not verify the supplied measurement. The report separates user_reported from illustrative and keeps independently_verified: false and executed_by_taf: false.

Measuring in your environment. Identify the GPU and phase boundary; record versions, actual format, backend, tokens and relevant options. With PyTorch, synchronize that device before starting, call torch.cuda.reset_peak_memory_stats(device), execute only the delimited phase and synchronize again before reading torch.cuda.max_memory_allocated(device) and torch.cuda.max_memory_reserved(device). Both return bytes: divide by 2**30 for GiB. Resetting counters does not free resident tensors. If you cannot separate prefill from decode, record the whole-run maximum as phase-unknown. TAF does not execute these operations.

PyTorch memory management explains the distinction between allocated, reserved and device-reported usage. See also the peak tensor counter and resetting peak statistics.

Saved example. Under “Explore another example”, choose “fits on paper, higher prefill peak”. It uses saved Qwen3-8B geometry, BF16, 4,096 tokens and a 24 GiB budget, with a synthetic 22 GiB peak. It illustrates the difference; it is not a measured Qwen benchmark or proof of OOM. Changing model, budget, tokens, precision or phase clears the measurement; applying an alternative requires measuring again. Language changes retain it. The report separates initial inputs from current inputs, and share links contain no measurements.

48.3.4 Save a case and continue another day

After a check, expand Save private case, read the notice and download the JSON file. It retains initial/current inputs, metadata, marked steps, observations and worked/still-fails feedback across all nine direct routes.

This file is unencrypted and may contain private text, code, reports or configurations you pasted. Keep it on your device and review it before sharing. TAF does not upload it or automatically persist a browser copy. Export report still produces the reduced report that omits pasted text and code from local routes; that report cannot restore inputs that were removed.

To continue, open Solve my problem → Open saved case, select the file (up to 4 MiB), check the route and save date, then choose Open and replace current case. Cancelling or selecting an invalid file preserves the current case. The same file works on either TAF host.

Opening recalculates checks with the current TAF version without contacting Hugging Face, executing pasted code or running a model. It retains the current UI language. File metadata and revisions remain unverified; examples remain illustrative. If the check plan has changed, incompatible follow-up is cleared. Run the HF check again to refresh repository metadata. Reopening a case does not establish that a repair worked.

48.3.5 Attach a memory measurement to the case

First calculate your memory case with its model, inspected revision, format, phase and token count. Open Import memory measurement, select a taf-memory-measurement JSON (up to 64 KiB) and inspect the declared conditions. The preview distinguishes matches, differences and undocumented values. Attach peak to this case fills only peak value, unit and metric; it does not change the case model, selected phase, precision or token count.

Same-workload and isolated-phase confirmations start unchecked. Review them in your runtime, then rerun the check. Checking them cannot override differences or missing data in the file. Model, revision, phase, format and workload must agree; one GPU, one sequence, resident weights and FP16 KV bound the comparison. Loading does not require token count or KV dtype because its baseline is weights. Reserved, device and unknown-phase peaks remain context. Illustrative files do not enable numerical differences either.

Collect a report. Import memory_probe.py into your existing PyTorch/CUDA program and wrap the operation you execute. It does not install packages, load models or run a task by itself. The example below uses variables and a function from your program; it is not a runnable benchmark:

from cli.memory_probe import memory_probe

with memory_probe(
    "prefill-memory.json", model=MODEL_ID, revision=MODEL_COMMIT,
    phase="prefill", tokens=ACTUAL_PROMPT_TOKENS, precision=WEIGHT_FORMAT,
    device=CUDA_DEVICE, phase_isolated=PHASE_WAS_ISOLATED,
    gpu_count=GPU_COUNT, batch_size=SEQUENCE_COUNT,
    resident_weights=WEIGHTS_RESIDENT, kv_dtype=ACTUAL_KV_DTYPE,
) as record:
    outputs = run_your_prefill()

The helper synchronizes the chosen device, resets counters, yields to your block, synchronizes again and writes peak allocated tensor memory in MiB, with the PyTorch version, device and timestamp. metric="reserved" records the reserved peak instead. Model/workload metadata is caller-declared; use None for unknowns. A revision must be a full commit hash, not main.

Use phase="generate" around a whole generate() call: this does not establish separate prefill/decode boundaries. During decode, record the actual cached length at the comparison point, not the configured maximum; update record["tokens"] inside the block if necessary. Isolate other activity and do not overlap probes on the same GPU: counters are process/device scoped. If the block fails, including OOM, no new report is written and the error propagates. Existing files are never overwritten. Resetting peaks does not free memory.

Save and share. A private case retains the normalized report and runtime details. It uses v2 for one measurement; if current or initial inputs contain a Before/After pair, it uses v3, as explained in the next section. Without any measurements it uses v1. The current reader accepts v1–v4. Reload an older app before opening a file from a newer format version. The reduced report retains the peak and comparison categories, but omits the original record and runtime identifiers. Changes to model, budget, length, format or phase clear the record; editing peak value/unit/metric detaches it into manual input. No declared match independently verifies a measurement or successful repair.

See full format, illustrative example and tests and PyTorch peak-counter documentation. UI/help are available in EN/ES/FR/ZH. The browser never executes file contents or performs GPU measurements.

48.3.6 Compare memory before and after

After attaching and confirming the first measurement, open Compare before and after. The attached record is Before. Select a second local JSON as After (same format, up to 64 KiB), review its conditions, runtime and dates, and choose Attach as After. The first peak and case settings remain intact. Every attachment starts with the pair confirmation unchecked.

Check both runs yourself: same input/workload, physical hardware and protocol, with isolated phases. Device label 0 does not identify the GPU or computer. The original peak’s workload/isolation confirmations must also remain checked. Attaching or confirming recalculates locally, without an HF request, and clears progress, observations and final feedback.

Both files must match the case model, revision, phase, format and workload. Engine, version and device label must be documented and identical. Both dates are required and After must be strictly later. Dates and labels remain unauthenticated declarations. Existing limits apply: allocated tensor peaks, known phase, one GPU, one sequence and supported geometry. Missing/different conditions, examples, reserved/device peaks, whole generation and unconfirmed pairs block the difference. Confirmation cannot override discrepancies. This version does not compare changed model, precision, context, runtime version or hardware; those changes require a separate controlled protocol.

Both peaks appear in GiB. When comparable, the panel calculates after − before and its percentage relative to Before. A zero initial peak makes the percentage undefined while leaving the absolute difference available. A negative delta only means a lower declared After peak. Two runs do not estimate uncertainty or prove causality, output quality or a resolved OOM. Repeat controlled measurements before drawing a conclusion.

Remove After measurement retains Before. Replacing the first clears After and its confirmation. Changing identity, budget, length, format or phase clears both; manually editing the first peak detaches both records. Language changes retain applied data; invalid files leave an existing pair intact.

A private case v3 retains both normalized records in current/initial inputs. Without a pair it uses v2 for one measurement or v1 for none; the current reader accepts v1–v4 and recalculates. Reload an older app before opening v3. The reduced report retains peaks, deltas and categories, but omits both raw records and their private runtime details. Measurement JSON itself remains v1.

See comparison contract, privacy and tests. UI/help are available in EN/ES/FR/ZH. Tests use illustrative data; no new actual GPU measurement was performed to validate this feature.

The 35-demo review dated 2026-10-25 records tested EN/ES/FR/ZH flows and test-environment issues. It does not imply that earlier videos demonstrate the new file-import/pair controls or guarantee future availability.

48.3.7 Open attention report files

In the attention route of Solve my problem, open a JSON as the primary report or optional reference without copying and pasting. It must be one object with finite numeric gamma or gamma_obs, up to 50 kB (50,000 bytes). Zero is valid; text, null or missing gamma does not become a measurement.

Expand Open primary report file or Open reference report file, select the JSON and review the preview: reported gamma, declared model/revision/source, context classification and undocumented protocol fields. Long labels are shortened only in the preview. Use this report replaces only the selected field, retaining the other. Discard preview leaves the case intact, as does an invalid or oversized file.

Then run the check to analyze both fields. Applying a file clears previous results and follow-up; it does not automatically analyze it. Existing rules remain: variable Diagnose CLI lengths, legacy N, conflicting T_eval/protocol values and missing conditions do not become comparable merely because a file was imported.

No model, Python or JSON-contained code is executed; no upload or HF lookup occurs. Contents and labels do not authenticate origin: the file may be illustrative even if it says diagnose-cli. Entropy-only reports do not supply gamma. Collections, compressed files and reports over the size limit are unsupported. Do not remove protocol conditions merely to reduce size. Structure is also bounded to 20 nested levels and 25,000 visited values.

Full text, including unknown fields and possible private details, remains in the input and Save private case. A leading BOM is removed and the textarea normalizes line endings to LF; JSON curves and fields are not projected away. Attention cases still use private format v1, retaining the same two text inputs. Reduced reports omit these texts and private protocol names. Private files are unencrypted and are not automatically redacted.

Editing inputs, switching routes, rerunning checks or selecting another file invalidates older previews. Language changes retain applied texts; a late file read cannot replace them. The original file and filename are not saved as an attachment: the case retains the field content.

See accepted format, privacy and tests. UI/help are available in EN/ES/FR/ZH; earlier videos do not show these selectors. The included uniform control is synthetic, not a new GPU measurement.

48.3.8 Open an adapter configuration

In Solve my problem → Adapters, enter the base you intend to use, expand Open adapter configuration file and select adapter_config.json. The limit is 50 kB (50,000 UTF-8 bytes). The preview shows declared PEFT type, base, revision, task, rank and alpha when present; long labels are shortened for display.

Use this configuration replaces only the JSON. The base-model field stays unchanged, including when empty, so the check can detect a mismatch with the declared base. Then run the check: applying does not analyze the file and clears previous results and follow-up. Discard preview or an invalid file preserves the case. Editing, switching routes, rerunning checks or selecting a newer file invalidates old previews and late reads.

One object with a nonempty peft_type is required. Present metadata must have correct types: positive integer rank, finite nonnegative alpha, string base/ revision/task, boolean flags and string or string-array targets. Rank/alpha patterns are numeric objects. Structure is bounded to 20 nested levels and 25,000 values; unknown fields and missing optional values are preserved. This is basic format checking, not full PEFT schema validation. Unknown PEFT types do not certify support; soft-prompt methods retain their existing check behavior.

No weights, code or training are run; no quality is measured or HF request made. Provenance is unverified and the displayed revision is not compared with the actual base revision. A family-only match does not establish exact identity. Target expressions remain text and are not executed.

Full JSON, including unknown fields, private paths or notes, remains in Save private case, format v1. It is unencrypted and not redacted. The reduced report omits the JSON and base-model text. A leading BOM is removed and the textarea normalizes line endings to LF; the original file is unchanged and its name is not saved. Switching language preserves applied text and discards preview.

See format, privacy and tests. UI/help are available in EN/ES/FR/ZH. Earlier videos do not show this selector; tests use synthetic metadata without training an adapter.

48.3.9 Open JSON, code and prompt files

The JSON, PEFT code and prompt prefix routes in Solve my problem accept local UTF-8 files up to 50 kB (50,000 bytes). Each prompt has its own selector. Expand the control under the field, select .json, .py/.txt or .txt respectively and review the literal preview. It shows bytes, lines and up to 12 lines/1,200 characters, with a partial-preview label when shortened. A trailing empty line is counted when the text ends with a newline.

Use this text retains the full accepted content and replaces only the chosen field. The other prompt remains intact. Previous results and follow-up are cleared; then run the check explicitly. Cancellation or an invalid file leaves the case intact. Edits, route changes, reruns or newer files invalidate late reads. Language changes preserve applied text and discard previews.

Invalid UTF-8, empty/whitespace-only text, NUL and oversized files are rejected. A leading BOM is removed and CRLF/CR is normalized to LF, retaining other spaces. Files with different line endings can therefore produce the same text. Prompt comparison still measures a prefix in UTF-16 units: it does not compare original bytes, tokenizer tokens or actual cache hits.

JSON must be one object with basic valid properties/required types, no nonfinite numbers, at most 20 nested levels and 25,000 values. This does not validate full JSON Schema or guarantee reasoning quality. Unknown fields are retained; reordering remains an explicit option. PEFT code remains text: existing pattern checks neither execute Python nor validate syntax. Notebook cell extraction and PDF/archive conversion are not provided.

There is no upload, HF lookup or prompt sent to a model. Text is displayed literally without executing HTML or scripts. Extensions do not verify content or authorship. Save private case, format v1, retains full normalized text, possibly including secrets, code or prompts; it is unencrypted and not redacted. Reduced reports omit these texts and the reorder proposal. The original file is unchanged and its name is not saved. Links do not contain the input text.

See contract, privacy and tests. UI/help EN/ES/FR/ZH; earlier videos do not show these controls. Tests use synthetic fixtures without running models, training or cache measurements.

48.3.10 Observe actual device usage

The optional cli/device_memory_probe.py queries NVIDIA without loading or stopping models. Run python cli/device_memory_probe.py --output device-window.json --seconds 5 and import the JSON as a memory measurement. It records the sampled maximum of the whole device, including other processes and the initial reading; short peaks can be missed. Sample count, actual gaps, duration, initial use and capacity are retained. This maximum is not attributed to llama.cpp or an isolated phase. Separate load/prefill/decode requires instrumentation and completion waits in your own program. UI explanations cover EN/ES/FR/ZH; numerical estimate and pair deltas stay blocked for this metric. Errors produce no new report and existing files are not overwritten.

Contract / Contrato.

48.3.11 Read llama.cpp memory logs

After checking a memory case, open Read a llama.cpp memory log. Select a UTF-8 .log/.txt file up to 256 KiB, or paste text and request a preview. Use an excerpt from one initialization. Attach log to this case recalculates locally without uploading or running a model. It does not change case settings or populate a peak field.

The table separates weights, KV cache, recurrent state, compute and output by location. CPU_Mapped and CUDA_Host remain host-side storage; each CUDA0, CUDA1, etc. is separate. Unknown backends remain unclassified. These are declared buffer sizes, not peak or total VRAM usage. Subtotals cover only recognized lines; driver, desktop, other processes and later allocations may be absent. Missing allocations are not zero. Repeated buffers or metadata block subtotals and differences because they may represent reloads, shards or mixed runs.

To calculate declared − estimated, confirm the exact model/revision, weight format and run conditions. Confirmation cannot replace missing data. A supported estimate, identified build, one CUDA GPU and full layer offload are required. Host weights block the weight comparison. KV additionally requires a maximum of one sequence, FP16 K/V, matching context/cells and no recurrent state. Loading has no KV comparison. Quantized caches, CPU/GPU splits, unsupported architectures or insufficient metadata keep declarations visible without a valid difference. This does not establish that the model fits or that an OOM was fixed.

The integrated example is synthetic and preview-only; it is not attached as a measurement. The parser recognizes specific initialization patterns in MiB; different prefixes may be unsupported. Arbitrary errors or numbers are not treated as memory. Log completeness and provenance are not authenticated.

Invalid UTF-8, NUL, empty text and excessive size are rejected. A leading BOM is removed and CRLF/CR normalized to LF. Save private case, version 4 when logs are present, keeps the entire text, possibly including paths or secrets, without encryption or redaction. Reduced reports omit the text and retain numerical declarations/checks. Filenames are not saved and logs never enter links. The reader also accepts v1–v3 and recalculates; older app versions reject v4.

Changing language retains the attachment. Changing model, budget, context, precision or phase removes it. Attaching, confirming or removing resets follow-up; invalid files and cancelled previews preserve the case. PyTorch peak import and before/after comparisons remain separate workflows.

See contract and tests. UI/help EN/ES/FR/ZH. Tests are synthetic; no GPU was measured. Earlier videos do not show this panel.

48.4 Choosing a model: recognition is not validation

A technical specification is like a blueprint: it describes parts, but does not prove how the machine behaves. Hugging Face search finds names; the importer also needs a compatible architecture; measuring attention requires running the weights under a documented protocol. These are three separate steps.

Review dated 2026-10-24: TAF includes eight public configurations pinned to revisions and two restricted Gemma 3 configurations left unverified. It retains the eleven historical examples and adds two dense Qwen3 presets. Explore these saved examples without downloading weights:

• Qwen3-0.6B: load a reviewed preset.
• Qwen3.8: inspect why the hybrid needs separate treatment.
• DeepSeek-V3.2: inspect the MLA and MoE boundary.

The panel shows provenance and limits before loading values. It does not start an analysis. Automatic imports in Profile, recipes, Inspector, Compare, Depth, Fit Check and Launch reject incompatible dense assumptions: hybrid layers, MoE, MLA, mixed windows, partial/scaled RoPE or multimodal components. Other modes keep their own scope; historical presets may simplify the architecture. A refusal does not mean the model is defective.

A careful-reading example: the official Qwen3-8B card lists 32,768 tokens of native context, while its configuration declares 40,960. Both new saved presets use 32,768 as their reference. Live config imports label configured context as a provisional reference: max_position_embeddings does not establish training length. Verify T_train before interpreting the formulas. Imported parameter counts are also estimates, not measurements from weights.

Editing Profile geometry detaches the model and creates a manual scenario. If a new import fails, TAF will not run the previous inputs under the new name. Understanding architectures helps you choose the next step; the technical review note details sources and checks. This update adds no atlas measurements and does not refresh benchmark tables.

48.5 The metrics it computes

Metric	What it tells you	Ch.
γ_Padé	γ predicted from geometry (θ, T)	15
γ_observed	γ imported from a measurement on real weights; protocol-dependent	15
d_horizon	horizon derived from the theoretical model; not a tested useful-context limit	15, 19
η (θ_eff_obs/θ_eff_Padé)	regime: Normal / Fraud / Compressed / Over-Padé / SWA	R1
KV memory	cache memory at length L	20, 36
L_NIAH	estimated needle-in-haystack ceiling	19
Δγ	phase probe for induction heads	24, 30
ΔPPL	perplexity shift from quantization	35
Phase A / Phase B	γ<1 (global) vs γ>1 (local collapse)	21

48.6 How it is organized: five questions, not a list of modes

The landing page groups the tools by what you want to do (modes grow with every release; the always-current list lives in the app’s own 📘 manual):

1. 🔬 “Will this model work for me?” — Profile (paste an id → the full TAF Card, the starting mode), Fit Check, Unmask, Memory Reality, NIAH→Reason, LongScore, Quant, YaRN Planner, GGUF Bridge, Launch Flags, Inspect config…
2. ✓ “Should I believe this number?” — Contamination, Drift, Arena CI, Saturation.
3. ⚙️ “Set up an eval correctly” — Chat-template Sniffer, Diagnose CLI, JSON CoT, PEFT Lint, Cache Diff, Spec-Decode, Token Tax.
4. 🆚 “Compare models” — Compare (2-3 models, same recipe) and the interactive phase diagram (the atlas, live).
5. 📋 “Manual / free-form” — Pick recipe (a specific X-) and Ask* (natural-language question, handled by a small in-browser LLM).

Recent highlight — 💾 Fit Check (“will it fit?”): model + precision + GPU + context → the full VRAM budget (weights + KV cache + scratch), why it doesn’t fit when it doesn’t (weights or KV?), the max context that does fit, and the cheapest rescue. It answers the most repeated forum question before downloading anything — and teaches the Ch. 21 lesson along the way: at long context, the KV cache can weigh as much as the model.

48.7 Guided demos and your language

• Every mode has a 🎬 Demo button: a guided simulation that types, clicks and narrates step by step, ending with a “what you just learned” card. Linkable: ?demo=fitcheck, ?demo=profile, ?demo=yarn… — handy for sharing or teaching.
• Four languages end-to-end (EN/ES/FR/ZH): since v0.12 not just the menus — the demos, the recipe verdicts and their explanations follow the browser language too.

48.8 The Anti-Bullshit Pack

Diagnostics that attack the “smoke” of model cards: Context Unmasker (real long context vs advertised), Chat-template Sniffer, Quant-regime Classifier, Multilingual Tokenizer Tax (tokenizes real text in 6 tokenizers → how much your language “costs”), Contamination Prior, LongScore (RULER+HELMET), PEFT Anti-Pattern, Spec-Decode, plus extension: YaRN/RoPE planner, GGUF Bridge, Launch-Flag Generator.

48.9 The recipes (8 core)

Recipe	For	Ch.
X-1	custom vs API	25, 36
X-2	long-context viability	19
X-3	budget pre-flight	25
X-5	hardware	36
X-19	KV compression (soft-decay/cutoff)	20
X-21	training imprint on γ (γ_train) — retired as a predictor: ν is not identified by current data (Chapter 39)	15
X-22	compute-context invariant	34
X-23	induction-head phase detector	24, 30

48.10 How to read the output: the TAF Card

The result is summarized in a TAF Card with ✅ / ⚠ / ❌ verdicts per dimension (context, quantization, template, regime). And there is a falsification dashboard (F1-F23): it doesn’t just hand you numbers, it puts the claims to the test —the same philosophy as Ch. 38—.

A typical flow: Profile (paste the id) → read the verdict on the TAF Card → if something comes back ⚠/❌, open the specific diagnostic (e.g. Context Unmasker or Quant-regime) → use the matching recipe (X-2 context, X-19 KV) to decide.

48.11 Evidence scores: points, not probabilities

X-2 and Memory Reality display Evidence score: N / 100. This is a heuristic for the listed factors, not a probability of correctness, measured accuracy or a task-quality benchmark. Even 100/100 only covers that checklist; it does not establish that a prediction will hold.

Each factor contributes 1 when supported, 0.5 when partial and 0 when missing or outside the stated regime. The weighted average is multiplied by 100 and rounded. Weights are 1 unless shown; high (≥ 80), medium (≥ 55) and low bands are heuristic design choices, not thresholds calibrated against accuracy. The interface can expand the method and change language with the result still displayed.

A supplied gamma is not an independent task-quality benchmark. Being inside a formula’s regime does not establish empirical validation either. Checklists differ between modes, so their scores should not rank model quality. The score runs no inference and collects no new measurements.

Prediction vs Reality compares records and protocol conditions without this score. R² remains goodness of fit, not a success probability (see R4). Legacy JSON fields confidence and pct remain for compatibility, alongside score, max_score: 100, kind: "evidence_checklist", calibrated: false and scope: "listed_factors_only".

48.12 Verification (the receipts)

• Pyodide for the math (deterministic), WebLLM for the natural language, transformers.js for the tokenizer.
• Lean+Mathlib verification: 15 identities formally proved (github.com/karlesmarin/lean-taf).
• Panel of 23 models open (github.com/karlesmarin/tafagent-registry). It is the tool’s registry (config + tested predictions), not the γ atlas of Ch. 16 —that one is 42 models and 79 measurements of real attention—.

Warning⚠ Honest — what is prediction and what is measurement

Many outputs (γ_Padé, estimated horizon, KV at length L) are predictions from the config —fast and useful for deciding before spending GPU—, not measurements of real attention. Once you have the model, contrast them with γ_observed (measured) and with your own measurement (R4). And remember the book’s limits: D_f and the context headroom are 🟡 rules not fully validated (R1).

Next reference (R6): the suggested solutions to each chapter’s exercises.

Studies and demos: Float32 · mHC. Optional illustrative calculations, without inference or weight downloads.