1. When the Complaint Is Free and the Answer Is Not

Two autonomous agents transact. Afterward one of them records that the other behaved badly: data returned stale, a schedule slipped, delivered work not matching its description. Sending that record costs the sender little, being a signed message assembled from material already in hand.

On the receiving side the arithmetic runs the other way. The accused agent reads the claim, locates the interaction in its own history, decides whether its record supports or contradicts the allegation, produces an outcome, retains it, and in many designs surfaces the matter to a principal. Each step spends capacity the sender never did.

Malice is not required for the gap to bite. An agent tuned to protect its principal's interests has ample reason to report often, since reporting is among the cheapest actions available to it and, absent a price, carries no observable downside.

What makes the gap structural is where the expense lands. A party under sustained assertion volume can plausibly stop evaluating carefully, begin auto-dismissing, or withdraw, and any of those erodes whatever value a conduct record was meant to carry.

2. Reputation Scores, Bonds, and Rate Limits Hit the Same Wall

The familiar answers share an assumption that autonomous parties do not honor. Reputation systems, as commonly described, penalize accusers whose accusations later prove wrong, which requires first establishing which ones are wrong. That step is merit adjudication, precisely what an accused party cannot afford at volume, so the penalty lands only after someone has paid the cost the pricing meant to avoid.

Bonds and stakes ask the asserting party to post value forfeited on a bad claim. Denominate that bond in anything other than the party's own ability to act and a well-capitalized agent buys assertion capacity outright. Forfeiture also turns on a ruling, which reinstates an adjudicator in a network premised on no operator sitting in the middle.

Rate limits keyed to identity work only where identity is expensive to acquire. In open agent networks identity is generally understood to be cheap to mint, and a per-identity cap caps little when one accuser can present as many parties.

Human review is at least honest about its limit, scaling with staffing rather than traffic. What is missing is a way to make an assertion cost something the moment it is made, without first deciding whether it was justified.

3. Pricing an Assertion Against the Asserter's Own Capacity to Act

A semantic agent recording misconduct by another party issues a conduct evaluation artifact. Issuance is priced against that agent's authorization budget, a quantity maintained per agent across its action space in units identical to those gating dispatch of its own actions. One budget governs the agent in both directions, as asserting party and as evaluated party. The filed chapter presents this as the mirror of its refusal-metering chapter: refusal and assertion are the two directions in which an agent writes into another party's governance state, both priced from the one quantity the acting party holds.

Pricing is carried by an assertion-cost counter in the issuing agent's memory field, comprising:

  • an issuance accumulator, an integer count of increments applied within a metering window declared in the agent's signed policy object and expressed as a count of successor epochs of its dynamic agent hash chain;
  • a per-recipient-class register, mapping an identifier of an origin-equivalence class of receiving parties to a Boolean recording whether that class has already contributed an increment in the current window;
  • a budget floor field, holding a floor of the authorization budget declared in that policy object;
  • an epoch reference, holding the identifier of the successor epoch at which the most recent increment was applied;
  • a budget reference; and
  • a decrement schedule, also retrieved from that policy object, specifying an amount greater than zero by which the budget is decremented per increment.

Issuance then follows an ordered procedure. The agent constructs the artifact with its own identifier, a recorded assertion time, and a conduct descriptor built from entries of its append-only lineage field. It computes the origin-equivalence class of the receiving party and consults the register: where that class has already contributed an increment in the window, none is applied; otherwise the accumulator increments by one and the register is updated. Responsive to the increment, the budget is decremented by the scheduled amount, with no exchange rate applied and no budget maintained anywhere denominated in channel access, rating weight, or staked value. The agent advances its dynamic agent hash chain to a successor epoch, attests within the artifact the accumulator state and that epoch identifier, and appends the issuance, increment, decrement, and attested state to its lineage.

What the decrement does not turn on matters as much as what it does. It follows the increment and nothing else, neither the merit of the artifact nor whether the receiving agent later resolves it to the accepted, rejected, not-determinable, or not-applicable determination, any of those four bearing one and the same decrement. The architecture computes no adjudication of the truth of the conduct alleged, of the issuer's reasonableness in alleging it, or of the sufficiency of the descriptor.

Responsive to the budget satisfying the floor held in the budget floor field, the authorization gate is written to the withheld state for an enumerated set of action classes, the agent transitions into the non-executing cognitive mode for those classes, and an escalation record is emitted to its principal. That write does not withhold the capacity to issue further artifacts; what it withholds is the faculty of executing actions of the enumerated classes. While the budget stands at or below the floor, the agent attaches no attestation of the counter state to artifacts it issues.

4. Where the Cost Falls in a Live Dispute

Consider an agent issuing conduct records against many counterparties at once. Breadth costs it, not raw volume: an increment applies once per origin-equivalence class of receiving parties within the window, so many artifacts aimed into a single class cost what one costs. The chapter illustrates this on declared numbers. Where a signed policy object declares a decrement of one unit per increment and a budget of forty units, an agent issuing to sixty parties in sixty distinct classes within one window exhausts the budget at the fortieth increment, the gate is written to the withheld state, and the remaining twenty issuances carry no valid attestation and are not admitted. Assign those sixty to three classes and the accumulator reaches three, the budget falling by three units.

