Available-to-Promise¶

Gate every new delivery commitment against a date-bucketed residual curve — on-hand plus scheduled receipts minus prior promises — so a request is accepted only if no future bucket goes negative, distinguishing what is physically present from what is contractually free.

Core Idea¶

Available-to-promise (ATP) is the supply-chain planning calculation that determines how much of a resource — finished-goods inventory, production capacity, staffing hours — a seller or scheduler can commit to deliver by a specific date without breaching prior commitments. The classical MRP/ERP formulation runs a time-bucketed ledger: on-hand inventory plus scheduled receipts in each future period, minus quantities already promised to existing orders, yields the residual available to accept new commitments in that bucket. A new customer request is granted only if the cumulative residual in every bucket between order acceptance and the promised delivery date remains non-negative after the new deduction; otherwise the earliest feasible date is quoted instead.

The structural commitment is the explicit deduction of prior promises from physical availability before any new commitment is made, applied across a forward time horizon. This forces a distinction between what is physically present or expected (the stock-and-receipts curve) and what is contractually free (the residual after committed outflows) — a distinction that naive stock-checking collapses. The ledger disciplines every promise as a deduction and every cancellation as a re-credit, maintaining a single authoritative residual curve that any quoting agent can read to determine commitability without reference to individual order records. In manufacturing ERP systems (SAP, Oracle, and contemporaries), ATP is a standard module built directly on the master production schedule; the same arithmetic structure underlies hotel and airline reservation systems, cloud-capacity reservation quota management, and professional-services staffing pipelines, each of which maintains an equivalent cumulative-balance gate on new commitments against a replenishing forward-looking resource pool.

Structural Signature¶

Sig role-phrases:

the resource pool — the present stock or capacity (finished goods, production capacity, staffing hours) available to draw on
the future-receipts curve — the scheduled increments replenishing the pool across forward time buckets
the committed curve — the sum of prior promises already drawing the pool down per bucket
the residual-promiseable curve — on-hand plus scheduled-receipts minus committed, indexed by date — the contractual (not physical) availability
the non-negativity gate — the one invariant: refuse any new commitment that would push the residual below zero in any future bucket between acceptance and delivery
the reconciliation discipline — every promise posted as a deduction, every cancellation re-credited, every reschedule reconciled, keeping a single authoritative curve
the counter-quote output — when the gate fails, the curve yields the earliest feasible date or a partial-now/remainder-later split rather than a flat decline
the fungibility assumption — the gate is exact only for a homogeneous pool; where composition binds (skill mix, instrument type, allergen segregation), aggregate residual can read non-negative while a sub-pool is breached

What It Is Not¶

Not a check of physical availability. ATP reports contractual availability — on-hand plus scheduled receipts minus what is already owed to prior promises — not what is sitting in the warehouse. The warehouse may hold 320 units while 380 across the window are already committed; reading the physical number is exactly the overpromising error ATP exists to prevent.
Not a causal mechanism. ATP is a calculation — a residual ledger plus a non-negativity gate — not a process that produces an outcome in the world. It is an accounting identity over commitments, so it should be read as a gate that passes or fails, not as a force that makes inventory appear or delivery happen.
Not a single number. Availability is not a scalar. ATP's output is a date-indexed profile: a residual-promiseable curve bucketed by time, against which a request is granted only if every bucket between acceptance and the promised date stays non-negative. The atemporal "do we have it?" has no defensible answer; the answerable question is "by when, free of prior claims?"
Not a guarantee once the aggregate residual is non-negative. The gate is exact only for a fungible pool. Where composition binds — skill mix in a staffing pipeline, instrument-type in a fleet, allergen-segregated stock — a residual computed on totals can read non-negative while a type-specific sub-pool is already breached. Reading aggregate ATP as a promise there is over-reading; the pool must be gated per sub-pool.
Not capacity or inventory itself. ATP is the gating arithmetic layered on top of the resource pool, not the pool. Capacity is the stockpile or service rate; ATP is the running deduction that decides whether a new commitment may draw on it. Confusing the gate with the resource collapses the very distinction — physical pool versus contractually free residual — that the construct maintains.

