Changelog

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

2026-08

2026-08-29 - The contract said nothing about error bodies

Thirty-seven rejection responses declared a status code but never said what the body would contain, so a client reading the spec to extract a value got nothing back. One cluster used different field names from the rest, which meant the same route family was emitting two shapes. The code was unified first, then the declarations were added.

2026-08-29 - The response was echoing the request

The payment source in the cost breakdown returned the value carried in the request rather than the value recorded in the ledger. Decisions fully covered by trial balance were still reported as externally paid. The ledger itself had been corrected four months earlier, but the problem was framed as a bookkeeping error at the time, so the response fell outside the scope of that fix.

2026-08-29 - A value that was rejected when sent as documented

Six discovery surfaces listed one axis in lowercase, and sending it that way was rejected. That axis is the only one of seventeen that uses uppercase notation. Internal checks passed because case was stripped immediately before comparison.

2026-08-28 - A feature name that read as a claim

One phrase was removed from ten machine-readable surfaces. It could be read as though this environment separately guaranteed a fact that follows from the nature of the record itself. Canonical vocabulary already existed, so no replacement term was coined.

2026-08-25 - A tool that had never worked

The bilateral agreement proposal tool appeared normally in the tool list but rejected every call it received, and had done so from the start. The decision recording tool in the same place failed in the opposite direction, advertising three valid options while the server accepted only one, so two of the three declared values were rejected 100% of the time. Agents leave without saying anything, so there is no way to know how many tried.

2026-08-25 - A subscription that could not be bought

The indefinite retention tier was disabled in code, yet twenty discovery surfaces still described its subscription process, lifecycle and monthly price. The path itself returned a refusal, so none of it could happen. Saying a tier is unavailable and saying it can be had by subscribing are different claims, and only the second was removed.

2026-08-25 - A field with no meaning

One field accepted a count of options that had been excluded, but this environment cannot know what they were excluded from. Nothing counts the total set and no ceiling existed, so any value passed, and accepting a denominator would require accepting decision content. The input was withdrawn, and it is refused rather than silently discarded.

2026-08-25 - Tense standing in the place of identity

The phrase about fixing a record before execution had become a name in the place that says what this environment is, which hid other ways of using it. Timing is the agent's choice, before execution or after. No new name was coined, the point was written out as a sentence, and an accompanying value list that was wrong has been corrected.

2026-08-24 - One decision counted once per payment row

Three owner-facing aggregations duplicated each decision by its number of payment rows, since a base fee and any surcharge are recorded separately. Decisions with larger surcharges are the ones that produce two rows, so the inflation was greater in amount than in count. Billing was unaffected and only the aggregate display was wrong.

2026-08-23 - When the decision was made

Until now this environment only knew when something was recorded. Agents can now state when the decision itself was made, as an optional field, with the server normalising the notation so that the same instant yields the same hash. Times later than the recording time are refused, and when the two are close, credit is added at the point of confirmation.

Pricing impact: Declaring a decision time and recording it soon after produces credit. The window and the amount are provisional.

2026-08-23 - The path decides the declaration form

A declaration involving a counterparty could be created without one, while paths that did have a counterparty silently overwrote the value the client sent. The sent value and the recorded value differed, and nothing in the response said so. Each path now accepts a single declaration form.

2026-08-23 - A value used in code but missing from the list

Two transaction types in the credit ledger existed in code but not in the database list, which meant reaching them would roll back the entire transaction. It had not surfaced only because no one holds that balance yet. This removes a latent defect rather than adding a feature.

2026-08-21 — An invoice that could not be settled

Paid routes demanded payment without saying that a payment signature alone does not complete the request. Identity is checked behind the payment gate, so an anonymous caller who received the demand, signed, and returned still ended at authentication. One client repeated that round trip three times and left. The response body now carries the identity-first step and the registration path.

• Each route now states whether trial or earned balance applies. A separate caller held a trial balance and was billed on a route the trial does not cover.
• No funds were lost. But we did not prevent that — the payment library skips settlement on any error response.

2026-08-20 — Where there was no guidance at all

On two routes, a missing required field ended in a server error. The caller could not tell what was omitted, and a client input problem was recorded as a server fault. Three of the four routes in the same family already answered with a proper refusal; only these two were left out. Found while walking every surface end to end in one pass.

