1. The Gap

Assertion-cost symmetry prices both directions in which one agent writes into another's governance state. An agent that refuses an execution pays a metered cost for the refusal, and an agent that issues a conduct evaluation artifact against a counterparty pays a metered cost for the assertion, each cost drawn from a single authorization budget held by the party taking the action. That budget is the same one that gates the acting agent's own execution. Issuance is therefore not free, and its price is charged to the very account the issuing agent draws on to act.

The base decrement schedule charges a fixed amount for each increment of the assertion-cost counter, where an increment is applied once per distinct recipient origin-equivalence class reached within a metering window. A flat schedule of that kind bounds total volume. In the specification's illustration, a decrement of one unit per increment against a budget of forty units exhausts the budget at the fortieth distinct class, after which the issuing agent's further artifacts carry no valid attestation and are not admitted.

What a flat schedule does not price is breadth. The first distinct counterparty an agent addresses and the fortieth cost exactly the same at the margin, so an agent holding a generous budget can spread across a wide population of distinct parties, writing into the governance state of each, at a cost that stays linear and entirely predictable. Volume is capped, but a flat curve places no growing charge on the act of continually widening the set of parties written into. That widening is what the progressive issuance decrement is directed at: breadth is what a flat curve leaves unpriced, and breadth is what the rising schedule prices.

2. Mechanism

The assertion-cost counter (400) is carried in the memory field of the issuing semantic agent. Its issuance accumulator holds an integer count of increments applied within a metering window declared in the signed policy object (112), the window expressed as a count of successor epochs of the agent's dynamic agent hash chain. A per-recipient-class register holds, per origin-equivalence class (200) of receiving parties, a Boolean recording whether that class has already contributed an increment within the current window. A decrement schedule, retrieved from the signed policy object in force, specifies the amount by which the authorization budget (404) is decremented per increment, and that amount is greater than zero.

The increment rule is the load-bearing detail. On issuance, the agent computes the origin-equivalence class of the receiving party and consults the per-recipient-class register. Where that class has already contributed an increment within the window, no increment is applied. Where it has not, the issuance accumulator is incremented by one and the register is updated. A second, third, or hundredth artifact directed at a class already counted in this window adds nothing to the accumulator. The accumulator therefore measures the breadth of the issuance, that is, the count of distinct recipient origin-equivalence classes addressed this window, and not the raw count of artifacts issued.

Responsive to an increment, the third step of the issuance procedure decrements the authorization budget by the amount the decrement schedule specifies. In the base case that amount is a single fixed quantity applied to every increment alike. The progressive issuance decrement changes what the schedule returns: the amount specified increases with the issuance accumulator value within the window. The schedule reads the accumulator's current value and returns a larger decrement as that value climbs, the amount being retrieved from the signed policy object as a step function or a linear function of the accumulator value. The direct consequence is that the marginal cost of issuing a conduct evaluation artifact rises with the count of distinct recipient origin-equivalence classes already addressed within that window.

Reaching the first distinct class costs the schedule's opening amount. Each further distinct class costs at least as much, and more as the accumulator climbs. Under a linear function the per-class charge grows with the accumulator value; under a step function it jumps at thresholds the policy declares. Budget exhaustion therefore arrives after fewer distinct classes than a flat schedule of the same opening amount would permit, and it arrives sooner the wider the agent tries to reach. When the authorization budget satisfies the floor held in the budget floor field, the sixth step of the issuance procedure writes the authorization gate (300) to the withheld state (310) for an enumerated set of action classes and the agent transitions into the non-executing cognitive mode (302) with respect to those classes. The capacity to issue conduct evaluation artifacts is not itself withheld. What is withheld is the faculty of executing actions of the enumerated classes, and while the budget stands at or below the floor the agent attaches no valid attestation to its issuances, so those issuances are not admitted by receiving agents. The price of breadth is paid, structurally, in the currency of the issuing agent's own capacity to act.

Two properties keep the rising curve from being circumvented. First, the accumulator keys on distinct origin-equivalence classes rather than on raw recipients, and an issuing agent that over-splits its classification of receiving parties, so understating its own breadth, is detected at the point of receipt: the receiving agent recomputes the class assignment over its own records and appends a class-splitting divergence record where the issuer attested a distinct identifier for parties that resolve to a common class. Fabricating fresh classes to keep the marginal cost low does not survive recipient-side verification. Second, the window is counted in successor epochs of the dynamic agent hash chain, which is not a wall-clock timestamp and is not drawn from any clock available to the host, so the window cannot be advanced by manipulating a clock.

The decrement is merit-independent. It follows from the increment alone and is not conditioned on the truth of the conduct alleged, on the reasonableness of alleging it, or on whether the artifact is later resolved to an accepted, rejected, not-determinable, or not-applicable determination. Every one of those resolutions bears one and the same decrement. The progressive price is thus a pure function of how many distinct parties an agent has chosen to write into, computed before any of them answers.

3. Operating Parameters