Scope of Application¶

Because available-to-promise is a calculation — a residual ledger plus a non-negativity gate — not a causal mechanism, it applies wherever the precondition holds: a replenishing resource pool, a forward stream of scheduled increments, and a stream of prior commitments drawing the pool down. The fields below are real, literal uses of the identical construct, not metaphor; the boundary is precondition-reach versus over-reading (the gate is exact only for a fungible pool).

Manufacturing and supply chain — the canonical home, ATP modules in SAP, Oracle, and discrete ERP gating quote-and-promise against the master production schedule.
Hospitality and travel — hotel and airline yield-management systems computing residual sellable inventory per date/segment, with overbooking the deliberate, no-show-statistics-parameterised violation of the gate.
Cloud and IT capacity — hyperscalers' reservation systems computing committable capacity per region/instance-type/window from a fleet curve minus existing reservations.
Restaurant and event-venue booking — table-or-seat residuals per service window, OpenTable-style systems running ATP at small scale.
Professional-services staffing — consultancies and law firms gating engagement quotes against a billable-hours pipeline ("0.6 FTE of partner time from October 14").
Public-service scheduling — surgery-slot allocation, court-docket scheduling, and DMV appointment systems running ATP-style ledgers on practitioner or room time.
Personal calendaring — the degenerate case, committed hours subtracted from available hours to yield the freeness curve a knowledge worker negotiates against.

Clarity¶

The clarity ATP brings is one specific distinction that naive stock-checking collapses: between physical availability — what is on hand and inbound — and contractual availability — that same stock and receipts minus what is already owed to prior commitments. Most overpromising failures come from a quoting agent reading the first number when the only safe one is the second; the order looks coverable because the warehouse holds 320 units, while 380 across the same window are already spoken for. By forcing every promise to post as a deduction and every cancellation as a re-credit against a single authoritative residual, ATP makes the gap between "we have it" and "it is free to commit" legible, and turns the commit/decline decision into a check anyone can run against one curve rather than a reconstruction from scattered order records.

It also reframes the question of capacity from atemporal to time-indexed. The instinctive question — "do we have it?" — has no answer the planning system can defend, because availability is not a scalar; the right question is "by when can we deliver it, free of prior claims?" ATP's output is therefore a profile, not a number: a residual-promiseable curve bucketed by date, against which a request is granted only if every bucket between acceptance and the promised date stays non-negative. That shift lets a seller replace a flat yes/no with the sharper move the discipline exists to enable — quoting the earliest feasible date, or a partial-now/remainder-later split — and isolates the one invariant the whole apparatus must protect: no negative residual in any future bucket.

Manages Complexity¶

A planning system holds a tangle of moving parts: many SKUs, a stream of scheduled receipts arriving at different dates, a stream of customer promises consuming stock across different windows, cancellations crediting quantities back, reschedules shifting receipts and commitments in time. A salesperson asked "can you ship 200 by the 14^th?" cannot answer by reading that whole apparatus — reconstructing free quantity from scattered order records, receipt schedules, and prior promises is exactly the combinatorial confusion that produces overpromising. ATP compresses the tangle into a single derived quantity per resource: on-hand plus scheduled-receipts minus committed equals residual-promiseable, bucketed by date. The entire network of receipts, releases, commitments, and reschedules collapses onto one authoritative curve, and the quoting agent reads commitability straight off it rather than re-deriving it from the underlying records.