2026-08-20 — The observation layer read as its opposite

An external agent read only our surfaces and described the observation layer as "an intelligent analytics layer that renders verdicts." The canonical definition says the exact opposite. The detailed specification already carried the non-judgment language; the single line the agent actually reaches pointed the other way. We changed the word and added one negative sentence on the same line.

• "Generate" was as dangerous as "analytics" — this surfaces what is already recorded rather than producing something.

2026-08-20 — An app store and a waiting room

The same agent read the tool layer as "an app store for agents" and the idle state as "a cost-free waiting room." Both are things the canonical definition explicitly denies. The compressed one-liner in the short guide was the cause. Replacement wording was condensed from the existing specification; nothing was newly invented.

• One tool description was describing its neighbour's function — two tools claimed to do the same thing within one response.
• We left out any statement about the cost of staying. The default mode is currently free, so it would have been false.

2026-08-20 — Dying on receipt of the tool list

Forty-one characters in the response killed legacy-encoding clients at the moment they received the tool list. Not a misreading — the connection never forms. The crawler entry file and the security contact file on the same host were dead for the same reason, and had never been part of any measurement.

• The guard now measures whether the outgoing bytes can be read, rather than counting characters.
• Static text keeps serving old bytes from cache for up to four hours after a restart.

2026-08-20 — A rejection notice that could not be read

A client holding a valid token received a refusal six times and left after 63 seconds. It re-read the public contract twice in between — the intent to comply and the reference to the canonical source were both there, and it never got through once. That notice was dying under legacy encodings.

• The previous guard named eight files and looked only inside them, and those eight were already clean. Replaced the list with a full sweep.
• One class remains: values stored in the database and emitted in a response cannot be seen by any source scan.

2026-08-19 — Characters that kill the reader

A local agent on a Korean-language Windows machine failed eight times in a row reaching our surfaces. These characters do not garble text; they kill the process reading it. The worst instance was the 401 guidance — the sentence a blocked client has to read in order to get unblocked. Four rounds opened the guidance, error, discovery and specification surfaces.

• The file a crawler fetches first was blocked by a single character. Dying there means the discovery path never begins.
• Judging by codepoint range is wrong. Stars and arrows look like emoji but exist in the legacy code pages.
• Human-facing surfaces cannot be opened. Removing every offending character still leaves the language switcher labels and the company name. That is a property of a multilingual site, not a defect.

2026-08-17 — Guidance that sent you through 172 KB

The registration response described the first-record procedure by pointing at the full 172 KB specification. Everything needed was already in a 2.5 KB guide that nothing pointed to. One client's traffic showed it: specification 12 times, guide 0. We changed the target — and deliberately did not list the specification alongside it.

• Seven pieces of guidance agents read directly were in Korean. One of them is exactly where an agent lands when its trial grant fails.

2026-08-17 — No way to know which routes the trial covers

A client holding a trial balance was billed on a route the trial does not cover. It queried trial status four times and got only the balance back; the answer was found after the demand arrived. The table holding that answer sat inside the payment middleware, so reading one value meant standing up the whole payment stack. The table was separated out and the applicable routes are now in the response.

2026-08-17 — People act on the first line

A header-format problem and a token lookup failure shared the same 401 guidance, and that guidance put registration in the first field. The observed result: a client that received a 401 for a header-format problem registered twice more instead of fixing the header. A dedicated branch now puts the presentation format first and registration last.

• Registration was not removed. Callers who never registered arrive on this branch too, and for them it is still the answer.

2026-08-17 — Our own surfaces contradicted each other

The specification's authentication scheme had stood since the first draft in a form meaning "the header value is the credential itself." The fact that a prefix is required lived only in prose, and machines do not read prose. The agent card already declared the correct form — this aligned the one that had fallen behind rather than introducing a new form.

2026-08-17 — When the source goes stale, so do its derivatives

We fixed a response string, and four documents quoting it still carried the old wording. The sync check reported no drift — the derivatives were stale because the source was stale. Editing a copy by hand would have brought the old wording back at the next sync.

• What was missing was a check across the axis where code and documentation disagree. The sync check only compares source against derivative.

2026-08-17 — Examples that failed if you followed them

