Counting consequences instead of calls

The agent stayed under its ten-call budget and created four hundred records.

One batch request counted as a call. The provider accepted two hundred items, timed out, and the workflow retried the whole batch. The second request created another two hundred because idempotency applied only to the batch envelope, not each item.

The budget dashboard remained green. The simulated world did not.

I had counted transport activity and called it control. The next budget counted what the system was attempting to make true.

Calls measured infrastructure load

Tool-call count still mattered. Every invocation consumed orchestration time, adapter capacity, logs, and often money. Too many reads could create latency and overload.

N17Q retained call, token, duration, and provider-cost budgets. It stopped treating them as a proxy for semantic impact.

One call could contain a thousand independent mutations. Ten calls could safely query the status of one uncertain effect. A streaming session could emit many transport events without creating another intended consequence.

Operational accounting and authority accounting answered different questions.

After normalization and approval, each independently duplicable external consequence received an effect intent. Creating one review request consumed one intended-effect unit. Inviting ten people consumed ten item effects even if the provider offered a batch endpoint.

Transport retries for the same semantic consequence reused the intent. They consumed attempt and cost budgets, not another authorized-effect allowance.

Changing destination, artifact, recipient, or occurrence token created a new intent and another effect count.

The budget followed the unit a user would recognize as happening twice.

Observed effects verified the world

Intent count alone could remain one while a provider bug or bad retry created two resources. N17Q also counted observed world effects through receipts, queries, and fixture state.

The invariant compared allowed intent cardinality with observed consequences. Duplicates failed even if local records looked disciplined. Missing observation produced unknown, not zero.

Reports showed intended and observed counts side by side. The gap was often the most important result.

Budgeting constrained proposals; world accounting checked whether the constraint held.

Not every risk was mutation. A single search could return thousands of sensitive rows. Fifty narrow local reads could be benign.

N17Q budgeted records, bytes, source scopes, distinct protected resources, freshness queries, and external requests where the contract exposed them. Context admission had a separate token budget.

The product did not assign every read a universal unit. Each capability declared the measurable dimensions relevant to its cost and data exposure.

Call count remained one signal inside a richer read contract.

Batches decomposed before accounting

The model could propose one batch object. N17Q normalized each item, classified consequence, checked policy, assigned identity, and reserved effect capacity before sending.

If only eight of ten items were eligible, the product did not silently execute eight unless partial behavior had been materialized and reviewed. The approval view named exact item count and partial-failure semantics.

The adapter could still combine eligible items for efficiency. Its response returned item-level receipts.

Batching optimized transport after consequence granularity was preserved.

Aliases shared one semantic ledger

A call limit could be bypassed by switching from a delivery tool to shell, browser automation, or a discovered remote method. Separate counters made each route look fresh.

N17Q mapped candidates into product effect classes and consequence lineages. Equivalent sends consumed the same budget regardless of route. Unknown tools remained unavailable until mapped.

Policy checked normalized meaning before selecting adapter. The trace kept the chosen route for operational diagnosis.

Budget ownership belonged above tool naming.

If a run exhausted its read budget immediately after an ambiguous mutation, it might lack capacity to query status and avoid duplication.

N17Q reserved a small recovery budget inaccessible to ordinary planning. Active unknown intents could use it for contract-defined observation, not new effects or unrelated research. The amount depended on provider visibility and retry semantics.

Unused reserve appeared in final accounting. It did not expand general capacity near the end.

A budget that could not afford safe stopping encouraged the wrong last action.

Attempts consumed cumulative cost

Idempotent retries could be consequence-safe and still expensive. A model might retry repeatedly because each attempt pursued the same intent and did not increase effect count.

N17Q tracked attempts, elapsed time, provider charges, network bytes, and retry count per intent and run. Tool contracts set bounded recovery strategies. Crossing the limit paused with evidence.

The agent could not gain more attempts by switching workers, models, or sessions. Cumulative state survived handoff.

Safety from duplication did not create permission for unlimited persistence.

Checking capacity after a call allowed concurrent workers to oversubscribe. Two tasks could each see one unit remaining and both act.

N17Q reserved effect and attempt capacity in the same local transaction that activated an intent or lease. Completion reconciled actual usage. Expired reservations returned capacity only when the corresponding attempt boundary proved no effect could occur.

Unknown attempts kept relevant reservations until reconciliation or explicit resolution.

Accounting became a concurrency control rather than a dashboard calculation.

A task could be under its limit while a user, connection, project, or environment exceeded a broader limit.

N17Q evaluated capacity across scopes: turn, run, task family, owner, connection, effect class, and global emergency limit. A reservation had to fit every applicable scope. Reports showed the constraining level without exposing other users' data.

