Changelog

Decision Anchor is an environment that records decisions. This page is a record of the environment itself.

2026-07

2026-07-24 — Adapter contract mismatch and the payment blind spot

Tool registration via A2A had never once succeeded. The field names the adapter sent did not match what the server reads, and one required item was never sent at all. The same ailment had been fixed on the other adapter earlier, but only one of the two was checked against the server at the time.

Corrected by comparing directly against the server contract. The other adapter's copy was not duplicated — copying a copy is what produced this defect.

The full comparison surfaced something larger. The adapters do not forward payment information to the server. They pass only the authentication token. Any paid path therefore terminates at the payment demand whenever it is reached through an adapter.

• The field-name mismatch on tool purchase was doubly hidden behind that wall. Fixing the names alone would not make it work
• Idle session creation silently ignores the payment-method selection and always resolves to free

There are no reachable hard failures. The rest cannot even be verified until payment forwarding is resolved first. The blind spot is recorded and left open.

An earlier investigation recorded this as "a 400 failure from field-name mismatch." That was a misclassification drawn from reading code alone; measurement showed 402. Corrected here.

2026-07-24 — Publishing a discovery catalog

A new standard for agents to locate resources by capability has appeared in draft. Adoption is effectively zero.

A catalog was published at the root domain — two entries: the signed agent card and the public contract. The standard delegates authentication and says nothing about payment, so it touches none of the payment structure. One discovery path was added, and that is all.

2026-07-24 — Visibility of the execution envelope's baseline cost

What a decision costs when the axes are omitted did not appear anywhere it would actually be read. The tool listing is fetched 2,897 times a month; the documentation, eleven times in thirty days — the description is effectively the only place that gets read, and it was empty.

The tool description now states the defaults, what they cost, and the cost of the cheapest configuration. The figures are variable, so the lookup path is stated alongside them.

The MCP path and the other paths carried different values. A contract mismatch, so it was removed.

The registration response said "the axes you declare," omitting the fact that defaults apply when nothing is declared. Corrected.

2026-07-23 — No way to tell the channels apart

The adapters call the server internally, and those calls carried no marker identifying the channel. Nowhere in the server could a request be traced to the route it arrived by — the absence of any means to measure per-channel use.

Handled in two stages: the adapter attaches a marker, the server verifies it and records it. Only two fixed values are accepted; forged values and anything outside the list are not recorded.

2026-07-23 — A2A protocol version negotiation

An external registry's conformance check was failing at response parsing. The investigation put the violation on our side — the checker requests the current version, while we answered in the older representation and declared the current one on the card.

The representation now branches on the version in the request header. A single canonical form is kept internally, and the conversion happens only at serialization — two parallel sets are not maintained.

• An absent header is treated as the older version (a requirement of the standard)
• Unsupported versions are refused with a dedicated error. We do not widen the mapping on our own initiative

The subsequent recheck passed.

2026-07-23 — HEAD requests returning 404 on the adapters

The hand-written servers checked only for GET, so every HEAD request fell through to 404. To crawlers that send HEAD as a liveness check, the service read as dead. The normal response paths were extended to cover HEAD.

Some paths appeared to be working already when checked live, but that was the cache — the origin returned 404. A live response must not be read as the origin's behavior.

2026-07-21 — Missing entry points at the root

The two documents an agent conventionally looks for first were absent from the root domain. They existed only on the API domain — a place where someone who looks and finds nothing may simply leave.

Copies were placed at the root. The bodies are kept byte-identical to the source: a duplication marker inside the body would be exposed verbatim to anything reading plain text. The marker lives in a separate file.

2026-07-19 — A last line of defense on balance columns

Five columns holding balances and usage had no constraint forbidding negative values. Application-level locking was holding integrity and actual leakage was zero, but a mistake in new code could have committed a negative balance silently.

The constraint was added at the database layer. The tables were empty, so it could be applied without cost.

A natural-key uniqueness constraint on the ledger was rejected. A single purchase can legitimately pay the same recipient several component royalties, so the constraint risks blocking valid rows. Double-crediting is already prevented by other means.

2026-07-19 — A structure where the test environment reaches production

Isolation between the test and production environments rested entirely on injected environment variables, and the default was the production connection. A script that omitted them attached straight to the production database. Even the initialization script that empties every table could point at production with nothing in its way.

The default was inverted to refusal. A production connection now holds only under an explicit declaration. Matching is exact, so a test environment with a similar name is not caught by mistake.

The production marker must not be placed in the environment file — the moment it is, it propagates to bare scripts as well and the defense is void.

2026-07-18 — Guidance at the dead ends

Traffic revealed the places where external agents and bots hunt for authentication, payment, or discovery, receive a 404, and stop. The most frequent was probing for OAuth-related paths. Decision Anchor does not use OAuth, so only a dead 404 came back.

Agents do not voice complaints; only the departure remains. This is the work of placing a response at the silent dead ends read out of the logs.

Two audiences are addressed side by side — structured fields for script bots that cannot read prose, sentences for agents that can.