Every parameter below is stated in the filed specification.

  • The decrement amount is greater than zero.
  • Under the progressive schedule the amount is an increasing function of the issuance accumulator value, expressed either as a step function or as a linear function of that value, and retrieved from the signed policy object (112) in force.
  • The metering window is declared in the signed policy object and is expressed as a count of successor epochs of the dynamic agent hash chain, one window governing both the issuance accumulator and the per-recipient-class register.
  • An increment is applied at most once per distinct recipient origin-equivalence class within the window.
  • The authorization gate is written to the withheld state upon the authorization budget satisfying a floor declared in the signed policy object.
  • The authorization budget is not restored by expiry of a metering window. Its only replenishment is bounded above by the authorization budget ceiling and, per increment, the replenishment amount is less than the amount by which the budget is decremented.
  • The flat baseline the progressive schedule departs from is illustrated with a decrement of one unit per increment against a budget of forty units, exhausting at the fortieth distinct class. These figures illustrate the flat schedule; the specification declares no specific numeric progressive schedule.

4. Composition

The progressive issuance decrement is not a separate subsystem. It parameterizes one field, the decrement schedule, of the assertion-cost counter, and it leaves the issuance procedure otherwise intact. The third step still decrements the budget by whatever the schedule returns; the progressive rule only changes what the schedule returns as the accumulator climbs. This places it in a family of decrement-schedule variants that occupy the same structural slot and all draw their amount from the signed policy object, the policy declaring which the agent applies.

Its siblings in that family are the reason-type-conditioned decrement, under which the amount is keyed to whether the edge to the recipient resolves want-sustained, payment-sustained, obligation-sustained, or not-typeable, and the rejected-determination return decrement, under which an agent whose artifact is affirmatively contradicted on the merits by the receiving agent bears a further decrement at a declared multiple, in addition to the merit-independent issuance decrement that remains constant across every resolution. The progressive rule keys on breadth, the reason-type rule keys on the nature of the relationship, and the return decrement keys on the outcome, but all three modulate the same charge against the same budget.

Upstream, the mechanism depends on origin-equivalence normalization. Because the accumulator counts distinct origin-equivalence classes, the same normalization that groups related identities into one class is what makes the rising curve meaningful, and the class-splitting detection performed at receipt is what stops an agent from resetting its own breadth by minting classes. Downstream, it composes with budget replenishment: replenishment turns on exposure to an uncounted origin-equivalence class the agent receives from, is capped below the per-increment decrement, and never restores the budget on a timer, so an agent cannot finance a volume of issuance with the receipts its own issuance provokes. A schedule whose per-increment decrement rises only widens the gap between what a class costs to address and what receiving from a class returns.

Finally, the mechanism sits inside assertion-cost symmetry proper. The issuing role and the evaluated role are governed by one authorization budget. An agent that spends its budget writing governance state into a broad population is the same agent, drawing on the same budget, that needs headroom to execute its own actions. The progressive decrement makes broad accusation compete directly, and at an accelerating rate, with the agent's own capacity to act.

5. Prior-Art Distinction

Rate limiting by fixed quota or token bucket charges a flat cost per request and refills on a wall-clock schedule. It bounds request volume but does not make the cost of reaching one more distinct counterparty rise, and its window is clock-metered, so a party controlling its host advances the window by advancing the clock. The progressive issuance decrement rises with the breadth of distinct recipient classes and meters in hash-chain epochs that no clock can accelerate.

Dynamic base-fee schemes in distributed ledgers are also progressive, but the variable they price is aggregate demand across all participants, and setting the fee requires a coordinator or a consensus that observes global load. Here the accumulator is per-agent and local, no coordinator participates, and the quantity that drives the price is the issuing agent's own count of distinct recipient origin-equivalence classes rather than any global congestion signal.

Stake-slashing and reputation-bond systems price conduct in a separate asset, a stake or a reputation score, and require a conversion between that asset and the right to act. This mechanism maintains no such second denomination. The budget is charged in units identical to those that gate the agent's own action dispatch, no exchange rate is applied, and no quantity denominated in channel access, rating weight, or staked value is maintained.

Sybil-resistance by proof-of-work or by identity registration imposes a cost per identity through an external puzzle or a registry lookup. The progressive decrement imposes no external puzzle and consults no registry. The rising cost is internal to the agent's own budget, is keyed to distinct recipient classes computed from records the two parties already hold, and depends on no party beyond the issuer and the recipient.

Recipient-side anti-spam throttling acts at the receiver, filtering or delaying inbound traffic after it arrives. This mechanism acts at the issuer and before transmission, pricing the breadth of what an agent chooses to send against the agent's own budget rather than rationing what a recipient chooses to accept.

6. Disclosure Scope

The progressive issuance decrement is disclosed in U.S. Provisional Application No. 64/117,812, at Section 10.11, paragraph [0489], as an embodiment of the decrement schedule whose structure and issuance procedure are set out in Section 4, paragraphs [0114] through [0147]. What is disclosed is the schedule that specifies an amount increasing with the issuance accumulator of the assertion-cost counter (400) within a window, so that the marginal cost of issuing a conduct evaluation artifact rises with the count of distinct recipient origin-equivalence classes addressed in that window, the amount being retrieved from the signed policy object (112) as a step function or a linear function of the accumulator value.

The filing declares no specific numeric progressive schedule. The one-unit-per-increment and forty-unit-budget figures cited above illustrate the flat baseline of Section 4 and are not the progressive schedule. No particular deployment context, integration surface, or numeric parameterization beyond the constraints stated here is part of the disclosed mechanism, and none is claimed by this article. Statements herein describe the mechanism as filed and are not an assertion that any specific external system practices it.