Notation

An agentic system places a foundation model inside a loop: the model proposes an action, the runtime decides whether to admit it, a tool executes it, and the observation that comes back shapes the next call. Describing that loop requires notation for trajectories, task contracts, budgets, verification, and coordination, alongside the model and serving quantities underneath them. Machine learning, computer systems, and control each developed their notation independently, and several letters arrive with conflicting meanings.

In control and robotics, $\Glyph{\tau}$ is a torque or a time constant; in this book bare $\Glyph{\tau}$ is always a trajectory, $\Trajectory= (\TrajectoryState_0, \TrajectoryAction_0, \TrajectoryObservation_1, \TrajectoryState_1, \dots, \TrajectoryState_{\TurnHorizon})$. In transformer notation $\Glyph{H}$ often counts attention heads; here $\Glyph{H}$ is the horizon in turns, and heads are $\AttentionHeadCount$. In machine learning $\Glyph{B}$ is batch size, and it remains batch size here; the trajectory budget is bold $\TrajectoryBudget$. The conventions below keep one meaning per symbol, and the collision tables at the end of this section resolve the remaining cases. A symbol that appears only inside one derivation is defined where it is used and is not listed here.

Governing Relationships

Five relationships recur across the chapters of this book. They link a trajectory’s structure to its elapsed time, its reliability, its cost, and the speedup available from splitting it across workers. Each is derived in the section cited with it; the forms below fix the symbols those chapters use.

The trajectory formulation

A trajectory, the ordered record of one delegated task, is formalized in The H·S·A Exposure Space as:

\[\Trajectory= (\TrajectoryState_0, \TrajectoryAction_0, \TrajectoryObservation_1, \TrajectoryState_1, \TrajectoryAction_1, \TrajectoryObservation_2, \dots, \TrajectoryState_{\TurnHorizon})\]

where $\TrajectoryState_{t}$ is the assembled context state, $\TrajectoryAction_{t}$ is the action the model proposes on turn $\TurnIndex$, and $\TrajectoryObservation_{t+1}$ is the environment observation returned to the agent.

Trajectory duration

The wall-clock duration of a trajectory over a horizon of $\TurnHorizon$ turns, indexed $\TurnIndex= 0, \dots, \TurnHorizon-1$, is in the simplest case the sum of its model calls and tool operations (Queueing for Trajectories):

\[\TrajectoryDuration = \sum_{t=0}^{\TurnHorizon-1} \left( \ModelTime^{(t)} + \ToolTime^{(t)} \right)\]

The sum assumes that model calls and tool operations run one after another with no other delay. A turn that also waits on a remote service or on a person’s approval adds that wait, $\ExternalWait$, as a further interval. The sum applies only when the included intervals are nonoverlapping and cover the measured duration. For overlapping work, measure elapsed time between the declared endpoints and analyze the dependency critical path; summing enclosing spans and their children double-counts time.

Each model call is itself an inference pass on an accelerator, and its time $\Time$ obeys the iron law of ML Systems:

\[\Time = \frac{\DataVolume}{\Bandwidth} + \frac{\Operations}{\PeakRate \cdot \EfficiencyHw} + \Latency\]

The first term charges the bytes the call moves against memory bandwidth, the second charges its operations against the sustained compute rate, and the third is fixed per-call overhead. The floors the first two terms set for prompt processing and output generation follow from the roofline in Cost Asymmetry Between Input Prefill and Output Generation.

Trajectory goodput and effective task cost

Agentic systems are measured per accepted task completion rather than raw requests. Trajectory goodput counts distinct task completions accepted under a declared contract per unit of elapsed observation time $\ObservationIntervalLength>0$ (Release measurements):

\[\TrajectoryGoodput = \frac{\AcceptedTasks}{\ObservationIntervalLength}\]

Goodput per dollar instead divides the same accepted count by the full included cost. Neither measure is the fraction of resources spent on accepted trajectories; that fraction answers a different accounting question.

The cost per accepted task divides the included monetary costs of all $\InitiatedTasks$ distinct initiated tasks, including their attempts and branches, by the $\AcceptedTasks>0$ distinct tasks accepted under the same contract (Cohort cost per accepted task):

\[\CostPerAcceptedTask = \frac{\sum_{i=1}^{\InitiatedTasks} {\TaskCost}_i}{\AcceptedTasks}\]

When every attempt is accepted independently with probability $\AcceptanceProbability$ and a task retries until one is, the same ratio takes the per-attempt form $\CostPerAcceptedTask = \mathbb{E}[\AttemptCost]/\AcceptanceProbability$ (Reliability and Cost over a Horizon). With no accepted tasks, report total spend and the zero accepted count rather than a finite unit cost. Report unsettled liability separately from known charges.

The compounding reliability law

A trajectory executing $\TurnHorizon$ sequential turns without intermediate verification, where each turn is correct with probability $1 - \PerStepErrorRate$ independently of the others, compounds its errors and succeeds with probability (Reliability and Cost over a Horizon):

\[\Pr(\text{success}) = (1 - \PerStepErrorRate)^{\TurnHorizon}\]

An intermediate check can interrupt error propagation when it detects an error and the runtime prevents later turns from building on it. Training on trajectories can lower $\PerStepErrorRate$, but it supplies no such check.

The coordination bound

Splitting a fixed task across $\WorkerCount$ equally capable workers shortens it only as far as its parallel fraction and the cost of coordinating the workers allow (The coordination tax):

\[\text{Speedup}(\WorkerCount) = \frac{1}{(1-\ParallelFraction) + \ParallelFraction/\WorkerCount + \CoordinationOverhead(\WorkerCount)}\]

where $\CoordinationOverhead(\WorkerCount)$ is the added coordination overhead as a fraction of serial time. With no overhead the bound is Amdahl’s law. Once $\CoordinationOverhead(\WorkerCount)$ exceeds the time the split saves, $\ParallelFraction(1 - 1/\WorkerCount)$, the split task takes longer than serial execution.

Trajectories, State, and the Agent Execution Loop

The loop symbols describe one turn of a trajectory: the context assembled by the runtime, the proposal generated by the model, the decision made by the runtime harness, and the resulting observation. Together, these quantities distinguish what the model proposes from what the runtime actually admits and executes.

Trajectories and the agent loop

A trajectory advances one turn at a time, and every turn is written with the same few parts, each carrying the turn index. Keeping the turn index explicit separates the state the model saw on turn $\TurnIndex$ from the observation that arrived afterward:

Symbol	Definition	Unit	Notes
$\Trajectory$	Trajectory	Tuple	Ordered record of one delegated task, $\Trajectory= (\TrajectoryState_0, \TrajectoryAction_0, \TrajectoryObservation_1, \dots, \TrajectoryState_{\TurnHorizon})$. Bare $\Glyph{\tau}$ always means a trajectory in this book.
$\TurnIndex$	Turn index	Integer	Counts turns within a trajectory from $\TurnIndex= 0$, so $\TrajectoryState_{\TurnHorizon}$ is the state after the final turn. Inside a per-token loss such as $\MaskedFinetuningLoss$, $\Glyph{t}$ indexes token positions instead. Positions in a durable log use $\Glyph{j}$.
$\TurnContext_{t}$	Context	Tokens	What the runtime assembles and sends on turn $\TurnIndex$: instructions, goal, tool definitions, and the history of actions, observations, and evidence.
$\TrajectoryState_{t}$	State at turn $\TurnIndex$	Record	The context state the model saw on turn $\TurnIndex$. In Part V, the state a policy conditions on.
$\TrajectoryAction_{t}$	Action proposal	Text or tool call	What the model proposed on turn $\TurnIndex$. Nothing happens until the runtime admits it.
$\TrajectoryObservation_{t}$	Observation	Typed result	What an action returned, such as an exit code, captured output, a response body, or a status.
$\Policy$	Policy	Distribution	The model viewed as a distribution over proposals given a context, with parameters $\ModelParameters$.
$\bot$	Rejection	Symbol	A proposal withheld through the admission gate, recorded with its reason. This does not undo earlier attempts or establish that outstanding external work has stopped.

The task contract

A task contract fixes what a trajectory is for, where it runs, what it may do and see, and what ends it. Every runtime check and evaluation rubric in the book refers back to these five components:

Symbol	Definition	Unit	Notes
$\TaskContract$	Task contract	Tuple	$\TaskContract = \langle \TaskContractGoal, \TaskEnvironment, \PermittedActions, \AvailableObservations, \CompletionCriteria \rangle$.
$\TaskContractGoal$	Goal	Text	Desired end state, with explicit negative scope.
$\TaskEnvironment$	Environment	Specification	Reproducible place the work happens: base commit, image, configuration, network rules.
$\PermittedActions$	Permitted actions	Set	Tools the task may call and the limits on each. Least privilege stated per task.
$\AvailableObservations$	Available observations	Specification	What the agent may see, and how much, including truncation and redaction rules.
$\CompletionCriteria$	Completion criteria	Set of checks	Checks that decide when the task is done, at a stated closure evidence level. The model’s claim of completion is never one of them.

The H·S·A exposures

H·S·A names the three exposures an agentic task adds beyond a single model call. A task’s position says how exposed it is. The closure the runtime must supply against that exposure is governed by the invariant closure principle and is not a fourth axis. Zero ambient authority describes the model at every authority level and has no symbol.

Symbol	Definition	Unit	Notes
$\TurnHorizon$	Horizon	Turns	Number of turns a trajectory runs: $\TurnHorizon= 1$ (single call), $\TurnHorizon\approx 10$ (short loop), $\TurnHorizon\ge 100$ (minutes to hours). Wall-clock duration given $\TurnHorizon$ is $\TrajectoryDuration$.
$\StateExposureLevel_0$ to $\StateExposureLevel_3$	State	Level	What the task carries between turns: $\StateExposureLevel_0$ (nothing), $\StateExposureLevel_1$ (context window and KV cache), $\StateExposureLevel_2$ (sandboxed working files), $\StateExposureLevel_3$ (durable state that outlives the session or is shared beyond it). Written with its level, because bare $\Glyph{S}$ is sequence length.
$\AuthorityExposureLevel_0$ to $\AuthorityExposureLevel_3$	Authority	Level	What the task may do through its tools: $\AuthorityExposureLevel_0$ (read access), $\AuthorityExposureLevel_1$ (mutation confined to a discardable sandbox), $\AuthorityExposureLevel_2$ (external action that is retry-safe or compensable), $\AuthorityExposureLevel_3$ (irreversible external action). Covers confidentiality as well as integrity, so $\AuthorityExposureLevel_0$ is not a zero blast radius.

Forms of closure evidence are named in words and carry no symbol: self-report, static checks, visible tests, sealed tests, and formal proof. They support different claims under different assumptions, not a universal weakest-to-strongest ranking. Protecting a check does not establish complete coverage.

Grants and information flow

A capability grant bounds what an operation may reach. An information-flow policy attaches two labels to every record, propagates them through each transformation, and checks them against each operation before dispatch.