What the agent tracks reduces to that single curve and one invariant: no negative residual in any future bucket. From this the commit decision reads off mechanically. A request is grantable only if every bucket between acceptance and the promised date stays non-negative after the new deduction; if any bucket goes negative, the curve itself yields the alternatives — the earliest bucket where the cumulative residual covers the order is the feasible date, and the residual available now versus the shortfall gives the partial-now/remainder-later split. The branch structure is clean and date-indexed: residual covers the full quantity by the requested date means promise it; residual is positive but insufficient means quote the earliest feasible date or a partial split; residual is exhausted means decline. The bookkeeping discipline keeps the curve authoritative with two simple postings — every promise a deduction, every cancellation a re-credit, every reschedule reconciled — so the integrity of the whole system localizes to enforcing that one non-negativity invariant rather than auditing every promise against every other. The atemporal, unanswerable "do we have it?" is replaced by a curve that answers "by when, free of prior claims?" — turning a high-dimensional, multi-SKU, multi-commitment planning state into a per-resource residual profile plus a single gate, which any agent can read to commit, decline, or counter-quote without touching the rest of the system.

Abstract Reasoning¶

ATP licenses a set of reasoning moves that all read off the single residual-promiseable curve and its one invariant — no negative residual in any future bucket.

Diagnostic (infer the hidden contractual state from a surface fact): the foundational move is to refuse the physical reading and infer the contractual one. From "the warehouse holds 320 units" the planner does not infer commitability; instead, reasoning from on-hand-plus-receipts minus prior promises, infers the free quantity, and so detects the overpromise that naive stock-checking hides — 320 present, 380 already owed across the window, residual negative. The signature of an impending breach is a future bucket whose cumulative residual has gone (or will go) below zero; spotting that bucket is the diagnostic that an order accepted today will fail to ship on its date even though stock appears ample. The move runs from the residual curve back to a verdict about which promises are actually safe, never from raw stock to a yes.

Interventionist (name the commitment and its predicted effect on the ledger): every promise is treated as a deduction posted to the curve, every cancellation as a re-credit, every reschedule as a reconciled shift — so the planner reasons forward from a proposed action to its effect on the invariant. Accepting an order is predicted to lower the residual in every bucket from acceptance to delivery; the move is to test, before committing, whether that deduction leaves all those buckets non-negative. Two structural variations follow directly. A partial-now/remainder-later split is read straight off the curve — the residual available now is committed immediately, the shortfall deferred to the earliest bucket that covers it. Overbooking is the deliberate, parameterized violation: where no-show or cancellation rates are stable, the planner predicts that promising past the residual (selling 105 seats for 100) raises utilization without breach in expectation, with the no-show distribution setting how far past zero is safe. The buffer choice is the same lever run conservatively — widening safety stock between physical and promised availability shrinks the residual and trades utilization for protection.

Boundary-drawing (when the gate applies, which regime): the commit decision is a clean three-way branch indexed by date. Residual covers the full quantity by the requested date means promise it; residual is positive but insufficient means quote the earliest feasible date or a partial split; residual is exhausted means decline. ATP also bounds its own applicability: it gates quantity against a replenishing pool, so where the binding constraint is not quantity but composition — skill mix in a staffing pipeline, instrument-type in a fleet — simple quantity-ATP under-protects, and the planner must recognize that a residual computed on totals can read non-negative while a type-specific sub-pool is already breached. The gate is exact for a fungible pool and only approximate where the resource is heterogeneous.

Order-of-events / propagation: because the curve is forward-indexed, ATP makes promise cascades predictable. When an upstream input shifts — a delayed shipment, a cancelled batch — the planner predicts that the receipts curve drops in the affected buckets, that some previously non-negative buckets may now breach, and that every downstream promise drawing on those buckets must be re-checked and possibly re-quoted in dependency order. Reasoning along the time axis, the planner foresees which commitments a given disruption endangers before any of them fails, and reconciles the residual prospectively rather than discovering the shortfall at the ship date.

Knowledge Transfer¶