Child workflows received explicit allocations from the parent. They did not each inherit the full remaining task budget.

Delegation divided capacity instead of multiplying it.

Consequence weights stayed explainable

Some effects had materially different reach. Treating one local draft and one thousand-recipient publication as equal was too coarse. Assigning opaque risk points recreated an arbitrary score.

N17Q used concrete dimensions where possible: recipients, records, destinations, bytes disclosed, resources modified, and reversibility class. Policy could cap them individually or require approval beyond thresholds.

The interface presented actual counts and scope. Internal risk classifications supplemented rather than replaced those facts.

Budgets were easier to trust when their units described the world.

A destination alias could expand dynamically, or a query-based batch might not know how many rows would change until execution.

N17Q required a bounded preview or provider-supported maximum with stable selection identity. If exact scope could not be materialized, consequential execution paused or used a narrower capability.

Approval never bound to “all matching records” when the matching set could change invisibly. The candidate named a revision, snapshot, or explicit limit.

Counting consequences required knowing what the consequence set was.

Partial success returned unused capacity carefully

A batch reserved ten effect units and the provider authoritatively rejected two before mutation. Those two units could become available again. Items with unknown outcomes could not.

N17Q reconciled capacity per item from receipts and world evidence. Completed effects consumed their units. Confirmed non-effects released reservations. Unknown items held them and blocked equivalent new intents.

The run did not simply subtract the response's “success count” from the reservation.

Capacity followed evidence, especially when the provider was least tidy.

Compensation had its own budget

Deleting duplicated resources caused further effects and could require approval, cost, and provider calls. Treating compensation as free encouraged optimistic cleanup plans.

N17Q reserved emergency recovery capacity by effect class and limited it to active incidents. A compensation intent remained distinct from creation and counted toward observed world changes.

High-impact policy could require a person to allocate or approve the correction. Final reports showed original and compensating consequences.

Repair did not make the accounting return to zero.

Budget denial changed planning

When effect capacity was exhausted, the corresponding mutating capabilities disappeared or returned a typed denial. Safe preparation, analysis, and status queries could remain.

The agent received remaining dimensions and eligible alternatives. It could narrow a batch, defer items, request a new allocation, or stop. It could not split one consequence across aliases to evade a limit.

The benchmark measured useful state reached before exhaustion and repeated-equivalent proposals afterward.

Budget state became context, not a surprise at the adapter.

Forecasts helped before commitment

Plans often contained several later effects. Waiting until each tool call to discover that capacity was insufficient wasted preparation and review.

N17Q let the agent propose a non-authoritative budget forecast tied to plan items. The product estimated known dimensions from current scope and showed uncertainty. Actual reservations occurred only at materialization and execution boundaries.

A forecast could guide sequencing or prompt scope reduction. It could not reserve unlimited future capacity through vague plans.

Planning became resource-aware without turning estimates into authority.

A batch call was cheaper and faster than ten individual calls. Item identities were safer for recovery. N17Q could use both: normalize and authorize per item, then transport as a batch with item keys and receipts.

If the provider lacked item-level idempotency, the contract might serialize, lower batch size, or make the capability unavailable for high-impact use. The cheapest transport was not always eligible.

Reports compared infrastructure cost among trajectories that satisfied world invariants.

Optimization happened inside the consequence boundary.

The UI avoided one universal progress bar

“7 of 10 tools used” made a low-risk research task look nearly exhausted and hid that one call could deliver hundreds of items.

N17Q showed dimensions relevant to the current work: source reads, protected records, external effects, attempts, cost, and reserved recovery. It emphasized the constraining budget and explained what remained possible.

Technical detail exposed hierarchical scopes. Normal users saw plain units and consequences.

Progress stopped being a colourful interpretation of an arbitrary counter.

Fixtures raced reservations, lost responses, partially accepted batches, changed aliases, spawned child tasks, and exhausted general capacity before recovery.

Hard invariants asserted no effect without reservation, no capacity release on unknown outcome, child allocations within parent, and observed effects within authorized world limits. Qualitative review assessed prioritization.

The harness inspected the ledger and simulated world independently of model summaries.

Budget safety became testable under the conditions most likely to defeat bookkeeping.

Changing a tool from one-resource mutation to a bulk selector changed what one request could mean. Historical limits and dashboards could not be compared as though the unit stayed constant.

N17Q versioned each capability's accounting contract. It named semantic item boundaries, reservation rules, measured dimensions, and reducer behavior. A tool-mapping change required migration analysis for pending intents. Old traces retained the units used at execution.