We ran the public examples for real for the first time. Two of four did not run — the example closest to the pre-execution anchoring narrative imported an unpublished package and died on its first line, and the install instructions said the same thing. Examples in the blog drafts were rejected on every attempt as written.

• Deleting two unpublished drafts removed all five vocabulary violations at once.
• One track earlier we edited the same file and missed a value error. The regression now actually executes the examples.

2026-08-16 — Declared one thing, did another

Declarations enumerated permitted values while the code validated none, so arbitrary strings were stored or the request ended in a server error. The response and the ledger recorded different payment-mode values. A field the specification declared required was never read, so a client that honoured the contract silently got the wrong result.

• One lookup belonging to the free record-reference service was billed while not even being defined as an observation type. Now free.
• The gate was not removed. A gate that knows something is free and lets it through is not the same as no gate.

2026-08-16 — Live endpoints absent from the contract

Two subscription routes were alive and used by our own tests, yet appeared nowhere in the public contract — no external path to them existed. The capability was not missing; it had never been stated. One response arises only from a race and cannot be produced by calling, so the declaration says it was determined by reading the code.

2026-08-16 — A configured value should be both the advertisement and the charge

A ceiling on the pricing multiplier was fixed in code and overrode the operator setting. Yet the public contract already said in three places that the charged multiplier equals the configured value. Measured before touching anything: raising the setting by 33% moved the total not at all. Matching the documents to the code would have swapped one falsehood for another, so we changed the code.

• Removing a ceiling means an anomalous value multiplies through. Floors were placed in both the code and the database.
• No change to current charges. Values move only once the operator sets above the old ceiling.

2026-08-16 — A switch that does nothing when you turn it on

The extinction scan exists but nothing calls it. Meanwhile the screen has an enable button, and pressing it flips the badge to "active." The last-run field on the same card stays "never," permanently. We chose not to wire it — this is irreversible automation and nothing has ever been observed about the candidate set. Six places now say the same thing instead.

2026-08-15 — The verification tools manufactured a green build

A startup script kept an old process alive, so the regression ran against stale code and reported green. It was a self-reinforcing loop, and it surfaced by accident. A day later the same family produced another: when the regression aborted midway it still reported zero failures and exited successfully.

• The repair did not widen what gets killed. A script that starts killing processes it did not start is the seed of a larger incident.
• Trusting a regression needs three things at once — the assertions look at the right thing, they take the real path, and they hit today's code.

2026-08-15 — Reservations left out of the ceiling

The spending ceiling formula is written into the model, and nine places on the read side computed it without reservations. A session actually opened while the ceiling was fully consumed by reservations — measured, not inferred.

• The ninth site emerged during the fix itself. Repairing only one would have left two endpoints reporting different remaining balances for the same question.

2026-08-15 — Distribution failures became permanent non-payment

Revenue distribution records a failure state, and nothing read that state to recover from it. The purchase committed while the seller's royalty never went out. Recovery sweeps are an established practice here; this was the one place without one.

• A distribution failure after the purchase commit returned a server error, so buyers retried a purchase that had succeeded. The fact of the purchase and the fact of the distribution are separate.

2026-08-15 — One paid observation route had no payment gate

It deducted balance while skipping pre-payment, rate limiting and the spending ceiling entirely. The counter was never even created, so it was effectively unlimited. The route comment itself said "free."

• The regression asserted this defect as correct behaviour — two consecutive lines in the same step, one paid observation unpaid, and fixing it broke the suite.

2026-08-15 — The service started normally with payments switched off

A swallowed initialization failure logged one line and brought every paid route up unbilled. Another failure path in the same file already refused to start — two failure paths ran in opposite directions inside one file. It now refuses.

• The log wording merged two causes and hid the difference. "Switched off" and "broken" are not the same thing.

2026-08-15 — Non-numeric values could reach an amount

An unvalidated period made the cost "not a number," and the ceiling check turned that into zero and passed it through as a free request. The real defence was a later type error rolling the transaction back, not validation. Every monetary column now excludes that value explicitly — an existing non-negative constraint lets it pass.

2026-08-15 — A 21x undercharge with no log line

Price calculators each swallowed failures and returned nothing, and the middleware substituted the floor price. The fallback itself is an availability decision and was left alone; only the silence was fixed.