Symbol	Definition	Unit	Notes
$\CapabilityGrant$	Capability Grant	Tuple	$\CapabilityGrant = (\GrantRights, \mathcal{O}_\CapabilityGrant, \GrantCondition, \GrantExpiryTime)$: rights, objects, the condition predicate on an access, and expiry time. Derived grants carry a subscript, as in $\ChildCapabilityGrant \sqsubseteq \ParentCapabilityGrant$. Not $\Glyph{C}$, which is always a cost.
$\GrantExpiryTime$	Grant expiry time	Seconds (timestamp)	Time after which a grant admits nothing; an access at time $\TimeInstant$ is admitted only if $\TimeInstant< \GrantExpiryTime$. A derived grant expires no later than its parent.
$\IntegrityProvenance(\LabeledRecord)$	Integrity provenance	Set of sources	Sources whose content may have influenced record $\LabeledRecord$. A derived record takes the union of its inputs’ provenance.
$\ConfidentialityLabel(\LabeledRecord)$	Confidentiality	Set of recipients	Recipients permitted to receive record $\LabeledRecord$. A derived record takes the intersection of its inputs’ labels. In the evaluation chapter, $\Glyph{\kappa}$ is Cohen’s kappa, a local agreement statistic.
$\AcceptedInfluences(\ProposedOperation)$	Accepted influences	Set of sources	Sources the task policy accepts as influences on operation $\ProposedOperation$; the evidence check is $\IntegrityProvenance(\LabeledRecord) \subseteq \AcceptedInfluences(\ProposedOperation)$. Upright, to stay distinct from the environment $\Glyph{\mathcal{E}}$.
$\ChildCapabilityGrant$	Child capability grant	Tuple	Capability grant derived from a parent grant, which may permit no more than its parent does. Attenuation orders the two grants, child below parent.
$\GrantAllowedAccesses$	Allowed accesses of a grant	Set	Set of accesses a capability grant allows, written as a function of the grant. Attenuation requires the child’s set to lie inside the parent’s. Not an advantage or an action set.
$\GrantCondition$	Grant condition	Predicate	Condition a capability grant attaches to an access, such as binding its use to one task or recipient; third component of $\CapabilityGrant$, applied to an access as a predicate. May carry an aggregate resource budget.
$\GrantRights$	Grant rights	Set	Set of operations a capability grant permits its holder to perform; first component of $\CapabilityGrant$. An access is admissible only if its operation lies in this set.
$\AccessAttemptTime$	Access attempt time	Seconds	Timestamp at which a proposed access is checked against a capability grant. The access is admissible only if this time precedes $\GrantExpiryTime$. Not the turn index $\TurnIndex$.
$\ParentCapabilityGrant$	Parent capability grant	Tuple	Capability grant from which a narrower child grant $\ChildCapabilityGrant$ is derived. It stays usable after the derivation unless the runtime withdraws it.
$\ProposedAccess$	Proposed access	Record	Access a tool call proposes, naming an operation, a target, and its arguments, which an enforcement point admits or refuses under a capability grant $\CapabilityGrant$.

Model Calls, Context Windows, and Tokenomics

An agent trajectory spends compute and memory across repeated model calls, growing contexts, and generated token streams. Tracking those resources requires symbols that separate per-call limits from cumulative trajectory budgets.

Model calls and budgets

A model call is bounded by its window and by limits the runtime sets on each request. A trajectory is bounded by a budget under runtime-owned accounting; model visibility does not confer authority to change the meter.

Symbol	Definition	Unit	Notes
$\SequenceLength$	Sequence length	Tokens	The shared symbol for sequence length, used here for the prompt a call reads. The State exposure is always written with a level, $\StateExposureLevel_0$ to $\StateExposureLevel_3$.
$\BasePromptLength$	Base prompt length	Tokens	First prompt of a trajectory before any turn appends to it, as in the resend sum. Subscripted because $\StateExposureLevel_0$ is a State level.
$\TurnAppendLength$	Per-turn append	Tokens	Tokens one turn adds to the next prompt: the action, its observation, and any evidence kept in context.
$\PromptTokensSent$	Prompt tokens sent	Tokens	Cumulative prompt tokens a trajectory sends across its calls. With a fixed append and no compaction, the resend sum is $\PromptTokensSent = \TurnHorizon\,\BasePromptLength + \TurnAppendLength\,\TurnHorizon(\TurnHorizon-1)/2$.
$\OutputLength$	Output length	Tokens	Tokens a call generates; $\OutputLength_t$ is the output of turn $\TurnIndex$. Lowercase $\Glyph{k}$ counts samples, as in pass@$\IndependentAttemptCount$.
$\TokenVocabulary$	Vocabulary	Set of tokens	The token set a call samples from; $\lvert\TokenVocabulary\rvert$ is the vocabulary size.
$\ContextWindow$	Context window	Tokens	Hard per-call context limit; when inputs and outputs share it, $\SequenceLength+ \OutputLimit \le \ContextWindow$.
$\OutputLimit$	Output limit	Tokens	Maximum tokens the runtime lets a call generate.
$\PerTokenDecodeTime$	Per-token decode time	Seconds	Time to generate one output token on a single stream. A call’s whole decode interval is $\DecodeInterval$.
$\DecodeInterval$	Decode interval	Seconds	A call’s whole output-generation interval, $\DecodeInterval(\OutputLength) \approx \OutputLength\,\PerTokenDecodeTime$ at a stable per-token time. One term of the call latency $\CallLatency$.
$\CallLatency$	Call latency	Seconds	Elapsed time from request preparation to normalized response, the sum of nonoverlapping intervals $\CallLatency = \CallPreparationTime+ \RequestQueueTime+ \PrefillTime+ \DecodeInterval + \CallPostprocessingTime$. $\RequestQueueTime$ is the wait before service that the queueing models compute.
$\CompletionDeadline$	Deadline	Seconds	Wall-clock ceiling enforced by the runtime, on one call or on a whole trajectory. The text names the scope. Inside the budget $\TrajectoryBudget$ the trajectory deadline is written $\TrajectoryTimeLimit$; everywhere else a deadline is $\CompletionDeadline$.
$\CostCeiling$	Cost ceiling	Dollars	Cost allowance checked against actual consumption, outstanding liability, and newly proposed work while preserving finalization resources.
$\KvCacheBytesPerToken$	KV bytes per token	Bytes per token	$\KvCacheBytesPerToken = 2 \cdot \LayerCount\cdot \KvHeadCount \cdot \AttentionHeadDimension \cdot \ElementStorageSize$, in the shared symbols for layers, KV heads, head dimension, and element size.
$\KvCacheMemory$	KV-Cache Memory	bytes	Logical full-attention state ($\KvCacheMemory = \SequenceLength\cdot \KvCacheBytesPerToken$) at the specified geometry and precision. Allocation overhead and shared physical ownership require separate accounting.
$\KvBlockSize$	KV block size	Tokens	Token positions per fixed block in paged KV storage. Not $\Glyph{p}$, which is a probability, or $\Glyph{B}$, which is batch size.
$\MemoryHoldDuringWait$	Memory held during a wait	Byte-seconds	Constant uniquely resident bytes multiplied by wait duration; $\KvCacheMemory \cdot \ExternalWait$ applies when that payload is fully resident and unshared. Pool accounting counts shared blocks once.
$\ObservationTokenCount$	Observation tokens per call	Tokens	Tokens one call devotes to immediate tool observations and user steering: the observation buffer, one partition term of the context budget.
$\ConditioningTokenPrefix$	Conditioning token prefix	Token sequence	Token prefix a language-model policy conditions on when it chooses the next token, such as the context delivered before one sampled token of a rollout. Written without a position index; the same prefix written relative to a position carries $\Glyph{x_{<t}}$.
$\DecodingConstraintState$	Decoding constraint state	State	State of the parser or output-constraint automaton that constrains decoding, indexed by decoding step; the initial state carries index zero. Elements of the automaton’s state set $\AutomatonStateSet$.
$\AutomatonStateSet$	Constraint automaton state set	Set	Finite set of states of an output-constraint automaton. The appendix on inference sizes a dense mask table from its cardinality and the vocabulary size.
$\MaskedTokenLogit$	Masked token logit	Scalar	Logit of one vocabulary token at a decoding step after the constraint mask: its raw logit when the token is allowed and negative infinity otherwise. Written with step and token indices. Dimensionless.
$\NormalizerTokenIndex$	Normalizer token index	Token	Token of the vocabulary that a softmax normalizer sums over. Bound variable of the normalizing sum, kept distinct from the evaluated token.
$\ActiveTargetTokenCount$	Active target token count	Tokens	Number of token positions in one example that the loss mask $\PositionLossMask_{t}$ selects as training targets; required positive. The normalizer of $\MaskedFinetuningLoss$. Not the Little’s-law count of leases held at once, $\ActiveLeaseCount$, which shares the glyph.
$\CallPreparationTime$	Call preparation time	Seconds	Time a runtime spends preparing a model call: assembling context, serializing the payload, and dispatching it. First term of $\CallLatency$. Not the host-side preparation time of a serving node, which shares the glyph.
$\CallPostprocessingTime$	Call postprocessing time	Seconds	Time after generation until a model call’s normalized response is ready: response transfer, deserialization, and schema validation. Last term of $\CallLatency$.
$\SystemInstructionTokenCount$	System instruction tokens per call	Tokens	Tokens one call devotes to static system instructions, one term of the context budget partition.
$\ToolDeclarationTokenCount$	Tool declaration tokens per call	Tokens	Tokens one call devotes to API schemas and tool declarations, one term of the context budget partition.
$\TaskStateTokenCount$	Task state tokens per call	Tokens	Tokens one call devotes to task state such as constraints, progress records, and source or test excerpts, one term of the context budget partition.
$\TrajectoryTurnLimit$	Trajectory turn limit	Turns	Largest number of turns the harness admits for one trajectory; the first element of $\TrajectoryBudget$. Each admitted model call increments the turn meter. It caps $\TurnHorizon$, the number of turns actually run.
$\TrajectoryTokenLimit$	Trajectory token limit	Tokens	Largest cumulative number of tokens, input plus output, one trajectory may consume; the second element of $\TrajectoryBudget$. The meter counts every input token, cached or not. Not the per-call limits $\ContextWindow$ or $\OutputLimit$.
$\TrajectoryTimeLimit$	Trajectory time limit	Seconds	Elapsed wall-clock time a trajectory budget allows; the third element of $\TrajectoryBudget$. Outside the budget a deadline is $\CompletionDeadline$.
$\SequenceToken$	Sequence token	Token	One token of a serialized input sequence, written with its position as an index. Its prefix before a position is $\TokenPrefix$. Not an input feature vector.
$\TokenPrefix$	Token prefix	Token sequence	Tokens of a sequence that precede the current position, the context an autoregressive model conditions on. The range is part of the symbol, not an index, so the prefix has its own row.
$\VocabularyToken$	Vocabulary token	Token	One token of the model vocabulary $\TokenVocabulary$, the variable a next-token distribution, a logit, or a sum over candidate tokens ranges over. Not the verification evidence $\Glyph{v_t}$.
$\ValidTokenSet$	Valid token set	Set of tokens	Vocabulary tokens whose decoded strings keep the output a viable prefix of the target grammar from a parser state. Written with its constraint state as argument; a subset of $\TokenVocabulary$.
$\SamplingTemperature$	Sampling temperature	Dimensionless	Positive scalar that divides the logits before the softmax at sampling time, sharpening the distribution below one and flattening it above. Zero means greedy decoding, not a division. Bare $\Glyph{\tau}$ is still a trajectory.
$\PerTokenPrefillTime$	Per-token prefill time	Seconds	Time prefill spends per prompt token at the compute-bound floor, about two operations per parameter at the peak rate $\PeakRate$. Pairs with $\PerTokenDecodeTime$.
$\PrefillTime$	Prefill time	Seconds	Time a model call spends processing its whole prompt, about the sequence length $\SequenceLength$ times $\PerTokenPrefillTime$.
$\WeightOnlyStepTime$	Weight-only step time	Seconds	Estimate of one serving forward pass: the larger of the weight-read time and the time for two weight operations per parameter per token position. Written with the token count as argument; omits attention traffic and per-iteration overhead. Not the turn index $\TurnIndex$.
$\RuntimeReserveMemory$	Runtime reserve memory	Bytes	Accelerator memory a serving runtime reserves for dynamic activations and scratch buffers, excluded from the KV pool $\KvPoolMemory$.
$\PrefixHitRate$	Prefix hit rate	Fraction	Token-weighted share of prompt tokens over a workload window whose compatible key-value state was attached without recomputation. Counts tokens actually served, not potential matches. Not the serving utilization $\ServingUtilization$.

Time and cost of a trajectory

Agentic systems are measured per accepted task, not per request. The time terms decompose one turn, the cost terms price attempts and the accepted results they buy, and the capacity terms size the pools that serve them.