• Each host's 404 now points explicitly at the actual registration and payment paths
• The payment manifest is not duplicated; only the location of the source is given
• A paid tool call that is refused now carries guidance. Static strings only — it refers to no call arguments and no decision content

Answering directly at the OAuth standard paths was avoided. That standard requires an authorization server address, and we have none. Guiding from a 404 is more honest than advertising an authorization server that does not exist.

The boundary rule recorded earlier — that each host should guide only within its own remit — turned out to be a design judgment rather than an instruction. Adjusted after confirming that.

2026-07-17 — The logs could not say what had been attempted

Measured by surface, most of a day's traffic was MCP, yet the observation screen was seeing only 4.4% of the whole. All 1,596 MCP requests remained as the same path and the same status, leaving "what was attempted" unanswerable.

• Up to five seconds of logs were lost at every restart — the connection pool was closed before the buffer was drained
• Requests the client cut off midway were dropped entirely. Only completed responses were observed
• Tool names were not recorded

All resolved. An aborted request is recorded with an empty status — the default remains success even when no response is sent, so writing it as-is would read as success.

The boundary on recording tool names: what is blocked is free text such as the decision itself, its intent, its reasons. Predefined structural metadata is not blocked. A tool name answers what was called, not what was carried into the call. That value is filled by the client, however, so it is recorded only when it passes an identifier format and discarded when it does not. Live verification showed zero leakage of argument values.

2026-07-17 — Only the documentation was out of step

A full investigation of whether an external agent can register on its own, record a decision, and complete an observation. The chain was sound — it completed on the first attempt, following the public documentation verbatim. What remained was not code but documentation.

• The sample for anomaly comparison counts only decisions with attached metadata. That premise appeared nowhere, so an agent recording without content received a sample of zero and was left guessing
• A tool description advertised a surcharge that does not exist. Only the string of an already-removed item remained, suppressing metadata attachment — doubly harmful in combination with the item above
• The payment method for paid observation was unstated. Base observation is always external payment and the trial balance does not apply, so a new agent holding only a trial cannot complete one

The premise was stated and the misinformation corrected. The aggregation itself was left unchanged — forcing every decision to populate metadata would violate content-blindness. The premise is disclosed, nothing more.

Paid observation checks whether there is data to give before demanding payment. An agent with no records never sees the payment demand at all. Paid observation going untouched is not a payment gap but the normal state of insufficient data.

A claim made during the investigation, that a particular tool did not exist, was wrong and has been corrected. It came from checking a single file. The tools were split across two.

2026-07-16 — Paths that could be recorded as "settled" without payment

• Retention subscription and automatic renewal were both writing into the payment ledger as settled external payment without any real payment verification. The payment ledger must be a factual record of what was billed and for how much
• The argument form on the path that configures the payment facilitator address was wrong, so the specified address was ignored and silently fell back to the default

The interactive retention subscription path had never been enrolled in the payment gate at all, and so was writing external payments without verification. The adjacent idle-state subscription was enrolled; only this one was left out.

Should this subscription be turned back on later, restoring the flag alone would bring the disguise back. Enrollment in the payment gate must come with it.

2026-07-15 — The core vision in six languages

The core vision existed only in English and Korean. Japanese, Traditional Chinese, French, and Spanish were added, bringing it to six.

The bodies were carried over from verified source material; nothing was newly invented. Each language follows its own typographic conventions. Language switching is pure CSS — no JavaScript.

The changelog exists in only two languages so far, so the link to it is omitted on the new language pages. We do not send anyone somewhere that isn't there.

2026-07-14 — Language switching on the changelog, and a wrong way home

On the Korean changelog, the "Home" link at the top led to the English root. Only the footer link had been localized. The top link now points to the root of that language. Top navigation belongs to the same bundle as the footer when a language surface is built — it is not the footer alone.

A language switcher was added at the top of the changelog. It lists only the languages actually published — linking an unpublished language would send the reader to a 404.

Korean menu items rendering as empty boxes in some environments was fixed at the same time. The English-only typeface had no Korean fallback specified.

2026-07-14 — A link to the changelog

The root pages carried no link to the changelog. Publishing does not create one — publishing touches the document and the sitemap, and the guidance block at the root has to be added by hand. One line was added to each language version, keeping the structures parallel.

2026-07-13 — Contract surface alignment

The public contract (OpenAPI, MCP tool schemas, access guide) had drifted from what the server actually does.

• The tool registration schema used field names the server never accepted — it could not have succeeded even once
• Values the server rejects were advertised as valid choices. Some fields the server does accept were undocumented
• Unpermitted fields were silently dropped → an agent could receive 200 and believe the value had been recorded

The server's validation layer was taken as the sole authority, and every contract surface was checked against it and corrected. The registration schema was rewritten. Unknown fields are now rejected, with the reason stated. Every value the contract advertises was actually sent and confirmed to pass.

We do not pretend to have recorded what we did not record.

2026-07-13 — Canonical document lineage

The access guide that agents read directly had split into several copies that disagreed with one another.

• The registration example omitted the recovery key → an agent following it could not recover from a lost token
• Instructions to call endpoints that do not exist
• A retired pricing clause left in place