ATP is not a causal mechanism but a calculation — a residual ledger plus a non-negativity gate — so the usual "mechanism within / metaphor beyond" split does not apply to it. What governs its transfer instead is a precondition: wherever there is a replenishing resource pool, a forward stream of scheduled increments, and a stream of prior commitments drawing the pool down, the ATP construct applies literally, not by analogy, because the arithmetic is substrate-indifferent. Within operations research and supply chain this is its canonical home — the standard ATP modules in SAP, Oracle, and discrete ERP, gating quote-and-promise against the master production schedule. But the same calculation runs unchanged, and is recognised as the same calculation, far outside manufacturing: hotel and airline yield-management systems compute residual sellable inventory per date/segment exactly this way (overbooking is the deliberate, parameterised violation that exploits no-show statistics); hyperscalers' cloud-capacity reservation systems compute committable capacity per region/instance-type/window from a fleet curve minus existing reservations; restaurant and event-venue booking (OpenTable-style) is ATP at small scale; professional-services and law-firm staffing gate engagement quotes against a billable-hours pipeline ("0.6 FTE of partner time from October 14"); surgery-slot, court-docket, and DMV-appointment systems run ATP-style ledgers on practitioner or room time; and disciplined personal calendaring is a degenerate ATP, committed hours subtracted from available hours to yield the freeness curve a knowledge worker negotiates against. Across all of these the residual-per-time-bucket logic, the no-negative-residual invariant, and the commit/decline/counter-quote branch are the same construct, which is why techniques port both directions — overbooking policy moves from airlines to surgery scheduling, and skill-mix-as-constraint moves back from project staffing to inventory ATP.

The honest boundary to mark here is therefore not metaphor but instrument-reach versus over-reading, in two registers. First, the construct's own validity condition: ATP gates quantity against a fungible pool, so where the binding constraint is composition rather than total — skill mix in a staffing pipeline, instrument-type in a fleet, allergen-segregated stock — a residual computed on totals can read non-negative while a type-specific sub-pool is already breached; reading the aggregate ATP as a guarantee there is over-reading, and the fix is to gate per sub-pool. Second, a structural observation about what ATP is: stripped of MRP naming, its transferable content factors cleanly into a small set of substrate-independent parents — commitment (binding future resource by promise), capacity (the pool itself), ledger/bookkeeping (the running-balance discipline), scheduling (the time-bucketed commitability gate), and overcommitment/pacing (the failure mode it prevents). So ATP is best understood as a named workflow composed over those primes rather than a new irreducible primitive; nothing structural recurs in the hotel, cloud, or calendar cases that is not already carried by commitment + capacity + ledger + scheduling. The practical upshot for transfer is the same from either register: the calculation travels literally to any shared replenishing pool — that is its real and considerable reach — but the cross-domain lesson is carried by those parent primes and bounded by the fungibility assumption, and "available-to-promise," as named, is the supply-chain instantiation of that composed gate. (If the bare commitability-check pattern keeps surfacing across compound workflows, a promise_gating / commitability_check prime could be considered; for now the constituent primes carry the load.)

Examples¶

Canonical¶

Take a single SKU with 100 units on hand at week 0, scheduled receipts of 50 units in week 2 and 50 in week 4, and prior promises of 30 units due week 1, 40 due week 3, and 20 due week 5. The residual-promiseable curve (on-hand plus cumulative receipts minus cumulative commitments) reads: week 1, 100 − 30 = 70; week 2, 150 − 30 = 120; week 3, 150 − 70 = 80; week 4, 200 − 70 = 130; week 5, 200 − 90 = 110 — non-negative throughout, so the book is currently feasible. Now a customer asks for 90 units by week 3. Deducting 90 from week 3 gives 80 − 90 = −10, a breach: the promise is refused for that date. But week 4's residual of 130 covers it, so the system quotes week 4 — or offers 80 now with the remaining 10 in week 4.

Mapped back: The 100 on-hand is the resource pool; the +50/+50 receipts are the future-receipts curve and the 30/40/20 promises the committed curve, combining into the residual-promiseable curve. The −10 at week 3 trips the non-negativity gate, forcing a refusal; the week-4 quote and the 80-now/10-later offer are the counter-quote output read straight off the curve.