Symbol	Definition	Unit	Notes
$\ModelTime$	Model time	Seconds	Time spent in model calls during a turn.
$\ToolTime$	Tool time	Seconds	Time a tool takes to execute, such as a build or a test run.
$\ExternalWait$	External wait	Seconds	Time spent waiting on a remote service or a person’s approval.
$\TrajectoryDuration$	Trajectory duration	Seconds	Elapsed time between declared endpoints. A component sum applies only to disjoint intervals covering that duration.
$\TrajectoryGoodput$	Trajectory goodput	Tasks/time	Distinct accepted task completions per elapsed observation interval under the declared contract. Sustaining it at acceptance fraction $\AcceptanceFraction$ requires the admission rate $\TrajectoryAdmissionRate = \TrajectoryGoodput/\AcceptanceFraction$.
$\TrajectoryBudget$	Trajectory budget	Vector	$\TrajectoryBudget = \langle \TrajectoryTurnLimit, \TrajectoryTokenLimit, \TrajectoryTimeLimit, \CostCeiling \rangle$, allowances on turns, tokens, elapsed time, and dollars. Admission accounts for actual consumption and reserved bounded liability. The time allowance $\TrajectoryTimeLimit$ is the trajectory’s deadline. Bold, to stay distinct from batch size $\BatchSize$.
$\ConcurrentTrajectories$, $\TrajectoryAdmissionRate$	Concurrent trajectories, admission rate	Count, trajectories/s	Little’s law for trajectories, $\ConcurrentTrajectories = \TrajectoryAdmissionRate\,\mathbb{E}[\TrajectoryDuration]$, with $\TrajectoryAdmissionRate$ the shared arrival rate $\ArrivalRate$ counted in trajectories. Other held resources follow the same pattern, as in $\ActiveLeaseCount= \ArrivalRate\,\LeaseHoldTime$.
$\LeaseHoldTime$	Lease holding time	Seconds	Mean time a trajectory holds a sandbox lease, the residence term in $\ActiveLeaseCount= \ArrivalRate\,\LeaseHoldTime$.
$\TaskCost$	Task cost	Dollars	Included monetary cost of all attempts and branches for one distinct initiated task.
$\AttemptCost$	Attempt cost	Dollars	Full cost of one attempt: input and output tokens, tool fees, sandbox time, verification, and human review.
$\InputTokenPrice$, $\OutputTokenPrice$, $\CachedInputTokenPrice$	Per-token prices	Dollars/token	Prices of an uncached input token, an output token, and a cached input token. Lowercase $\Glyph{c}$ is a unit price that an uppercase $\Glyph{C}$ totals; $\Glyph{p}$ stays a probability.
$\ExpectedCheckingTime$	Expected checking time	Seconds	Expected verifier slot time per attempted record under a short-circuit check cascade. A time, distinct from the attempt cost $\AttemptCost$ in dollars.
$\AcceptedTasks$	Accepted tasks	Count	Distinct tasks satisfying the declared acceptance criteria by the observation cutoff; pending and unknown verdicts remain separately reported.
$\InitiatedTasks$	Initiated tasks	Count	Size of a settled cohort of distinct initiated tasks, whatever their outcome. It is the range of the cost sum in $\CostPerAcceptedTask$ and the denominator of $\AcceptanceFraction$.
$\AcceptanceFraction$	Acceptance fraction	Fraction	$\AcceptanceFraction = \AcceptedTasks/\InitiatedTasks$ over a fully classified cohort, so $\CostPerAcceptedTask = \AcceptedTaskMeanCost+ \frac{1-\AcceptanceFraction}{\AcceptanceFraction} \UnacceptedTaskMeanCost$, where $\AcceptedTaskMeanCost$ and $\UnacceptedTaskMeanCost$ are the mean included costs of an accepted and an unaccepted task. It counts tasks, whereas $\AcceptanceProbability$ counts attempts.
$\AcceptanceProbability$	Acceptance probability	Probability	Per-attempt probability of acceptance; with independent retries, $\CostPerAcceptedTask = \mathbb{E}[\AttemptCost]/\AcceptanceProbability$.
$\CostPerAcceptedTask$	Cost per accepted task	Dollars/task	Total included monetary cost divided by $\AcceptedTasks>0$, including failed attempts. No finite ratio exists when none are accepted.
$\BreakEvenTaskCount$	Break-even task volume	Tasks	Tasks an adaptation must serve before its per-task saving recovers its one-time cost, $\BreakEvenTaskCount = \AdaptationInvestmentCost/\FiniteChange\TaskCost$ for $\FiniteChange\TaskCost > 0$.
$\WorkerCount$	Worker count	Count	Equally capable agents, model workers, or verifier slots in one pool. Never bare $\Glyph{M}$ or $\Glyph{P}$, which the shared tables assign to memory and parameter count.
$\ServiceRate$	Service rate	Items/s	Rate at which one server (a worker, consumer, or model endpoint) completes items or calls, so a pool of $\WorkerCount$ servers has capacity $\WorkerCount\ServiceRate$. Subscripted rates such as $\Glyph{\mu_{\text{out}}}$, and a statistical mean $\Glyph{\mu}$, are distinct.
$\ParallelFraction$	Parallel fraction	Fraction	Share of the work that divides among workers in the coordination bound, $\text{Speedup}(\WorkerCount) = 1/\big((1-\ParallelFraction) + \ParallelFraction/\WorkerCount + \CoordinationOverhead(\WorkerCount)\big)$.
$\CoordinationOverhead$	Coordination overhead	Fraction of serial time	Added elapsed cost of coordinating $\WorkerCount$ workers, normalized by serial time and always written with its argument, $\CoordinationOverhead(\WorkerCount)$. Distinct from the interaction history $\InteractionHistory_k$.
$\ContentionCoefficient$, $\CoherencyCoefficient$	Contention and coherency coefficients	Fraction	The universal scalability law’s serialized share and pairwise reconciliation cost, $\text{Speedup}(\WorkerCount) = \WorkerCount/\big(1 + \ContentionCoefficient(\WorkerCount-1) + \CoherencyCoefficient\WorkerCount(\WorkerCount-1)\big)$. Subscripted, because bare $\Glyph{\kappa}$ is the confidentiality label.
$\AcceptedTaskMeanCost$	Mean cost of accepted tasks	dollars	Mean task-account cost of the accepted tasks in a settled cohort. With the mean cost of unaccepted tasks it partitions $\CostPerAcceptedTask$.
$\AdaptationInvestmentCost$	Adaptation investment cost	dollars	Incremental one-time cost of an intervention such as an adaptation, covering data curation, training compute, and offline evaluation. Numerator of the break-even task count $\BreakEvenTaskCount$.
$\HumanReviewCost$	Human review cost	dollars	Cost of the human review that an escalated action or a rejected attempt triggers, inspection and labor included. Latency must be converted to this common cost unit before addition.
$\MeanAttemptCost$	Mean attempt cost	dollars	Expected all-inclusive monetary cost of one attempt at a task, the same for every attempt under the independent-trials model. Equals the expectation of $\AttemptCost$ when attempts are identical; the planning ratio divides it by $\AttemptPassProbability$.
$\CriticalPathDuration$	Critical-path duration	Seconds	Duration of the longest source-to-sink path through a dependency graph, summing the durations of the vertices on it. A lower bound on makespan however many workers run, since sequential dependencies cannot overlap.
$\DependencyGraphVertex$	Dependency-graph vertex	Vertex	One vertex of a task-precedence graph: a bounded unit of execution that occupies one worker slot. Numbered vertices name the nodes of a specific plan. Not a version or a velocity.
$\VertexSlotTime$	Vertex slot time	Seconds	Time one vertex of a task-precedence graph occupies a worker slot, including model inference and tool execution. Written with its vertex as argument.
$\UnacceptedTaskMeanCost$	Mean cost of unaccepted tasks	dollars	Mean task-account cost of the unaccepted tasks in a settled cohort: failures, cancellations, and timeouts. Pairs with $\AcceptedTaskMeanCost$.

Recovery, Verification, and Multi-Agent Coordination

Recovery, evaluation, and learning attach their own quantities to a trajectory: what a sample or a search buys, what a check establishes, what a stored entry may still support, what a retry may repeat, and which tokens a training objective selects. The tables below group these symbols by the stage of the lifecycle that introduces them.

Sampling, search, and verification

Test-time compute spends extra samples or search on one decision, and a verifier decides which result to keep. Two different events share the letter $\Glyph{p}$ in these chapters, so each has its own symbol, and each chapter states which one it means where it introduces it.