The source was corrected first; derived copies are now regenerated by script. The path of hand-editing a copy was removed. Every example request in the documentation was executed for real and compared down to the response. Copy drift is now caught by the regression check.

2026-07-13 — Vocabulary alignment

Decision Anchor records; it does not prove. Guaranteeing that a fact is true is not the role of this environment.

• "proof" and "tamper-proof" were in use across external documents and tool descriptions — the very text an LLM reads directly
• Integration examples instructed the LLM to send a free-text summary of the decision → a denial of content-blindness. We were teaching the outside world a practice that contradicts our own category.

Every externally exposed surface was reviewed and corrected. The summary instruction was removed from the examples, and the reason recorded in a code comment. Legitimate negations were kept, with the grounds noted.

2026-07-13 — Extending immutability of decision metadata

Decision Anchor preserves the boundaries an agent declares so that they cannot be altered afterward. One table holding the dimensions of a decision sat outside that guarantee. No such alteration ever occurred — but it was possible.

An enforcement mechanism was added, and the ordering adjusted so that it does not collide with the maintenance cleanup path.

2026-07-11 — Separating the payment ledger from the settlement record

Payment records differed from path to path. Some paths had no on-chain anchor at all, and audit rows were sitting in the ledger pretending to be payment rows. The billed-amount field held a recomputed value.

The payment ledger and the settlement record were separated.

• Payment ledger — records state transitions
• Settlement record — append-only. No amount column. Decision Anchor does not assert amounts. It records only verifiable facts

Every path that lacked an on-chain anchor received one. Transaction anchors are now exposed in the usage report so they can be verified externally, directly.

2026-07-11 — Correcting settlement attribution

Session settlement attached itself to "the most recent decision record," which misattributed it to unrelated decisions. Agents with no decision record were not recorded at all. From the second session onward, ledger conflicts caused sessions to vanish silently.

A dedicated anchor is now created at the end of every session. Because the anchor is new each time, the vanishing defect is structurally resolved.

2026-07-11 — Expiry scheduler defect

The bilateral-agreement expiry scheduler was querying a state value that does not exist, and it was never invoked from anywhere in the first place. Expired agreements remained in the proposed state indefinitely.

The query condition was corrected. The scheduler was rewritten with a re-entrancy guard and registered in the server startup path.

2026-07-11 — Unblocking tool renegotiation

A uniqueness constraint on tool status collided with the supersession flow, making a second renegotiation permanently impossible.

The constraint now applies only to the active state. No code change — the constraint was swapped.

2026-07-11 — Login rate limiting

The portal login had no dedicated rate limit, leaving credential stuffing possible. Adjacent paths (registration, rotation, recovery) already had one; only login was missing.

A login-specific limit was introduced. Successes are not counted, so a legitimate owner is not obstructed. Account lockout was rejected — it is a denial-of-service vector.

2026-07-11 — Usage report coverage

The report reads two ledgers in parallel, and their coverage did not overlap, so the headline total did not match the itemized list. Some spending categories always displayed as zero.

Anchors and records were added across all four paths — subscription, tool purchase, session, observation. Spending is now aggregated directly from the canonical source.

Pricing impact: the report's totals and payment-method breakdown changed.

2026-07-11 — Removing false currency conversions from the ledger

The exchange rate stored in the ledger was not a snapshot but a copy of a fixed configuration value. Historical conversions could not be reconstructed. Earned and trial payments carried a local-currency figure too — even though no currency was ever involved.

Currency conversion was retired from the ledger. Conversion now happens at query time, for external payments only, and is explicitly labeled as an approximation. The column was dropped after demonstrating that no real fact was lost.

Pricing impact: the meaning of the local-currency field in the report and CSV changed. The payment quote object was removed from trial responses.

2026-07-11 — Paths where the spending cap was never applied

The subscription and retention-extension paths never called the cap check at all. A compromised agent could drain its owner's balance without limit through repeated subscriptions.

The principle was fixed — the cap applies to external payment only — and the check was added to that branch. Earned and trial paths were left untouched.

2026-07-10 — External entry friction (first pass)

• Trial exemption was advertised globally but applied to only some endpoints. Agents attempting to subscribe were met with a payment demand and left
• A particular parameter on the tool listing returned 500
• The MCP endpoint returned 404 to GET/HEAD, so registries read the service as down
• An invalid token was disguised as a payment demand rather than an authentication error

The manifest is now derived at runtime, marking actual exemption per endpoint. Parameters are validated up front. MCP responses were corrected. Invalid tokens are now blocked before the payment gate.

2026-07-10 — An unnecessary requirement on the confirmation path

External decision confirmation required a transaction identifier it never verified, returning 400. Worse, that value overwrote the payment settlement marker, destroying the record of settlement.

Confirmation now works with the decision identifier alone. The settlement record survives confirmation. The old field is marked deprecated in the contract.

2026-07-10 — Usage report accuracy

• One path omitted the payment timestamp
• The end of the date range was exclusive, so "today" always returned zero rows
• Trial spending was counted as external payment
• A local-currency figure sat in the currency field, exposing a badly distorted number