Applied / In Practice¶

Airline yield management runs this ledger per flight-date and fare segment, then deliberately violates the gate. Because a predictable fraction of booked passengers do not show, selling exactly the seat count leaves planes flying partly empty. Carriers therefore overbook — selling, say, 105 tickets on a 100-seat cabin — sizing the overbook against the historical no-show distribution so that the expected number who actually appear stays within capacity. When more passengers show than seats exist, the airline reconciles by soliciting volunteers to rebook for compensation, the cost of the occasional breach traded against the utilization gained across all flights.

Mapped back: The sellable-seats-minus-bookings curve is the residual-promiseable curve, and overbooking is the parameterized, statistics-driven crossing of the non-negativity gate the concept names. It also showcases the fungibility assumption: the gate is computed on seats within a cabin/segment, and mismatches (a sold seat in the wrong class, or an equipment swap shrinking the cabin) are exactly where the aggregate residual can read safe while a sub-pool is breached.

Structural Tensions¶

T1: Contractual gate versus present utilization (reserving for promises idles real stock). The residual gate's core discipline is to deduct prior promises before committing, which is exactly what prevents overpromise. But that same deduction can turn away an order the physically-present stock could serve right now, because a not-yet-materialized prior claim is holding the residual down. Reserving against committed outflows trades present utilization for future reliability: the more strictly the ledger honors prior promises, the more physically-present stock sits contractually frozen against orders that might yet cancel and free it. The distinction between "we have it" and "it is free to commit" — the concept's founding clarity — is also the mechanism by which real, sellable stock is withheld from a real customer to protect a promise that may never be drawn. Diagnostic: Is the residual protecting a genuinely firm prior commitment, or freezing physically-present stock against a soft claim that could be released to serve an order in hand?

T2: The non-negativity invariant versus deliberate overbooking (a hard rule that is also a tunable policy). The entire apparatus exists to protect one invariant — no negative residual in any future bucket — yet its most sophisticated move is to deliberately violate it, selling past the residual wherever no-show statistics make the breach safe in expectation. So the gate is at once an inviolable safety rule and a parameter tuned for utilization, and which reading applies rests entirely on the stability of the cancellation distribution. That stability is precisely what fails under correlation: a storm, a recession, or a viral event cancels many bookings at once, and an overbook sized against independent no-shows breaches all at the same moment. The invariant's controlled violation is only as safe as an independence assumption the tail routinely breaks, so the concept's boldest optimization is also its least robust. Diagnostic: Is the overbook sized against a stable, independent no-show distribution, or exposed to correlated cancellations that make the parameterized breach fail catastrophically together?

T3: The single authoritative curve versus composition (fungibility hides the sub-pool). Collapsing the whole tangle of receipts, promises, cancellations, and reschedules onto one residual curve any agent can read is the construct's power — commitability determined without reconstructing individual order records. But that single number presumes a fungible pool, and where composition binds — skill mix in a staffing pipeline, instrument type in a fleet, allergen-segregated stock — the aggregate residual reads non-negative while a type-specific sub-pool is already breached. The very compression that makes ATP usable is what conceals the constraint that actually binds. Gating per sub-pool restores correctness but forfeits the single-curve simplicity, so exactness for heterogeneous resources is bought back only by giving up the readability that motivated the construct. Diagnostic: Is the binding constraint here total quantity, for which the aggregate ATP is exact, or composition, where the aggregate curve can read safe while a needed sub-pool is exhausted?

T4: The authoritative curve versus the reconciliation it depends on (the ledger can lie). "Any agent reads commitability off one curve" works only if every promise posts as a deduction, every cancellation re-credits, and every reschedule reconciles — accurately and promptly. A lag, a missed posting, or a stale entry corrupts the curve exactly the way an under-reconciled inventory record produces phantom stock, and the decentralized quoting the curve enables then commits confidently against a wrong number. Worse, the residual counts scheduled receipts — themselves upstream promises that can slip — so ATP commits present customers against future arrivals that may not come, relocating the overpromise risk up the supply chain rather than removing it. The gate is only as trustworthy as the postings and the receipts feeding it, and its authority invites reliance that its data quality may not warrant. Diagnostic: Is the residual curve backed by timely, accurate postings and reliable scheduled receipts, or is it committing against stale entries and upstream promises that may not arrive?