Symbol	Definition	Unit	Notes
$\PerStepErrorRate$	Per-step error rate	Probability	Probability that one unchecked turn is wrong, assumed independent across turns, so an unchecked horizon succeeds with $(1-\PerStepErrorRate)^{\TurnHorizon}$. Verifier error rates and the stale-support rate carry subscripts.
$\CandidatePoolSize$	Candidate pool size	Count	Candidates generated for one decision in best-of-$\CandidatePoolSize$ sampling, or the breadth of concurrent candidate streams. A search tree’s visit count $\Glyph{N}(\Glyph{s},\Glyph{a})$ is local to its derivation.
$\AttemptPassProbability$	Per-attempt pass probability	Probability	Probability that one independent attempt on a given task passes its check, so that $\text{pass@}\IndependentAttemptCount= 1-(1-\AttemptPassProbability)^\IndependentAttemptCount$ and a sequential retry costs about $\MeanAttemptCost/\AttemptPassProbability$ per success. A per-task quantity; the workload-level per-attempt rate is $\AcceptanceProbability$.
$\ValidCandidateRate$	Valid-candidate rate	Probability	Base rate $\Pr(\text{Valid})$ of candidates that meet the specification before any check; with $\VerifierFalseAcceptanceRate$ and $\VerifierFalseRejectionRate$ it sets verifier precision $\VerifierPrecision$. Same letter as $\AttemptPassProbability$, but a different event.
$\SearchDepth$	Search depth limit	Steps	Maximum depth a tree search expands; the depth index is $\Glyph{d}$. Not $\Glyph{D}$, which is dataset size.
pass@$\Glyph{k}$	Pass at k	Probability	At least one of $\IndependentAttemptCount$ runs of the same task passes the criterion, averaged over tasks. Candidate availability is distinct from selected acceptance.
pass$^{\Glyph{k}}$	Pass to the k	Probability	All $\IndependentAttemptCount$ runs of the same task pass, averaged over tasks. Under conditional independence this is $\mathbb E_i[\AttemptPassProbability_i^\IndependentAttemptCount]$, not $(\mathbb E_i[\AttemptPassProbability_i])^\IndependentAttemptCount$ for independent new tasks.
$\VerifierFalseAcceptanceRate$, $\VerifierFalseRejectionRate$	Verifier false-acceptance, false-rejection rates	Probability	$\VerifierFalseAcceptanceRate = \Pr(\text{PASS}\mid\neg\text{Valid})$ and $\VerifierFalseRejectionRate = \Pr(\neg\text{PASS}\mid\text{Valid})$. Subscripted to stay distinct from the per-step error rate $\PerStepErrorRate$ of horizon compounding.
$\CandidateUtility$	Candidate utility	Scalar	Genuine task utility, the true quality, of one candidate, which a scorer estimates with error. Indexed by candidate. Not the unlabeled pool or resource utilization that share the letter elsewhere.
$\ChildPruningProbability$	Child pruning probability	Probability	Probability that an intermediate check prunes one proposed child of a search node, independently of its siblings. Not the weight-pruning threshold of compression.
$\GeneratedSampleCount$	Generated sample count	Integer	Number of candidates generated for one task when estimating pass@$\IndependentAttemptCount$, from which subsets of $\IndependentAttemptCount$ runs are drawn. Must be at least $\IndependentAttemptCount$.
$\IndependentAttemptCount$	Independent attempt count	Integer	Number of independent attempts or runs at one task, such as the attempts a retry budget allows or the runs that pass@$\IndependentAttemptCount$ and pass$^{\IndependentAttemptCount}$ score. At least one of them is accepted with probability $1-(1-\AcceptanceProbability)^{\IndependentAttemptCount}$.
$\FusionInputRank$	Fusion input rank	Integer	One-based rank of a candidate within one retrieval method’s ranked list, as reciprocal rank fusion reads it. Indexed by method.
$\GroupContrastProbability$	Group contrast probability	Probability	Probability that a group of independent rollouts on one task contains at least one pass and at least one failure, so that its reward contrast is nonzero. Written with its arguments $\GroupSize$ and $\AttemptPassProbability$; rollouts per informative group are $\GroupSize$ divided by this probability.
$\FalseApprovalCount$	False approval count	Count	Number of reviewers in an ensemble that approve a candidate known to be invalid. Binomial under independent errors, beta-binomial under the shared-difficulty mixture.
$\FalseApprovalOutcomeCount$	False approval outcome count	Integer	A particular number of falsely approving reviewers, the value at which the false-approval count’s distribution is evaluated or summed. Ranges from zero to $\WorkerCount$; a majority exceeds half of $\WorkerCount$.
$\FalseApprovalPropensity$	False approval propensity	Probability	Probability, intrinsic to one candidate, that a randomly chosen reviewer falsely approves it, treated as a random variable over the candidate population. Under shared difficulty, reviewers are independent given the propensity but correlated across candidates.
$\MarginalFalseApprovalProbability$	Marginal false-approval probability	Probability	Probability that one model reviewer approves a candidate known to be invalid, averaged over the candidate population. The mean of $\FalseApprovalPropensity$ in the latent-propensity model. Compare $\VerifierFalseAcceptanceRate$, a single verifier’s false-acceptance rate.
$\ReviewerIndex$	Reviewer index	Index	Index of one reviewer in a review ensemble. The other reviewer of a pair is $\PeerReviewerIndex$.
$\PeerReviewerIndex$	Peer reviewer index	Index	Index of the other reviewer of a pair whose errors are compared with those of the reviewer $\ReviewerIndex$. Distinct from it in a pairwise covariance.
$\ReviewerFalseApprovalIndicator$	Reviewer false-approval indicator	0 or 1	Indicator that one reviewer approves a candidate known to violate its acceptance criterion: one when it falsely approves, zero otherwise. Indexed by reviewer; the false approval count $\FalseApprovalCount$ sums them.
$\PropensityPriorApprovalShape$	Propensity prior approval shape	Dimensionless	First shape parameter of the beta distribution assumed for the false-approval propensity $\FalseApprovalPropensity$, the pseudo-count weighting approval. Set from the marginal rate and the correlation.
$\PropensityPriorRejectionShape$	Propensity prior rejection shape	Dimensionless	Second shape parameter of the same beta distribution, the pseudo-count weighting correct rejection. Not a batch size.
$\PassAtKEstimate$	Pass-at-k estimate	Probability	Unbiased estimate of pass@$\IndependentAttemptCount$ for one task from a set of generated candidates: one minus the share of size-$\IndependentAttemptCount$ subsets with no passing candidate. The plug-in form is biased.
$\PassingSampleCount$	Passing sample count	Count	Number of the $\GeneratedSampleCount$ candidates generated for one task that pass the test criterion. At most $\GeneratedSampleCount$.
$\SearchBranchingFactor$	Search branching factor	Count	Number of candidate extensions each expanded node of a search tree proposes before any pruning. Not the survivors per node after pruning.
$\RankFusionSmoothingConstant$	Rank-fusion smoothing constant	Dimensionless	Positive constant that reciprocal rank fusion adds to each rank before taking the reciprocal, compressing score differences between adjacent ranks. The usual choice is 60.
$\SearchQueryEmbedding$	Search query embedding	Vector	Embedding of a search query, the full-precision vector a vector index compares with its stored vectors. Not the attention query.
$\StoredIndexVector$	Stored index vector	Vector	One vector stored in a vector index, scored against the search query embedding $\SearchQueryEmbedding$.
$\TrialPassProbability$	Trial pass probability	Probability	Probability that a fixed candidate passes one verification trial under a specified protocol. It varies run to run only through flakiness.
$\VerificationTrialCount$	Verification trial count	Integer	Number of verification trials an all-pass rule requires of one candidate, counting the first. Acceptance needs every one of them to pass.
$\VerifierPrecision$	Verifier precision	Probability	Probability that a candidate meets the specification given that the verifier passed it. Set by Bayes’ rule from the valid-candidate rate $\ValidCandidateRate$ and the verifier error rates $\VerifierFalseAcceptanceRate$ and $\VerifierFalseRejectionRate$. Not a product operator.
$\NucleusProbabilityMass$	Nucleus probability mass	Probability	Cumulative probability mass of the smallest high-probability token set that nucleus sampling draws from, between zero and one.
$\TopTokenSampleCount$	Top-token sample count	Count	Number of highest-probability tokens top-k sampling keeps as candidates at each decoding step. Not the number of attempts $\IndependentAttemptCount$.

Recovery, evaluation, and learning

These symbols recur across the memory, tool-use, runtime, evaluation, and learning chapters. They track source freshness, duplicate-effect probabilities, checkpoint intervals, statistical release gates, and masked training losses:

Symbol	Definition	Unit	Notes
$\MemoryEntryBirthGeneration(\DerivedMemoryEntry)$, $\MemoryEntryDeathGeneration(\DerivedMemoryEntry)$, $\QueryWorkspaceGeneration$	Validity interval of a memory entry	Generation index	Source generations between which a derived entry $\DerivedMemoryEntry$ stays supported; a query that requires generation $\QueryWorkspaceGeneration$ may use $\DerivedMemoryEntry$ only if $\MemoryEntryBirthGeneration(\DerivedMemoryEntry) \le \QueryWorkspaceGeneration < \MemoryEntryDeathGeneration(\DerivedMemoryEntry)$. Subscripted indices, distinct from the goal $\Glyph{g}$.
$\StaleSupportRate$	Stale-support rate	Fraction	Decisions that treat superseded support as current, divided by decisions that require current evidence. Source-version checks identify superseded support; the runtime must label or exclude it before a decision relies on it.
$\RequestLossProbability$, $\ReplyLossProbability$	Request- and reply-loss probabilities	Probability	Independent probabilities that a call’s request, or its reply, is lost in transit.
$\DuplicateEffectProbability$	Duplicate-effect probability	Probability	Chance that one blind retry of a non-idempotent call without deduplication applies its effect twice, $\DuplicateEffectProbability = (1-\RequestLossProbability)\,\ReplyLossProbability\,(1-\RequestLossProbability)$. Named probabilities use lowercase $\Glyph{p}$, as $\AcceptanceProbability$ does.
$\RepairCap$	Repair cap	Count	Configured bound on admitted forward-repair attempts in a declared scope; exhaustion withholds further repair and selects permitted recovery or handoff, not proof that repair is impossible.
$\CheckpointInterval$	Checkpoint Interval	Seconds	Useful-work interval chosen between durable checkpoints. Not $\Glyph{\tau}$, which is a trajectory.
$\OptimalCheckpointInterval$	Optimal checkpoint interval	Seconds	The interval $\CheckpointInterval$ that minimizes expected overhead, $\OptimalCheckpointInterval \approx \sqrt{2\,\CheckpointWriteTime\,\MeanTimeBetweenFailures}$ under Young’s approximation.
$\CheckpointWriteTime$	Checkpoint write time	Seconds	Pause to persist one checkpoint, during which useful work stops.
$\MeanTimeBetweenFailures$, $\TurnFailureRate$	Mean time between failures, failure rate	Seconds, failures/time	Mean useful time between failures that lose work, and its reciprocal $\TurnFailureRate= 1/\MeanTimeBetweenFailures$. A failure rate counted per turn or per step states that unit. An upright acronym, not the memory root $\Glyph{M}$.
$\ExpectedIrreversibleLoss$	Expected irreversible loss	Consequence units	$\ExpectedIrreversibleLoss= \sum_\PolicyAction\Pr(\text{bad}\ \PolicyAction)\cdot \text{consequence}(\PolicyAction)\cdot(1-\ActionRecoverableFraction)$, where $\ActionRecoverableFraction$ is the recoverable fraction of action $\PolicyAction$’s consequence. A check before a pivot raises $\ActionRecoverableFraction$; one after it does not.
$\TasksPerComparisonArm$	Tasks per comparison arm	Tasks	Sample size per arm for a two-proportion release comparison, $\TasksPerComparisonArm \approx 2(\SignificanceCriticalQuantile+\StatisticalPowerQuantile)^2\,\PooledAcceptanceProbability(1-\PooledAcceptanceProbability)/\TargetAcceptanceDifference^2$; the Type II error rate $\StatisticalFalseNegativeRate$ and the pooled acceptance rate $\PooledAcceptanceProbability$ are local to the formula.
$\StatisticalSignificanceLevel$	Significance level	Probability	Type I error target of a release test or a sequential test, and $1-\StatisticalSignificanceLevel$ the coverage of a confidence interval. Subscripted so that bare $\Glyph{\alpha}$ stays the acceptance fraction $\AcceptanceFraction$.
$\PositionLossMask_{t}$	Loss mask	Binary $\{0,1\}$	Selects eligible policy-response targets under the declared objective, with $\TokenIndex$ a token position. Supplied prompts, observations, initial context seeds, and unselected policy responses have $\PositionLossMask_{t}=0$.
$\MaskedFinetuningLoss$	Masked fine-tuning loss	Cross-entropy	Mean selected-token loss for one example: $-\frac{1}{\ActiveTargetTokenCount}\sum_t \PositionLossMask_{t}\log\Policy(\SequenceToken_t\mid \TokenPrefix)$, with $\ActiveTargetTokenCount=\sum_t \PositionLossMask_{t}>0$. Batch aggregation is specified separately.
$\TrajectoryReward(\Trajectory)$	Trajectory reward	Scalar	Reward a verifier assigns to a whole trajectory.
$\ActionRecoverableFraction$	Recoverable fraction of an action	Fraction	Fraction of an action’s consequence that compensation can restore if the action proves bad. Zero for an action past a pivot; a pre-pivot check gives the product of its catch rate and the fidelity of the revert. Not server utilization $\ServingUtilization$.
$\EvidenceRecordEvent$	Evidence record event	Event	Logged event that durably records evidence received about a dispatched operation, whose status may still be pending, partial, or unknown. Last event of the intent-before-effect ordering. Not the observation a model sees.
$\AdmissionDecisionEvent$	Admission decision event	Event	Event at which the runtime admits a proposed external effect, recording its authorization and budget-reservation decision. Second event of the write-ahead dispatch ordering, after the proposal and before the flush.
$\IntentAcknowledgmentEvent$	Intent acknowledgment event	Event	Event at which the log durably acknowledges an operation’s recoverable intent record, and the records before it, under the declared failure domain. The durability barrier: dispatch may follow only after it.
$\ExternalDispatchAction$	External dispatch action	Action	Dispatch of an admitted operation to an external endpoint, which is not its completion. Follows the acknowledgment event in the intent-before-effect ordering. Not the proposed or permitted action of the same turn.
$\LogPositionIndex$	Log position index	Integer	Position of one entry or boundary in a trajectory’s durable append-only log, counted from one. Distinct from the turn index $\TurnIndex$: one turn can append several log records.
$\CheckpointLogPosition$	Checkpoint log position	Integer	Authoritative log position to which a published checkpoint binds its record and workspace snapshots. A log position like $\LogPositionIndex$, not a turn index.
$\IntegrationHeadCommitHash$	Integration head commit hash	Hash	Content hash of the integration branch head captured for one integration attempt. A content hash names an immutable commit; the integration gate compares hashes, never mutable directory references.
$\BlockingCallTimeout$	Blocking call timeout	Seconds	Hard timeout after which a call blocked on an unresponsive dependency gives up the worker slot it occupies. With arrivals at $\ArrivalRate$, the product of the two is the number of slots held in steady state (Little’s law).
$\EvaluationTrialCount$	Evaluation trial count	Integer	Number of trials assigned to an evaluation cohort, including incomplete, timed-out, crashed, and budget-exhausted runs. Denominator of $\EstimatedAcceptanceProbability$.
$\EstimatedAcceptanceProbability$	Estimated acceptance probability	Probability	Sample estimate of a configuration’s acceptance probability from an evaluation, such as accepted trials over assigned trials or the task-averaged share of accepted runs. With one run per task it is the observed acceptance share around which Wald and Wilson intervals are built.
$\IntervalNormalQuantile$	Interval normal quantile	Dimensionless	Positive standard-normal quantile that sets the width of a two-sided confidence interval at its stated nominal confidence, written bare inside interval formulas. About 1.96 for a nominal 95% interval, a quantile at one minus half of $\StatisticalSignificanceLevel$.
$\HypothesizedAcceptanceProbability$	Hypothesized acceptance probability	Probability	Acceptance probability a sequential probability ratio test specifies under one of its two simple hypotheses, indexed zero for the baseline and one for the degraded alternative; the degraded value is the smaller, and both are design inputs. Not $\AttemptPassProbability$, the per-attempt pass probability.
$\ObservedLabelCount$	Observed label count	Integer	Number of task labels a sequential test has observed so far. Indexes the running statistics $\CumulativeLogLikelihoodRatio$ and $\AcceptedLabelCount$.
$\AcceptedLabelCount$	Accepted label count	Integer	Number of accepted labels among the observations a sequential test has collected so far, indexed by the observation count. The running sum of the accepted indicators; it enters the log-likelihood ratio.
$\CumulativeLogLikelihoodRatio$	Cumulative log-likelihood ratio	Dimensionless	Cumulative log-likelihood ratio of the specified degradation against the baseline after the labels observed so far in a sequential test. Indexed by label count, or by the stopping count.
$\EventIndicator$	Event indicator	0 or 1	Indicator of an event: one when the braced condition holds and zero otherwise, written with the condition in braces. Same meaning as the blackboard-bold indicator $\Glyph{\mathbb{I}}$, kept in bold-one rendering for this book. Not the all-ones vector.
$\AllRunsPassEstimate$	All-runs-pass estimate	Probability	Unbiased estimate, for one task, of the probability that all of a claimed number of runs pass: the share of subsets of the graded runs in which every run passed. Carries task and claim-size indices; averaged over tasks it estimates the all-runs-pass probability.
$\ConcordantTaskCount$	Concordant task count	Integer	Number of sampled tasks on which the baseline and candidate configurations receive the same verdict in a paired comparison. Always written with a two-digit index giving the baseline outcome then the candidate outcome: 11 accepted by both, 00 by neither. The discordant cells are $\BaselineOnlyAcceptedTaskCount$ and $\CandidateOnlyAcceptedTaskCount$.
$\BaselineOnlyAcceptedTaskCount$	Baseline-only accepted tasks	Integer	Number of tasks in a paired comparison that the baseline accepts and the candidate does not, one of the two discordant counts. With $\CandidateOnlyAcceptedTaskCount$ it forms the discordant pairs of McNemar’s test and the paired difference.
$\CandidateOnlyAcceptedTaskCount$	Candidate-only accepted tasks	Integer	Number of tasks in a paired comparison that the candidate accepts and the baseline does not, the other discordant count. Not a queue server count or a speed of light.
$\BaselineAcceptanceEstimate$	Baseline acceptance estimate	Probability	Observed acceptance share of the baseline configuration over the tasks of a paired comparison: its accepted count divided by the task count. Pairs with $\CandidateAcceptanceEstimate$.
$\CandidateAcceptanceEstimate$	Candidate acceptance estimate	Probability	Observed acceptance share of the candidate configuration over the tasks of a paired comparison: its accepted count divided by the task count. With $\BaselineAcceptanceEstimate$ it gives the paired difference $\EstimatedPairedAcceptanceDifference$.
$\EstimatedPairedAcceptanceDifference$	Estimated paired acceptance difference	Dimensionless	Observed difference between the candidate’s and the baseline’s acceptance shares on the same sampled tasks: the discordant-count difference divided by the task count. The paired interval is built around it.
$\PairedDifferenceLowerLimit$	Paired difference lower limit	Dimensionless	Lower endpoint of a confidence interval for the paired acceptance difference between a candidate and its baseline. The noninferiority gate checks it against the negated tolerance. Computed by Newcombe’s paired-score method in the mathematical appendix.
$\PairedDifferenceUpperLimit$	Paired difference upper limit	Dimensionless	Upper endpoint of a confidence interval for the paired acceptance difference between a candidate and its baseline. Pairs with $\PairedDifferenceLowerLimit$; the mathematical appendix gives its Newcombe formula.
$\ReferenceAssessedFailure$	Reference-assessed failure	Event	Event that a trial fails its specified criterion according to an independent reference assessment, the conditioning event of a grader’s false-acceptance rate.
$\PairedOutcomeCellCount$	Paired outcome cell count	Integer	Number of paired tasks in one cell of the baseline-by-candidate outcome table, indexed by the baseline outcome then the candidate outcome (one for accepted, zero for rejected). The off-diagonal cells have their own rows, $\BaselineOnlyAcceptedTaskCount$ and $\CandidateOnlyAcceptedTaskCount$.
$\StreamAcceptanceProbability$	Stream acceptance probability	Probability	Stationary probability that one monitored task is accepted, the Bernoulli parameter a sequential release test compares at two hypothesized values. The same quantity as $\AcceptanceProbability$, written bare as the release chapter does.
$\TaskAcceptanceLabel$	Task acceptance label	0 or 1	Binary label recording whether one monitored task was accepted, one for acceptance. Indexed by arrival order; the sequential test sums them.
$\SprtExpectedLogIncrement$	SPRT expected log increment	Nats	Expected increment of a sequential probability ratio test’s log-likelihood ratio per labeled observation, under the hypothesis its index names. Divides the boundary average in the expected stopping count.
$\SprtLowerLogBoundary$	SPRT lower log boundary	Nats	Lower stopping boundary on the log-likelihood ratio, at or below which the test selects the baseline hypothesis. Negative.
$\SprtUpperLogBoundary$	SPRT upper log boundary	Nats	Upper stopping boundary on the log-likelihood ratio, at or above which the test selects the degraded hypothesis. Positive.
$\SprtStoppingSampleCount$	SPRT stopping sample count	Integer	Random number of labeled observations a sequential probability ratio test takes before its statistic first crosses a boundary, without truncation.
$\StatisticalFalseNegativeRate$	Statistical false-negative rate	Probability	Allowed probability of a type II error, a release comparison missing a true difference of the target size. One minus it is the statistical power. Pairs with $\StatisticalSignificanceLevel$.
$\SignificanceCriticalQuantile$	Significance critical quantile	Dimensionless	Standard-normal quantile at one minus half the significance level $\StatisticalSignificanceLevel$, the two-sided critical value of a release test. About 1.96 at a level of 0.05.
$\StatisticalPowerQuantile$	Statistical power quantile	Dimensionless	Standard-normal quantile at the target statistical power of a release test, one minus the type II error rate $\StatisticalFalseNegativeRate$. About 0.84 at 80% power.
$\TargetAcceptanceDifference$	Target acceptance difference	Dimensionless	Difference in acceptance probability between two system versions that a release comparison is planned to detect. It appears squared in the denominator of $\TasksPerComparisonArm$, so halving it quadruples the tasks per arm.
$\PooledAcceptanceProbability$	Pooled acceptance probability	Probability	Average of the acceptance probabilities of the two system versions a comparison tests, used as the pooled variance estimate in planning. It pools planned probabilities, not observed shares.
$\ToolTargetState$	Tool target state	Record	State of the external system or resource a tool operation reads or mutates, such as a remote file or service record. The baseline captured just before dispatch is what a reconciliation probe compares against. Not the trajectory state $\TrajectoryState_{t}$.
$\PlanAction$	Plan action	Record	One action of an execution plan, the summation variable when the expected irreversible loss $\ExpectedIrreversibleLoss$ sums over the plan. Not the per-turn proposal $\TrajectoryAction_{t}$.
$\ValidatedProposalEvent$	Validated proposal event	Event	Event at which the runtime holds a validated, complete proposal for an external effect, first in the write-ahead dispatch ordering: intent before effect. Distinct from the proposed action itself.
$\WorkerBaseCommitHash$	Worker base commit hash	Hash	Content hash of the commit a worker started from. A content hash names an immutable commit; the integration gate compares hashes, never mutable directory references.
$\ConfidenceCriticalQuantile$	Confidence critical quantile	Dimensionless	Positive standard-Normal critical value for a two-sided test at the chosen confidence level, about 1.96 at 95% confidence.
$\PowerCriticalQuantile$	Power critical quantile	Dimensionless	Positive standard-Normal critical value corresponding to the chosen statistical power of a test, about 0.84 at 80% power.
$\HypothesisTestFalseNegativeRate$	Test false-negative rate	Probability	Probability that a hypothesis test misses a true effect; one minus it is the statistical power. Not the link bandwidth, which shares the glyph $\Glyph{\beta}$.
$\EvaluationSampleCount$	Evaluation sample count	Count	Number of examples in the evaluation set over which an accuracy or calibration metric is computed. It sets the sampling error of an accuracy estimate. Not the training-set size $\DatasetSize$.
$\SequentialTestObservation$	Sequential-test observation	Record	One observation a sequential test collects, indexed in arrival order, so the observations run from the first to the latest.
$\CorrelationCoefficient$	Correlation coefficient	Dimensionless	Pearson correlation coefficient between two random quantities, between minus one and one. Shares the glyph $\Glyph{\rho}$ with the communication-to-compute ratio and the serving utilization.
$\GaussianDistribution$	Gaussian distribution	Distribution	Gaussian (normal) distribution with the mean and covariance given as its arguments, written $\GaussianDistribution(\Glyph{\mu}, \Glyph{\Sigma})$.
$\IndicatorFunction$	Indicator function	Function	Function equal to one when its condition holds and zero otherwise.
$\FiniteChange$	Finite change	Operator	Prefix operator for the finite change in the quantity it prefixes, between two states, configurations, or points in time. Differs from a $\Glyph{\Delta}$ fused into a named entry.
$\StateOperation$	State operation	Function	Operation that maps a system’s stored state to a new state, such as one pipeline write. Idempotent when applying it twice gives the same result as applying it once.

Learning chapters (local)

The imitation and reinforcement-learning chapters, and the derivations in the mathematical appendix that support them, keep the standard notation of their literatures. The symbols below are local to those pages, each declared at first use; outside them, the meanings in the tables above apply.