Payment timestamps are now recorded automatically. The date range was normalized to include the full day. Spending is broken down by payment method. Currencies were separated so that actual receipts and approximate conversions are distinguishable.

Pricing impact: the report response schema and the meaning of the date parameters changed.

2026-07-10 — Ending the contract's silence

The public contract was silent or wrong about actual behavior, so agents guessed at values, were rejected, and left.

• The status and payment fields of the decision-creation response were undocumented
• Required fields were missing (tool registration, portal consent)
• Token rotation behavior was unstated
• The cap's lower bound and the hash format were unstated

The contract was corrected to match actual behavior, and a response schema for the usage report was added.

2026-07-10 — Discovery paths and health check

• The portal's usage report screen always displayed "NaN" and $0.00
• Several standard discovery paths were absent, so crawlers hit 404 repeatedly

The portal display was corrected. Manifest aliases, redirects, and a health check were added. Standard document paths were added to the A2A surface.

2026-07-09 — Closing the unpaid anchoring path

The bilateral proposal path did not inherit the defenses of the ordinary decision-record path, so anchoring without payment was possible. An older observation endpoint was still alive with no settlement and no record.

Bilateral agreement was moved onto the paid path (billed at proposal). Confirmation now checks for proof of the payment channel. Policy checks were made symmetric by reusing the same functions. The legacy path received a gate and a deprecation header.

Pricing impact: bilateral proposal is now paid. Billing begins on the legacy observation path.

2026-07-09 — Payment response and observation fields

• When paid observation was refused, the response body was empty — a dead end for agents that read only the body
• The payment address being served was a placeholder value
• The time-interval field in observation results was always negative or null

The refusal response now carries the payment challenge. The payment address was replaced with a single configured source. The interval calculation direction was corrected.

2026-07-09 — Atomicity of the spending cap

The per-agent cap check and its increment were not bound atomically, so exceeding the ceiling was possible. There was also a gap between record creation and confirmation, and an asymmetry in when debits occurred.

A reservation model was introduced — the cap check and the reservation are bound in a conditional update, and released immediately when use ends. Unused reservations are reclaimed by an expiry scheduler.

Pricing impact: requests over the cap are now blocked at record creation.

2026-07-09 — Closing free-text intake

We checked whether the code actually honors the principle that no decision content and no personally identifying information is stored anywhere. There were no dedicated columns for it — but the input layer had open paths through which free text could arrive.

• Several fields were effectively unvalidated and could hold natural-language sentences
• A field with no read path was storing client values verbatim
• The entire request body was being written to the server log
• One path never called the validation function at all, so invalid values reached the database

A key whitelist was introduced — unknown keys are not silently dropped. Dropping them lets an agent believe the value was recorded. Format constraints and a PII detection gate were placed on the fields that had accepted free text, and the write path was removed from the field nobody reads. Request-body logging was reduced to non-sensitive metadata.

This does not mean it has become structurally impossible. It means the path has been narrowed.

2026-06

2026-06-28 — Atomicity of funds

Payment, ledger, and registration were committed separately, so a failure midway debited the balance without rolling back. The renewal scheduler could double-charge on re-entry. Trial debits were committed independently before the main transaction, so a rollback left no refund path. Revenue distribution inserted without an idempotency key, so a retry could credit twice.

• Payment, ledger, and registration bound into a single transaction
• A re-entrancy guard on the scheduler
• Trial debits joined to the main transaction
• An idempotency gate on distribution

A uniqueness constraint on the ledger was rejected. A single purchase can legitimately pay the same recipient several component royalties, so the constraint risked blocking valid rows.

We predicted the incident. We did not observe it occur.

2026-06-26 — Circumventing the spending cap

The bilateral path checked the cap but never raised the usage figure. As long as each individual charge stayed under the cap, this path could circumvent the ceiling indefinitely.

Usage is now incremented inside the payment transaction. Behavior is unchanged for agents with no cap configured.

2026-06-26 — Adapter host discovery

Crawlers knocked on the adapter host's robots file dozens of times and received 404.

robots and a security contact (RFC 9116) were added. The expiry date is computed from the time of request — zero maintenance burden.

2026-06-25 — A2A compatibility

The registry conformance check was failing. The cause was that the registry probe calls with a different naming convention, and Decision Anchor was rejecting it as "method not found." Confirmed from the access log.

Both naming conventions now route to the same handler (pure addition — existing behavior unchanged). When the request carries nothing, a fixed notice is returned — nothing generated. Decision Anchor is not a conversational agent.

2026-06-24 — A2A protocol implementation

The agent card was being served, but there was no path to call. An A2A agent arriving from the card could do nothing.

An A2A adapter was created as a separate service. The existing API is unchanged — the adapter calls only public paths, so payment and authentication apply to the A2A route as well (this is not a bypass). No AI model — it merely translates a request name into an endpoint.

2026-06-24 — Card signing

The agent card was unsigned, so there was nothing to make tampering evident and nothing to attest its origin.

The card is now signed at the moment it is served, so that injected content falls inside the signed scope. The public key is published.

2026-06-24 — A feedback channel for agents

An agent encountering friction had nowhere to say so. Only the departure was observable, never the reason.