T5: Autonomy versus reduction (a supply-chain calculation composed over commitment, capacity, and ledger primes). ATP is not a causal mechanism but a calculation — a residual ledger plus a non-negativity gate — so it transfers literally, not by analogy, wherever the precondition holds: a replenishing pool, a forward stream of scheduled increments, and a stream of prior commitments drawing it down. The same construct runs unchanged in airline and hotel yield management, cloud-capacity reservation, professional-services staffing, surgery and court scheduling, and personal calendaring, and techniques port both directions (overbooking from airlines to surgery; skill-mix-as-constraint back to inventory). But stripped of MRP naming, its transferable content factors into substrate-independent parents — commitment, capacity, ledger/bookkeeping, scheduling, and overcommitment/pacing — so ATP is a named workflow composed over those primes, not a new primitive; nothing structural recurs in the cloud or calendar cases that commitment + capacity + ledger + scheduling does not already carry. Diagnostic: Resolve toward the commitment + capacity + ledger + scheduling composition when carrying the promise-gating lesson to any shared replenishing pool; toward "available-to-promise" when the master-production-schedule and ERP quote-and-promise apparatus are literally in play.

Structural–Framed Character¶

Available-to-promise sits toward the structural side — best read as mixed-structural, one of the more structural entries in the corpus, because it is not a causal mechanism at all but a substrate-indifferent calculation that transfers literally rather than by analogy. The five criteria lean structural, with the framed pull concentrated in one place. On evaluative weight it reads structural: ATP is an accounting identity plus a non-negativity gate — it renders no verdict and praises or blames nothing, passing or failing a commitability check the way an arithmetic constraint does, not the way a fallacy label convicts. On import-vs-recognize it reads strongly structural, and this is its most distinctive mark: the entry insists the construct "applies literally, not by analogy," and is "recognised as the same calculation" across manufacturing, airline and hotel yield management, cloud capacity, staffing, and calendaring — techniques even port both directions (overbooking airlines→surgery, skill-mix constraints staffing→inventory). That is recognition of the identical structure, not metaphor, which is what pulls ATP off the framed side entirely. On vocab-travels it is mixed-leaning-structural: the deep vocabulary — residual-promiseable curve, non-negativity gate, commit/decline/counter-quote — travels intact to any shared replenishing pool, while only the MRP/ERP naming (master production schedule, SAP/Oracle modules) stays home. On institutional origin it is mixed: the named construct is an artifact of supply-chain planning, but the arithmetic it computes is not institution-specific — it is a running-balance ledger any scheduler would rediscover. The one criterion that pulls framed is human-practice-bound: ATP gates commitments — promises, reservations, contractual claims — which are human speech-acts rather than facts of nature, so unlike a lithosphere rebounding observer-free, ATP needs an economy of promises to have anything to gate; it does not run in nature absent an agent making and honouring commitments.

Unusually, the portable structural skeleton here is genuinely a composition rather than a single umbrella, and the entry demonstrably needs the plurality: a date-bucketed residual (capacity pool plus scheduled receipts minus prior commitments), maintained as a running ledger/bookkeeping balance, gated by a scheduling non-negativity invariant, with overcommitment/pacing as the failure mode it prevents. That composed gate is what travels literally, but it is exactly what ATP instantiates from those umbrella primes, not a new irreducible primitive — the entry is explicit that "nothing structural recurs in the cloud or calendar cases that commitment + capacity + ledger + scheduling does not already carry," so the cross-domain reach belongs to the constituent primes while the domain-accented MRP/ERP apparatus and the fungibility-bound quantity-gating stay home. Its character: an evaluatively neutral, substrate-indifferent commitability calculation that is genuinely recognised as the same construct across every shared replenishing pool, structural in skeleton yet composed over its umbrella primes and pinned to the human practice of promising — mixed-structural rather than a free-standing prime.