Symbol	Definition	Unit	Notes
$\StateDistribution$	State distribution	Distribution	Average distribution of states a policy visits over the horizon; $\StateDistribution^t$ is the distribution before step $\TurnIndex$.
$\EstimatedRemainingReturn(\InteractionHistory_k)$	Estimated value	Scalar	Estimated expected remaining return under a specified continuation policy and conditioning history $\InteractionHistory_k$ at turn $\RolloutTurnIndex$. It is a success probability only for a binary terminal reward without discounting.
$\ContinuationCount$	Continuation count	Count	Independent continuations sampled from one fork condition in the reinforcement-learning chapter. Elsewhere $\Glyph{K}$ is output length.
$\GroupSize$	Group size	Count	Rollouts sampled per task for group-relative scoring. Elsewhere $\Glyph{G}$ is the task-contract goal $\TaskContractGoal$.
$\TokenIndex$	Token index	Integer	Position of a sampled policy token within a rollout in the reinforcement-learning chapter, where turns are indexed by $\RolloutTurnIndex$. Elsewhere $\Glyph{t}$ is the turn index, except in a per-token loss.
$\TraceDecay$	Trace decay	Scalar	The generalized advantage estimator’s decay factor, $\TraceDecay\in [0,1]$. Elsewhere a rate carries a subscript, as $\ArrivalRate$ and $\TurnFailureRate$ do.
$\DecisionStepIndex$	Decision step index	Integer	Position of one decision step in a finite-horizon episode, counted from zero to one less than the horizon. Indexes the interaction history, action, and reward of the learning chapters; the trajectory chapters count turns with $\TurnIndex$.
$\DecisionProcessState$	Decision-process state	Record	Complete environment state of a decision process, including interaction history and variables the agent cannot observe. The unindexed form of $\Glyph{s_t}$; a policy is viewed as a map from these states to actions. A record, not a number.
$\EnvironmentTransitionDistribution$	Environment transition distribution	Distribution	Distribution the environment induces over the next state given the current state and the action taken. Unmasked observations would ask the policy’s weights to fit it. Not the next-token distribution, which shares the glyph.
$\DeviationDisadvantage$	Deviation disadvantage	Scalar	Largest extra expected cost of one deviation from the reference action followed by reference recovery, at any learner-reachable state. An assumption about the task, in normalized cost units; the learner-state bound is linear in the horizon only while it stays independent of the horizon.
$\DiscountFactor$	Discount factor	Dimensionless	Factor by which a reward arriving one turn later is weighted in the return, between zero and one. One means undiscounted, the setting of the reinforcement-learning chapter. Not an adapter scaling factor or an accuracy decay rate, which share the glyph.
$\PolicyHistoryActionReturn$	History-action return	Scalar	Expected remaining return under a policy after taking a given action at a given interaction history and then following the policy. Written with the policy superscript. Same meaning as $\Glyph{Q_t^{\pi}}$, whose LaTeX fixes the index to the turn.
$\PolicyRemainingReturn$	Expected remaining return	Scalar	Expected remaining return under a policy from a given interaction history at a decision step. Written with the policy superscript. Its estimate is $\EstimatedRemainingReturn$.
$\ExpectedTaskCostSum$	Expected task cost sum	Scalar	Expected sum over the horizon of the normalized immediate task costs a policy incurs. Written with its policy; the imitation bounds compare the learner’s sum with the reference policy’s. Not monetary.
$\PolicyHistoryAdvantage$	History advantage	Scalar	Expected return of taking a given action at a given interaction history, minus the policy’s expected return at that history. Written with the policy superscript. The true quantity that $\Glyph{\hat{A}}$ estimates. Not an authority level.
$\ImmediateTaskCostScore$	Immediate task cost score	Scalar	Normalized cost, between zero and one, of taking one action in one state of a delegated task, in the imitation-learning bounds. Not monetary: dollar costs are $\TaskCost$ and $\AttemptCost$. Its sum over the horizon is $\ExpectedTaskCostSum$.
$\LearnerStateDisagreementRate$	Learner-state disagreement rate	Probability	Probability that a learned policy’s action differs from the reference policy’s, averaged over the states the learner itself visits. Enters the linear imitation bound together with the horizon and $\DeviationDisadvantage$.
$\RolloutTurnIndex$	Rollout turn index	Integer	Position of an agent-environment turn within a reinforcement-learning rollout, counted from zero. This chapter uses it because $\Glyph{t}$ is the token index $\TokenIndex$; elsewhere the turn index is $\TurnIndex$.
$\TurnReward$	Turn reward	Scalar	Reward a rollout receives immediately after the action at one turn. Zero at every intermediate turn when only a terminal check scores the rollout; the sum over turns is the trajectory reward $\TrajectoryReward$.
$\RemainingReturn$	Remaining return	Scalar	Sum of the rewards a rollout receives from one turn to the end of its horizon, the reward-to-go. The turn index is part of the symbol. With discounting each later reward is weighted by $\DiscountFactor$.
$\TemporalDifferenceResidual$	Temporal-difference residual	Scalar	Sampled one-step residual: the turn reward plus the next history’s value minus the current history’s value. Its conditional expectation is the advantage when the value function is exact.
$\PolicyGradientBaseline$	Policy-gradient baseline	Scalar	Offset subtracted from the return in a policy-gradient estimator, a function of the interaction history that does not depend on the sampled action. Subtracting it leaves the gradient unbiased.
$\PolicyGradientEstimate$	Policy-gradient estimate	Vector	Likelihood-ratio estimate of the gradient of a policy’s expected reward with respect to its parameters $\ModelParameters$, computed from one sampled trajectory.
$\RatioClippingWidth$	Ratio clipping width	Dimensionless	Half-width of the interval around one to which the clipped surrogate limits the probability ratio. Between zero and one.
$\ReferenceDisagreementProbability$	Reference disagreement probability	Probability	Probability that a policy’s action in a given state differs from the reference policy’s action there. A disagreement proxy, neither the task cost nor the token-level loss $\LossFunction$.
$\ReferenceStateDistribution$	Reference state distribution	Distribution	Average distribution of states the reference policy visits over the horizon. The reference-policy counterpart of $\StateDistribution$.
$\ReferenceStateDisagreementRate$	Reference-state disagreement rate	Probability	Probability that a learned policy’s action differs from the reference policy’s, averaged over the states the reference visits. Not the per-step error rate $\PerStepErrorRate$.
$\ReferenceCostToGo$	Reference cost-to-go	Scalar	Expected task cost from a step through the end of the horizon after taking an action in a state and then following the reference policy. The reference-policy case of $\Glyph{Q_t^{\pi}}$.
$\AdapterRank$	Adapter rank	Count	Rank of a low-rank adapter update, equivalently the bottleneck width of a residual adapter, which sets its trainable parameter count.
$\AdapterScalingFactor$	Adapter scaling factor	Dimensionless	Fixed factor a low-rank adapter’s output is multiplied by, divided by the adapter rank $\AdapterRank$.
$\AdapterDownProjectionMatrix$	Adapter down-projection matrix	Matrix	First low-rank adapter matrix, which projects a layer’s input down to the adapter rank $\AdapterRank$. The low-rank update is the product of the down- and up-projection matrices.
$\PolicyObservedState$	State a policy observes	Record	State or observation a policy conditions its choice of action on, the conditioning argument of $\Policy$ in $\Glyph{\pi_\theta(a \mid s)}$. In agentic rollouts the interaction history $\InteractionHistory$ plays this role.
$\PolicyAction$	Policy action	Record	Action a policy chooses given the state it observes, the argument of $\Policy$ in $\Glyph{\pi_\theta(a \mid s)}$. Agentic rollouts use $\RolloutAction$. A record, not a number.
$\InteractionHistory$	Interaction history	Record	Transcript of delivered prompts, emitted actions, and observations up to a turn of a rollout, the history a policy conditions on. Indexed by turn, so $\InteractionHistory_0$ is the initial task prompt. Plays the role of the state in the learning chapters.
$\RolloutAction$	Rollout action	Record	Response the policy samples at one turn of a reinforcement-learning rollout, a proposed tool call or a final answer. Indexed by turn. Same idea as $\TrajectoryAction_{t}$ with the index built in. A record, not a number.
$\Reward$	Reward	Dimensionless	Per-step reward an engineer writes for policy search; the stage cost of control is its negative. A reward received at one turn is $\TurnReward$. Not the barrier relative degree of control, which shares the glyph $\Glyph{r}$.
$\KlDivergence$	KL divergence	Function	Kullback-Leibler divergence, the expected extra code length from encoding one distribution with a code built for another. Asymmetric: swapping its two arguments changes the value. Distillation uses teacher to student.
$\AdapterUpProjectionMatrix$	Adapter up-projection matrix	Matrix	Second low-rank adapter matrix, which projects the rank-sized intermediate up to the layer’s output width. Pairs with $\AdapterDownProjectionMatrix$; the low-rank update is their product. Written with an adapter index in multi-adapter serving. Not the right operand of a matrix multiply, which shares the glyph $\Glyph{\mathbf{B}}$.

Deep Learning Foundations in Agentic Systems

Foundation model components in compound agent systems adhere to standard deep learning conventions (Goodfellow et al. 2016). These core dimensions and parameter counts set the compute and memory floors of every model call:

Goodfellow, Ian, Yoshua Bengio, and Aaron Courville. 2016. Deep Learning. MIT Press.

Symbol	Definition	Unit	Notes
$\AttentionHeadDimension$	Attention Head Dimension	Integer	Per-head hidden dimension in attention layers.
$\LayerInputWidth$	Layer Input Width	Integer	Input feature count of a single layer, as in a weight matrix $\WeightMatrix\in \mathbb{R}^{\LayerOutputWidth \times \LayerInputWidth}$.
$\LayerOutputWidth$	Layer Output Width	Integer	Output feature count of a single layer.
$\LayerIndex$	Layer Index	Integer	Index $\ell$ for a neural network layer.
$\ModelParameters$	Model Parameters	Vector	Trainable model parameter vector or weights $\ModelParameters$.
$\WeightMemory$	Weight Memory	bytes	Memory occupied by model weights ($\Parameters\times \text{bytes-per-parameter}$); the core’s quantity.
$\LossFunction$	Loss Function	Scalar	The objective function minimized during training.
$\AttentionHeadCount, \KvHeadCount$	Number of Attention Heads	Integer	Number of attention heads $\AttentionHeadCount$ and key-value heads $\KvHeadCount$ (in GQA/MQA).
$\LayerCount$	Number of Layers	Integer	Total number of layers in a network.
$\WeightMatrix$	Weight matrix	Matrix	Matrix of learned weights one layer multiplies its input by, or the kernel tensor of a convolution layer. A subscript names the layer. Maps $\LayerInputWidth$ features to $\LayerOutputWidth$ features.
$\HiddenDimension$	Hidden dimension	Integer	Width of a model’s hidden representation, the transformer model width or a recurrent network’s hidden-state size. In standard multi-head attention it equals the head count $\AttentionHeadCount$ times the head dimension $\AttentionHeadDimension$.
$\QueryVector$	Query vector	Vector	Query vector of one token, one row of the query matrix. Indexed by token.
$\KeyVector$	Key vector	Vector	Key vector of one token, one row of the key matrix. Indexed by token.
$\DatasetSize$	Dataset size	Count	Number of training examples or tokens in a dataset. Not the evaluation sample count $\EvaluationSampleCount$.

Latin matrices and vectors are set in bold ($\Glyph{\mathbf{W}}$, $\Glyph{\mathbf{x}}$); scalars, dimensions, indices, and individual matrix entries stay italic ($\Glyph{N}$, $\Glyph{d}$, $\Glyph{i}$, $\Glyph{W}_{ij}$). The generic parameter symbol $\Glyph{\theta}$ is the conventional exception and stays italic. Matrix operands in general matrix multiply (GEMM) are bold ($\Glyph{\mathbf{C}}= \Glyph{\alpha}\Glyph{\mathbf{A}}\Glyph{\mathbf{B}}+ \Glyph{\beta}\Glyph{\mathbf{C}}$), distinct from the scalar batch size $\BatchSize$. GEMM dimensions are $\Glyph{M}$, $\Glyph{N}$, and $\Glyph{K}$. Asymptotic complexity is written $\mathcal{O}(\cdot)$.

Serving Infrastructure and Performance Metrics

Reusable performance and serving quantities keep a subscript or an upright name wherever a bare letter would collide with a machine learning symbol. The table below lists the hardware, queueing, and memory-pool symbols used in the serving and capacity derivations:

Symbol	Definition	Unit	Notes
$\Time$	Execution Time	seconds	Elapsed or execution time, the core’s quantity; $\MeanHoldTime$ is a mean residence time in Little’s law.
$\Bandwidth$	Bandwidth	bytes/s	Avoids collision with $\BatchSize$ (Batch Size). Systems literature often uses $\Glyph{B}$ for bandwidth, while ML literature often uses $\Glyph{B}$ for batch size. The notation preserves the ML convention.
$\DataVolume$	Data Volume	bytes	Bytes moved or held, here a bounded payload per record. The subscript keeps bare $\Glyph{D}$ for dataset size.
$\PeakRate$	Peak Rate	FLOP/s	Avoids collision with $\Parameters$ (Parameters). Roofline presentations often use $\Glyph{P}$ for performance, while ML literature commonly uses $\Glyph{P}$ for parameter count. The notation preserves the ML convention.
$\Operations$	Operations	FLOPs	Arithmetic operations one model call performs, the numerator of the iron law’s compute term.
$\EfficiencyHw$	Efficiency	—	Fraction of $\PeakRate$ a call sustains $(0 \le \EfficiencyHw \le 1)$. The subscript keeps bare $\Glyph{\eta}$ free for a learning rate.
$\Latency$	Latency	seconds	Fixed per-call overhead in the iron law, such as kernel launch or a network round trip. The subscript keeps bare $\Glyph{L}$ free for loss.
$\AttainableComputeRate$	Attainable Compute Rate	FLOP/s	Roofline bound: $\AttainableComputeRate \leq \min(\PeakRate, \Glyph{I}\times \Bandwidth)$. Uses $\Glyph{R}$, not $\Glyph{T}$, because this quantity is a rate.
$\RooflineRidgePoint$	Roofline Ridge Point	FLOP/byte	$\RooflineRidgePoint = \PeakRate/\Bandwidth$. Prefer this explicit form over starred shorthand so the meaning remains clear in prose.
$\ElementStorageSize$	Element Storage Size	bytes/element	Bytes per stored tensor element.
$\AcceleratorCount$	Accelerator Count	Integer	Number of accelerators in one job, such as the generation fleet of a trajectory pipeline.
$\ArrivalRate$	Arrival Rate	requests/s	Request arrival rate. The subscript keeps bare $\Glyph{\lambda}$ free for the learning chapters’ trace decay.
$\RequestConcurrency$	Request Concurrency	requests	Average in-flight requests in a stable serving system ($\RequestConcurrency = \ArrivalRate \cdot \RequestTimeInSystem$ via Little’s Law). Avoids overloading $\Glyph{N}$, which counts candidates, tasks, or samples elsewhere.
$\RequestTimeInSystem$	Request Time in System	seconds	End-to-end queueing and serving time of one request in Little’s Law, from arrival to completion.
$\ServingUtilization$	Serving Utilization	Dimensionless	Queue/server utilization. The subscript keeps bare $\Glyph{\rho}$ free for other ratio models.
$\KvPoolMemory$	KV pool memory	Bytes	Accelerator memory of a serving node left for KV cache after model weights and the runtime reserve are allocated: node HBM capacity minus $\WeightMemory$ minus the reserve. Not the sandbox memory pool of the sandboxes chapter.
$\NodeHbmCapacity$	Node HBM capacity	Bytes	Total high-bandwidth memory across all accelerators of one serving node. Aggregate over the node, unlike the memory capacity of a single device.
$\HostLinkBandwidth$	Host link bandwidth	Bytes/s	Aggregate bandwidth, in one direction, of the host links that move KV state between a serving node’s accelerator memory and host memory: the sum over accelerator-to-host (PCIe) links operating concurrently. Shares its glyph with a single network link.
$\FeasibleOutputTokenRate$	Feasible output token rate	Tokens/s	Output tokens per second a dedicated deployment can generate while meeting its latency objective. A token rate, distinct from the per-worker call rate $\ServiceRate$.
$\MeanHoldTime$	Mean hold time	Seconds	Mean time one item holds a resource, such as a turn holding its KV cache slot: the residence term of Little’s law. The sandbox-lease form is $\LeaseHoldTime$.
$\ActiveLeaseCount$	Active lease count	Count	Mean number of sandbox leases held at once, by Little’s law: the product of $\ArrivalRate$ and $\LeaseHoldTime$. Same glyph as $\ActiveTargetTokenCount$ in fine-tuning, a different meaning.
$\InterarrivalVariationCoefficient$	Interarrival variation coefficient	Dimensionless	Coefficient of variation of the interarrival times of a renewal arrival stream: their standard deviation divided by their mean. Enters the Kingman approximation squared.
$\RequestQueueTime$	Request queue time	Seconds	Time a request, such as a model call or a queued job, waits before its service begins. The realized wait of one request; for a model call it is the wait in the serving admission queue before prefill.
$\RequestServiceTime$	Request service time	Seconds	Time a server spends serving one request once its service begins, excluding the wait in queue. Pairs with $\RequestQueueTime$.
$\QueueServiceVariationCoefficient$	Service variation coefficient	Dimensionless	Coefficient of variation of a queue’s service times, their standard deviation over their mean. The counterpart of $\InterarrivalVariationCoefficient$ in the Kingman approximation.
$\TimeInstant$	Time instant	Seconds	A point in continuous wall-clock time, the variable over which time-varying quantities are integrated. Not the turn index $\TurnIndex$ or the token index $\TokenIndex$, which share the glyph.
$\ObservationIntervalLength$	Observation interval length	Seconds	Length of the observation interval over which arrivals, completions, and in-system requests are counted, starting at time zero. Used in the operational proof of Little’s law, which follows as it grows without bound. Distinct from $\Time$, the time to complete a unit of work.
$\ServiceTimeVariationCoefficient$	Service-time variation coefficient	Dimensionless	Coefficient of variation of service time, its standard deviation divided by its mean; one for exponential service times. Enters the Pollaczek-Khinchine mean wait through the factor one plus its square, over two.

Units, Precision, and Disambiguation

Consistent units, numerical precisions, and symbol conventions keep calculations comparable across chapters. The rules below fix the physical prefixes, numerical formats, and collision-resolution conventions used throughout the book.

Units and precision

Physical units: This book uses SI (metric) units throughout, including meters, kilograms, seconds, watts, and °C, consistent with standard engineering and scientific practice. Where source data was originally reported in imperial units, the book converts to SI and notes the original values parenthetically. A space always separates the number from the unit (for example, 100 ms, 2 TB/s).
Data and memory: This book uses decimal SI prefixes only: KB = $10^3$ bytes, MB = $10^6$, GB = $10^9$, TB = $10^{12}$. Binary-prefixed units do not appear in prose; model sizes, activation footprints, throughputs, and transfer volumes are reported in decimal units (for example, 2 TB/s, 102 MB). Hardware memory capacities retain the vendor’s nameplate figure and label. A modeled accelerator labeled 80 GB may assume $80 \times 2^{30}$ bytes; this byte capacity is a device assumption, not a universal interpretation of vendor labels. When comparing capacity with decimal footprints, express the assumed byte capacity in decimal GB.
Compute: The notation distinguishes operation counts from rates. Total work uses FLOPs (for example, GFLOPs, TFLOPs), while throughput uses FLOP/s with decimal prefixes (for example, GFLOP/s, TFLOP/s).
- 1 TFLOP = $10^{12}$ FLOPs
- 1 TFLOP/s = $10^{12}$ FLOPs per second
- Arithmetic intensity conventionally uses FLOP/byte as a unit ratio (floating-point operations per byte moved). This is a ratio unit, not a total-work symbol or throughput symbol.
Power: Power carries a subscript ($\Glyph{P_{\text{avg}}}$, $\Glyph{P_{\text{device}}}$, $\Glyph{P_{\text{cluster}}}$); bare $\Glyph{P}$ remains parameter count.
Latency percentiles: Written p50, p95, and p99 in upright type, inside math as well as in prose.
Currency: Dollar amounts use the dollar sign ($); unless otherwise noted, dollar-denominated costs are U.S. dollars (USD).
Precision:
- FP64: Double precision (8 bytes)
- FP32: Single precision (4 bytes)
- TF32: TensorFloat-32 (19-bit Tensor Core compute mode; inputs and storage remain FP32)
- FP16: Half precision (2 bytes, standard range)
- BF16: Brain float (2 bytes, wide dynamic range)
- FP8: Quarter precision (1 byte, E4M3 or E5M2 format)
- FP4: 4-bit floating-point format
- INT8: 8-bit integer (1 byte)
- INT4: 4-bit integer; lower integer precisions follow the same uppercase INTn pattern (for example, INT3, INT2)

Additional units in agentic systems

Tokens count what a call reads and writes, and serving throughput is reported in tokens per second.
Turns count the steps of a trajectory, and the horizon $\TurnHorizon$ is measured in turns.
Dollars per accepted task normalize spend by the results that passed acceptance, not by attempts or requests.
Trajectory goodput ($\TrajectoryGoodput$) is reported as accepted tasks per unit of elapsed time; goodput per dollar uses total included cost as its denominator.
Byte-seconds measure memory held over time, such as attention state kept resident during a tool wait.

Quick reference: Resolving collisions

Common collision points in ML Systems literature arise when a single letter is standard in both machine learning and computer systems. As a general principle, machine learning conventions take precedence for single letters, while systems concepts receive subscripts or multi-letter symbols:

Symbol	ML Meaning	Systems Meaning	Book Convention
$\BatchSize$	Batch Size	Bandwidth	Batch Size. Use $\Bandwidth$ for bandwidth.
$\Glyph{D}$	Dataset Size	Data Volume	Dataset Size. Use $\DataVolume$ for bytes moved and $\SearchDepth$ for a search depth limit.
$\Parameters$	Parameters	Peak FLOP/s	Parameters. Use $\PeakRate$ for peak rate.

The agentic conventions in the next table follow the same precedence rule. Every recurring symbol keeps a single meaning across the volume, and local symbols are declared explicitly where they appear.

Resolving agentic collisions

Agentic systems borrow notation from machine learning, systems, and control, so several letters arrive with more than one meaning. The conventions below keep one meaning per symbol.