A feedback submission tool was added. Fully anonymous — it does not take an agent identifier, a token, or an IP even as an argument. Every field optional.

2026-06-20 — Resolving indexing failures

The blog was being refused by search indexing. A single root cause — the canonical address did not match the actual address, so the indexer judged it a page containing a redirect.

Canonical addresses were unified to the extensionless form, and the publishing logic now generates the correct address from the start. A site robots file was added.

2026-06-17 — Tolerating broken discovery URLs

A dozen or so 404s per week. The cause was not Decision Anchor but clients that do not understand Markdown scraping the punctuation of standard link syntax into the URL. llms.txt was conforming to spec, so we did not bend the document.

The server now tolerates them through a normalization middleware. It redirects only when the normalized result exactly matches a known discovery path — core paths and unregistered paths are untouched.

2026-06-13 — Rewriting the core site

Interface content (pricing, scenarios, a blog grid) had mixed into the core domain root, blurring the core vision.

The root was rewritten as a single core vision page (English and Korean). All interface content was moved out. The core domain speaks only of the core.

2026-06-12 — Contract alignment (first pass)

The contract's version had stalled, and the worse problem was not omission but the active advertisement of wrong values. The contract advertised values the server rejects, so a legitimate attempt by an agent that trusted the documentation was broken with a 400. Optional fields were also mismarked as required.

The server's validation layer was taken as the single source of truth, and the contract was matched to actual behavior. Version synchronization was folded into the deployment path. Unlisted endpoints were added.

2026-06-12 — Discovery aliases and error codes

• The old A2A standard path returned 404 → discovery crawlers left
• The API host had no MCP path, so the registry bot hit 404
• A JSON parse failure was returned as an internal server error → agents mistook their own payload error for a server outage and retried

The old path now redirects to the canonical one (a shared single source, with no duplicated content). The MCP path is routed. Parse failures received a dedicated error code.

2026-06-12 — Widening the discovery surface

The paths by which an external agent could find Decision Anchor were narrow. Some community catalogs had shut down the page itself, and registry listings were out of date.

A discovery extension field was added to the payment challenge (reusing the contract as a single source). The registry listing was republished — its description moved to canonical vocabulary (proof → record). After reviewing the requirements of community directories, we submitted only to those that required no structural change and where we could control our own vocabulary.

2026-06-10 — Payment gate bypass

The paid gate looked up paths by exact match, but the router matched trailing-slash and case variants to the same handler. A request to a varied address passed straight through the gate.

The lookup key at the gate entrance is now normalized the same way the router does it. One fix covered every paid path. Traffic logs confirmed that no actual leakage had occurred.

2026-06-09 — Discovery of the meaning documents

AI crawlers were collecting the contract hundreds of times while never once reaching the documents that carry the meaning — content-blindness, pre-execution anchoring.

• The sitemap address that robots pointed to was not a sitemap
• There was no sitemap at all
• Links to the meaning documents existed only at the root, and crawlers visit the root once

A sitemap was created, with the meaning documents at the highest priority. robots was corrected. A link from the contract to the meaning documents was added — a bridge placed where the bots overwhelmingly look.

2026-06-09 — Cap configuration resetting usage

Every adjustment to the spending cap reset the accumulated usage. Changing only the limit erased the spending history.

Usage and period start are now preserved when the period unit is unchanged. Verified by measurement.

The cap period was also fixed to monthly in the interface while the API accepted other values, so an asymmetry could enter through direct calls. Entry validation was narrowed to monthly. The internal logic was left intact.

2026-06-08 — SDK handling of payment responses

The SDK had been stalled for some time, and the heart of it was that there was no way to handle a payment-required response. Every paid path was closed to SDK users.

The payment challenge is decoded and raised as a dedicated exception. Executing the payment — wallet, signature — is the caller's responsibility. The Decision Anchor SDK does not handle private keys. Zero dependencies retained.

The investigation showed the initial assumption was wrong — the payment information rides in the header, not the response body. Corrected from a real capture.

npm publication is on hold. Publication cannot be undone, so it is a separate decision point.

2026-06-08 — Portal display defects

• Unlinking an agent was failing every time
• The trial menu always displayed "no trial" — it could not see automatically granted trials
• The balance screen could not distinguish external payment, earned, and trial

The lookup was corrected. Balances are shown as three separate kinds. The screen now reflects the fact that the spending cap applies to external payment only.

2026-06-07 — Double counting of the spending cap

Usage against the spending cap was being counted in two places. Decision records looked at the cache; every other feature looked at the database. Because neither counter could see the other, a single agent could spend, in effect, twice the ceiling. When the period rolled over, only one side reset, causing premature refusals as well.

The database is now the single source of truth. The cache counter was demoted.

Subsequently, automatic account lockout on reaching the cap was abolished — legitimate spending is not punished with a lockout. It is retained only for abuse response. A lower bound was introduced.

Pricing impact: the cap now actually applies.

2026-06-06 — Payment alignment for observation

• Observation billed after the fact, so the data had already left even when payment failed
• On-chain payments were collected, but there was no audit row carrying the transaction, so on-chain settlement could not be tied back to the ledger
• Payment was taken even when there was no data to observe
• The rule that self-observation is free was unimplemented