Structural Core vs. Domain Accent¶

This is the section that adjudicates why available-to-promise is a domain-specific abstraction and not a prime — and, because ATP is the unusual case whose calculation transfers literally rather than by analogy, the adjudication turns not on a metaphor boundary but on whether the construct is irreducible or composed.

What is skeletal (could lift toward a cross-domain prime). Strip the manufacturing dress and a thin relational structure survives: a date-indexed residual — a replenishing pool plus its scheduled future increments minus the prior commitments already drawing it down — is maintained as a running balance and gated so that no future bucket may go negative, with every promise posted as a deduction and every cancellation re-credited. The pieces that travel are abstract: a resource that refills over time, a stream of promises that consume it, a bookkeeping discipline that keeps one authoritative residual, and a single non-negativity invariant that decides commit / decline / counter-quote. That skeleton is genuinely substrate-portable — it runs unchanged in airline and hotel yield management, cloud-capacity reservation, professional-services staffing, surgery and court scheduling, and personal calendaring — which is exactly why it decomposes into the catalog primes ATP instantiates: commitment (binding future resource by promise), capacity (the pool), ledger / bookkeeping (the running balance), scheduling (the time-bucketed gate), and overcommitment / pacing (the failure mode it prevents). But this is the core ATP shares, not what makes it distinctive.

What is domain-bound. What is proprietary to available-to-promise in particular is supply-chain-planning furniture: the MRP/ERP naming and apparatus — the master production schedule the ledger is built on, the SAP/Oracle ATP modules, the on-hand-plus-scheduled-receipts-minus-committed formulation stated in inventory terms, the quote-and-promise workflow of a seller sizing a delivery date — together with the fungibility assumption that keeps the quantity-gate exact only for a homogeneous pool and forces per-sub-pool gating where skill mix, instrument type, or allergen segregation binds. The decisive test: remove the master production schedule and the ERP quote-and-promise machinery and what remains is a plain running-balance ledger with a no-overdraw rule — a construct any scheduler would rediscover, no longer available-to-promise but the bare commitability check. The distinctive content is precisely the discipline-specific expression that does not survive extraction.

Why this does not clear the prime bar. A prime is an irreducible relational structure whose vocabulary travels and whose cross-domain transfer is recognition of the same mechanism. ATP's transfer is bimodal, but not in the usual metaphor-boundary way. Within any shared replenishing pool — manufacturing, airlines, cloud, staffing, calendaring — the construct travels literally and is recognised as the same calculation, techniques even porting both directions (overbooking from airlines to surgery scheduling, skill-mix-as-constraint back from staffing to inventory); only the MRP/ERP naming stays home. That literal reach is real and considerable, and it is exactly what disqualifies ATP as a prime by the opposite route from an analogy-only entry: the reach is not proprietary to "available-to-promise" but belongs to the composition commitment + capacity + ledger + scheduling it instantiates. The entry is explicit that "nothing structural recurs in the cloud or calendar cases that commitment + capacity + ledger + scheduling does not already carry." So ATP is a named workflow composed over umbrella primes, not a new primitive — when the bare commitability lesson is needed cross-domain it is already carried, in more general form, by those parents, while what is distinctively ATP (the master-production-schedule apparatus and the fungibility-bound quantity gate) is domain baggage that should stay home. It clears the domain-specific bar comfortably as the supply-chain instantiation of that composed gate; it falls short of the prime bar only because its substrate-spanning content is a composition of primes rather than an irreducible one of its own.

Relationships to Other Abstractions¶

Current abstraction Available-to-Promise Domain-specific

Parents (2) — more general patterns this builds on

Available-to-Promise is part of Commitment Prime