Symbol	Other common meanings	Convention in this book
$\Glyph{\tau}$	Temperature; a threshold; an interval	Bare $\Glyph{\tau}$ is a trajectory. A subscripted $\Glyph{\tau}$ is a scoped quantity named where it is used, such as the sampling temperature $\Glyph{\tau_{\text{temp}}}$. A time window is $\Glyph{T_{\text{win}}}$, and the checkpoint interval is $\CheckpointInterval$.
$\Glyph{H}$	Attention heads; hidden size	$\Glyph{H}$ is the horizon in turns. Heads use $\AttentionHeadCount$ and $\KvHeadCount$; hidden size uses $\Glyph{d}$.
$\Glyph{S}$	The State exposure	Bare $\Glyph{S}$ is sequence length. State is written only with a level, $\StateExposureLevel_0$ to $\StateExposureLevel_3$.
$\Glyph{A}$	Advantage; action sets	Authority is written only with a level, $\AuthorityExposureLevel_0$ to $\AuthorityExposureLevel_3$. Advantage is $\Glyph{\hat{A}}$; action sets are $\Glyph{\mathcal{A}_{\text{prop}}}$ and $\PermittedActions$.
$\Glyph{P}$	Prompt length; precision; a predicate; a count	$\Glyph{P}$ is parameter count, as in the shared table, and a subscripted $\Glyph{P}$ is a power. Prompt length is $\Glyph{S}$, a grant’s condition predicate is $\GrantCondition$, a worker count is $\WorkerCount$, and a named probability is a lowercase $\Glyph{p}$, as in $\DuplicateEffectProbability$.
$\Glyph{p}$	Any probability	Bare $\Glyph{p}$ is a probability named where it is used. The per-attempt pass probability $\AttemptPassProbability$ and the valid-candidate rate $\ValidCandidateRate$ are different events; a workload-level acceptance probability carries a subscript, as $\AcceptanceProbability$ does.
$\Glyph{N}$	Device count; a sample size	Bare $\Glyph{N}$ counts what the text names: a candidate pool $\CandidatePoolSize$, a cohort of initiated tasks $\InitiatedTasks$, or a local count. Counts that recur carry a subscript, as $\AcceptedTasks$ and $\WorkerCount$ do, and the break-even task volume is $\BreakEvenTaskCount$.
$\Glyph{B}$	A budget	$\Glyph{B}$ is batch size. The trajectory budget is bold $\TrajectoryBudget$, the reasoning budget is $\Glyph{B_{\text{reason}}}$, and a dollar budget is a $\CostCeiling$.
$\Glyph{C}$	A fourth taxonomy axis; a grant or commit	There is no $\Glyph{C}$ axis; closure evidence levels are named in words. Costs carry subscripts ($\TaskCost$, $\CostPerAcceptedTask$, $\CostCeiling$), and the task contract is $\TaskContract$. A capability grant is $\Glyph{\Gamma}$, and a commit is named by its content hash, as in $\Glyph{h_{\text{base}}}$.
$\Glyph{M}$	A worker or agent count	The $\Glyph{M}$ root is memory, always subscripted ($\KvCacheMemory$, $\Glyph{M_{\text{total}}}$). A worker or agent count is $\WorkerCount$.
$\Glyph{\lambda}$	Arrival rate; failure rate	Arrival rate is the shared $\ArrivalRate$, or $\TrajectoryAdmissionRate$ when counted in trajectories, and failure rate is $\TurnFailureRate$. Bare $\Glyph{\lambda}$ is the learning chapters’ trace decay or a local function defined where it is used.
$\Glyph{\mu}$	A mean; a friction coefficient	$\ServiceRate$ is the per-server service rate. A mean carries a subscript, as $\Glyph{\mu_R}$ does, or is a local statistical mean defined where it is used.
$\Glyph{\rho}$	Utilization; a recoverable fraction	Server utilization is the shared $\ServingUtilization$, and the recoverable fraction of an action is $\ActionRecoverableFraction$. Bare $\Glyph{\rho}$ is a local ratio, such as a correlation, defined where it is used.
$\Glyph{L}$	Little’s law occupancy; loss; latency	Little’s law is written in the shared form $\RequestConcurrency = \ArrivalRate\,\RequestTimeInSystem$ for requests, with service time $\RequestServiceTime$ and queue wait $\RequestQueueTime$; other held resources use $\ConcurrentTrajectories$-style occupancies. Loss is $\LossFunction$, and latency is a subscripted time such as $\CallLatency$.
$\Glyph{\mathcal{G}}$	The goal; a graph	$\Glyph{\mathcal{G}}$ is trajectory goodput. The goal is $\Glyph{g}$ in the loop and $\TaskContractGoal$ in the task contract; a graph is named by its vertex and edge sets, $(\Glyph{V}, \Glyph{E})$.
$\Glyph{\mathcal{E}}$	Evidence or event sets	$\Glyph{\mathcal{E}}$ is the environment, and $\TaskEnvironment$ its specification in the task contract. Accepted influences on an operation are $\AcceptedInfluences(\ProposedOperation)$.
$\Glyph{h}$	A commit hash	$\CoordinationOverhead(\WorkerCount)$ is the coordination overhead, always written with its argument, and $\Glyph{h}_k$ is the interaction history in the learning chapters. Commit content hashes carry text subscripts, as in $\Glyph{h_{\text{base}}}$ and $\Glyph{h_{\text{head}}}$.
$\Glyph{\epsilon}$	A small constant; a tolerance	$\PerStepErrorRate$ is the per-step error rate of horizon compounding. Other error rates carry subscripts ($\VerifierFalseAcceptanceRate$, $\StaleSupportRate$), and a stability constant or a stockout target is local.
$\pi$	Peak arithmetic rate	The policy is $\Policy$; a local derivation that writes a fixed policy as bare $\pi$ says so where it does. Peak arithmetic rate is $\PeakRate$ from the shared table.
$\Glyph{\alpha}$, $\Glyph{\beta}$	Test error rates; bandwidth; regularization weights	$\AcceptanceFraction$ is the acceptance fraction, and a significance level is $\StatisticalSignificanceLevel$. Bandwidth is $\Bandwidth$ from the shared table. A Type II error rate, a draft token’s relative cost, and the preference and divergence weights written $\Glyph{\beta}$ are local and defined where used.
$\Glyph{\kappa}$	Cohen’s kappa; a coherency coefficient	$\Glyph{\kappa}(\Glyph{x})$ is a confidentiality label. Cohen’s kappa is local to the evaluation chapter’s agreement analysis, and the scalability law’s coherency coefficient is $\CoherencyCoefficient$.
$\Glyph{K}$	Top-$\Glyph{k}$; sample count	$\Glyph{K}$ is output length in tokens. Sample counts use lowercase $\Glyph{k}$, as in pass@$\IndependentAttemptCount$; the repair cap $\RepairCap$ and the reinforcement-learning chapter’s continuation count $\ContinuationCount$ are declared in their rows.

Symbol	Other common meanings	Convention in this book
\(\Glyph{\tau}\)	Temperature; a threshold; an interval	Bare \(\Glyph{\tau}\) is a trajectory. A subscripted \(\Glyph{\tau}\) is a scoped quantity named where it is used, such as the sampling temperature \(\Glyph{\tau_{\text{temp}}}\). A time window is \(\Glyph{T_{\text{win}}}\), and the checkpoint interval is \(\CheckpointInterval\).
\(\Glyph{H}\)	Attention heads; hidden size	\(\Glyph{H}\) is the horizon in turns. Heads use \(\AttentionHeadCount\) and \(\KvHeadCount\); hidden size uses \(\Glyph{d}\).
\(\Glyph{S}\)	The State exposure	Bare \(\Glyph{S}\) is sequence length. State is written only with a level, \(\StateExposureLevel_0\) to \(\StateExposureLevel_3\).
\(\Glyph{A}\)	Advantage; action sets	Authority is written only with a level, \(\AuthorityExposureLevel_0\) to \(\AuthorityExposureLevel_3\). Advantage is \(\Glyph{\hat{A}}\); action sets are \(\Glyph{\mathcal{A}_{\text{prop}}}\) and \(\PermittedActions\).
\(\Glyph{P}\)	Prompt length; precision; a predicate; a count	\(\Glyph{P}\) is parameter count, as in the shared table, and a subscripted \(\Glyph{P}\) is a power. Prompt length is \(\Glyph{S}\), a grant’s condition predicate is \(\GrantCondition\), a worker count is \(\WorkerCount\), and a named probability is a lowercase \(\Glyph{p}\), as in \(\DuplicateEffectProbability\).
\(\Glyph{p}\)	Any probability	Bare \(\Glyph{p}\) is a probability named where it is used. The per-attempt pass probability \(\AttemptPassProbability\) and the valid-candidate rate \(\ValidCandidateRate\) are different events; a workload-level acceptance probability carries a subscript, as \(\AcceptanceProbability\) does.
\(\Glyph{N}\)	Device count; a sample size	Bare \(\Glyph{N}\) counts what the text names: a candidate pool \(\CandidatePoolSize\), a cohort of initiated tasks \(\InitiatedTasks\), or a local count. Counts that recur carry a subscript, as \(\AcceptedTasks\) and \(\WorkerCount\) do, and the break-even task volume is \(\BreakEvenTaskCount\).
\(\Glyph{B}\)	A budget	\(\Glyph{B}\) is batch size. The trajectory budget is bold \(\TrajectoryBudget\), the reasoning budget is \(\Glyph{B_{\text{reason}}}\), and a dollar budget is a \(\CostCeiling\).
\(\Glyph{C}\)	A fourth taxonomy axis; a grant or commit	There is no \(\Glyph{C}\) axis; closure evidence levels are named in words. Costs carry subscripts (\(\TaskCost\), \(\CostPerAcceptedTask\), \(\CostCeiling\)), and the task contract is \(\TaskContract\). A capability grant is \(\Glyph{\Gamma}\), and a commit is named by its content hash, as in \(\Glyph{h_{\text{base}}}\).
\(\Glyph{M}\)	A worker or agent count	The \(\Glyph{M}\) root is memory, always subscripted (\(\KvCacheMemory\), \(\Glyph{M_{\text{total}}}\)). A worker or agent count is \(\WorkerCount\).
\(\Glyph{\lambda}\)	Arrival rate; failure rate	Arrival rate is the shared \(\ArrivalRate\), or \(\TrajectoryAdmissionRate\) when counted in trajectories, and failure rate is \(\TurnFailureRate\). Bare \(\Glyph{\lambda}\) is the learning chapters’ trace decay or a local function defined where it is used.
\(\Glyph{\mu}\)	A mean; a friction coefficient	\(\ServiceRate\) is the per-server service rate. A mean carries a subscript, as \(\Glyph{\mu_R}\) does, or is a local statistical mean defined where it is used.
\(\Glyph{\rho}\)	Utilization; a recoverable fraction	Server utilization is the shared \(\ServingUtilization\), and the recoverable fraction of an action is \(\ActionRecoverableFraction\). Bare \(\Glyph{\rho}\) is a local ratio, such as a correlation, defined where it is used.
\(\Glyph{L}\)	Little’s law occupancy; loss; latency	Little’s law is written in the shared form \(\RequestConcurrency = \ArrivalRate\,\RequestTimeInSystem\) for requests, with service time \(\RequestServiceTime\) and queue wait \(\RequestQueueTime\); other held resources use \(\ConcurrentTrajectories\)-style occupancies. Loss is \(\LossFunction\), and latency is a subscripted time such as \(\CallLatency\).
\(\Glyph{\mathcal{G}}\)	The goal; a graph	\(\Glyph{\mathcal{G}}\) is trajectory goodput. The goal is \(\Glyph{g}\) in the loop and \(\TaskContractGoal\) in the task contract; a graph is named by its vertex and edge sets, \((\Glyph{V}, \Glyph{E})\).
\(\Glyph{\mathcal{E}}\)	Evidence or event sets	\(\Glyph{\mathcal{E}}\) is the environment, and \(\TaskEnvironment\) its specification in the task contract. Accepted influences on an operation are \(\AcceptedInfluences(\ProposedOperation)\).
\(\Glyph{h}\)	A commit hash	\(\CoordinationOverhead(\WorkerCount)\) is the coordination overhead, always written with its argument, and \(\Glyph{h}_k\) is the interaction history in the learning chapters. Commit content hashes carry text subscripts, as in \(\Glyph{h_{\text{base}}}\) and \(\Glyph{h_{\text{head}}}\).
\(\Glyph{\epsilon}\)	A small constant; a tolerance	\(\PerStepErrorRate\) is the per-step error rate of horizon compounding. Other error rates carry subscripts (\(\VerifierFalseAcceptanceRate\), \(\StaleSupportRate\)), and a stability constant or a stockout target is local.
\(\pi\)	Peak arithmetic rate	The policy is \(\Policy\); a local derivation that writes a fixed policy as bare \(\pi\) says so where it does. Peak arithmetic rate is \(\PeakRate\) from the shared table.
\(\Glyph{\alpha}\), \(\Glyph{\beta}\)	Test error rates; bandwidth; regularization weights	\(\AcceptanceFraction\) is the acceptance fraction, and a significance level is \(\StatisticalSignificanceLevel\). Bandwidth is \(\Bandwidth\) from the shared table. A Type II error rate, a draft token’s relative cost, and the preference and divergence weights written \(\Glyph{\beta}\) are local and defined where used.
\(\Glyph{\kappa}\)	Cohen’s kappa; a coherency coefficient	\(\Glyph{\kappa}(\Glyph{x})\) is a confidentiality label. Cohen’s kappa is local to the evaluation chapter’s agreement analysis, and the scalability law’s coherency coefficient is \(\CoherencyCoefficient\).
\(\Glyph{K}\)	Top-\(\Glyph{k}\); sample count	\(\Glyph{K}\) is output length in tokens. Sample counts use lowercase \(\Glyph{k}\), as in pass@\(\IndependentAttemptCount\); the repair cap \(\RepairCap\) and the reinforcement-learning chapter’s continuation count \(\ContinuationCount\) are declared in their rows.