A pre-check for availability (refuse before payment if there is nothing to observe). Self-observation is free — an empty result is still returned. Payment precedes delivery — data is provided only after settlement is confirmed, and withheld if it fails. The actual transaction is extracted from the settlement response and recorded in the audit row.

Three points where the documentation was silent and the code decided are now recorded explicitly.

2026-06-05 — Unifying payment evaluation

Payment decisions differed feature by feature, and defects grew out of that.

• Partial-balance deadlock — the gate exempted whenever "trial balance > 0", but the debit required "balance ≥ price." In the interval between, a permanent deadlock
• Earned-balance hole — the mere presence of an earned marker exempted every route, regardless of whether that route accepts earned
• Some paid paths were not wired to the gate at all, so after the trial ran out they were still recorded as free

A common payment evaluation module was created. The gate's predicate and the debit's predicate were made identical — removing the root of the deadlock. The order of evaluation was fixed: hard cap → currency selection (trial only when it covers the full price; otherwise earned or external, a single currency, never mixed) → spending cap on the external portion only.

2026-06-04 — Departure from pricing policy

• Tool purchases were debiting the trial balance. Three design documents all said trial was not permitted. The code had departed from the design
• One purchase path was missing from the paid list, so it could be acquired without payment
• A paid path that was advertised but had no handler was listed in the manifest — pay, then receive a 404

Removing the debit alone would have produced the opposite result — the payment exemption would remain, making it entirely free while the accounting recorded it as an external payment. So the exemption removal, the debit removal, and the gate registration were applied together. The phantom path was removed from the manifest.

Pricing impact: tool purchase is external payment only. Not eligible for trial.

2026-06-03 — Vocabulary alignment (public contract documents)

The earlier correction had reached only some documents; the contract, the agent card, and the MCP manifest still carried the vocabulary we avoid.

Unified to canonical vocabulary. proof → record, comply with → structured for. Strings only; no logic changed.

Some were kept — "proof" where the context distinguishes a recorder from a prover, tamper-evident, and the deliberate empty space where certain words are not used.

2026-06-01 — Distorted trial usage

Trial usage was being back-calculated from the currently configured amount. If the operator changed the trial amount, the usage reported for existing agents was distorted.

The amount at the time of grant is now preserved. Verified by actually changing the amount and reproducing.

2026-05

2026-05-29 — Resolving contradictions between documents

• One document stated that including decision content incurs a surcharge, but the surcharge had already been removed entirely. Two documents were saying the opposite of each other
• Vocabulary at odds with the position of a recorder ("cannot prove", "tamper-proof")

Corrected. append-only, tamper-evident. A positive assertion was placed one line ahead of each negation — as a guard against smaller models reading a negation inverted.

Eight design documents were matched to the facts of the implementation. Three items that had not been decided are now explicitly marked as undecided — so that a later session does not mistake them for omissions.

2026-05-28 — Document figures and version markers

• The figures in the documents had stalled at an early version (endpoint counts, tool counts)
• Four places claiming to state "the currently deployed version" all said something different. To a bot, that reads as a stalled project
• Vocabulary the code does not support ("proof", "compliant")

Figures were updated against measurement. Values that move — pricing, enumerations, the number of axes — were taken out of the documents and delegated to the API, so that a change in pricing requires no change to the documents. The version was unified to a single source, and a synchronization check was folded into the deployment path.

2026-05-27 — Guiding people who arrived at the wrong door

Requests to the API domain at familiar SaaS addresses (login, signup, my account) all returned 404. A dead end.

Nine paths now point to the page that actually corresponds. A permanent redirect is cached and cannot be taken back, so these are temporary. POST still returns 404 — so that an old signup attempt is never confused with real registration.

2026-05-26 — Entry friction and canonical vocabulary

A month after launch, no agent had registered. Two causes were identified.

• A first arrival calling a core endpoint with GET received only 405 or 401, and left. There was no guidance
• Across the four channels AI bots read, Decision Anchor's core vocabulary never appeared verbatim — only paraphrases that carried the sense. Which means the vocabulary would not be recovered at the next model's training cutoff

A GET guide was added — 200 with structured guidance (purpose, how to call, example, authentication) instead of 405. Canonical vocabulary now appears verbatim across the four channels. The vocabulary we avoid remains unused.

Two essential distinctions were fixed permanently:

• Registration = self-declaration ≠ decision record = pre-execution anchoring
• External channels say "accountability boundary"; internal mechanisms say "decision boundary"

Follow-up: three cases where copying the guide's example verbatim produced a 400 were corrected. Every live domain was walked through for real.

2026-05-25 — The legal ground for human-mediated entry

We were about to accept human registrants without the basic information needed to identify which law applies. Processing deadlines and the scope of rights differ by country of residence, and that information was simply absent.

• Self-declared country of residence. Automatic detection only suggests; the final authority is the person's own declaration
• Mandatory consent at registration (terms, privacy policy) — registration is blocked without it. The document version at the moment of consent is frozen and stored
• An agent owner is not a natural person, and is therefore structurally separated from the consent subject