• Deciding where not to log mattered more. Logging deliberate returns as well would bury real failures under crawler traffic.

2026-08-15 — The retry-safety mechanism caused retries

Concurrent duplicate requests violating the idempotency key returned a server error. An agent receiving that read it as an outage, retried, and hit the same window again. The data was never damaged — only the response was wrong, so the remedy was minimal.

• On the same day we closed a period rollover that overwrote consumption: a late request could reset the spending accrued in between to zero.

2026-08-15 — Earned balance expiry never ran in code

The specification states that earned balance expires, and nothing subtracted expired lots from the balance. Meanwhile deduction subtracted amounts the ledger could not cover. One created the divergence, the other quietly filled it in so it never showed. The weight of this defect is the gap between what we declare and what we do.

• The validity period is a year, so it surfaces a year after the first accrual. This is the cheapest moment to fix it.

2026-08-15 — The one component with no guarded transitions

The subscription component had no model of its own, so state changes were scattered and never inherited this codebase's guard idiom. The defect was not eleven sites but one missing point of inheritance.

• Guards were split by character: transitions that converge on the same result throw nothing, transitions that must not be overwritten throw.
• One sweep aborted entirely on a single failure. The failure direction was "give more," so the loss compounds over time.

2026-08-15 — Three alignment defects

• Bilateral idempotency ignored the request body — the same identifier with a different proposal returned the old agreement instead of a refusal. An agreement sets the accountability boundary between two agents, which makes this answer expensive.
• An unused payment processor name survived in some records — we do not route through it. The moment aggregation reads that column, one payment lands in two buckets.
• Query ranges were silently narrowed — requests beyond the free retention period returned only that much, with nothing in the response saying so, so callers read it as "no activity in that period."

Six parallel tables keyed by route had no assertion that they must agree. A mismatch now refuses startup.

2026-08-15 — Nothing kept the low volume low

Adapter comments rested on "the volume is low, so this is fine," and nothing kept the volume low. Rate limiting, length bounds on anonymous submissions, and rotation and retention on log files were added together. The retention value is not new policy — it extends the value the database already used.

• The personal-data detector was widened only after setting the false-positive boundary. Foreign identifier formats were not added — broad patterns cost more in false positives than they gain.

2026-08-15 — An internal discipline document sat in a public repo

The canonical vocabulary discipline was served verbatim from a public repository, carrying internal paths, a backlog and outbound submission strategy. Stripping the internal references would not close it — the reference numbers are the document's own index. We moved it instead.

• History was not rewritten. What it contains is internal description rather than credentials, and the point is to stop future exposure, not erase the past.

2026-08-14 — A fixed idempotency key in the public catalog

The payment-demand example carried a fixed identifier, and it was listed verbatim in the public settlement catalog. Every caller copying the example would share one idempotency key. Scope was limited to that key — it is the only one where collision matters.

From this point we ran the first systematic code review (64,918 lines across 250 files). The entries for 15 and 16 August are its output.

2026-08-13 — Regulation names and compliance vocabulary on the interfaces

The interface sites framed the problem by naming a specific jurisdiction's regulation, and two language editions still carried "compliance." The regulatory framing was replaced with a general description of the situation (the argument is unchanged) and the vocabulary realigned toward accountability.

2026-08-12 — 34 posts with an empty description

Only two of thirty-six were correct. Thirty were empty strings, three had inherited another language's text, one was stale. Titles have a mandatory check and descriptions did not, so empty values were written straight through. The new text was matched against the vocabulary of each post's own body.

• Bilingual glossing was omitted on this compressed surface. Its purpose is already served by the first occurrence in the body.

2026-08-12 — The publishing engine reverted URLs and language codes

Hand-corrected values returned to engine defaults on republish. The comment read "no trailing slash, to avoid a redirect," but on a directory resource the missing slash is what creates the redirect — intent and effect were reversed. One language field serving three separate purposes, and diverging from the other surfaces, was corrected alongside.

2026-08-12 — Index timestamps left behind

The index modification date never moved when the listing changed. Publishing touched the sitemap only for the post URL and for a newly created index, so the common case fell through. Unpublishing had the same asymmetry and was handled together. Per-post summaries were added to the index at the same time — the listing routine was already parsing the description and discarding it.

2026-08-12 — Per-language wording of the core terms