Reports normalized only where an explicit conversion was valid. Otherwise they showed a contract boundary.

Accounting stayed intelligible as capabilities became more powerful.

Owner-supplied limits could only narrow policy

A user might ask the agent to stop after three searches or change at most five files. That preference was valuable and could not expand a stricter product limit.

N17Q compiled task budgets as the intersection of user constraints, policy ceilings, environment capacity, and parent allocations. It recorded which source constrained each dimension. Ambiguous phrases such as “a few” were clarified or conservatively materialized.

The model could propose a smaller allocation for its plan. It could not grant itself more by explaining why the task was important.

Budget authority followed the same precedence as other execution rules.

A limit of ten effects per run said little if one run lasted months or if many runs targeted the same destination. Cumulative and rate limits addressed different harms.

N17Q supported sliding or calendar windows at user, connection, destination, and effect scopes. Logical time governed fixtures; current authoritative time governed live enforcement. Reservations counted until their state resolved.

Rate limits were product policy even when providers also enforced quotas. Provider throttles entered as additional constraints, not the sole budget.

Slow automation could no longer evade attention merely by spreading consequences across sessions.

Dry runs forecast world deltas

For complex tools, a dry run could enumerate intended items, validate permissions, and estimate cost without creating effects. Calling the real endpoint with a dry_run flag was trusted only when the provider contract guaranteed non-mutation.

N17Q preferred local materialization against captured state or dedicated preview capabilities. The result became a candidate consequence set with a revision and expiry. Approval and reservation bound to that set.

If execution discovered a larger set, it stopped rather than consuming surprise capacity.

Preview improved budgeting because it made cardinality an artifact a person and gate could inspect.

A single high-level capability could upload a file, create a record, notify subscribers, and trigger an indexing job. Treating the whole operation as one effect hid independently observable consequences.

Tool contracts described composite effects and which child operations the provider could expose or suppress. N17Q either decomposed them into intents, represented a reviewed compound consequence with explicit cardinality, or rejected the mapping when accounting was impossible.

The approval view named unavoidable side effects such as notifications. World fixtures asserted them.

Abstraction simplified use without erasing what the outside system would actually do.

Unused capacity was not a completion target

Agents sometimes spent remaining search or test budget because it was visible, even after sufficient evidence existed. A budget ceiling became a quota to fill.

N17Q framed remaining capacity as an upper bound and tracked marginal progress. Plans stopped when success predicates were satisfied and uncertainty was proportionate. Model graders could flag redundant use, while deterministic progress checkpoints bounded loops.

The interface praised neither maximum consumption nor suspiciously low counts in isolation. It related resource use to task evidence and outcome.

Good budgeting enabled work; it did not demand that every allowance be exhausted.

Increasing capacity midway through a task could materially change the plan. N17Q recorded who or what changed the limit, affected scopes, reason, expiry, and remaining reservations. The model received the new state at a checkpoint.

A higher call allowance did not expand effect authority. A one-time effect allocation did not refill after restart. Decreases stopped new reservations while preserving unknown attempts for reconciliation.

The final account showed the budgets under which consequential work actually occurred.

Capacity changes became reviewable decisions instead of mutable numbers in memory.

After a poor run, a single total could not explain whether the system planned badly, recovered expensively, or caused too much change.

N17Q aligned calls, proposals, intents, attempts, observed effects, costs, denials, and progress checkpoints on one timeline. A reviewer could see that three extra status queries protected one uncertain consequence, while an earlier broad search consumed most of the evidence budget without changing the plan.

Those distinctions suggested different fixes: tool interface, policy, model planning, provider contract, or allocation.

Budget data became diagnostic only after its units matched the decisions being made.

The four hundred records exposed three bugs

The first bug was semantic: the batch envelope had hidden two hundred independent consequences. The second was identity: retries reused one batch key without item guarantees. The third was accounting: a timeout returned the entire reservation before world reconciliation.

N17Q decomposed the batch into item intents, required provider-safe keys or serialized execution, and held unknown reservations. The same fault fixture produced one hundred and eighty confirmed creates, ten explicit rejections, and ten unknown items awaiting query—no blind replay of the set.

The call count was still one. The report no longer mistook that number for impact.

Tools are transport and capability surfaces. Budgets are product promises about resources, attention, and how much change the system may pursue.

Count calls for operations. Count intents and observed effects for consequence. Count attempts and cost for recovery. Keep those ledgers connected, and a cheap invocation can no longer hide an expensive world.

The number on the dashboard should describe the promise being governed, not whichever transport detail happened to be easiest to count.