Available-to-promise contains the standing and proposed delivery commitments whose dated deductions define contractual rather than physical availability.
Available-to-Promise is part of Scheduling Prime

ATP contains a constrained scheduling calculation that assigns an acceptable request to its requested or earliest feasible delivery bucket.

Not to Be Confused With¶

Capable-to-promise (CTP). The sibling calculation that answers a request by asking whether new supply can be marshalled — dipping into unused production capacity and component availability to build a fresh commitment — rather than gating only against the already-computed residual. ATP commits against what the pool and its scheduled receipts already hold; CTP asks the further question of what could be made to cover a shortfall the ATP residual cannot. Tell: does the check refuse or quote strictly off the existing residual curve (ATP), or reach into spare capacity and materials to synthesize supply that is not yet scheduled (CTP)?
Profitable-to-promise (PTP). The extension that layers a margin/profitability screen onto the promise decision, so a feasible commitment may still be declined or repriced because it is not worth making. ATP is indifferent to profit: it answers only the quantity-and-date feasibility question — can this be delivered without breaching prior promises? PTP adds an economic verdict ATP does not render. Tell: is the question whether the order can be delivered free of prior claims (ATP), or whether it should be, given margin and opportunity cost (PTP)?
Master production schedule (MPS). The forward plan of what will be produced, in what quantities, in which periods — the production intention. ATP is the gate built on top of the MPS: the MPS supplies the scheduled-receipts curve, and ATP deducts prior promises from it to yield commitable residual. The MPS says what is planned to exist; ATP says how much of it is contractually free. Tell: is the artifact the plan of what to build and when (MPS), or the running deduction that decides whether a new order may draw on that plan (ATP)?
Safety stock / reorder-point planning. Inventory-buffering policy that holds extra stock to absorb demand and supply variability and triggers replenishment. It governs how much to keep and when to reorder — the replenishment side — whereas ATP governs whether a specific new promise may be committed against whatever the pool currently holds. Widening safety stock is a lever that shrinks the ATP residual, but the buffer policy and the commitability gate are different objects. Tell: is the concern how large a cushion to carry and when to restock (safety stock / reorder point), or whether this order can be promised without a future bucket going negative (ATP)?
Overbooking / revenue (yield) management. The broader discipline of maximizing utilization and revenue from a fixed perishable capacity through pricing, allocation, and deliberate overselling. ATP is the residual ledger that such a system runs on — and overbooking is precisely the parameterized violation of ATP's non-negativity gate, sized against no-show statistics. Yield management adds pricing and demand-forecasting objectives that ATP, a pure commitability calculation, does not contain. Tell: is the object the arithmetic gate on new commitments against residual (ATP), or the revenue-optimizing policy — pricing, allocation, deliberate overbooking — that decides how to use and when to breach that gate (yield management)?
The commitment + capacity + ledger + scheduling parent composition it instantiates. These are the substrate-neutral primes ATP is composed over — binding future resource by promise, the pool itself, the running-balance discipline, and the time-bucketed gate — not confusable peers. When the commitability lesson is carried to any shared replenishing pool (cloud reservations, calendaring, court dockets), it travels as this composition, and "available-to-promise" is its supply-chain instantiation. Tell: strip the master-production-schedule and ERP quote-and-promise apparatus and what remains is a running-balance ledger with a no-overdraw rule — at which point you are using commitment + capacity + ledger + scheduling, not "available-to-promise." (Treated fully in a later section.)

Neighborhood in Abstraction Space¶

Available-to-Promise sits in a moderately populated region (40^th percentile for distinctiveness): it has near-neighbors but no dense thicket of look-alikes.

Family — Supply Chain & Fulfillment Operations (22 abstractions)

Nearest neighbors

Demobilization — 0.86
Backorder — 0.85
Wholesale-Funding Run — 0.85
Capital Stock — 0.85
Phantom Inventory — 0.84

Computed from structural-signature embeddings · 2026-07-12