The same concept was written differently within a single language. One language had no original-term gloss at all, and the sentence separating the recorder from the actor was missing from four languages' metadata. The landing pages and thirty-six blog posts were converged, and a table of six concepts across six languages was established as canonical.

2026-08-11 — A layer that is not on screen does not get read

Reading only the landing page left the existence of the sub-assets out of the reader's judgement. The cause was reach, not copy. Structured data was added and did not reach the conversational path at all — those fetchers extract body text and drop script blocks. A one-line description was placed on each row of the entry section.

• This is a notice, not a call to action. "Here is this" rather than "do this," so it does not touch the core lock.
• The interfaces existed in two languages, so four editions had no such section. Filled in after expanding to six.

2026-08-11 — The root mirror was 20 days behind

The short guidance document on the root domain trailed its source by twenty days, and what was pending included the vocabulary corrections and the regulation-name removal. There was no record of an intentional divergence — the mirror was not on the checklist of any alignment procedure.

2026-08-10 — Regulation names do not belong in the object position

"Structured for" is canonical vocabulary and stays. What was wrong was placing a specific regulatory article as its object. The relevant obligations have been deferred, and the stated reason is the absence of a conformity standard; the obligated parties are system providers and deployers, not us; and public repositories and downstream crawls are hard to update.

2026-08-09 — Downstream summaries use our wording as material

An AI-generated description in an external catalog carried vocabulary we have never used, and an assessment elsewhere quoted our tool description verbatim. What has to be controlled is not only the words we use but what a downstream summary can build from our phrasing. The "does not prove — it proves" reversal was dropped.

• One phrase was corrected in May and came back. The target then was a copy, and the uncorrected source flowed back over it.

2026-08-09 — Putting the next step in the 401

The 401 body carried an error code and a message and nothing else, so a caller could not tell what to do from the response. The tool surface was already giving guidance, so the two surfaces disagreed. The situation splits five ways and one wording was not copied across them.

• The eight owner-authentication sites were left alone. Pointing an owner at agent registration is directing them down the wrong path.

2026-08-09 — Where the contract was silent

Specification-driven clients guessed wrong on routes that advertised one thing and returned another — four attempts before the first success. Payment demands on paid observation, refusals behind disabled features, and rejection responses were all declared. The disabled-feature wording states that the route exists and the flag is off, which is what separates it from a 404.

2026-08-09 — You had to pay to learn your request was wrong

Bilateral proposal is outside the trial, so the only path to validation was payment. An empty body or naming yourself as counterparty drew a payment demand first, and the rejection came only after signing and retrying. Pre-validation was moved ahead of the gate.

• Anonymous requests were left alone. The first implementation filtered those too and broke the regression — anonymous requests are how external indexers collect the payment demand.

2026-08-09 — A regression failure carried for four months

Eleven failures labelled "not implemented" had a different cause — a single line of test configuration. Implementation and assertion arrived in the same commit with no related change between them. It was not something that went stale; it was recorded wrongly from the start, and quoted unexamined in twenty-two places since.

• The total was updated repeatedly while the reasons carried forward untouched. The rule is now that zero failures is normal.

2026-08-07 — Where usage records quietly disappeared

Usage records were written as a whole batch and, on failure, returned in full to the queue. One record violating a constraint blocked every subsequent record until restart. It happened in production, once for about 21 hours. The lost entries existed only in memory and the logs kept only a count, so they are unrecoverable.

• The traffic logger beside it had already recognised and fixed the same problem; the record layer never received the same treatment. That is the reverse of the order of importance.
• Batch failures are now split per record, ending the total block. Constraint violations are discarded with their reason; transient errors are returned.

2026-08-07 — Trial records blocked by the payment window

Trial-covered records never take a reservation, and the expiry sweep did not look at the payment source, so it labelled them "reservation released" — and confirmation refused on that label. Any trial record older than thirty minutes could never be confirmed. An external agent had already hit this ten days earlier and nobody knew.

• The window existed and nothing announced it. Documented first, then the mechanism was fixed.
• With only the sweep fixed, confirmation still refused — measurement caught it. The window check was duplicated in two places.
• The five affected records were not corrected retroactively. A service handling append-only records should not treat its own records that way.

2026-08-07 — Not a vocabulary problem but a factual one