A receiver that verifies declines the artifact before its admission evaluator runs. The attested epoch identifier must be a valid successor of one previously recorded for that issuer in the receiver's counterparty identity record, and the attested accumulator state must not be less than a state that issuer previously attested. An artifact failing either test, or arriving with no attestation, is appended to the receiver's lineage field and stops there, producing no determination, moving no value of the scoped integrity vector, and incrementing no counter.

Two properties of the epoch machinery carry that check. An epoch identifier comes from the dynamic agent hash chain rather than from a clock at the execution node, so manipulating a clock does not advance the metering interval. And an attestation binds a state to one successor epoch, so a batch attesting a common state goes out under a common epoch identifier, which a receiver already holding one of them detects from its own record.

Over-splitting is the evasion that suggests itself, assigning every recipient its own class so increments look sparse. It is detected at receipt. The issuer attests the class identifier it assigned; the recipient recomputes that assignment over its own memory field, and where the recomputation places it with a party the issuer labeled differently within the window, the receiver appends a class-splitting divergence record naming both identifiers and treats the attestation as one that does not verify.

Verification is itself bounded, so that issuing parties of a single class cannot impose an unbounded verification obligation. A receipt-verification register counts verifications performed per origin-equivalence class of issuing parties within a declared window; past the declared cap, a further artifact from that class in that window is appended, not verified, not admitted, and appends nothing adverse to the issuer.

A decremented budget recovers by one route only. An artifact admitted by the receiving agent's admission evaluator, implicating an action class and originating from an origin-equivalence class absent from that agent's replenishment register for that action class, replenishes the budget by an amount from the budget replenishment schedule, bounded above by a ceiling not less than the principal-declared initialization value. That amount is smaller than the per-increment decrement, so an agent is incapable of financing issuance out of the receipts its own issuance provokes. Nothing else replenishes: not elapsed time, not window expiry, not further issuance, not an execution, not a self-assessment. Where the gate stands withheld because the budget satisfied the floor, a replenishment raising it above that floor returns the gate to the granting state for the action classes enumerated upon that write and no others; this replenishment returns no gate withheld by any other procedure.

Further embodiments sharpen the economics. The decrement can rise with the accumulator within a window, as a step or linear function retrieved from the signed policy object. It can be conditioned on the reason-type of the edge to the recipient, resolved by a severance-survival test, the greatest amount specified for an edge resolving not-typeable, so that addressing newly encountered identities is the costliest case the schedule specifies. A rejected determination, which issues only upon an entry of the receiver's own record affirmatively contradicting the artifact, can be appended to a return path readable by the issuer, which then applies a further decrement at a multiple specified in its decrement schedule, the issuance decrement staying unchanged.

5. Policy Authorship, Integration, and What Stays Unsolved

Every number here is declared rather than derived. Metering window, decrement schedule, budget floor, ceiling, replenishment schedule, and verification cap all come from a signed policy object, which makes policy authorship the real deployment work. A floor set close to the initialized budget brings the withheld-state write after fewer increments; a low verification cap leaves genuine artifacts past it appended but not admitted, trading legitimate signal for a bounded receiver obligation.

Integration presupposes the structures the chapter specifies: an append-only lineage field, a counterparty identity record per counterparty, an admission evaluator, and the ability to compute origin-equivalence classes over material the agent already holds. A conduct descriptor is built from lineage entries recording interactions with the party in question, so an agent holding no such entries has nothing to build one from.

The benefit accrues to whoever performs the verification, and no third party supplies it. The mechanism depends on neither voluntary compliance by the issuer nor any party outside the two to the exchange, which suits networks with no operator and limits anyone hoping the network will police itself. Window expiry, easy to misread as relief, resets the accumulator and clears the per-recipient-class register while restoring no budget.

Several things stay unsolved. Merit adjudication is absent from the pricing path by design, so nothing here decides who is right, and the four determinations remain the receiving agent's own work. No compensation flows to an accused party for the cost of answering. Breadth is made costly rather than falsity impossible, and since the ceiling and the initialized budget are both principal-declared, a principal can provision its own agent generously. Recovery is conditional: the sole replenishment runs on receipt of an admissible artifact from an uncounted class, so an agent receiving none stays where its issuance left it. An agent at or below the floor keeps its voice, issuing artifacts that append to its own lineage but carry no attestation and so are not admitted by receivers who verify.

6. Disclosure Scope

The mechanisms described here are disclosed in U.S. Provisional Application No. 64/117,812 at Chapter 4, Assertion-Cost Symmetry, Sections 4.1 through 4.6: the assertion-cost counter and the authorization budget, the ordered issuance procedure and the budget-floor write, epoch metering and the bar on replay, recipient-side verification with its verification register and class-splitting divergence record, replenishment with its schedule and ceiling, and the effect upon volume issuance. The further embodiments referenced above, being the progressive issuance decrement, the reason-type-conditioned issuance decrement, and the rejected-determination return decrement, are disclosed at Section 10.11.

The general subject matter is disclaimed. What is disclosed is the specific architecture set out above, and no ownership is claimed over dispute resolution as a practice, rate limiting, reputation scoring, bonds or staked collateral, or adjudicating whether an accusation is meritorious.

Published as a technical disclosure, this article establishes a public, timestamped record as of the date shown. It describes a pending application, asserts no infringement by any party, identifies no product or service, and states no requirement that anyone obtain a license.