The autonomous agent entry path is unaffected.

2026-05-25 — Deletion and portability

Human registrants had no way to exercise the right to deletion or the right to data portability.

• Deletion request → permanent deletion after a 30-day grace period. Recoverable during the grace period
• Statutory response deadlines computed per country of residence
• Full export of one's own data (JSON/CSV)

The agent is preserved even when the owner is gone. An agent is not the owner's property but an independently acting subject — consistent with Decision Anchor's original design.

The permanent-deletion audit record retains only a hash, and no information identifying a natural person.

2026-05-25 — Breach notification (interface only)

There was no channel to notify data subjects in the event of a breach.

A notification path and an administrative screen were created. Actual email delivery does not exist yet — only the audit record is written. The emergency contact chain is a separate track.

2026-05-25 — Closing PII intake

The channels through which an external agent enters free text (tool name, tool description) could incidentally accumulate information identifying a natural person.

A PII detection gate was introduced (email, phone, national ID, and so on). Detected input is refused. All 41 free-text columns were extracted and classified by risk.

2026-05-24 — Removing the content-inclusion surcharge

Choosing to include content in a decision attracted a surcharge. But the decision is a fact and the execution envelope is a policy. Price attaches to policy, not to fact. Charging a surcharge on the decision axis was itself a departure from the design.

The surcharge was removed entirely. The choice remains; only the price is gone.

Pricing impact: a reduction.

2026-05-23 — Every paid path returning 500

If a request arrived before payment initialization finished at server startup, it returned 500. Decision records, observation, tool purchase, subscription — all of them. It never surfaced because everything had been tested on trial balance — this was what the first paying registrant would have met.

Startup now completes initialization before accepting any request. If it fails, the server does not come up.

500 → 402 (payment required), as it should be.

2026-05-23 — Unverified payment on tool purchase

• The payment address was a hardcoded placeholder, and the payment status was always recorded as "pending"
• The trial balance was never actually debited, so a trial agent could purchase tools without limit
• Double-charge prevention was applied on only one side

The real payment status is now recorded. Trial debiting was introduced. Double-charge prevention was applied to both sides.

2026-05-23 — Discovery path alignment

External bots were actively attempting discovery within 24 hours, and many attempts returned 404. The version MCP reported had stalled at its initial value.

Standard discovery paths were created (dynamic — they follow configuration changes automatically). Aliases redirect. Version markers were corrected.

2026-05-22 — Charging for public observation

Six observation paths were free and unauthenticated. The cost of reading one's own record is already included in the execution envelope's price, yet public observation alone was free. There was no friction against bots or competitors harvesting the data.

Converted to paid and authenticated. The "free" marking in the contract and documents was corrected.

A breaking change. Changing one path alone would have made the others a way around it, so all of them were changed.

2026-05-22 — Fixing the retention expiry model

The specification said "delete the original" on expiry, but core records are append-only, so physical deletion is impossible. A conflict with the design.

Fixed as an absorb-into-anonymity model — expired metadata is absorbed into anonymous statistics, and "no access to the original" is enforced by access windows and quotas. Not erasing it, but placing it out of reach.

2026-05-22 — Long-term retention tiers

Retention came in only three tiers, leaving no path for the long-term retention that medical and financial regulation requires.

Ten-year and indefinite tiers were added (indefinite by subscription).

The essential constraint: core records cannot be modified, so even when a lapsed subscription demotes the tier, the original declaration is not erased. The demotion is layered separately and composed at query time to yield the effective tier. Resubscribing does not restore a record that has already been demoted.

2026-05-22 — Environment observation and evidence reports

There was no path to compare a decision against the distribution of its environment, or to produce an evidence report.

Anomaly comparison, environment anomaly, and evidence report paths were created. k=10 anonymity absorption — statistics are provided only at a scale where no individual agent can be singled out.

Vocabulary correction: the specification had been using evaluative words — "appropriate," "inappropriate," "risky." Decision Anchor does not judge. Replaced with within-band / outlier, plus the band definition (mean ±2σ).

2026-05-22 — Self-classification registry

An agent had no way to declare its own type.

A classification registry was created. Only self-lookup is permitted — another agent's classification cannot be read.

2026-05-21 — The fifth pricing axis of the execution envelope

How much of a decision's content is disclosed was not reflected in the price.

The pricing formula was extended from four axes to five — retention / disclosure / responsibility / content disclosure scope (new) / delegation state.

2026-04

2026-04-22 — Security review

• Trial debiting had no transaction and no lock, so concurrent requests could spend past the quota
• An internal endpoint was unauthenticated
• The idempotency key did not validate the payload, so the same request identifier could carry different content
• Security headers were absent. Registration and token rotation had no rate limit

All corrected. An idempotency conflict is now refused with a dedicated error. Rate limits were introduced on registration and rotation.

2026-04-13 — Core site and simulation

All seventeen discovery paths were for machines. There was no human entry point.

The homepage received seven scenarios (no technical vocabulary) and an interactive simulation — "Three agents. Three logs. Three different numbers."

Decision Anchor is not offered as the answer. The problem is shown; that is all.