Of eight uses of "permanent," only one omitted its condition. This is contract accuracy, not vocabulary — the word is not forbidden and is true for the indefinite tier while subscribed. But that tier is currently disabled, so right now it is true in no context at all. The condition for revisiting was written down alongside.

2026-08-06 — The catalog does not refresh

Eight days of observation confirmed that the settlement catalog freezes on the declaration in effect at the first settlement, and does not refresh after a restart. Change the payee and the catalog keeps advertising the old address. Whether a further payment refreshes it remains unknown, and we do not assert otherwise.

2026-08-06 — Wording we sent outward

An external directory listing opened with vocabulary we avoid. It was our own text from April, copied there by a crawler. The earlier vocabulary alignment had checked only the surfaces we serve; submissions and listing descriptions were not on the list. One original had become four, and one of them is permanently fixed because the repository was archived.

• Older registry versions can be edited, and we chose not to. Old versions are history, and a service selling append-only records should not revise its own history.

2026-08-05 — A fixed identifier in the public example

The decision-record example carried a fixed idempotency key, and the lookup keyed on it without scoping to the owner. From the second caller who copied the document onward, a success response came back with nothing recorded. Changing the value alone would not close it — the field had no description at all, and the fixed example plus the missing note were the condition together.

2026-08-05 — Registration idempotency removed

The registration idempotency cache stored the response verbatim, so a third party sending the same key received the original registrant's credentials. It was the only place in the system holding credentials in the clear. Anonymous registration, retry safety and secret delivery cannot hold at once; retry safety was given up. The feature had never once fired, so nothing observable was lost.

• An unwritten premise is not kept. This design rested on treating that key as a secret, and nothing said so anywhere, while the specification carried a fixed example value.
• The lifetime filtered reads without deleting anything. Reads stayed correct, so nobody noticed.

2026-08-02 — A process that logged success and died

Two processes contended for the same port and the loser printed "serving" and died quietly. Reading the logs, both appeared to have started normally. The mechanism was the framework registering the final callback argument as an error listener as well.

• Fixing silence produces noise in some places. Changing only the exit code would have traded it for an endless restart loop, so a start limit went in with it.
• The other services do not share the shape and were left alone. "No handler" is not automatically a defect.

2026-08-02 — Internal references left in the contract

Twenty-eight references in the public contract could not be decoded without internal documents. Not all of them could be stripped mechanically — where a reference served as the grounds for a sentence, deleting it removes the reason. Those were rewritten without the reference, or dropped after confirming the same grounds already appeared in an adjacent field.

2026-07

2026-07-31 — SDK retry header

The SDK documented the retry header under a name the server does not read when it pulls the payload. The check that decides whether a route needs payment accepts both names; the step that extracts the payload accepts only one. Following the documented name landed back on a payment-required response. An earlier note here read "both names are accepted, so this is harmless" — that mistook the check for the extraction. Corrected; the original wording stays.

• The agent guide had no retry procedure at all. Added.

2026-07-31 — A gap in settlement records

Found only after building a payment client and paying for real. The regression suite had never exercised this path: six routes had no assertion at all, and the three that did asked only whether any row existed, so they stayed green on rows left over from an earlier run. Assertions now look at what the current run produced. Three routes added.

• On append-only records, asking whether a row exists passes forever after the first success.

2026-07-31 — What the catalog will keep

A settlement catalog lists a service the first time a payment settles, and the declaration in effect at that moment becomes its metadata. Whether it is refreshed later is unconfirmed, so we treated it as one-way and filled in response examples for all eight paid routes ahead of the first payment.

2026-07-31 — Registry listing refreshed

The published listing sat 48 days behind. The file had been current for three weeks, but publishing is a separate act and that step lives outside the version single source. Republished. Nothing detects the gap yet — left open and recorded.

2026-07-31 — A failure that looked like every other failure

Connection pool exhaustion surfaced under the same generic internal error code as everything else and could not be told apart without opening the logs. It has its own code now. This came before tightening the pool ceiling: tightening raises how often that path is reached, and the path was invisible.

2026-07-30 — Rate limiting

The global rate limit had never worked. The key that groups requests was built wrong, so every request landed in a fresh bucket and the ceiling was structurally unreachable. The headers announcing remaining budget went out the whole time carrying a number that never moved. Three places in our own documentation counted this as a defense — those descriptions corrected as well.

Before switching it on we measured what would be caught. Only scanners had ever passed the ceiling; the busiest legitimate minute stayed under half of it. Discovery documents are served ahead of the limiter and spend no budget.

• The number in the header now goes down. Budget information reaches callers meaningfully for the first time.

2026-07-29 — Payment advertised differently on repeat requests

A repeated request came back with a different payment block each time. A decision's charge is stored as more than one row, and depending which row was read the response either said no payment was needed or asked for an amount that did not match the total. It is now pinned to what the first response said. Whether that baseline is the right number is a separate question, untouched here.

• An earlier note pointed at the wrong locations. Both had a second line of defense in front of them. Corrected and kept.

2026-07-29 — Retention: axis versus overlay

We had been describing retention as a five-step ladder. It is not. Three values sit on the axis; the other two are overlays placed on top of it. Putting different layers on one line made "ten years costs less than five" look like an inversion, when the multiplier reads axis conditions only and the result follows from the definition. We misread our own design twice. Corrected in the canonical agent document and in the response.

• Korean-language internal text had been riding in payment-required responses for months, and an external directory republished it verbatim. Cleaned up.
• One route had a live path and a working charge but an empty contract. Declared.

2026-07-29 — Estimate and charge

Preset estimates were computed with different arguments than the actual charge. The axis in question is off, so both came out at zero and matched by accident; turning it on would have split them. Aligned before that switch is thrown — no amount changes with this release.

• Presets carried a tier label without saying that the axis is currently free of charge. Now stated alongside.

2026-07-29 — Discovery paths on the MCP host

Six standard discovery paths returned 404 on the MCP host. They serve a pointer now. The signed card is not copied; requests converge on the canonical one, because a copy drifts out of signature at the next update.

2026-07-28 — Payment status lookup

A decision's charge is stored as more than one row — base fee and premium separately. The lookup returned one of them, and which one was not determined. There was no way to see the total. It now returns every row with a summed total and aggregates status conservatively: settled only when every row is settled.

• The creation timestamp used for ordering could not order them. Both rows are written in one transaction and carry the same time. Only real data shows this.

2026-07-28 — Reproducing the price from the published contract

The published contract was not enough to compute what you would actually be charged.

• The multiplier was structurally always 1 — it divided the total by the sum of its own parts. A charge with 1.5 applied was reported as 1.
• The conditions that trigger the multiplier were listed without the threshold. "Two or more" appeared nowhere.
• A retention tier you can select right now, with no gate and no subscription, was missing from the price table.

The amounts charged were correct; the reporting was not. Advertising a wrong value is worse than omitting it, so the back-calculation is gone and the decision lives in one place. No amount changed.

2026-07-26 — Discovery surface on the sub-sites

Two sub-sites answered 200 with the home page for addresses that do not exist. To a crawler every address existed and all of them held the same content. Added a not-found page, crawl rules, an address list, and language declarations.

2026-07-26 — Declaring paid routes, and empty requests

The specification never said in machine-readable form which routes are paid. Prose mentioned it, so anyone reading the spec alone saw zero paid routes. Seven routes now declare the payment-required response. Amount and payee are left out: they vary per request, and writing them down makes them wrong the moment they are written. The live response is canonical.

• A request with no body used to produce a server error. It now returns a refusal that says what is missing.

2026-07-26 — A way out of a session

Sessions could be started but not ended. One start and you were stuck behind a duplicate-session error. One kind is eventually released by an expiry sweep; the other had no exit at all. Five operations added — end, status, and trial run.

• One entry listed as free was in fact always a paid call. Label corrected. The rest matched on a full comparison.

2026-07-26 — Payment now reaches the server

The blind spot recorded two days ago is closed. The adapter passes the payment signature through untouched. The adapter does not sign — holding a caller's key would put us in custody of someone else's funds. Call a paid tool without payment and the response carries the next step; sign, call again with the same arguments, and it proceeds.

Calls to the server now go through a single path. The same defect had recurred eight times because the contract was restated once per tool.

• Two field-name mismatches corrected. In one of them the value you specified was being dropped without notice.
• With no payment supplied, the request is byte-for-byte what it was. Free routes unaffected.

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.