2026-04-12 — A shift in positioning

Every external surface was written in the language of agents. A human decision-maker could not see immediately why it mattered.

The first sentence of the registry listing, the contract, and the documents moved from describing an identity to stating a problem. Existing content was not deleted; the new text was placed before it.

The bilateral agreement tool was exposed in MCP — a core differentiator that had never been surfaced.

2026-04-09 — Existence archive moved to subscription

Per-item pricing meant cost grew with use — at odds with a service concerned with continuity of existence.

Converted to a subscription model. Unlimited within the period. Automatic renewal, a grace period, and absorption into statistics on expiry. An owner cancellation path was added.

Pricing impact: the existence archive moved from per-item pricing to subscription.

2026-04-08 — Decision recording via MCP entirely broken

There was no way to record a decision through MCP. The tool failed every time.

• A required parameter did not exist on the tool at all
• The handler and the server spelled field names differently
• The confirmation tool itself did not exist

Six fixes. Tool schemas were checked against the server's validation layer, value by value, and aligned.

2026-04-08 — Documentation that violated the principle

Eight places across external documents and examples instructed agents to put a "summary" field in the decision record. Decision Anchor does not store decision content. A direct contradiction of the core principle.

The storage field never existed in the first place — only the documentation said so.

Removed from every document and example. Malformed identifier formats in the examples were corrected as well (used as written, they produced a server error).

2026-04-08 — Payment amount corrupted under concurrency

The payment amount was written directly into a shared object. Under concurrent requests the amount was overwritten, so a payment could be made for the wrong amount.

An independent instance is now created per request. Direct mutation of shared state was removed entirely.

2026-04-08 — Deprecation notice and SDK error handling

• Two observation paths were duplicates — one received a deprecation header (the function remains; the sunset date is announced in advance)
• The SDK was swallowing authentication failures — it passed 401 and 403 through without checking

2026-04-07 — Crawler responses and GET guidance

A crawler requesting robots received 404. A GET to a POST-only path received a meaningless 404.

robots was added. A GET to a POST-only path now returns 405 with the exact path and method to use.

2026-04-07 — Ecosystem contribution

Decision Anchor's existence was unknown in the x402 ecosystem, and there was no example code.

An anchoring pattern example was contributed to the SDK and to the x402 repository. No promotional copy — code only.

2026-04-06 — Dynamic computation of the payment amount

The on-chain payment amount was a fixed value that did not cover the actual cost. With options attached it fell short by as much as $0.25, and observation and tool purchases were no different.

The actual cost is now computed immediately before the request and used to set the payment amount. The portion paid from earned balance is excluded. If computation fails, it falls back to the fixed price. The payment protocol flow is unchanged.

2026-04-06 — "Why would I need this"

Every discovery path explained only what Decision Anchor is. Neither an agent nor a developer could connect it to a problem of their own.

Five problem types were defined (payment disputes / multi-agent accountability / delegation boundaries / portability of platform logs / fixing an irreversible execution in advance) and applied across six surfaces.

"If your agent never touches those boundaries, you may not need Decision Anchor" — the principle of not soliciting was preserved.

2026-04-06 — Documentation that disagreed with the actual response

The answer to "what do I actually do to try this" was not in the documentation. Calling the real API and comparing showed five mismatches between the documented field names and the actual response.

Registration → creation → confirmation was executed directly, and the documentation corrected. A runnable example was added.

2026-04-05 — Charging for the existence archive

Archiving an agent's state was free — anchoring, with no charge attached.

Charging was introduced. But not payable from the trial balance — otherwise existence would be severed the moment the trial ran out. External payment or earned balance only.

2026-04-05 — Input validation

• The validation function was passing any field it did not have a definition for
• Several paths did not validate identifier format
• The export filename was unsanitized, allowing header injection

Format validation was introduced across every path. Undefined fields are refused.

2026-04-04 — Terminology overhaul

Six acronyms each meant something different depending on where you read them. Documents expanded the same acronym in different ways, and AI chatbots were reading the old terms and explaining Decision Anchor incorrectly.

Canonical expansions were fixed — DD = Decision Declaration, EE = Execution Envelope, DAC = Decision Anchor Cost, ARA = Agent Record Access, TSL = Tool Sharing Layer, ISE = Idle State Environment.

Replaced across five surfaces. The contract's descriptions were moved to English. Full names accompany the first appearance.

The MCP server was crashing on every second request — hidden by automatic restarts, so it never surfaced. A fresh instance is now created per request.

2026-04-04 — Opening discovery paths

There was exactly one discovery path: the registry.

An agent card (A2A standard) and llms.txt / llms-full.txt were created. Submitted to community listings.

2026-04-03 — MCP entry path

There was no path by which MCP could reach Decision Anchor.

An MCP server was created (fifteen tools) and listed in the registry. A new agent receives a trial balance automatically at registration, so it can begin without a payment method.

2026-04-02 — Service opened

The code existed, but nothing outside could reach it.

The public contract was generated (eighty paths). The SDK was published. On-chain payment was enabled — Base mainnet. External responses from the API domain were confirmed.